JAVA EE: Spring bean java based configuration using @Configuration and @Bean[employee constructor]

Monday, 29 October 2018

Spring bean java based configuration using @Configuration and @Bean[employee constructor]

🚀 Master Java-Based Spring Configuration!

Subscribe to Ram N Java for clean Java tutorials, Spring framework integrations, and step-by-step code demonstrations!

🔔 Subscribe to Ram N Java

Understanding Spring Java-Based Configuration

In modern enterprise Spring applications, configuring components programmatically using Java classes has become the industry standard over traditional XML files. With Spring JavaConfig, developers define application beans using standard Java classes annotated with @Configuration and methods marked with @Bean. This tutorial walks through creating and managing an Employee bean directly within a pure Java configuration class.

Core Annotations Explained

@Configuration: Designates a Java class as a configuration source for the Spring IoC container, containing methods that generate and configure beans.
@Bean: Marks a factory method that Spring calls to instantiate, configure, and register a bean inside the application context. By default, the bean name matches the method name.
POJO (Plain Old Java Object): Standard model classes like Employee containing member variables, constructors, and accessor methods that Spring manages effortlessly.

Step-by-Step Implementation Flow

Define the Employee POJO: Create an Employee class with appropriate properties (such as id and name) along with getter and setter methods.
Build the Configuration Class: Annotate a class (e.g., AppConfig) with @Configuration to indicate it provides bean definitions.
Declare the @Bean Method: Add a public method returning an Employee instance annotated with @Bean, instantiating the object via new Employee().
Bootstrap the IoC Container: Initialize the container using new AnnotationConfigApplicationContext(AppConfig.class) to load all defined beans.
Retrieve and Utilize Bean: Use context.getBean(Employee.class) to retrieve the managed instance and execute business logic.

Why Choose Java-Based Configuration?

Type Safety: Catch configuration errors and mismatched types at compile time rather than facing runtime exceptions.
Seamless IDE Support: Enjoy complete code completion, navigation, and automated refactoring tools directly inside your IDE.
Eliminate XML Overhead: No need to maintain verbose, brittle XML configuration files across large codebases.

Recommended Next Videos

Continue mastering Spring JavaConfig and bean management with these related tutorials from our channel:

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

Click the below Image to Enlarge:

Spring bean java based configuration using @Configuration and @Bean[employee constructor]

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 int id;

    private String name;

    public Employee(int id, String name)

    {

        System.out.println("Employee(int id, String name) constructor "

                + "is called by the Spring container");

        this.id = id;

        this.name = name;

    }

    public void displayEmployeeDetails()

    {

        System.out.println("Employee [id=" + id + ", name=" + name + "]");

    }

}

ApplicationBeans.java

package com.ram.config;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import com.ram.model.Employee;

/**

 * Annotate with @Configuration to tell Spring that this is the core

 * Spring configuration file, and define bean via @Bean.

 */

@Configuration

public class ApplicationBeans

{

    @Bean(name = "employee")

    public Employee getEmployee()

    {

        return new Employee(36,"Peter");

    }

}

App.java

package com.ram.core;

import org.springframework.context.ApplicationContext;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.ram.config.ApplicationBeans;

import com.ram.model.Employee;

public class App

{

    public static void main(String[] args)

    {

        ApplicationContext context = new AnnotationConfigApplicationContext(

                ApplicationBeans.class);

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

        Employee employee = (Employee) context.getBean("employee");

        System.out.println(

                "Got employee object from the ApplicationContext(Spring Container)");

        employee.displayEmployeeDetails();

    }

}

Output

Sep 30, 2018 10:47:21 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh

INFO: Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@5f4da5c3: startup date [Sun Sep 30 10:47:21 IST 2018]; root of context hierarchy

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

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

Got employee object from the ApplicationContext(Spring Container)

Employee [id=36, name=Peter]