Spring BeanFactory Interface Example

In this quick article, we will discuss the Spring BeanFactory interface with an example.
BeanFactory interface provides a simple, yet flexible configuration mechanism to manage objects of any nature via the Spring IoC container. Let’s have a look at some basics before diving deep into an example.
Spring beans are the Java objects which form the backbone of a Spring application and are managed by Spring IoC container. Other than being managed by the container, there is nothing special about a bean (in all other respects it’s one of many objects in the application).
The Spring IoC container is responsible for instantiating, configuring, and assembling the beans. The container gets its information on what objects to instantiate, configure, and manage by reading configuration metadata we define for the application.
BeanFactory holds bean definitions and instantiates them whenever asked for by the client application.

Spring BeanFactory Example

In this example, we will supply XML-based configuration metadata to Spring IoC container.

Spring Development Process

Follow these three steps to develop a spring application:
  1. Create a simple Maven Project
  2. Add Maven Dependencies
  3. Configure HellowWorld Spring Beans
  4. Create a Spring Container
  5. Retrieve Beans from Spring Container

1. Create a simple Maven Project

Create a simple maven project using your favorite IDE and refer below diagram for packaging structure. If you are new to maven then read this article How to Create a Simple Maven Project.


2. Add Maven Dependencies

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>net.javaguides.spring</groupId>
 <artifactId>spring-bean-factory-example</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <url>http://maven.apache.org</url>

 <properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 </properties>

 <dependencies>
  <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-context</artifactId>
   <version>5.1.0.RELEASE</version>
  </dependency>

 </dependencies>
 <build>
  <sourceDirectory>src/main/java</sourceDirectory>
  <plugins>
   <plugin>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.5.1</version>
    <configuration>
     <source>1.8</source>
     <target>1.8</target>
    </configuration>
   </plugin>
  </plugins>
 </build>
</project>

3. Configure HelloWorld Spring Beans

Define Spring Bean - HelloWorld.java

Spring beans are Java objects that are managed by the Spring container.
package net.javaguides.spring.ioc;

public class HelloWorld {
    private String message;

    public void setMessage(String message) {
        this.message = message;
    }

    public void getMessage() {
        System.out.println("My Message : " + message);
    }
}

Configuration Metadata - Configure HelloWorld Spring Beans

<?xml version = "1.0" encoding = "UTF-8"?>
<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-3.0.xsd">
   
 <bean id="helloWorld" class="net.javaguides.spring.ioc.HelloWorld">
  <property name="message" value="Hello World!" />
 </bean>
</beans>

4. Create a Spring Container

If we have spring bean configuration XML file in a standalone application, then we can use ClassPathXmlApplicationContext class to load the file and get the container object.
package net.javaguides.spring.ioc;

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

public class Application {
    public static void main(String[] args) {
        XmlBeanFactory factory = new XmlBeanFactory (new ClassPathResource("applicationContext.xml"));
    }
}

5. Retrieve Beans from Spring Container

ApplicationContext interface provides getBean() method to retrieve bean from spring container.
package net.javaguides.spring.ioc;

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

public class Application {
    public static void main(String[] args) {
        XmlBeanFactory factory = new XmlBeanFactory (new ClassPathResource("applicationContext.xml"));
        HelloWorld obj = (HelloWorld) factory.getBean("helloWorld");
 obj.getMessage();
    }
}
The source code of this example is available on my GitHub repository https://github.com/RameshMF/spring-core-tutorial

Free Spring Boot Tutorial | Full In-depth Course | Learn Spring Boot in 10 Hours


Watch this course on YouTube at Spring Boot Tutorial | Fee 10 Hours Full Course

Comments