JAVA EE: Prototype Scope

Showing posts with label Prototype Scope. Show all posts

Tuesday, 7 August 2018

Spring bean Prototype scope using annotation

Enjoying This Tutorial?

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

Introduction

In the Spring Framework, bean scope determines the lifecycle and visibility of a bean instance managed by the IoC container. While the default scope is singleton (a single shared instance), configuring a bean as prototype instructs Spring to create a brand-new instance every time the bean is requested.

Why Use Prototype Scope?

Stateful Beans: Ideal for beans that maintain conversational or mutable state specific to a user or task.
Thread Safety: Because each caller gets its own instance, concurrent operations do not interfere with each other.
Annotation-Driven Simplicity: Instead of XML declarations, modern Spring uses annotations like @Scope("prototype") to keep configuration clean and intuitive.

Step-by-Step Configuration with Annotations

Configuring prototype scope is straightforward using the @Scope annotation alongside @Component or within a @Configuration class.

1. Using @Component with @Scope

package com.ram.model;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("prototype")
public class TaskService {
    public void execute() {
        System.out.println("Executing task in a new instance: " + this.hashCode());
    }
}

2. Verifying New Instances

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

TaskService task1 = context.getBean(TaskService.class);
TaskService task2 = context.getBean(TaskService.class);

// Returns false because each request produces a distinct object instance
System.out.println("Are beans identical? " + (task1 == task2));

Key Takeaway

Use prototype scope when your beans hold individual state that cannot be shared across multiple threads. Keep in mind that Spring initializes and configures prototype beans, but does not manage their complete lifecycle destruction—the client code is responsible for cleaning up prototype instances.

Recommended Spring Scope Tutorials from Ram N Java

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

Click the below Image to Enlarge:

Spring bean Prototype scope using annotation

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;

import org.springframework.context.annotation.Scope;

import org.springframework.stereotype.Component;

@Component

@Scope("prototype")

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"

    xmlns:context="http://www.springframework.org/schema/context"

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

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

    http://www.springframework.org/schema/context

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

    <context:component-scan base-package="com.ram.model" />

</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 25, 2018 10:59:22 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh

INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@5b37e0d2: startup date [Wed Jul 25 10:59:22 IST 2018]; root of context hierarchy

Jul 25, 2018 10:59:22 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_annotation.zip?attredirects=0&d=1

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

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

See also:

All JavaEE Videos Playlist

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Kids Tutorial

Cooking Tutorial

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));