Showing posts with label IoC Container. Show all posts
Showing posts with label IoC Container. Show all posts

Tuesday, 7 August 2018

Spring Prototype scope

Enjoying This Tutorial?

Subscribe to Ram N Java for high-quality, practical Java and Spring tutorials!

SUBSCRIBE NOW

Introduction

In the Spring Framework, bean scope defines how the Spring IoC container creates, manages, and provides instances of beans. While Spring defaults to singleton scope (where one shared instance is reused), the prototype scope ensures that every single request for a bean produces a completely new, independent bean instance.

The Core Essence of Prototype Scope

  • Fresh Instance Per Request: Every call to context.getBean() or every injection into another bean creates a brand-new object with its own state.
  • Ideal for Stateful Beans: When objects hold user-specific data, shopping carts, or transaction session data, prototype prevents state leakage across threads.
  • Lifecycle Responsibility: Spring creates, configures, and assembles prototype beans, but does not manage their full destruction lifecycle. The client code is responsible for cleaning up resources.

Step-by-Step Configuration in Spring XML

Setting up a prototype bean in XML is done simply by configuring the scope="prototype" attribute on the <bean> tag:

1. Bean Definition in applicationContext.xml

<bean id="customerService" 
      class="com.ram.service.CustomerService" 
      scope="prototype">
    <property name="message" value="Hello Prototype!" />
</bean>

2. Verifying Independent Instances in Java

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

CustomerService obj1 = (CustomerService) context.getBean("customerService");
CustomerService obj2 = (CustomerService) context.getBean("customerService");

// Output will be false: two distinct memory references
System.out.println("Are beans identical? " + (obj1 == obj2));

Key Takeaway

Use prototype scope when your beans hold state that cannot be safely shared across concurrent execution threads. Remember that Spring hands over the prototype instance to the caller, meaning your code must handle any necessary resource disposal or cleanup.


Click here to watch on Youtube:
https://www.youtube.com/watch?v=GOGfxCp4ujs&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge:
Spring Prototype scope


Spring Prototype scope

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0%20http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.ram.core</groupId>
    <artifactId>SpringDemo</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>SpringDemo</name>
    <url>http://maven.apache.org</url>

    <properties>
        <spring.version>5.0.2.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>

        <!-- Spring 5 dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>
</project>

Employee.java

package com.ram.model;

public class Employee
{
    private String name;

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    @Override
    public String toString()
    {
        return "Employee [name=" + name + "]";
    }

}

applicationContext.xml

<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-4.3.xsd">


    <bean id="employee" class="com.ram.model.Employee" scope="prototype">
    </bean>

</beans>

App.java

package com.ram.core;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ram.model.Employee;

public class App
{
    public static void main(String[] args)
    {
        ApplicationContext context = new ClassPathXmlApplicationContext(
                "applicationContext.xml");

        System.out.println("-------------------------------------------");

        Employee employee1 = (Employee) context.getBean("employee");
        employee1.setName("John");

        System.out.println(
                "Got employee object from the ApplicationContext(Spring Container)");

        System.out.println(employee1);

        System.out.println("-------------------------------------------");
       
        Employee employee2 = (Employee) context.getBean("employee");
        System.out.println(
                "Got employee object from the ApplicationContext(Spring Container)");
        System.out.println(employee2);

    }

}

Output

Jul 21, 2018 9:02:35 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@5b37e0d2: startup date [Sat Jul 21 09:02:35 IST 2018]; root of context hierarchy
Jul 21, 2018 9:02:35 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [applicationContext.xml]
-------------------------------------------
Got employee object from the ApplicationContext(Spring Container)
Employee [name=John]
-------------------------------------------
Got employee object from the ApplicationContext(Spring Container)
Employee [name=null]

Click the below link to download the code:
https://sites.google.com/site/ramj2eev2/java_basics/SpringDemo_prototype_scope.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/javaee/tree/master/Spring_2018/SpringDemo_prototype_scope

Bitbucket Link:
https://bitbucket.org/ramram43210/spring/src/e1b6e4c3fbeda148bbe23a5cd92f521a01e39305/Spring_2018/SpringDemo_prototype_scope/?at=master

See also:

  • All JavaEE Videos Playlist
  • All JavaEE Videos
  • All JAVA EE Links
  • Spring Tutorial
  • Servlets Tutorial
  • All Design Patterns Links
  • JDBC Tutorial
  • Java Collection Framework Tutorial
  • JAVA Tutorial
  • Kids Tutorial
  • Cooking Tutorial
  • Monday, 6 August 2018

    Spring Singleton scope

    Enjoying This Tutorial?

    Subscribe to Ram N Java for high-quality, practical Java and Spring tutorials!

    SUBSCRIBE NOW

    Introduction

    In the Spring Framework, bean scopes define the lifecycle, visibility, and instantiation behavior of beans managed inside the Spring IoC container. The default and most fundamental scope is the Singleton scope. Understanding how the container creates, caches, and supplies singleton beans is essential for developing performant and reliable Spring applications.

    What Is Singleton Scope in Spring?

    • One Instance Per Container: Unlike the Gang of Four (GoF) singleton pattern (which enforces one instance per ClassLoader), Spring creates exactly one shared instance per ApplicationContext.
    • Shared and Cached: When the container starts, it creates the singleton instance and places it into an internal cache. Every subsequent lookup or injection returns that identical instance.
    • Default Behavior: If you omit the scope attribute in your XML bean definition, Spring automatically treats the bean as a singleton.

    Step-by-Step Configuration Example

    Here is how you configure and test a singleton bean using Spring XML configuration:

    1. Declaring the Bean in applicationContext.xml

    <!-- scope="singleton" can be explicitly set or omitted -->
    <bean id="welcomeService" 
          class="com.ram.service.WelcomeService" 
          scope="singleton">
        <property name="message" value="Welcome to Spring!" />
    </bean>

    2. Verifying Single Shared Reference in Java

    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    
    WelcomeService service1 = (WelcomeService) context.getBean("welcomeService");
    WelcomeService service2 = (WelcomeService) context.getBean("welcomeService");
    
    // Both point to the exact same object reference
    System.out.println("Are beans identical? " + (service1 == service2)); // true
    System.out.println("Hash code 1: " + service1.hashCode());
    System.out.println("Hash code 2: " + service2.hashCode());

    Key Takeaway

    Singleton beans are best suited for stateless components such as service layers, repositories, and controllers. Because multiple threads concurrently access the single shared instance, avoid storing client-specific mutable state within singleton beans.


    Click here to watch on Youtube:
    https://www.youtube.com/watch?v=4dYXQJxTGjM&list=UUhwKlOVR041tngjerWxVccw

    Click the below Image to Enlarge:

    Spring Singleton scope

    Spring Singleton scope

    pom.xml

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0%20http://maven.apache.org/maven-v4_0_0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <groupId>com.ram.core</groupId>
        <artifactId>SpringDemo</artifactId>
        <packaging>jar</packaging>
        <version>1.0-SNAPSHOT</version>
        <name>SpringDemo</name>
        <url>http://maven.apache.org</url>

        <properties>
            <spring.version>5.0.2.RELEASE</spring.version>
        </properties>

        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>3.8.1</version>
                <scope>test</scope>
            </dependency>

            <!-- Spring 5 dependencies -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
        </dependencies>
    </project>

    Employee.java

    package com.ram.model;

    public class Employee
    {
        private String name;

        public String getName()
        {
            return name;
        }

        public void setName(String name)
        {
            this.name = name;
        }

        @Override
        public String toString()
        {
            return "Employee [name=" + name + "]";
        }

    }

    applicationContext.xml

    <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-4.3.xsd">


        <bean id="employee" class="com.ram.model.Employee">
        </bean>

    </beans>

    App.java

    package com.ram.core;

    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;

    import com.ram.model.Employee;

    public class App
    {
        public static void main(String[] args)
        {
            ApplicationContext context = new ClassPathXmlApplicationContext(
                    "applicationContext.xml");

            System.out.println("-------------------------------------------");

            Employee employee1 = (Employee) context.getBean("employee");
            employee1.setName("John");

            System.out.println(
                    "Got employee object from the ApplicationContext(Spring Container)");

            System.out.println(employee1);

            System.out.println("-------------------------------------------");
           
            Employee employee2 = (Employee) context.getBean("employee");
            System.out.println(
                    "Got employee object from the ApplicationContext(Spring Container)");
            System.out.println(employee2);

        }

    }

    Output

    Jul 21, 2018 8:24:18 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh
    INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@5b37e0d2: startup date [Sat Jul 21 08:24:17 IST 2018]; root of context hierarchy
    Jul 21, 2018 8:24:18 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
    INFO: Loading XML bean definitions from class path resource [applicationContext.xml]
    -------------------------------------------
    Got employee object from the ApplicationContext(Spring Container)
    Employee [name=John]
    -------------------------------------------
    Got employee object from the ApplicationContext(Spring Container)
    Employee [name=John]

    Click the below link to download the code:
    https://sites.google.com/site/ramj2eev2/java_basics/SpringDemo_singleton_scope.zip?attredirects=0&d=1

    Github Link:
    https://github.com/ramram43210/javaee/tree/master/Spring_2018/SpringDemo_singleton_scope

    Bitbucket Link:
    https://bitbucket.org/ramram43210/spring/src/764179f1702395ebc0d4ce50fe5125258c342eb8/Spring_2018/SpringDemo_singleton_scope/?at=master

    See also:

  • All JavaEE Videos Playlist
  • All JavaEE Videos
  • All JAVA EE Links
  • Spring Tutorial
  • Servlets Tutorial
  • All Design Patterns Links
  • JDBC Tutorial
  • Java Collection Framework Tutorial
  • JAVA Tutorial
  • Kids Tutorial
  • Cooking Tutorial
  • Tuesday, 31 July 2018

    What is Spring Dependency Injection with static Factory Method? - Playlist

    Enjoying This Tutorial?

    Subscribe to Ram N Java for high-quality, practical Java and Spring tutorials!

    SUBSCRIBE NOW

    Introduction

    In Spring, the IoC container typically instantiates beans by calling their public constructors directly. However, in enterprise applications and legacy integrations, objects are often created through static factory methods. Spring provides built-in support for static factory instantiation using the factory-method attribute in XML configuration.

    Why Use Static Factory Methods in Spring?

    • Legacy & Third-Party Library Integration: Allows seamless management of existing classes that restrict constructor access in favor of static creator methods.
    • Centralized Instantiation Logic: Encapsulates complex creation logic, object reuse, or pre-configuration within the factory method.
    • Full Dependency Injection Support: Spring can pass arguments directly into the static factory method using standard <constructor-arg> elements.

    Step-by-Step Configuration Example

    Suppose you have a service class with a private constructor and a static factory method:

    1. The Java Class with Static Factory Method

    package com.ram.service;
    
    public class OrderService {
        private OrderService() {}
    
        public static OrderService createInstance() {
            return new OrderService();
        }
    
        public void serve() {
            System.out.println("Order service executed successfully.");
        }
    }

    2. XML Configuration with factory-method

    <bean id="orderService" 
          class="com.ram.service.OrderService" 
          factory-method="createInstance" />

    3. Loading the Bean via ApplicationContext

    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    
    OrderService service = (OrderService) context.getBean("orderService");
    service.serve();

    Key Takeaway

    Specifying factory-method instructs Spring's IoC container to invoke the static method on the specified class rather than invoking a constructor. This makes integrating non-standard or legacy factories into your Spring context clean and effortless.


    Click here to watch on Youtube: 
    https://www.youtube.com/watch?v=t8r-Xikrf6Y&list=PLmCsXDGbJHdiw40lKqmUAmFs753ZAnhhq

    See also:
  • All JavaEE Videos Playlist
  • All JavaEE Videos
  • All JAVA EE Links
  • Spring Tutorial
  • Servlets Tutorial
  • All Design Patterns Links
  • JDBC Tutorial
  • Java Collection Framework Tutorial
  • JAVA Tutorial
  • Kids Tutorial
  • Cooking Tutorial
  • Wednesday, 18 July 2018

    What is Spring Dependency Injection with static Factory Method?

    Enjoying This Tutorial?

    Subscribe to Ram N Java for high-quality, practical Java and Spring tutorials!

    SUBSCRIBE NOW

    Introduction

    In Spring, bean creation is typically handled automatically by invoking class constructors. However, when working with singleton patterns, utility classes, or legacy components where constructor access is restricted (e.g., marked private), you must instantiate objects through static factory methods. Spring supports this seamlessly using the factory-method attribute.

    Why Use Static Factory Methods in Spring?

    • Encapsulated Object Creation: Allows classes with private constructors to be managed directly by the Spring IoC container.
    • Seamless Integration: Ideal for legacy systems or third-party libraries that use factory creation methods.
    • Passing Arguments: Spring can pass parameters to the static factory method using standard <constructor-arg> elements if required.

    Step-by-Step Configuration Example

    Here is an example of creating a bean via a static factory method defined on the class itself:

    1. Java Class with Private Constructor & Static Factory Method

    package com.ram.service;
    
    public class OrderService {
        private OrderService() {
            // Private constructor
        }
    
        public static OrderService createInstance() {
            return new OrderService();
        }
    
        public void serve() {
            System.out.println("Order service executed successfully.");
        }
    }

    2. Configuring the Bean in applicationContext.xml

    Use the class attribute to specify the class name and factory-method to specify the static method to call:

    <bean id="orderService" 
          class="com.ram.service.OrderService" 
          factory-method="createInstance" />

    3. Loading and Using the Bean

    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    
    OrderService service = (OrderService) context.getBean("orderService");
    service.serve();

    Key Takeaway

    When factory-method is defined alongside class, Spring delegates object creation to that static method instead of calling a public constructor. This provides complete flexibility for legacy architecture patterns and factory implementations.


    Click here to watch on Youtube:
    https://www.youtube.com/watch?v=t8r-Xikrf6Y&list=UUhwKlOVR041tngjerWxVccw

    Click the below Image to Enlarge:
    What is Spring Dependency Injection with static Factory Method?

    What is Spring Dependency Injection with static Factory Method?


    pom.xml

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0%20http://maven.apache.org/maven-v4_0_0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <groupId>com.ram.core</groupId>
        <artifactId>SpringDemo</artifactId>
        <packaging>jar</packaging>
        <version>1.0-SNAPSHOT</version>
        <name>SpringDemo</name>
        <url>http://maven.apache.org</url>

        <properties>
            <spring.version>5.0.2.RELEASE</spring.version>
        </properties>

        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>3.8.1</version>
                <scope>test</scope>
            </dependency>

            <!-- Spring 5 dependencies -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
        </dependencies>
    </project>

    Employee.java

    package com.ram.model;

    /*
     * This class is a singleton class
     */

    public class Employee
    {
        private String name;
        private int age;

        private static Employee employee = null;

        private Employee()
        {
            name = "Peter";
            age = 42;
        }

        public static Employee getEmployee()
        {
            System.out.println("getEmployee() factory method "
                    + "is called by the spring container ");
            if (employee == null)
            {
                employee = new Employee();
            }

            return employee;
        }

        public void displayEmployeeDetails()
        {
            System.out.println("Employee [name=" + name + ", age=" + age + "]");
        }

    }

    applicationContext.xml

    <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-4.3.xsd">


        <bean id="employee" class="com.ram.model.Employee" factory-method="getEmployee">
        </bean>

    </beans>


    App.java

    package com.ram.core;

    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;

    import com.ram.model.Employee;

    public class App
    {
        public static void main(String[] args)
        {
            ApplicationContext context = new ClassPathXmlApplicationContext(
                    "applicationContext.xml");

            System.out.println("---------------------------------------");

            Employee employee = (Employee) context.getBean("employee");
            System.out.println(
                    "Got employee object from the ApplicationContext[Spring Container]");
           
            employee.displayEmployeeDetails();
        }

    }

    Output

    <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-4.3.xsd">


        <bean id="address" class="com.ram.model.Address" >
            <constructor-arg value="Chennai"></constructor-arg>
            <constructor-arg value="Tamil Nadu"></constructor-arg>
            <constructor-arg value="India"></constructor-arg>
        </bean>

        <bean id="employee" class="com.ram.model.Employee" autowire="no">
            <constructor-arg value="Peter"></constructor-arg>
        </bean>

    </beans>


    Click the below link to download the code:
    https://sites.google.com/site/ramj2eev2/java_basics/SpringDemo_DI_StaticfactoryMethod.zip?attredirects=0&d=1

    Github Link:
    https://github.com/ramram43210/javaee/tree/master/Spring_2018/SpringDemo_DI_StaticfactoryMethod

    Bitbucket Link:
    https://bitbucket.org/ramram43210/spring/src/a2a3948db9c8932cede027a3aaf7ba5a87170ed8/Spring_2018/SpringDemo_DI_StaticfactoryMethod/?at=master

    See also:

  • All JavaEE Videos Playlist
  • All JavaEE Videos
  • All JAVA EE Links
  • Spring Tutorial
  • Servlets Tutorial
  • All Design Patterns Links
  • JDBC Tutorial
  • Java Collection Framework Tutorial
  • JAVA Tutorial
  • Kids Tutorial
  • Cooking Tutorial
  • Tutorials