Spring in Brief

What is Spring

The most popular application development framework for enterprise Java

What is Spring Framework

An open source java platform.

Framework of Frameworks: supports other frameworks like hibernate

It has modules: IoC, AOP

Advantages of Spring

●Predefined Templates – for JDBC, JPA ; save a lot of code

●Lightweight – no inherit or implement of class, POJO implementation

●Loosely Coupling – dependency injection

●Easy to Test – dependency injection

●Fast Development – dependency injection

●Powerful Abstraction

●Declarative Support – for validation, formatting

Dependency Injection

●Dependency  :

          object A depends on object B, if object A needs object B to execute  correctly.

●Tightly Coupled ☹

●If object B has other dependencies, A need to know about them too.

●If change of implementation, need to change the code.

         ●Loosely Coupled ☺

       ●Reusable of code

       ●Easy to test

●Injection :

       adding something external to the flow.

         ●Glue 2 classes together while keeping them independent.

●Two types of Dependency Injection in Spring

●Constructor based

●Setter based

Inversion of Control (IoC)

●A design pattern, removes dependency from code, makes the code loosely coupled.

●No modification of code if logic is moved to a new environment.

Spring IoC Container

●In Spring Framework, IOC container is responsible to inject the dependency.

●Provide metadata to the IOC container either by XML file or annotation.

Two types of IoC Containers in Spring

●BeanFactory

●ApplicationContext

What is a Bean

●The objects that are instantiated, assembled or managed by the Spring IOC container.

●Created with configuration metadata supplied to the container in the form of XML.

●declare bean using <bean> element and inject <bean> with using

 <constructor-arg> and <property> elements in xml configuration file.

●Another way of bean configuration is using annotations.

Spring as a Container

● Spring is a Container of Beans/a Factory of Beans, dependency injection is possible.

● What is a container?

● Tomcat Servlet Container

● All servlets are configured in xml and supply the classes.

● Tomcat creates servlets required by reading xml

         ● Similarly;

         ●  Spring is a container of beans, POJOs (objects) are contained in spring       

           container, supplied as requested by others.

         ●  All objects are managed by Spring Container

          ● Handles the instantiation

          ● Handles whole lifecycle

          ● Handles destruction of objects

Bean Factory

● Factory Pattern

●   Instead of creating a new object, make a call to Object Factory which creates new objects according to some configuration and hands it over to the requested object.

● ApplicationContext

●   BeanFactory with additional functionalities.

●   When defining ApplicationContext, reads Spring XML and initializes available beans itself without any call of getBean

●   When another object call getBean, ApplicationContext handsover the objects that already been initialized.

● Advantage

● Spring bean is created in the Bean Factory

● Spring has the handle of the Bean

● Spring acts as a container of this newly created bean

Bean Life Cycle

●   Spring container is responsible for managing the lifecycle of beans created through it.

●   When a bean is instantiated, it may be required to perform some initialization to get it into a usable state.

●   Similarly, when the bean is no longer required and is removed from the container, some cleanup may be required.

●   Lifecycle consists of call back methods :

             1. post initialization call back methods

             2. pre destruction call back methods  

●  Spring Framework provides 4 ways of controlling lifecycle events of bean :

            1. InitializingBean and DisposableBean callback interfaces

            2. custom init() and destroy() methods in bean configuration file

            3. @PostConstruct and @PreDestroy annotations

            4. Other Aware interfaces for specific behavior

InitializingBean and DisposableBean callback interfaces with single methods in each

org.springframework.beans.factory

InitializingBean : void afterPropertiesSet() throws Exception;

                                   allows a bean to perform initialization work after all necessary                                                  properties on the bean have been set by the container. 

DisposableBean : void distroy() throws Exception;

                                   allows a bean to get a callback when the container containing it is                                          destroyed. 

custom init() and destroy() methods in bean configuration file

●The previous one is not a preferable way to initialize the bean because it tightly couple your bean class with spring container.

●A better approach is to use “init-method” attribute in bean definition in applicationContext.xml file.

●The default init and destroy methods in bean configuration file can be defined in two ways:

●Bean local definition applicable to a single bean

<beans>

  <bean id="beanC" class="com.virtusa.model.BeanC" init-method="customInit" destroy-method="customDestroy"/>

</beans>

●Global definition applicable to all beans defined in beans context

<beans default-init-method="customInit" default-destroy-method="customDestroy">

  <bean id="beanA" class="com.virtusa.model.BeanA“/>

  <bean id="beanB" class="com.virtusa.model.BeanB“/>

</beans>

@PostConstruct and @PreDestroy annotations

●Spring 2.5 onwards, you can use annotations also for specifying life cycle methods using @PostConstruct and @PreDestroy annotations.

@PostConstruct annotated method

  will be invoked after the bean has been constructed

  using default constructor and just before it’s instance

  is returned to requesting object.

@PreDestroy annotated method

  is called just before the bean is about be destroyed

  inside bean container.

this post processor will do the validation at the back end :

<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor" />

Other aware interfaces for specific behavior

●Spring offers a range of Aware interfaces that allow beans to indicate to the container that they require a certain infrastructure dependency. Each interface will require you to implement a method to inject the dependency in bean.

● These interfaces can be summarized as :

●ApplicationContextAware

●ApplicationEventPublisherAware

●BeanClassLoaderAware

●BeanFactoryAware

●BeanNameAware

●BootstrapContextAware

●LoadTimeWeaverAware

●MessageSourceAware

●NotificationPublisherAware

●PortletConfigAware

●PortletContextAware

●ResourceLoaderAware

●ServletConfigAware

●ServletContextAware

Bean Scope

2 basic bean scopes : 

● Singleton – only once per Spring container

●    when ApplicationContext initialized, all Singleton beans are initialized.

● Prototype – new bean created with every request or reference

●   spring waits for a getBean to happen, then it initializes the prototype, a new reference.

●  ex: Point0 , defined as a prototype bean, if it is referenced in two other beans, each of those beans would have different instance of that Point0 object.

other bean scopes :

Web-aware scopes

        Spring tights to web applications, can use to create servlet beans, tights to servlet API. Spring knows when is a new request, when is a new session. Can tie the beans scope to request and the session.

● Request - new bean per servlet request

●    call getBean inside a new request scope, a new bean is created, but in same request scope, same bean is going to be used.

● Session - new bean per session

●   if one user access a single session, no matter how many getBean calls happen, only one bean is returned, if one user with new session, a new bean is created.

● Global Session - new bean per global HTTP session (portlet context)

●   if have a global session and an individual portlet sessions, can tie a bean into a portlet context.

Bean Auto-wiring in Spring 

●   This feature of spring framework enables injecting object dependency implicitly.

●   Work with reference only, cannot use to inject primitive or string values.

● The Spring Container can autowire relationships between collaborating beans without using  <constructor-arg> and <property> elements which used to skip some of the configurations.

●   First look for bean type to be injected or if there are multiple beans of same type then looking for a matching name or a clue.

●   Auto-Wiring modes

● no  : no autowiring by default (autowiring is OFF) ;

       explicitely set the dependencies using tags in bean definitions

● byName  : inject the object dependency based on bean name, property name = bean name  ; internally calls setter

● byType  : inject the object dependency based on bean type,

     property name != bean name  ; internally calls setter

● byConstructor  : injects the dependency by calling the constructor of the class,

     (constructor with larger no of parameters)

● Autodetect  : Spring first tries to wire using autowire by constructor,

      if it does not work, Spring tries to autowire by byType.

Annotations

●Used to provide bean configuration , configure the dependency injection

●@Required

●applies to bean property setter methods.

●@Autowired

●can apply to bean property setter methods, non-setter methods, constructor and properties.

●@Qualifier

●along with @Autowired can be used to remove the confusion by specifiying which exact bean will be wired.

●JSR-250 Annotations

●Spring supports JSR-250 based annotations which include @Resource, @PostConstruct and @PreDestroy annotations.

●Post processor

Post Processor

Spring MVC

Aspect Oriented Programming (AOP)  

●Breaking down the program logic into distinct parts, concerns.

  cross-cutting concerns : functions that span multiple points of an application.

●Remove these common functionalities and create an Aspect.

  aspect : the unit of modularity (class or object : OOP)

examples of aspects : logging, caching, auditing, security

DI helps decouple your application objects from each other.

AOP helps decouple cross-cutting concerns from the objects that they affect.

AOP implementations : Spring AOP, AspectJ, JBoss AOP

AOP Concepts and Terminology 

●Aspect  : A module which has a set of APIs providing cross-cutting requirements.

●Join Point  : This represents a point in your application where you can plug-in AOP aspect. 

●Advice  : The actual action to be taken by the aspect either before or after the method execution. 

●Before Advice  : Run advice before the a method execution.

●After Returning Advice  : Run advice after the a method execution regardless of its outcome.

●After Throwing Advice  : Run advice after the a method execution only if method completes successfully.

●After (finally) Advice  : Run advice after the a method execution only if method exits by throwing an exception.

●Around Advice   : Run advice before and after the advised method is invoked.

●Pointcut  : A set of one or more join points where an advice should be executed.

●Introduction  : Allows you to add new methods or attributes to existing classes.

●Target Object  : The object being advised by one or more aspects, this object will always be a proxied object. (advised     object)

●Intercepter  : An aspect that contains only one advice.

●AOP Proxy  : Used to implement aspect contracts, created by AOP framework. It will be a JDK dynamic     proxy or CGLIB proxy in spring framework.

●Weaving  : The process of linking aspects with other application types or objects to create an advised      object. This can be done at compile time, load time, or at runtime.

Spring AOP

Spring AspectJ AOP implementation 

1) By annotation

@Aspect  declares the class as aspect.

@Pointcut  declares the pointcut expression.

To define advice :-

@Before  declares the before advice. It is applied before calling the actual method.

@After  declares the after advice. It is applied after calling the actual method and before returning result.

@AfterReturning  declares the after returning advice. It is applied after calling the actual method and before returning   result. But you can get the result value in the advice.

@Around  declares the around advice. It is applied before and after calling the actual method.

@AfterThrowing  declares the throws advice. It is applied if actual method throws exception.

2) By XML configuration (schema based)

To define advice :-

aop:before  applied before calling the actual business logic method.

aop: after  applied after calling the actual business logic method.

aop:after-returning  applied after calling the actual business logic method. It can be used to intercept the return value in advice.

aop:around  applied before and after calling the actual business logic method.

aop:after-throwing  applied if actual business logic method throws exception.

******************************************************************************************