Spring is an open-source lightweight framework that allows Java EE 7 developers to build simple, reliable, and scalable enterprise applications. This framework mainly focuses on providing various ways to help you manage your business objects. It made the development of Web applications much easier than compared to classic Java frameworks and Application Programming Interfaces (APIs), such as Java database connectivity (JDBC), JavaServer Pages(JSP), and Java Servlet. This framework uses various new techniques such as Aspect-Oriented Programming (AOP), Plain Old Java Object (POJO), and dependency injection (DI), to develop enterprise applications.
Spring IoC (Inversion of Control)
Spring IoC (Inversion of Control) Container is the core of Spring Framework. It creates the objects, configures and assembles their dependencies, manages their entire life cycle. The Container uses Dependency Injection(DI) to manage the components that make up the application. It gets the information about the objects from a configuration file(XML) or Java Code or Java Annotations and Java POJO class. These objects are called Beans. Since the Controlling of Java objects and their lifecycle is not done by the developers, hence the name Inversion Of Control. The followings are some of the main features of Spring IoC,
- Creating Object for us,
- Managing our objects,
- Helping our application to be configurable,
- Managing dependencies
To read more on Spring IoC (Inversion of Control) please refer to this article: Spring IoC (Inversion of Control)
Spring Dependency Injection
Dependency Injection is the main functionality provided by Spring IOC(Inversion of Control). The Spring-Core module is responsible for injecting dependencies through either Constructor or Setter methods. The design principle of Inversion of Control emphasizes keeping the Java classes independent of each other and the container frees them from object creation and maintenance. These classes, managed by Spring, must adhere to the standard definition of Java-Bean. Dependency Injection in Spring also ensures loose coupling between the classes. There are two types of Spring Dependency Injection.
- Setter Dependency Injection (SDI)
- Constructor Dependency Injection (CDI)
A. Setter Dependency Injection (SDI)
Setter Injection is the simpler of the two Dependency Injection methods. In this, the Dependency Injection will be injected with the help of setter and/or getter methods. Now to set the Dependency Injection as Setter Injection in the bean, it is done through the bean-configuration file For this, the property to be set with the Setter Injection is declared under the <property> tag in the bean-config file.
B. Constructor Dependency Injection (CDI)
In Constructor Injection, the Dependency Injection will be injected with the help of constructors. Now to set the Dependency Injection as Constructor Dependency Injection in bean, it is done through the bean-configuration file. For this, the property to be set with the CDI is declared under the <constructor-arg> tag in the bean-config file.
Let us finally come up with cut-throat differences between them depicted via the table given below to get a better understanding as there persists always a dilemma if not understood to great depth.
|
Spring IoC (Inversion of Control) |
Spring Dependency Injection |
|---|---|
| Spring IoC Container is the core of Spring Framework. It creates the objects, configures and assembles their dependencies, manages their entire life cycle. | Spring Dependency injection is a way to inject the dependency of a framework component by the following ways of spring: Constructor Injection and Setter Injection |
| Spring helps in creating objects, managing objects, configurations, etc. because of IoC (Inversion of Control). | Spring framework helps in the creation of loosely-coupled applications because of Dependency Injection. |
| Spring IoC is achieved through Dependency Injection. | Dependency Injection is the method of providing the dependencies and Inversion of Control is the end result of Dependency Injection. |
| IoC is a design principle where the control flow of the program is inverted. | Dependency Injection is one of the subtypes of the IOC principle. |
| Aspect-Oriented Programming is one way to implement Inversion of Control. | In case of any changes in business requirements, no code change is required. |
Related Article:
