Spring Interview Questions - 2
Question: What are the pros or benefits of Spring framework ?
The pros of Spring framework are as follows:
- Spring is an open source framework and free to download.
- Spring has layered architecture. You can select the feature you wants, you can have Struts MVC and Springs IOC container in one application itself. Eventhough spring has MVC framework if you want you can opt out.
- Spring Enables Plain Old Java Object (POJO) Programming. POJO programming enables continuous integration and testability.
- Dependency Injection is really cool stuff, spring 3.0 onwards the introduction of component-scan/autowiring and Spring Expression Language makes it even spicier.
- spring is lightweight.
The
basic concept of the Dependency Injection or Inversion of Control is
that, programmer do not need to create the objects, instead just
describe how it should be created. No need to directly connect your
components and services together in program, instead just describe which
services are needed by which components in a configuration file/xml
file. The Spring IOC container is then responsible for binding it all
up.
In other
words, while applying Inversion Of Control, at the time of object
creation, objects are given their dependencies by some external entity
that coordinates each object in the system. That means, dependencies are
injected into objects at the time of their creation. So, Inversion of
Control means an inversion of responsibility with regard to how an
object obtains references to collaborating objects.
There are three different types of Inversion of Control or dependency injection:
- Setter Injection: Dependencies are injected through JavaBeans properties (ex: setter/Getter methods in bean objects).
- Constructor Injection: Dependencies are assigned as constructor parameters.
- Interface Injection: Injection is done through an interface.
Constructor and Setter Injection are the two dependency injection method which Spring supports.
Question: What are the advantages or Pros of IOC (Dependency Injection) ?
Advantages of Dependency Injection/Inversion of Control are as follows:
- Dependency Injection minimizes the amount of code in any application. Dependency is handled by the framework itself.
- Dependency Injection makes developers life easier. With Inversion of Control containers developers do not need to think about how services are created and how to get references to the ones he needs.
- Easily scalable applications. It’s very easy to add additional services by adding a new constructor or a getter/setter method with a minimal configuration. With Spring Framework 3.0, its even easier as <context:component-scan base-package=”com.blah.blah”/> will do everything for you, you don’t need to add getter and setter method and beans for each dependency injection, just autowire the services wherever it needed.<Read how spring 3.0 made a developers life easier>
- Dependency Injection makes your application more test-friendly by not demanding any JNDI lookup mechanisms or singletons in your test cases. IOC containers make testing and switching implementations easy by allowing you to inject your own objects into the object under test.
- Comparing to other options like factory design pattern the IOC container is injecting the dependency into requesting piece of code where as the factory design pattern is more intrusive and components or services need to be requested explicitly.
- IOC containers support eager instantiation and lazy loading of services.
- IOC Containers provide support for instantiation of cyclical dependencies, managed objects, life cycles management and dependency resolution between managed objects etc.
Question: What are the difference between BeanFactory and ApplicationContext in spring?
ApplicationContext.
|
BeanFactory
|
Here we can have more than one config files possible
|
In this only one config file or .xml file
|
Application contexts can publish events to beans that are registered as listeners
|
Doesn’t support.
|
Support internationalization (I18N) messages
|
It’s not
|
Support application life-cycle events, and validation.
|
Doesn’t support.
|
Support many enterprise services such JNDI access, EJB integration, remoting
|
Doesn’t support.
|
Question: What is difference between singleton and prototype bean?
Ans: Basically a bean has scopes which defines their existence on the application
Singleton: means single bean definition to a single object instance per Spring IOC container.
Prototype: means a single bean definition to any number of object instances.
Prototype: means a single bean definition to any number of object instances.
Whatever
beans we defined in spring framework are singleton beans. There is an
attribute in bean tag named ‘singleton’ if specified true then bean
becomes singleton and if set to false then the bean becomes a prototype
bean. By default it is set to true. So, all the beans in spring
framework are by default singleton beans.
<bean id="createNewStock" class="springexample.stockMarket.CreateNewStockAccont" singleton=”false”>
<property name="newBid"/>
</bean>
</bean>
Question: What is bean wiring?
Ans:
Combining together beans within the Spring container is known as bean
wiring or wiring. When wiring beans, you should tell the container what
beans are needed and how the container should use dependency injection
to tie them together.
Question: What are the important beans lifecycle methods?
Ans:
There are two important bean lifecycle methods. The first one is setup
which is called when the bean is loaded in to the container. The second
method is the teardown method which is called when the bean is unloaded
from the container.
Question: Explain Bean-LifeCycle.
Ans: Spring framework
is based on IOC so we call it as IOC container also. So Spring beans
reside inside the IOCcontainer. Spring beans are nothing but Plain old
java object (POJO).
Following steps explain their life cycle inside container.
- Container will look the bean definition inside configuration file (e.g. bean.xml).
- 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 before the properties for the Bean are set.
- If an init() method is specified for the bean, it will be called.
- If the Bean class implements the DisposableBean interface, then the method destroy() will be called when the Application no longer needs the bean reference.
- If the Bean definition in the Configuration file contains a 'destroy-method' attribute, then the corresponding method definition in the Bean class will be called.
Question: How can you override beans default lifecycle methods?
Ans:The
bean tag has two more important attributes with which you can define
your own custom initialization and destroy methods. Here I have shown a
small demonstration. Two new methods fooSetup and fooTeardown are to be
added to your Foo class.
<beans>
<bean id="bar" class="com.act.Foo"
init-method="fooSetup" destroy="fooTeardown"/>
</beans>
|
Question: What are Inner Beans?
When
wiring beans, if a bean element is embedded to a property tag directly,
then that bean is said to the Inner Bean. The drawback of this bean is
that it cannot be reused anywhere else.
Question: What is Auto wiring?
You can
wire the beans as you wish. But spring framework also does this work for
you. It can auto wire the related beans together. All you have to do is
just set the autowire attribute of bean tag to an autowire type.
<beans>
<bean id="bar" class="com.act.Foo" Autowire="autowire type"/>
</beans>
|
Question: How do add a bean in spring application?
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
<beans>
<bean id="foo" class="com.act.Foo"/>
<bean id="bar" class="com.act.Bar"/
</beans>
|
In the bean tag the id attribute specifies the bean name and the class attribute specifies the fully qualified class name.
Question: What are different types of Autowire types?
There are four different types by which autowiring can be done.
- byName
- byType
- constructor
- autodetect
Question: What is an Aspect?
An
aspect is the cross-cutting functionality that you are implementing. It
is the aspect of your application you are modularizing. An example of an
aspect is logging. Logging is something that is required throughout an
application. However, because applications tend to be broken down into
layers based on functionality, reusing a logging module through
inheritance does not make sense. However, you can create a logging
aspect and apply it throughout your application using AOP.
Question: What is a Jointpoint?
A
joinpoint is a point in the execution of the application where an aspect
can be plugged in. This point could be a method being called, an
exception being thrown, or even a field being modified. These are the
points where your aspect’s code can be inserted into the normal flow of
your application to add new behavior.
Question: What is an Advice?
Advice
is the implementation of an aspect. It is something like telling your
application of a new behavior. Generally, and advice is inserted into an
application at joinpoints.
Question: What is a Pointcut?
A
pointcut is something that defines at what joinpoints an advice should
be applied. Advices can be applied at any joinpoint that is supported by
the AOP framework. These Pointcuts allow you to specify where the
advice can be applied.
Question: What is an Introduction in AOP?
An
introduction allows the user to add new methods or attributes to an
existing class. This can then be introduced to an existing class without
having to change the structure of the class, but give them the new
behavior and state.
Question: What is a Target?
A target
is the class that is being advised. The class can be a third party
class or your own class to which you want to add your own custom
behavior. By using the concepts of AOP, the target class is free to
center on its major concern, unaware to any advice that is being
applied.
Question: What is a Proxy?
A proxy
is an object that is created after applying advice to a target object.
When you think of client objects the target object and the proxy object
are the same.
Question: What is meant by Weaving?
The
process of applying aspects to a target object to create a new proxy
object is called as Weaving. The aspects are woven into the target
object at the specified joinpoints.
Question: What are the different points where weaving can be applied?
- Compile Time
- Classload Time
- Runtime
Question: What are the different advice types in spring?
- Around : Intercepts the calls to the target method
- Before : This is called before the target method is invoked
- After : This is called after the target method is returned
- Throws : This is called when the target method throws and exception
- Around : org.aopalliance.intercept.MethodInterceptor
- Before : org.springframework.aop.BeforeAdvice
- After : org.springframework.aop.AfterReturningAdvice
- Throws : org.springframework.aop.ThrowsAdvice
Question: Explain about PreparedStatementCreator?
Ans:
PreparedStatementCreator is one of the most common used interfaces for
writing data to database. The interface has one method
createPreparedStatement().
1
2
|
PreparedStatement <strong>createPreparedStatement</strong>
(Connection conn) throws SQLException;
|
When
this interface is implemented, we should create and return a
PreparedStatement from the Connection argument, and the exception
handling is automatically taken care off. When this interface is
implemented, another interface SqlProvider is also implemented which has a method called getSql()which is used to provide sql strings to JdbcTemplate.
