JAVA EE: Setter Injection

Showing posts with label Setter Injection. Show all posts

Friday, 21 September 2018

Apply @Resource Annotation in setter method in Spring Autowiring | Spring - @Resource annotation

Master Spring & Java Development!

Subscribe to Ram N Java for clean, beginner-friendly coding guides!

Overview: Setter-Based Injection with @Resource

The standard Java @Resource annotation (part of the JSR-250 specification) provides a clean, standardized approach to dependency injection in the Spring Framework. While commonly used for field injection, applying @Resource on setter methods enables setter-based dependency injection, promoting proper encapsulation, easier testing, and flexibility during bean configuration.

In this guide, you will learn how to configure and use @Resource on setter methods to inject dependencies cleanly into your Spring beans.

Understanding Setter-Based @Resource Injection

Using @Resource at the setter method level follows intuitive resolution rules:

Injection by Name by Default: When placed on a setter (such as setAddress(Address address)), Spring derives the default bean name from the property name (e.g., address).
Explicit Name Matching: You can explicitly specify the target bean name using @Resource(name = "customBeanName") directly on the setter method.
Fallback to Type: If no bean is found matching the derived name and no explicit name is specified, Spring resolves the dependency by type.
Encapsulation & Reusability: Setter injection keeps member variables private while still allowing dependencies to be provided or mocked during unit tests.

Step-by-Step Implementation

Define the Dependency Bean: Create the component to be injected and register it with the Spring container.
Add Setter Method with @Resource: Create a standard setter method in your dependent class and annotate it with @Resource:
@Resource public void setService(OrderService service) { this.service = service; }
Initialize the Spring ApplicationContext: When the container starts, Spring invokes the annotated setter method and injects the matching bean.

Recommended Next Videos from Ram N Java

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

Click the below Image to Enlarge:

Apply @Resource Annotation in setter method in Spring Autowiring | Spring - @Resource 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>

Address.java

package com.ram.model;

public class Address

{

    private String city;

    private String state;

    private String country;

    public Address(String city, String state, String country)

    {

        this.city = city;

        this.state = state;

        this.country = country;

    }

    @Override

    public String toString()

    {

        return "Address [city=" + city + ", state=" + state + ", country="

                + country + "]";

    }

}

Employee.java

package com.ram.model;

import javax.annotation.Resource;

public class Employee

{

    private String name;

    private Address address;

    public Employee(String name)

    {

        System.out.println("Employee(String name) constructor "

                + "is called by the Spring container");

        this.name = name;

    }

    @Resource

    public void setAddress(Address address)

    {

        this.address = address;

    }

    public void displayEmployeeDetails()

    {

        System.out.println(

                "Employee [name=" + name + ", address=" + address + "]");

    }

}

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:annotation-config />

    <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">

        <constructor-arg value="Peter"></constructor-arg>

    </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

Aug 22, 2018 10:00:33 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh

INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@5a2e4553: startup date [Wed Aug 22 10:00:33 IST 2018]; root of context hierarchy

Aug 22, 2018 10:00:34 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions

INFO: Loading XML bean definitions from class path resource [applicationContext.xml]

Employee(String name) constructor is called by the Spring container

---------------------------------------

Got employee object from the ApplicationContext[Spring Container]

Employee [name=Peter, address=Address [city=Chennai, state=Tamil Nadu, country=India]]

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

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

Bitbucket Link:
https://bitbucket.org/ramram43210/spring/src/02e04aa1b68a77d4f5a01ebf111e80370bd99ca8/Spring_2018/SpringDemo_Resource_annotation_setter/?at=master

See also:

All JavaEE Videos Playlist

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Kids Tutorial

Cooking Tutorial

Monday, 10 September 2018

Spring Auto-Wiring Beans with @Autowired annotation in setter method | Spring @Autowired Annotation

Master Spring & Java Development!

Subscribe to Ram N Java for clean, beginner-friendly coding guides!

🔔 Subscribe to Ram N Java

Overview: Setter Injection with @Autowired

In the Spring Framework, Dependency Injection can be achieved through multiple mechanisms, including constructor, field, and setter injection. Using the @Autowired annotation on setter methods allows Spring to inject dependencies via traditional JavaBean getter and setter conventions, providing flexibility for optional or reconfigurable dependencies.

In this guide, you will learn how setter-based dependency injection works using @Autowired, how Spring resolves bean dependencies by type, and how to configure it cleanly in your Java applications.

How @Autowired Works on Setter Methods

Applying @Autowired on a setter method follows standard Spring autowiring mechanics:

Injection by Type: Spring inspects the parameter type of the setter method and scans the ApplicationContext for a matching bean.
Encapsulation Preserved: Keeps internal class fields private while exposing standard mutator methods for dependency configuration.
Flexibility & Re-injection: Allows dependencies to be changed, reassigned, or supplied dynamically during unit testing or runtime reconfiguration.
Works with Arbitrary Method Names: Although conventionally used with standard setter methods (e.g., setService(...)), @Autowired can technically be placed on any configuration method with arguments.