Spring Tutorials

Spring Framework have mainly two Important Core Concept as given below.

1. IOC (or Dependency Injection)

   The basic concept of the Inversion of Control pattern (also known as dependency injection) is that you do not create your objects but describe how they should be created. You don't directly connect your components and services together in code but describe which services are needed by which components in a configuration file. A container (in the case of the Spring framework, the IOC container) is then responsible for hooking it all up.

   i.e., Applying IoC, objects are given their dependencies at creation time by some external entity that coordinates each object in the system. That is, dependencies are injected into objects. So, IoC means an inversion of responsibility with regard to how an object obtains references to collaborating objects. There are three types of Dependency Injection working by IoC container providers.

   DI Type	Description
   Constructor Injection	The constructor arguments are injected during instance instantiation.
   Setter Injection	This is the most favored method of dependency injection in Spring. Dependencies are “set” in the objects through setter methods defined in a Spring configuration file.
   Interface Injection	This is not implemented in Spring currently, but by Avalon. It’s a different type of DI that involves mapping items to inject to specific interfaces.

2. Aspect Oriented Programming(AOP)

   AOP in spring allows cross cutting of concerns. AOP is not dependent on Spring’s IOC container. The key unit of modularity in OOP(Object Oriented Programming) is the class, whereas in AOP the unit of modularity is the aspect. Spring AOP is implemented in pure java and hence does not require a separate compilation process.

   The key unit of modularity in OOP is the class, whereas in AOP the unit of modularity is the aspect. Whereas DI helps you decouple your application objects from each other, AOP helps you decouple cross-cutting concerns from the objects that they affect. The AOP module of Spring Framework provides aspect-oriented programming implementation allowing you to define method-interceptors and pointcuts to cleanly decouple code that implements functionality that should be separated.

   The Spring Framework uses Spring AOP internally for transaction management, security, remote access, and JMX. Since version 2.0 of the framework, Spring provides two approaches to the AOP configuration:

1. schema-based approach
2. @AspectJ-based annotation style.