3. Spring IoC Container

Spring IoC Container 

- Spring Framework provides two of the most fundamental and important packages, they are the org.springframework.beans and org.springframework.context packages. 

-  The Spring container is the core of Spring Framework. 

- The container, use for creating the objects and configuring them. Also, Spring IoC Containers use for managing the complete lifecycle from creation to its destruction. 

- It uses Dependency Injection (DI) to manage components that make up the application.  

- Spring containers are responsible for creating bean objects and injecting them into the classes. 

- The container uses configuration metadata which represent by Java code, annotations or XML along with Java POJO classes.



How the Spring IoC Container Works:

1. Bean Definition:

   - Beans in a Spring application are defined by creating a bean definition, which is essentially a metadata that defines how the bean should be created, configured, and managed.


2. Bean Lifecycle:

   - The container manages the complete lifecycle of a bean: instantiation, population of properties, and initialization.

   - It also manages the destruction of beans, calling any configured cleanup methods.


3. Dependency Injection:

   - The container injects dependencies into the beans at runtime, resolving them from the container itself.


4. Configuration Metadata:

   - The configuration metadata can be provided in XML, Java annotations Configuration (Spring 2.5 introduced), or Java-based configuration (Spring 3.0 introduced).

   -  Java-based configuration To use these new features, see the @Configuration, @Bean, @Import and @DependsOn annotations.

  - Java configuration typically uses @Bean annotated methods within a @Configuration class.

   - This metadata helps the container understand how to create and wire beans.


Example (XML-based configuration):

Consider the following XML configuration:


<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans.xsd">


    <!-- Bean definition -->

    <bean id="myService" class="com.example.MyService">

        <property name="myDependency" ref="myDependencyBean"/>

    </bean>


    <!-- Another bean definition -->

    <bean id="myDependencyBean" class="com.example.MyDependency"/>

</beans>


In this example, the container will create a `MyService` bean and inject the `MyDependency` bean into it based on the configuration.



Configuration metadata

- configuration metadata represents how you as an application developer tell the Spring container to instantiate, configure, and assemble the objects in your application.

Note : XML-based metadata is not the only allowed form of configuration metadata. The Spring IoC container itself is totally decoupled from the format in which this configuration metadata is actually written. These days many developers choose Java-based configuration for their Spring applications.



Instantiating a container

ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"services.xml", "daos.xml"});





The two containers are namely,

BeanFactory(I) – Available in org.springframework.beans.factory package.

ApplicationContext(I) – Available in org.springframework.context package.


1. BeanFactory Interface

- This is the root interface for accessing a Spring bean container. 

- It is the actual container that instantiates, configures, and manages a number of beans. 

-  XmlBeanFactory reads configuration metadata from XML file for creating a fully configured application.

-  Lazy-loading of beans, which means beans are only created when requested.

   

Syntax : 

ClassPathResource resource = new ClassPathResource("beans.xml");

XmlBeanFactory factory = new XmlBeanFactory(resource);


2. ApplicationContext Interface

   - The ApplicationContext container is Spring’s advanced container.

   - The ApplicationContext container has all the functionalities of BeanFactory. 

   - It is generally recommended over BeanFactory. The most common implementations of ApplicationContext are:

   - Provides additional features like event propagation, AOP (Aspect-Oriented Programming), declarative mechanisms for handling transactions, etc.

   - Supports eager-loading of beans, meaning beans are created eagerly at the application startup.

   - ApplicationContext supports different ways of configuring beans. The configuration can be done using XML-based configuration, annotation-based configuration, or Java-based configuration.

   -  Use to implement ApplicationContext interface by using AnnotationConfigApplicationContext, ClasspathXMLApplicationContext , FileSystemXMLApplicationContext this classes.



ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");




Spring Dependency Injection


- Dependency injection (DI) is a process whereby objects define their dependencies .
- Dependency Injection is a way to achieve Inversion of Control (IoC) in a software application. 
- In IoC, the control flow is inverted as compared to traditional programming. Instead of the application controlling the flow of execution, the framework or container controls it. 
- Dependency Injection is a technique commonly used in Java development to connect different classes together. It allows you to wire these classes while keeping them loosely coupled, meaning they're not tightly dependent on each other's implementations.
- So, as to increase the possibility of reuse of it .





 Dependency Injection Types:
  - Constructor Injection
  - Setter Injection



1. Constructor-Based Dependency Injection
The Constructor-based Spring Dependency Injection is attained when the class constructor is invoked by the container with the number of arguments each having a dependency on other class.


2. Setter Based Dependency Injection
The Setter Based Spring Dependency Injection, is attained by calling the setter methods on the beans after invoking no-arg constructor using the Bean container.



Configuration File : where We declare beans and its dependency.
Data Types(use to inject Dependencies ) 
- 1. Primitive datatypes
- 2. Collection Type : List , Set,Map ,Properties.
- 3. Reference Type : class Object 


Comments

Post a Comment

Popular posts from this blog

11. Spring MVC @RequestMapping

  Spring MVC @RequestMapping In spring MVC @RequestMapping plays the role of mapping URL to the method of controller class. In Spring MVC application we generally use a URL which calls the Controller. In the Controller to map a given URL we use @RequestMapping annotation. RequestMapping can be used in many ways. 1. RequestMapping at Class Level 2. RequestMapping only at Method level 3. @RequestMapping annotations at class level as well as method levels 4. RequestMapping using HTTP methods 5. @RequestMapping with @RequestParam 6. @RequestMapping with @PathVariable 1. RequestMapping at Class Level @RequestMapping can be added at class Level. This way the URI provided will act as base URI for all other methods in the Controller class. @Controller @RequestMapping(value = "/employee") public class EmployeeController { // Methods.... } Now any requests with /employee as URL will hit this Controller class. 2. RequestMapping only at Method level @RequestMapping is optional for class ...
Read more

2. Spring Framework Module (Architecture)

Image
  Spring Framework Architecture The Spring Framework is a comprehensive framework for enterprise Java development. It provides a modular and organized way to build enterprise-level applications. The framework is divided into several modules, each addressing specific concerns.  Types  1. The Core Container: 2. Data Access / Integration 3. The Web   4. Miscellaneous (AOP)   1. Spring Core Container:    CORE: This module provides the fundamental parts of the framework,  its including the IoC (Inversion of Control) container and Dependency Injection features.   BEAN : It deals with the creation and management of Java objects (beans) and their dependencies.A sophisticated implementation of factory pattern called BeanFactory, is provided by, Bean module. CONTEXT : This module builds on the core and beans modules, providing a way to access application objects and services in a consistent manner. It has access rights for any objects that de...
Read more

10. Spring - MVC Framework

Image
  Introduction to Spring MVC Framework - Spring MVC is used to develop the web applications that uses MVC design pattern. By using Spring MVC we can build flexible and loosely coupled web applications. - The MVC design pattern helps in seperating the business logic, presentation logic and controller logic. - Models are responsible for encapsulating the application data.  - The Views render response to the user with the help of the model object .  - Controllers are responsible for receiving the request from the user and calling the back-end services. Spring MVC will make application development faster, cost effective and flexible. Advantage of Spring MVC Framework - Clear separation of responsibilities because it implements MVC design pattern. - Loose coupling among Model, View and Controller. - Inbuilt front controller. - Simplified Validation implementation. - Simplified Exception Handling. - Internationalization logic is simplified compared to other frameworks. - Spring...
Read more