Spring/Spring Mcq Set 16 Sample Test,Sample questions

 If the preceding job was run on a batch with a 100 rows, each item was read and passed through the processor, and it found 10 items invalid (it returned null 10 times), the value for the filter_count column would be:-

 Serving to abstract away the functionality of other components in an abbreviated interface to provide courser functionality.

 Spring Batch will, by default, try to pluck the:-

 Spring core framework provides first-class support for transactions.

 The first thing that the client configuration does is import a shared application context (to save typing if nothing else) that declares a JMS connection factor.

 The only custom logic is a POJO with an @Aggregator annotation on a method expecting a collection of Message objects.

 The RetryTemplate supports many use cases, with convenient APIs to wrap.

 There are some convenient default routers available to fill common needs:-

 To load the contents of a properties file (batch.properties) whose values you use to configure the data source.

Adapters are opaque in nature.

Attribute to configure how many items will be processed before the transaction is committed all the input is sent to the writer.

Class which delegates the task of delimiting fields and records within a file to a LineMapper, which in turn delegates the task of identifying the fields within that record, to LineTokenizer.

Element to configure this for the step:-

However, it’s important to wear another hat, that of a DBA, when writing applications.

Indeed, a step could be considered the smallest unit of work for a job. Input (what’s read) is passed to the Step and potentially processed; then output (what’s written) is created from the step.

MapJobRegistry instance. This is critical—it is the central store for information regarding a given Job.

Messages sent on the requests channel are forwarded to the:-

No processing system (such as an ESB) can deal with a million records at once efficiently.

SimpleJobLauncher, whose sole purpose is to give you a mechanism to launch batch jobs, where a “job” in this case is our batch solution.

Some invocations will fail but may be retried with some likelihood of success in a transactional scenario.

Sometimes, functionality is made available from within the application via:-

Spring Batch excels in the robustness it surfaces as simple configuration options for the edge and failure cases.

Spring Batch models solutions using XML schema.

Spring Batch provides a convenience class, CompositeItemProcessor, which forwards the output of the filter to the input of the successive filter.

Spring Batch provides a lot of flexibility and guarantees to your application, but it cannot work in a vacuum. To do its work:-

Spring Batch reads the file, transforms the records into:-

Spring Integration does support reading files into the bus.

The API surfaces a Paging object, which works something like Criteria in Hibernate.

The batch.xml file establishes a:-

The BPM engine would thread together the different actors and work lists,

The capability to hide messaging behind a POJO interface.

The gateway element simply exists to identify the component and the interface.

The most fundamental support for gateways comes from the Spring Integration class:-

The names and values for the named parameters are being created by the bean configured for the itemSqlParameterSourceProvider property, an instance of the interface

The processor attribute on the chunk element expects a reference to a bean of the interface:-

The service-activator is what handles actual processing and there’s no mention of a response channel, for either the service-activator, or for the inbound JMS gateway.

The SimpleMessagingGateway needs a request and a response channel, and it coordinates the rest.

The template that (much like its various other Template cousins) isolates your logic from the nuances of retries and instead enables you to write the code as though you were only going to attempt it once.

There is no coupling between the client facing interface exposed via the gateway component and the interface of the service that ultimately handles the messages.

There’s only one really useful implementation of the JobRepository interface, which stores information about the state of the batch processes in a database.

There’s support for writing JMS:-

To receive messages from an external system and process them using Spring Integration.

To take an input file or a payload and reliably, and systematically, decompose it into events that an ESB can work with:-

Transaction capabilities are built on top of the first class support already provided by the core Spring framework.

You can leverage Spring Batch support for retries and recovery in your own code.

You can specify exception classes on which to retry the operation.

<step id = "step23">
       <tasklet transaction-manager="transactionManager">
            <chunk reader="csvFileReader" writer="jdbcItemWriter" commit-interval="10" retry-limit="3" cache-capacity="10">
           <retryable-exception-classes>
           <include class="org.springframework.dao.DeadlockLoserDataAccessException"/>
           </retryable-exception-classes> 
           </chunk>
       </tasklet>
</step>

You use Spring Integration’s inbound-channel-adapter element to wire the TwitterMessageSource and a poller element.

You want to conditionally move a message through different processes based on some criteria.

You want to expose an interface to clients of your service, without betraying the fact that your service is implemented in terms of messaging middleware.

You want to work with a resource that may fail when you try to read from or write to it.