Spring AOP:
The Spring AOP module integrates aspect-oriented programming functionality
directly into the Spring framework, through its configuration management
feature. As a result you can easily AOP-enable any object managed by the Spring
framework. The Spring AOP module provides transaction management services for
objects in any Spring-based application. With Spring AOP you can incorporate
declarative transaction management into your applications without relying on
EJB components.
Spring DAO:
The Spring JDBC DAO abstraction layer offers a meaningful exception hierarchy
for managing the exception handling and error messages thrown by different
database vendors. The exception hierarchy simplifies error handling and greatly
reduces the amount of exception code you need to write, such as opening and
closing connections. Spring DAO’s JDBC-oriented exceptions comply to its
generic DAO exception hierarchy.
Spring ORM:
The Spring framework plugs into several ORM frameworks to provide its Object
Relational tool, including JDO, Hibernate, and iBatis
SQL Maps. All of these comply to Spring’s generic transaction and DAO exception
hierarchies.
Spring Web module:
The Web context module builds on top of the application context module,
providing contexts for Web-based applications. As a result, the Spring
framework supports integration with Jakarta Struts. The Web module also eases
the tasks of handling multi-part requests and binding request parameters to
domain objects.
Spring MVC framework:
The Model-View-Controller (MVC) framework is a full-featured MVC implementation
for building Web applications. The MVC framework is highly configurable via
strategy interfaces and accommodates numerous view technologies including JSP,
Velocity, Tiles, iText, and POI.
What are the types of Dependency Injection
Spring supports?
Setter
Injection:
Setter-based DI is realized by calling setter methods on your beans after
invoking a no-argument constructor or no-argument static factory method to
instantiate your bean.
Constructor
Injection:
Constructor-based DI is realized by invoking a constructor with a number of
arguments, each representing a collaborator.
What is Bean Factory ?
A BeanFactory is like a factory class that
contains a collection of beans. The BeanFactory holds
Bean Definitions of multiple beans within itself and then instantiates the bean
whenever asked for by clients.
–>BeanFactory is able to create associations between
collaborating objects as they are instantiated. This removes the burden of
configuration from bean itself and the beans client.
–> BeanFactory
also takes part in the life cycle of a bean, making calls to custom
initialization and destruction methods.
What is Application Context?
A bean factory is fine to simple applications, but to take advantage of
the full power of the Spring framework, you may want to move up to Springs more
advanced container, the application context. On the surface, an application
context is same as a bean factory.Both load bean
definitions, wire beans together, and dispense beans upon request. But it also
provides:
–> A means for resolving text messages,
including support for internationalization.
–> A generic way to load file resources.
–> Events to beans that are registered as
listeners.
What is
the difference between Bean Factory and Application Context ? Important
Question
On the
surface, an application context is same as a bean factory. But application
context offers much more..
–> Application contexts provide a means
for resolving text messages, including support for i18n of those messages.
–> Application contexts provide a generic
way to load file resources, such as images.
–> Application contexts can publish
events to beans that are registered as listeners.
–> Certain operations on the container or
beans in the container, which have to be handled in a programmatic fashion with
a bean factory, can be handled declaratively in an application context.
–> ResourceLoader
support: Spring’s Resource interface us a flexible generic abstraction for handling
low-level resources. An application context itself is a ResourceLoader,
Hence provides an application with access to deployment-specific Resource
instances.
–> MessageSource
support: The application context implements MessageSource,
an interface used to obtain localized messages, with the actual implementation
being pluggable
What are the common
implementations of the Application Context ?
The three commonly used implementation of ‘Application Context’ are
–> ClassPathXmlApplicationContext
: It Loads context definition from an XML file located in the classpath, treating context definitions as classpath resources. The application context is loaded from
the application’s classpath by using the code .
–> ApplicationContext
context = new ClassPathXmlApplicationContext(”bean.xml”);
FileSystemXmlApplicationContext : It loads context
definition from an XML file in the filesystem. The
application context is loaded from the file system by using the code .
–> ApplicationContext
context = new FileSystemXmlApplicationContext(”bean.xml”);
XmlWebApplicationContext : It loads context
definition from an XML file contained within a web application.
How is a typical spring
implementation look like ?
For a
typical Spring Application we need the following files:
–> An interface that defines the
functions.
–> An Implementation that contains
properties, its setter and getter methods, functions etc.,
–> Spring AOP (Aspect Oriented
Programming)
–> A XML file called Spring configuration
file.
–> Client program that uses the function.
What is the typical Bean life cycle in Spring Bean Factory
Container ?
Bean life cycle in Spring
Bean Factory Container is as follows:
–> The spring container finds the bean’s
definition from the XML file and instantiates the bean.
–> Using the dependency injection, spring
populates all of the properties as specified in the bean definition
–> If the bean implements the BeanNameAware interface, the factory calls setBeanName() passing the bean’s ID.
–> If the bean implements the BeanFactoryAware interface, the factory calls setBeanFactory(), passing an instance of itself.
–> If there are any BeanPostProcessors
associated with the bean, their post- ProcessBeforeInitialization()
methods will be called.
–> If an init-method is specified for the
bean, it will be called.
Finally, if there are any BeanPostProcessors
associated with the bean, their postProcessAfterInitialization()
methods will be called.
What do
you mean by Bean wiring ?
The
act of creating associations between application components (beans) within the
Spring container is reffered to as Bean wiring.
What do you mean by Auto Wiring?
The
Spring container is able to autowire relationships
between collaborating beans. This means that it is possible to automatically
let Spring resolve collaborators (other beans) for your bean by inspecting the
contents of the BeanFactory. The autowiring
functionality has five modes.
–> no
–> byName
–> byType
–> constructor
–> autodirect
No comments:
Post a Comment