Spring Framework Quiz # 6

<%@ taglib prefix="form" uri="http://www.springframework.org/form/tags" %>

<%@ taglib prefix="form" uri="http://www.springframework.com/tags/form" %>

<%@ taglib prefix="form" uri="http://www.springframework.org/tags" %>

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

BeanFactory does not support enterprise services such JNDI access and EJB integration whereas ApplicationContext facilitates integration with enterprise services

BeanFactory does not support internationalization (I18N) messages whereas ApplicationContext includes support for I18N messages

ApplicationContext does NOT publish events to beans that are registered as listeners whereas BeanFactory published events to registered beans

BeanFactory supports just one config file whereas ApplicationContext can have multiple config files

Class.forName()

None of these

registerDriver()

Both registerDriver() method and Class.forName()

@RequestMapping

@InitBinder

@Valid

@Controller

No Rollbacks possible

Rollback can happen on any Exception

Rollback for a CompiletimeException

Rollback for a RuntimeException

LocalFactoryBean

SessionFactoryBean

LocalSessionFactoryBean

SessionFactory

False

TRUE

Spring Batch provides classes and APIs for job processing statistics, job restart and partitioning techniques to process high-volume of data and read/write to resources but NOT for transaction management

Spring Batch does NOT provides classes and APIs for job processing statistics, job restart and partitioning techniques but does provide functionality for complex processes like skipping or retrying failed items

Spring Batch provides classes and APIs to read/write resources, transaction management, job processing statistics, job restart and partitioning techniques to process high-volume of data

Spring Batch provides classes and APIs for job processing statistics, job restart and partitioning techniques to process high-volume of data but NOT for read/write resources and transaction management

Spring WS Security

Spring OXM

Spring ORM

Spring XML

No

Depends on how they are setup

Yes

By extending HibernateDaoSupport class, you can simply call getHibernateTemplate() method to retrieve the template instance.

The common use is to extend this class and inject the SessionFactory dependency

HibernateDaoSupport class, has a commit() method which can commit the transaction

HibernateDaoSupport class allows you to obtain Session and HibernateTemplate

When using expression based authorization the <http> elements need to be marked as use-expressions="true"

When defining the <intercept-url> elements the sequence doesn't matter

The path attribute of the <intercept-url> element is independent and is not aware of the path attribute of the <http> element.

The <intercept-ur> element won't work in the <http> elements that are marked as security = "none".

TilesViewResolver: Looks up a view that is defined as a Tiles template. The name of the template is the same as the logical view name.

BeanNameViewResolver: Finds an implementation of View that’s registered as a <bean> whose class is the same as the logical view name.

ContentNegotiatingViewResolver: Delegates to one or more other view resolvers, the choice of which is based on the content type being requested.

InternalResourceViewResolver: Finds a view template. The path to the view template is derived by prefixing and suffixing the logical view name.

The redirect: prefix in the view name is used to avoid a problem known as duplicate form submission.

The BindingResult object is used to map the user request to the controller method.

The @SessionAttributes is used to save a Reservation object to a user’s session.

The @ModelAttribute("reservation") is used to reference the Reservation object.

InternalResourceViewResolver

Both InternalResourceViewResolver and ResourceBundleViewResolver

JstlView

ResourceBundleViewResolver

JSPResourceViewResolver

aspects

logging

beans

configuration

To enable LDAP authentication

To limit number of user sessions

To support stateless authentication

To support concurrent authentication

To support authentication in clustered environment

REQUIRES_NEW: Create a new transaction. If there an active transaction exists, throw exception

MANDATORY: There must be a transaction; otherwise, throw an exception.

REQUIRED: If there’s a transaction, support it; otherwise throw exception

SUPPORTS: If there’s a transaction, it will be supported, if not create a new one

A subflow state starts a new flow within the context of a flow that is already underway.

The End state is the last stop. Each flow can only have one end state.

Decision states branch the flow in two directions, routing the flow based on the outcome of evaluation flow data.

Action states are where the logic of a flow takes place.

It enables the support of annotation configuration for Spring MVC controllers.

It enables Spring 3 type conversion and formatting support.

It enables the support of annotation configuration for transactions.

It enables Spring's support for JSR-303 Bean Validation.

global-session

response

prototype

All of these

singleton

Uses JDBC API but eliminates lot of problems associated with it

Supports Java 5 features (autoboxing, generics)

Converts standard JDBC SQLExceptions into checked exceptions

Supports operation on stored procedures and batch operations

To inject a singleton bean inside an prototype bean

To inject a non-singleton bean inside a singleton bean

To inject a singleton bean inside a non-singleton bean

To inject a larger scope bean in a smaller scope bean

Injecting Spring Scoped Proxy Beans

Support for CAS proxy tickets

Support for limiting number of user sessions

Support for multiple http elements

Support for stateless authentication

All of the above

@Component annotation scanning and @Transactional annotation scanning

@Aspect annotation detection enabling

@Autowired annotation enabling and @Component annotation scanning

@Transactional annotation scanning

In combination with @ContextConfiguration, used to declare a test as a "web test"

Used to configure a Spring web project instead of web.xml

Enable view resolution in Spring Web MVC

FacesContext

ActionSupport

DelegatingVariableResolver

WebApplicationContext

ApplicationContext

getSql()

getProvider()

getSqlProvider()

Request mapping

Request parameter binding

Validation

Redirect URL

Using @Transactional annotation

@Controller

Using PlatformTransactionManager

using TransactionInterceptor