Spring创建bean实例的几种方式分享
作者：蓝黑2020 发布时间：2022-02-21 22:08:19
前言
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
<!-- 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>
来源：https://blog.csdn.net/duke_ding2/article/details/125648736
0
投稿猜你喜欢
目录事件最基本的用法理解路由事件WPF中使用路由事件升级了传统应用开发中的事件，在WPF中使用路由事件能更好的处理事件相关的逻辑，我们从这篇- 本文是引用开源图表库框架 MPAndroidChart的LineChart地址：https://github.com/PhilJay/MPA
- 定义广播 * 的Action：private static final String TAG ="SmsService"
- 人机猜拳小游戏，只要用到的java面向对象的思维模式。本游戏中有游戏玩家和计算机两个参与者。玩家和计算机都有的属性是姓名和得分。共分为4个类
- 直接插入排序直接插入排序的思路很容易理解，它是这样的：1.把待排序的数组分成已排序和未排序两部分，初始的时候把第一个元素认为是已排好序的。2
- 首先，我们使用使用命令创建模板项目，创建的命令如下。taro init myApp然后，使用 yarn 或者 npm install安装依赖
- Java常用类包装类由于Java语言中的基本类型不是面向对象，并不具备对象的性质，实际使用存在很多不便。Java在java.lang包中提供
- 简介API Gateway，时系统的唯一对外的入口，介于客户端和服务端之间的中间层，处理非业务功能，提供路由请求，鉴权，监控，缓存，限流等功
- Map是键值对的集合，又叫作字典或关联数组等，是最常见的数据结构之一。在java如何让一个map按value排序呢？ 看似简单，但却不容易！
- RandomAccessFileRandomAccessFile 是随机访问文件(包括读/写)的类。它支持对文件随机访问的读取和写入，即我们
- 本文实例讲述了获取Android系统唯一识别码的方法。分享给大家供大家参考。具体如下：在计算机上，我们习惯用MAC地址来标志一台计算机。在A
- 前言 最近利用空闲时间学习了自定义View的一些知识，为了巩固，写了一个小东西，顺便分享出来，下面话不多说了，来一起看看详细的介绍吧。简介
- 今天在线上发现一个问题，在使用Jackson进行时间的反序列化时，配置的 @JsonFormat 没有生效查看源码发现，Jackson在反序
- 继承JpaRepository,找不到findOne()方法问题：以前一直使用findOne(ID id);，这次用SpringBoot构建
- 简介在多线程中解决线程安全的问题时常用到Synchronized，现在的synchronized相对于早期的synchronized做出了优
- 目录通过Resource接口手动加载通过@Value自动转换通过ResourceLoader加载使用ResourceUtils加载资源读取资
- 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。代码public cla
- 本文实例讲述了C#实现获取程序路径方法。分享给大家供大家参考。具体如下：获取DLL的目录：Assembly myAssembly = Ass
- 前言大家好，我是小郭，前面我们学习了利用Semaphore来防止多线程同时操作一个资源，通常我们都会利用并行来优化性能，但是对于串行化的业务
- 上周五东西都收拾好了，然后被叫住加班，直接搞到凌晨一两点，原因是另一个项目的性能出了点问题。为此我抓包写了一下主业务流的接口，涉及到文件上传
