Spring创建bean实例的几种方式分享

2024-12-04 11:07:46

前言

Spring常见的创建bean实例的方式有：

1.通过bean的class属性创建实例

无参构造器
带参构造器

2.工厂方法

静态工厂方法
实例工厂方法

3.工厂bean

关于每种方式的Spring配置，详见文末总结。

环境

Ubuntu 22.04
IntelliJ IDEA 2022.1.3
JDK 17.0.3
Spring 5.3.21 准备

创建Maven项目 test0705 。

修改 pom.xml 文件，添加依赖：

        ......
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.21</version>
        </dependency>
        ......

在 src/main/resources 目录下创建 applicationContext.xml 文件：

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

</beans>

在 src/test/java 目录下创建测试：

public class Test0705 {
}

通过bean的class属性创建实例（无参构造器）

注：这是最常见的创建bean的方式。我其它文档也用过相似代码。如果已熟悉可直接略过。

创建如下POJO：

Axe ：Axe接口；
StoneAxe ：Axe实现类；
SteelAxe ：Axe实现类；
Person ：Person持有Axe；

package pojo;

public interface Axe {
    public void chop();
}

package pojo;
public class StoneAxe implements Axe{
    public StoneAxe() {
        System.out.println("StoneAxe constructor");
    }
    @Override
    public void chop() {
        System.out.println("Stone axe!");
    }
}

package pojo;
public class SteelAxe implements Axe{
    public SteelAxe() {
        System.out.println("SteelAxe constructor");
    }

    @Override
    public void chop() {
        System.out.println("Steel axe!");
    }
}

package pojo;
public class Person {
    private String name;
    private Axe axe;
    public void setAxe(Axe axe) {
        this.axe = axe;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Person() {
        System.out.println("Person constructor");
    }
    public void useAxe() {
        System.out.println("I am " + name);
        axe.chop();
    }
}

在 applicationContext.xml 中注册bean：

    ......
    <bean id="stoneAxe" class="pojo.StoneAxe"/>
    <bean id="steelAxe" class="pojo.SteelAxe"/>
    <bean id="person" class="pojo.Person">
        <property name="name" value="Tom"/>
        <property name="axe" ref="stoneAxe"/>
    </bean>
    ......

创建测试用例：

    @Test
    public void test1() {
        var ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("before getBean person");
        var person = ctx.getBean("person", Person.class);
        person.useAxe();
    }

运行测试，如下：

StoneAxe constructor
SteelAxe constructor
Person constructor
before getBean person
I am Tom
Stone axe!

通过bean的class属性创建实例（带参构造器）

注：这是较为常见的创建bean的方式。我其它文档也用过相似代码。如果已熟悉可直接略过。

创建如下POJO：

Book ：Book接口；
PlayBook ：Book实现类；
StudyBook ：Book实现类；
Student ：Student持有Book；

package pojo;
public interface Book {
    public void show();
}

package pojo;
public class PlayBook implements Book{
    public PlayBook() {
        System.out.println("PlayBook constructor");
    }

    @Override
    public void show() {
        System.out.println("Play book!");
    }
}

package pojo;
public class StudyBook implements Book{
    public StudyBook() {
        System.out.println("StudyBook constructor");
    }

    @Override
    public void show() {
        System.out.println("Study book!");
    }
}

package pojo;

public class Student {
    private String name;
    private Book book;
    public Student(String name, Book book) {
        System.out.println("Student constructor");
        this.name = name;
        this.book = book;
    }
    public void readBook() {
        System.out.println("I am " + name);
        book.show();
    }
}

在 applicationContext.xml 中注册bean：

    ......
    <bean id="playBook" class="pojo.PlayBook"/>
    <bean id="studyBook" class="pojo.StudyBook"/>
    <bean id="student" class="pojo.Student">
        <constructor-arg index="0" value="Jerry"/>
        <constructor-arg index="1" ref="playBook"/>
    </bean>
    ......

创建测试用例：

    @Test
    public void test2() {
        var ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("before getBean student");
        var student = ctx.getBean("student", Student.class);
        student.readBook();
    }

运行测试，如下：

......
PlayBook constructor
StudyBook constructor
Student constructor
before getBean student
I am Jerry
Play book!

工厂方法（静态工厂方法）

配置：

class 属性指向静态工厂类
factory-method 属性指向静态工厂方法

注：如果静态工厂方法需要参数，则通过 constructor-arg 来指定。

例如：

    <bean id="dog" class="factory.AnimalFactory" factory-method="getAnimal">
        <constructor-arg value="dog"/>
        <property name="name" value="Snoopy"/>
    </bean>

当调用 ctx.getBean("dog") 时，Spring会调用 AnimalFactory 类的静态方法 getAnimal() ，并传入参数 "dog"，创建一个Animal的实例并返回。

注：同普通的bean一样，其默认scope是 singleton ，多次调用 ctx.getBean("dog") 返回的是同一个实例（在Spring初始化时生产bean）。

完整例子如下：

创建如下POJO：

Animal ：Animal接口；
Dog ：Animal实现类；
Cat ：Animal实现类；

package pojo;

public interface Animal {
    public void cry();
}

package pojo;
public class Dog implements Animal{
    private String name;

    public void setName(String name) {
        this.name = name;
    }
    public Dog() {
        System.out.println("Dog constructor");
    }
    @Override
    public void cry() {
        System.out.println("I am " + name);
        System.out.println("Wang wang...");
    }
}

package pojo;
public class Cat implements Animal{
    private String name;

    public void setName(String name) {
        this.name = name;
    }
    public Cat() {
        System.out.println("Cat constructor");
    }
    @Override
    public void cry() {
        System.out.println("I am " + name);
        System.out.println("Miao Miao...");
    }
}

创建工厂类 AnimalFactory ：

package factory;

import pojo.Animal;
import pojo.Cat;
import pojo.Dog;
public class AnimalFactory {
    public static Animal getAnimal(String type) {
        System.out.println("creating new Animal object");
        if (type.equalsIgnoreCase("dog")) {
            return new Dog();
        } else if (type.equalsIgnoreCase("cat")) {
            return new Cat();
        } else {
            return null;
        }
    }
}

在 applicationContext.xml 中注册bean：

    <bean id="dog" class="factory.AnimalFactory" factory-method="getAnimal">
        <constructor-arg value="dog"/>
        <property name="name" value="Snoopy"/>
    </bean>

    <bean id="cat" class="factory.AnimalFactory" factory-method="getAnimal">
        <constructor-arg value="cat"/>
        <property name="name" value="Kitty"/>
    </bean>

创建测试用例：

    @Test
    public void test3() {
        var ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        System.out.println("before getBean dog cat");

        var animal1 = ctx.getBean("dog", Animal.class);
        animal1.cry();

        var animal2 = ctx.getBean("cat", Animal.class);
        animal2.cry();
    }

运行测试，如下：

creating new Animal object
Dog constructor
creating new Animal object
Cat constructor
before getBean dog cat
I am Snoopy
Wang wang...
I am Kitty
Miao Miao...

工厂方法（实例工厂方法）

实例工厂方法跟静态工厂方法很相像，主要区别是：

静态工厂方法：不用实例化工厂，只需直接调用工厂类的静态工厂方法；
实例工厂方法：工厂方法不是静态的，因此需要通过 factory-bean 来指定工厂类的实例。

比如：

    <bean id="fruitFactory" class="factory.FruitFactory"/>

    <bean id="apple" factory-bean="fruitFactory" factory-method="getFruit">
        <constructor-arg value="apple"/>
        <property name="name" value="Fuji"/>
    </bean>

其它都一样。

完整例子如下：

创建如下POJO：

Fruit ：Fruit接口；
Apple ：Fruit实现类；
Banana ：Fruit实现类；

package pojo;

public interface Fruit {
    public void describe();
}

package pojo;

public class Apple implements Fruit {
    private String name;

    public void setName(String name) {
        this.name = name;
    }
    public Apple() {
        System.out.println("Apple constructor");
    }
    @Override
    public void describe() {
        System.out.println("I am " + name);

        System.out.println("Juicy!");
    }
}

package pojo;
public class Banana implements Fruit {
    private String name;

    public void setName(String name) {
        this.name = name;
    }
    public Banana() {
        System.out.println("Banana constructor");
    }
    @Override
    public void describe() {
        System.out.println("I am " + name);

        System.out.println("Sweet!");
    }
}

创建工厂类 FruitFactory ：

package factory;

import pojo.Apple;
import pojo.Banana;
import pojo.Fruit;

public class FruitFactory {
    public Fruit getFruit(String type) {
        System.out.println("creating new Fruit object");

        if (type.equalsIgnoreCase("apple")) {
            return new Apple();
        } else if (type.equalsIgnoreCase("banana")) {
            return new Banana();
        } else {
            return null;
        }
    }
}

在 applicationContext.xml 中注册bean：

    ......
    <bean id="fruitFactory" class="factory.FruitFactory"/>

    <bean id="apple" factory-bean="fruitFactory" factory-method="getFruit">
        <constructor-arg value="apple"/>
        <property name="name" value="Fuji"/>
    </bean>

    <bean id="banana" factory-bean="fruitFactory" factory-method="getFruit">
        <constructor-arg value="banana"/>
        <property name="name" value="Pisang"/>
    </bean>
    ......

创建测试用例：

    @Test
    public void test4() {
        var ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("before getBean apple banana");
        var fruit1 = ctx.getBean("apple", Fruit.class);
        fruit1.describe();
        var fruit2 = ctx.getBean("banana", Fruit.class);
        fruit2.describe();
    }

运行测试，如下：

creating new Fruit object
Apple constructor
creating new Fruit object
Banana constructor
before getBean apple banana
I am Fuji
Juicy!
I am Pisang
Sweet!

工厂bean

工厂bean是指实现了 FactoryBean 接口的类。

FactoryBean 接口有3个方法：

T getObject() throws ：创建产品实例；
Class<?> getObjectType() ：获取产品的类；
default boolean isSingleton() {return true;} ：是否单例，默认值为true；

实现 FactoryBean 接口，则无需再配置 factory-method ，Spring知道如何创建产品（通过 getObject() 方法）。

比如：

    <bean id="benz" class="factory.CarFactoryBean">
        <property name="type" value="benz"/>
    </bean>

注意：该配置看起来很像普通的bean，实际上因为 CarFactoryBean 实现了 FactoryBean 接口，当调用 ctx.getBean("benz") 方法时，返回的并不是 CarFactoryBean 的实例，而是其 getObject() 方法的返回值。

注：默认scope是 singleton ，多次调用 ctx.getBean("dog") 返回的是同一个实例。如果在 CarFactoryBean 中override isSingleton() 方法并返回false，则每次调用ctx.getBean("benz") 返回的是不同对象。

注：工厂bean跟其它bean有一点不同，即使是singleton，它也不是在Spring初始化时生产bean，而是在第一次调用 ctx.getBean() 时才生产bean。

完整例子如下：

创建如下POJO：

Car ：Car接口；
Benz ：Car实现类；
Audi ：Car实现类；

package pojo;

public interface Car {
    public void run();
}

package pojo;
public class Benz implements Car{
    public Benz() {
        System.out.println("Benz constructor");
    }
    @Override
    public void run() {
        System.out.println("Go go go!");
    }
}

package pojo;
public class Audi implements Car{
    public Audi() {
        System.out.println("Audi constructor");
    }
    @Override
    public void run() {
        System.out.println("OOOO");
    }
}

创建工厂类 FactoryBean ：

package factory;

import org.springframework.beans.factory.FactoryBean;
import pojo.Audi;
import pojo.Benz;
import pojo.Car;

public class CarFactoryBean implements FactoryBean {
    private String type;

    public void setType(String type) {
        this.type = type;
    }
    @Override
    public Object getObject() throws Exception {
        System.out.println("creating new Car object");
        if (type.equalsIgnoreCase("benz")) {
            return new Benz();
        } else if (type.equalsIgnoreCase("audi")) {
            return new Audi();
        } else return null;
    }
    @Override
    public Class<?> getObjectType() {
        return Car.class;
    }
}

在 applicationContext.xml 中注册bean：

    ......
    <bean id="benz" class="factory.CarFactoryBean">
        <property name="type" value="benz"/>
    </bean>

    <bean id="audi" class="factory.CarFactoryBean">
        <property name="type" value="audi"/>
    </bean>
    ......

创建测试用例：

    @Test
    public void test5() {
        var ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        System.out.println("before getBean benz audi");
        var car1 = ctx.getBean("benz", Car.class);
        car1.run();

        var car2 = ctx.getBean("audi", Car.class);
        car2.run();
    }

运行测试，如下：

before getBean benz audi
creating new Car object
Benz constructor
Go go go!
creating new Car object
Audi constructor
OOOO

总结

    ......
    <!-- 通过bean的class属性创建bean实例（无参构造器） -->
    <bean id="stoneAxe" class="pojo.StoneAxe"/>
    <bean id="steelAxe" class="pojo.SteelAxe"/>
    <bean id="person" class="pojo.Person">
        <property name="name" value="Tom"/>
        <property name="axe" ref="stoneAxe"/>
    </bean>
    <!-- 通过bean的class属性创建bean实例（带参构造器） -->
    <bean id="playBook" class="pojo.PlayBook"/>
    <bean id="studyBook" class="pojo.StudyBook"/>
    <bean id="student" class="pojo.Student">
        <constructor-arg index="0" value="Jerry"/>
        <constructor-arg index="1" ref="playBook"/>
    </bean>
    <!-- 通过静态工厂方法创建bean实例 -->
    <bean id="dog" class="factory.AnimalFactory" factory-method="getAnimal">
        <constructor-arg value="dog"/>
        <property name="name" value="Snoopy"/>
    </bean>

    <bean id="cat" class="factory.AnimalFactory" factory-method="getAnimal">
        <constructor-arg value="cat"/>
        <property name="name" value="Kitty"/>
    </bean>
    <!-- 通过实例工厂方法创建bean实例 -->
    <bean id="fruitFactory" class="factory.FruitFactory"/>
    <bean id="apple" factory-bean="fruitFactory" factory-method="getFruit">
        <constructor-arg value="apple"/>
        <property name="name" value="Fuji"/>
    </bean>
    <bean id="banana" factory-bean="fruitFactory" factory-method="getFruit">
        <constructor-arg value="banana"/>
        <property name="name" value="Pisang"/>
    </bean>
    <!-- 通过工厂bean创建bean实例 -->
    <bean id="benz" class="factory.CarFactoryBean">
        <property name="type" value="benz"/>
    </bean>
    <bean id="audi" class="factory.CarFactoryBean">
        <property name="type" value="audi"/>
    </bean>
    ......

此外，有几点说明：

使用工厂bean来管理的bean，即使scope是 singleton ，也并不是在Spring初始化时生产对象的，而是在第一次调用 ctx.getBean() 方法时生产的。

Spring整合MyBatis，使用了 SqlSessionFactoryBean 、 MapperFactoryBean ，这两个就是工厂bean，它们实现了 FactoryBean 接口。前者生产 SqlSessionFactory ，后者生产 Mapper 。比如：

    <!-- sqlSessionFactory -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--        <property name="configLocation" value="classpath:mybatis-config.xml"/>-->
        <property name="mapperLocations" value="classpath:dao/*.xml"/>
        <property name="transactionFactory">
            <bean class="org.apache.ibatis.transaction.managed.ManagedTransactionFactory" />
        </property>
    </bean>
    <bean id="myMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
        <property name="mapperInterface" value="dao.MyMapper" />
        <property name="sqlSessionFactory" ref="sqlSessionFactory" />
    </bean>

到此这篇关于Spring创建bean实例的几种方式分享的文章就介绍到这了,更多相关Spring创建bean 内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

Spring如何使用注解的方式创建bean

这篇文章主要介绍了Spring如何使用注解的方式创建bean,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下第一种使用配置类的方式 1.创建一个bean package com.springbean; public class Person { private String name; private Integer age ; public Person(String name, Integer age) { this.name = name
Spring创建bean对象三种方式代码实例

一.使用无参构造方法创建二.使用静态工厂创建三.使用实例工厂创建以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们.
JavaBean和SpringBean的区别及创建SpringBean方式

目录一:对象,JavaBean,SpringBean的区别 1.什么是JavaBean 2.什么是SpringBean 3.SpringBean和JAVABean的区别二:如何定义一个SpringBean 1.通过ClassPathXmlApplicationContext 2.通过AnnotationConfigApplicationContext底层 3.通过BeanDefinition 4.通过FactoryBean 5.通过Supplier 一:对象,JavaBean,SpringB
Spring框架通过工厂创建Bean的三种方式实现

工厂模式 Spring中bean的创建,默认是框架利用反射new出来的bean实例.有时候也会有一些复杂的情况. 假设有一个飞机,属性如下,现在需要造很多同型号的飞机,那么唯一需要改变的属性只有DriverName(机长姓名),此时可以使用工厂模式帮我们创建对象,有一个专门帮我们创建对象的类帮我们创建对象,这个类就叫工厂. public class AirPlane { private String DriverName;// 机长姓名 private String AirPlaneName;/
Spring-Bean创建对象的步骤方式详解

1.通过无参构造函数创建(默认) 2.通过有参构造创建 1.constructor 的index赋值 <bean id="user" class="com.c.pojo.user"> <constructor-arg index= 0 value=" "> </bean> 2.constructor 的 type 方式: <bean id="user" class="com.
Spring创建Bean的6种方式详解

前言本文讲解了在Spring 应用中创建Bean的多种方式,包括自动创建,以及手动创建注入方式,实际开发中可以根据业务场景选择合适的方案. 方式1: 使用Spring XML方式配置,该方式用于在纯Spring 应用中,适用于简单的小应用,当应用变得复杂,将会导致XMl配置文件膨胀 ,不利于对象管理. <bean id="xxxx" class="xxxx.xxxx"/> 方式2: 使用@Component,@Service,@Controler,@R
Spring创建bean实例的几种方式分享

目录前言环境通过bean的class属性创建实例(带参构造器) 工厂方法(静态工厂方法) 工厂方法(实例工厂方法) 工厂bean 总结前言 Spring常见的创建bean实例的方式有: 1.通过bean的class属性创建实例无参构造器带参构造器 2.工厂方法静态工厂方法实例工厂方法 3.工厂bean 关于每种方式的Spring配置,详见文末总结. 环境 Ubuntu 22.04 IntelliJ IDEA 2022.1.3 JDK 17.0.3 Spring 5.3.21 准备
详解Spring中bean实例化的三种方式

今天我想来说说如何通过xml配置来实例化bean,其实也很简单. 使用xml配置来实例化bean共分为三种方式,分别是普通构造方法创建.静态工厂创建.实例工厂创建,OK,那么接下来我们来分别看看这几种方式. 普通构造方法创建这种创建方式使我们使用最多的一种创建方式,直接配置bean节点即可,比如我有一个User类,如下: public class User { public void add() { System.out.println("add()---------"); } }
Spring中集成Groovy的四种方式(小结)

groovy是一种动态脚本语言,适用于一些可变.和规则配置性的需求,目前Spring提供ScriptSource接口,支持两种类型,一种是 ResourceScriptSource,另一种是 StaticScriptSource,但是有的场景我们需要把groovy代码放进DB中,所以我们需要扩展这个. ResourceScriptSource:在 resources 下面写groovy类 StaticScriptSource:把groovy类代码放进XML里 DatabaseScriptSour
详析Spring中依赖注入的三种方式

前言平常的java开发中,程序员在某个类中需要依赖其它类的方法,则通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理,spring提出了依赖注入的思想,即依赖类不由程序员实例化,而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中.依赖注入的另一种说法是"控制反转",通俗的理解是:平常我们new一个实例,这个实例的控制权是我们程序员,而控制反转是指new实例工作不由我们程序员来做而是交给spring容器来做. 在Sprin
在AOP中Spring生成代理类的两种方式

Java 动态代理.具体有如下四步骤: 通过实现 InvocationHandler 接口创建自己的调用处理器: 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类: 通过反射机制获得动态代理类的构造函数,其唯一参数类型是调用处理器接口类型: 通过构造函数创建动态代理类实例,构造时调用处理器对象作为参数被传入. 在AOP中,Spring通过生成代理类,来完成切面的织入. Spring生成代理类有2种方式. 如果目标对象实现的是一个接口,Sprin
Spring创建Bean的过程Debug的详细流程

Spring流程Debug 1.1 Spring测试环境搭建 Spring模块概览,绿色是模块,Spring中八大模块,黑色表示该模块包含的jar包(组件).例如我们想要用IOC容器,也就是绿色的CoreContainer,我们需要导入Beans,Core,Context,SpEL(spring-expression)四个包. Test:测试相关 Core Container:IOC容器 AOP:面向切面编程 Aspects:切面 Instrumenttation:跟JDK关联,一般不用 Mes
Spring Security添加验证码的两种方式小结

目录一.自定义认证逻辑二.自定义过滤器总结一.自定义认证逻辑生成验证码工具 <dependency> <groupId>com.github.penggle</groupId> <artifactId>kaptcha</artifactId> <version>2.3.2</version> </dependency> 添加Kaptcha配置 @Configuration public class K
Spring框架实现AOP的两种方式详解

目录第一种AOP实现方式 AfterLog Log 配置文件实例调用定义接口第二种AOP实现方式第一种AOP实现方式 AfterLog package com.xxx.demo.service1; import org.junit.After; import org.springframework.aop.AfterReturningAdvice; import java.lang.reflect.Method; public class AfterLog implements Aft
Spring创建Bean的生命周期详析

目录 1.Bean 的创建生命周期 2.Spring AOP 大致流程 3.Spring 事务 4.Spring 源码阅读前戏 BeanDefinition BeanDefinitionReader AnnotatedBeanDefinitionReader XmlBeanDefinitionReader ClassPathBeanDefinitionScanner BeanFactory ApplicationContext AnnotationConfigApplicationContext
spring boot 注入 property的三种方式（推荐）

以前使用spring的使用要注入property要配置PropertyPlaceholder的bean对象.在springboot除了这种方式以外还可以通过制定配置ConfigurationProperties直接把property文件的属性映射到当前类里面. @ConfigurationProperties(prefix = "mypro", merge = true, locations = { "classpath:my.properties" })

Spring创建bean实例的几种方式分享

目录

前言

环境

通过bean的class属性创建实例（带参构造器）

工厂方法（静态工厂方法）

工厂方法（实例工厂方法）

工厂bean

总结

相关推荐

随机推荐