Java MCQ Number 01103

Answer: a [Reason:] This has a lot of implications. Applications built in Roo are Java applications that benefit from the mature Java language and platform.

Answer: b [Reason:] The shell is quite smart, featuring tab completion, line history, and much more. These features are surfaced pretty consistently on all platforms, thanks to the excellent JLine library (http://jline.sourceforge.net). JLine handles some features inconsistently, however, on Windows—nothing fundamentally irresolvable, mind you, just nuisances like shell color differences and line history glitches. Proceed full speed ahead, but if you’re not using a Unix-like operating system, be aware of the (ever diminishing) possibility of issues.

Answer: c [Reason:] Start a new shell session and confirm that you can issue the following command without error, in any directory on your system: mvn –version.

Answer: d [Reason:] Confirm that you saw output. On my system, the output looked like this:
$ roo.sh quit
____ ____ ____
/ __ / __ / __
/ /_/ / / / / / / /
/ _, _/ /_/ / /_/ /
/_/ |_|____/____/
1.0.2.RELEASE [rev 638]
Welcome to Spring Roo. For assistance press TAB or type “hint” then hit ENTER.

Answer: a [Reason:] A custom command line shell to facilitate the developer. This shell can be intimidating to the uninitiated.

Answer: a [Reason:] It supports tab completion, which will enable you to tab your way to a completely specified command.

Answer: b [Reason:] You can ask it questions using the hint command, and it does its best to direct you in response.

Answer: c [Reason:] The Spring Roo shell is pretty darned handy, and even fun, but on the surface, it would appear to lack the reusability we developers have come to expect from our tools.

Answer: a [Reason:] To run the script, simply invoke the Roo shell as follows (changing the path of the file as appropriate):
roo.sh script –file ~/Desktop/myapp.roo.

Answer: a [Reason:] A directory to hold the non–unit-test Java files for your application.

Answer: b [Reason:] Note, this is for classpath resources and is not appropriate, for example, for web application resources. For that you need src/main/webapp.

Answer: c [Reason:] If you were going to develop a web application, put everything except what you would put in WEB-INF/classes in this folder.

Answer: a [Reason:] Typically, the package structures mirrors the package structure in src/main/java, allowing your tests to have package-friendly visibility to the classes under test.

Answer: b [Reason:] This directory holds resources needed by your test classes at test time, in the same way that src/main/resources works.

Answer: c [Reason:] pring Roo also lets you perform certain operations using Maven from within the Roo shell. To package the project using the Roo shell, launch it again (using roo.sh), and invoke the following command:
$ roo perform package

Answer: a [Reason:] The m2eclipse plug-in, which provides Maven support to Eclipse (and thus to SpringSource Tool Suite), can do all the heavy lifting of importing your project, since it is just a stock-standard Maven project.

Answer: a [Reason:] It’s entirely possible there’s a plug-in that will do the job for you.

Answer: a [Reason:] Enter persistence setup as it suggests. On my console, I ended up entering the following command:
roo> persistence setup –database HYPERSONIC_IN_MEMORY –provider HIBERNATE

Answer: c [Reason:] In my project, the command created two new files (src/main/resources/META-INF/persistence.xml and src/main/resources/META-INF/spring/database.properties), and it updated two files (src/main/resources/META-INF/spring/applicationContext.xml and pom.xml).

Answer: a [Reason:] The file src/main/resources/META-INF/spring/database.properties contains useful configuration to facilitate connection to the Hypersonic in-memory database.

Answer: b [Reason:] The file src/main/resources/META-INF/persistence.xml is the standard JPA configuration file to enable the Hibernate-based JPA implementation to do its work.

Answer: d [Reason:] Finally, the Spring application context, src/main/resources/META-INF/spring/applicationContext.xml, has been updated to have a data source, a JPA transaction manager, and a JPA entity manager factory.

Answer: a [Reason:] Type the following command to create a Spring MVC controller that provides a UI to manipulate Customer entities (and stand back!):
controller scaff –class ~.web.CustomerController –entity ~.domain.Customer

Answer: c [Reason:] In the project directory, in the standard shell, run mvn tomcat:run or mvn jetty:run, and open http://localhost:8080 in your browser.

Answer: d [Reason:] The root folder (or any of the source packages, e.g., src/main/java, src/main/resources, src/test/java, or src/test/resources).

Answer: d [Reason:] The concept of transactions can be described with four key properties: atomicity, consistency, isolation, and durability (ACID).
• Atomicity: A transaction is an atomic operation that consists of a series of actions.
The atomicity of a transaction ensures that the actions either complete entirely or
take no effect at all.
• Consistency: Once all actions of a transaction have completed, the transaction is
committed. Then your data and resources will be in a consistent state that
conforms to business rules.
• Isolation: Because there may be many transactions processing with the same data
set at the same time, each transaction should be isolated from others to prevent
data corruption.
• Durability: Once a transaction has completed, its result should be durable to
survive any system failure (imagine if the power to your machine was cut right in
the middle of a transaction’s commit). Usually, the result of a transaction is
written to persistent storage.

Answer: a [Reason:] To access a database running on the Derby server, you have to the Derby client library to your CLASSPATH.

Answer: c [Reason:] Spring’s transaction support offers a set of technology-independent facilities, a transaction template (e.g., org.springframework.transaction.support.TransactionTemplate), and transaction declaration support to simplify your transaction management tasks.

Answer: b [Reason:] It encapsulates a set of technology-independent methods for transaction management.

Answer: d [Reason:]
• TransactionStatus getTransaction(TransactionDefinition definition) throws
TransactionException
• void commit(TransactionStatus status) throws TransactionException;
• void rollback(TransactionStatus status) throws TransactionException;

Answer: a [Reason:]
• If you have to deal with only a single data source in your application and access it
with JDBC, DataSourceTransactionManager should meet your needs.
• If you are using JTA for transaction management on a Java EE application server,
you should use JtaTransactionManager to look up a transaction from the
application server. Additionally, JtaTransactionManager is appropriate for
distributed transactions (transactions that span multiple resources). Note that
while it’s common to use a JTA transaction manager to integrate the application
servers’ transaction manager, there’s nothing stopping you from using a stand-
alone JTA transaction manager such as Atomikos.
• If you are using an object/relational mapping framework to access a database, you
should choose a corresponding transaction manager for this framework, such as
HibernateTransactionManager and JpaTransactionManager.

Answer: a [Reason:] For example, the following bean configuration declares a DataSourceTransactionManager instance. It requires the dataSource property to be set so that it can manage transactions for connections made by this data source.

Answer: a [Reason:] Spring’s transaction manager provides a technology-independent API that allows you to start a new transaction (or obtain the currently active transaction) by calling the getTransaction() method.

Answer: a [Reason:] Because PlatformTransactionManager is an abstract unit for transaction management, the methods you called for transaction management are guaranteed to be technology independent.

Answer: a [Reason:] Once you have a transaction definition, you can ask the transaction manager to start a new transaction with that definition by calling the getTransaction() method.

Answer: b [Reason:] Spring also provides a TransactionTemplate to help you control the overall transaction management process and transaction exception handling.

Answer: a [Reason:] In this way, you don’t need to repeat the boilerplate transaction management code for this block.

Answer: c [Reason:] A TransactionTemplate can accept a transaction callback object that implements either the TransactionCallback or an instance of the one implementor of that interface provided by the framework, the TransactionCallbackWithoutResult class.

Answer: c [Reason:] This advice can be enabled with the AOP configuration facilities defined in the aop saop schema.

Answer: a [Reason:] This element will automatically detect a transaction manager with this name. You have to specify a transaction manager only when it has a different name.

Answer: c [Reason:] You might also want to transform a message by enriching it—adding extra headers or augmenting the payload so that components downstream in the processing pipeline can benefit from it. Use a transformer component to take a Message of a payload and send the Message out with a payload of a different type.

Answer: a [Reason:] Spring Integration provides a transformer message endpoint to permit the augmentation of the message headers or the transformation of the message itself. In Spring Integration, components are chained together, and output from one component is returned by way of the method invoked for that component.

Answer: b [Reason:] As before, this code is simply a method with an input and an output. The output is constructed dynamically using MessageBuilder to create a message that has the same payload as the input message as well as copy the existing headers and adds an extra header: randomlySelectedForSurvey.

Answer: d [Reason:] You can have components subscribe to messages from this channel to override the exception handling behavior.

Answer: a [Reason:] We just use it for convenience here. The code for the following service-activator depicts some of the machinations you might go through to build a handler for the errorChannel.

Answer: b [Reason:] MessagingException carries a pointer to the original Message that caused an error, which you can dissect for more context information.

Answer: c [Reason:] Sometimes, more specific error handling is required. One way to discriminate by Exception type is to use the org.springframework.integration.router.ErrorMessageExceptionTypeRouter class.

Answer: a [Reason:] Instead, it’s better to selectively route error messages to the error channel most appropriate to each integration.

Answer: a [Reason:] A component (service-activator) that upon receiving a message, adds a header indicating the name of the error channel.

Answer: a [Reason:] The following example shows a component (service-activator) that upon receiving a message, adds a header indicating the name of the error channel. Spring Integration will use that header and forward errors encountered in the processing of this message to that channel.

import org.apache.log4j.Logger;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.integration.core.Message;
import org.springframework.integration.core.MessageHeaders;
import org.springframework.integration.message.MessageBuilder;
public class ServiceActivatorThatSpecifiesErrorChannel {
private static final Logger logger = Logger.getLogger(
	ServiceActivatorThatSpecifiesErrorChannel.class);
	@ServiceActivator
public Message<?> startIntegrationFlow(Message<?> firstMessage)
throws Throwable {
return MessageBuilder.fromMessage(firstMessage).
setHeaderIfAbsent( MessageHeaders.ERROR_CHANNEL,
"errorChannelForMySolution").build();
}
}

Answer: a [Reason:] Thus, all errors that come from the integration in which this component is used will be directed to customErrorChannel, to which you can subscribe any component you like.

Answer: a [Reason:] This encapsulates the context of a test’s execution, including the application context, test class, current test instance, current test method, and current test exception.

Answer: b [Reason:] This manages a test context for a test and triggers test execution listeners at predefined test execution points, including when preparing a test instance, before executing a test method (before any framework-specific initialization methods), and after executing a test method (after any framework-specific cleanup methods).

Answer: d [Reason:] The TestContext framework provides several test execution listeners for common testing features, but you are free to create your own.

Answer: d [Reason:] Spring provides convenient TestContext support classes for JUnit 3, JUnit 4, and TestNG 5, with particular test execution listeners preregistered.

Answer: a [Reason:] JUnit 4 allows you to annotate your test methods with JUnit’s @Test annotation, so an arbitrary public method can be run as a test case.

Answer: a [Reason:] (e.g., test) from the source files of other classes (e.g., src).

Answer: c [Reason:] You can override the tearDown() method to perform cleanup tasks, such as releasing permanent resources.

Answer: c [Reason:] You can override the tearDown() method to perform cleanup tasks, such as releasing permanent resources.

Answer: b [Reason:] JUnit 4 offers a powerful feature that allows you to expect an exception to be thrown in a test case. You can simply specify the exception type in the expected attribute of the @Test annotation.

Answer: a [Reason:] In TestNG, test data sets are provided by data providers, which are methods with the @DataProvider annotation.

Answer: a [Reason:] A stub is an object that simulates a dependent object with the minimum number of methods required for a test.

Answer: b [Reason:] In contrast to a stub, a mock object usually knows how its methods are expected to be called in a test.

Answer: c [Reason:] In Java, there are several libraries that can help create mock objects, including EasyMock and jMock.

Answer: a [Reason:] Integration tests, in contrast, are used to test several units in combination as a whole.

Answer: d [Reason:] Spring supports web controller testing by providing a set of mock objects for the Servlet API (including MockHttpServletRequest, MockHttpServletResponse, and MockHttpSession).