Spring（Bean详解）

GoF之工厂模式

GoF是指二十三种设计模式
GoF23种设计模式可分为三大类：

• 创建型（5个）：解决对象创建问题。
  
• 
  
  
  
  • 
    
    
    
    • 单例模式
      
    • 工厂方法模式
      
    • 抽象工厂模式
      
    • 建造者模式
      
    • 原型模式
      
    
    
  
  
• 结构型（7个）：一些类或对象组合在一起的经典结构。
  
• 
  
  
  
  • 
    
    
    
    • 代理模式
      
    • 装饰模式
      
    • 适配器模式
      
    • 组合模式
      
    • 享元模式
      
    • 外观模式
      
    • 桥接模式
      
    
    
  
  
• 行为型（11个）：解决类或对象之间的交互问题。
  
• 
  
  
  
  • 
    
    
    
    • 策略模式
      
    • 模板方法模式
      
    • 责任链模式
      
    • 观察者模式
      
    • 迭代子模式
      
    • 命令模式
      
    • 备忘录模式
      
    • 状态模式
      
    • 访问者模式
      
    • 中介者模式
      
    • 解释器模式
      
    
    
  
  

工厂模式是解决对象创建问题的，所以工厂模式属于创建型设计模式。这里为什么学习工厂模式呢？这是因为Spring框架底层使用了大量的工厂模式。
1.1工厂模式的三种形态

工厂模式通常有三种形态：

• 第一种：简单工厂模式（Simple Factory）：不属于23种设计模式之一。简单工厂模式又叫做静态工厂模式。简单工厂模式是工厂模式的一种特殊实现。
  
• 工厂方法模式（Factory Method）：是二十三种设计模式之一。
  
• 抽象工厂模式（Abstract Factory）：是二十三种设计模式之一。
  

1.2 简单工厂模式

简单工厂模式的角色包括三个：

• 抽象产品：角色
  
• 具体产品：角色
  
• 工厂类：角色
  

代码如下：
抽象产品角色：

1. package com.powernode.factory;
2. ​
3. /**
4. * 武器（抽象产品角色）
5. * @author 耀耀
6. * @version 1.0
7. * @className Weapon
8. * @since 1.0
9. **/
10. public abstract class Weapon {
11.    /**
12.     * 所有的武器都有攻击行为
13.     */
14.    public abstract void attack();
15. }

复制代码

具体产品角色：

1. package com.powernode.factory;
2. ​
3. /**
4. * 坦克（具体产品角色）
5. * @author 耀耀
6. * @version 1.0
7. * @className Tank
8. * @since 1.0
9. **/
10. public class Tank extends Weapon{
11.    @Override
12.    public void attack() {
13.        System.out.println("坦克开炮！");
14.    }
15. }
16. ​

复制代码

1. package com.powernode.factory;
2. ​
3. /**
4. * 战斗机（具体产品角色）
5. * @author 耀耀
6. * @version 1.0
7. * @className Fighter
8. * @since 1.0
9. **/
10. public class Fighter extends Weapon{
11.    @Override
12.    public void attack() {
13.        System.out.println("战斗机投下原子弹！");
14.    }
15. }
16. ​

复制代码

1. package com.powernode.factory;
2. ​
3. /**
4. * 匕首（具体产品角色）
5. * @author 耀耀
6. * @version 1.0
7. * @className Dagger
8. * @since 1.0
9. **/
10. public class Dagger extends Weapon{
11.    @Override
12.    public void attack() {
13.        System.out.println("砍他丫的！");
14.    }
15. }
16. ​

复制代码

工厂类角色：

1. package com.powernode.factory;
2. ​
3. /**
4. * 工厂类角色
5. * @author 耀耀
6. * @version 1.0
7. * @className WeaponFactory
8. * @since 1.0
9. **/
10. public class WeaponFactory {
11.    /**
12.     * 根据不同的武器类型生产武器
13.     * @param weaponType 武器类型
14.     * @return 武器对象
15.     */
16.    public static Weapon get(String weaponType){
17.        if (weaponType == null || weaponType.trim().length() == 0) {
18.            return null;
19.        }
20.        Weapon weapon = null;
21.        if ("TANK".equals(weaponType)) {
22.            weapon = new Tank();
23.        } else if ("FIGHTER".equals(weaponType)) {
24.            weapon = new Fighter();
25.        } else if ("DAGGER".equals(weaponType)) {
26.            weapon = new Dagger();
27.        } else {
28.            throw new RuntimeException("不支持该武器！");
29.        }
30.        return weapon;
31.    }
32. }
33. ​

复制代码

测试程序（客户端程序）：

1. package com.powernode.factory;
2. ​
3. /**
4. * @author 耀耀1
5. * @version 1.0
6. * @className Client
7. * @since 1.0
8. **/
9. public class Client {
10.    public static void main(String[] args) {
11.        Weapon weapon1 = WeaponFactory.get("TANK");
12.        weapon1.attack();
13. ​
14.        Weapon weapon2 = WeaponFactory.get("FIGHTER");
15.        weapon2.attack();
16. ​
17.        Weapon weapon3 = WeaponFactory.get("DAGGER");
18.        weapon3.attack();
19.    }
20. }
21. ​

复制代码

简单工厂模式的优点：

• 客户端程序不需要关心对象的创建细节，需要哪个对象时，只需要向工厂索要即可，初步实现了责任的分离。客户端只负责“消费”，工厂负责“生产”。生产和消费分离。
  

简单工厂模式的缺点：

• 缺点1：工厂类集中了所有产品的创造逻辑，形成一个无所不知的全能类，有人把它叫做上帝类。显然工厂类非常关键，不能出问题，一旦出问题，整个系统瘫痪。
  
• 缺点2：不符合OCP开闭原则，在进行系统扩展时，需要修改工厂类。
  

Spring中的BeanFactory就使用了简单工厂模式。
1.3 工厂方法模式

工厂方法模式既保留了简单工厂模式的优点，同时又解决了简单工厂模式的缺点。
工厂模式的角色包括：

• 抽象工厂角色
  
• 具体工厂角色
  
• 抽象产品角色
  
• 具体产品角色
  

代码如下：

1. package com.powernode.factory;
2. ​
3. /**
4. * 武器类（抽象产品角色）
5. * @author 耀耀
6. * @version 1.0
7. * @className Weapon
8. * @since 1.0
9. **/
10. public abstract class Weapon {
11.    /**
12.     * 所有武器都有攻击行为
13.     */
14.    public abstract void attack();
15. }
16. ​

复制代码

具体产品角色：

1. package com.powernode.factory;
2. ​
3. /**
4. * 具体产品角色
5. * @author 耀耀
6. * @version 1.0
7. * @className Gun
8. * @since 1.0
9. **/
10. public class Gun extends Weapon{
11.    @Override
12.    public void attack() {
13.        System.out.println("开枪射击！");
14.    }
15. }
16. ​

复制代码

抽象工厂角色：

1. package com.powernode.factory;
2. ​
3. /**
4. * 武器工厂接口(抽象工厂角色)
5. * @author 耀耀
6. * @version 1.0
7. * @className WeaponFactory
8. * @since 1.0
9. **/
10. public interface WeaponFactory {
11.    Weapon get();
12. }
13. ​
14. ​

复制代码

具体工厂角色：

1. package com.powernode.factory;
2. ​
3. /**
4. * 具体工厂角色
5. * @author 耀耀
6. * @version 1.0
7. * @className GunFactory
8. * @since 1.0
9. **/
10. public class GunFactory implements WeaponFactory{
11.    @Override
12.    public Weapon get() {
13.        return new Gun();
14.    }
15. }
16. ​

复制代码

具体工厂角色：

1. package com.powernode.factory;
2. ​
3. /**
4. * 具体工厂角色
5. * @author 耀耀
6. * @version 1.0
7. * @className FighterFactory
8. * @since 1.0
9. **/
10. public class FighterFactory implements WeaponFactory{
11.    @Override
12.    public Weapon get() {
13.        return new Fighter();
14.    }
15. }
16. ​

复制代码

客户端程序：

1. package com.powernode.factory;
2. ​
3. /**
4. * @author 耀耀
5. * @version 1.0
6. * @className Client
7. * @since 1.0
8. **/
9. public class Client {
10.    public static void main(String[] args) {
11.        WeaponFactory factory = new GunFactory();
12.        Weapon weapon = factory.get();
13.        weapon.attack();
14. ​
15.        WeaponFactory factory1 = new FighterFactory();
16.        Weapon weapon1 = factory1.get();
17.        weapon1.attack();
18.    }
19. }
20. ​

复制代码

如果想扩展一个新的产品，只要新增一个产品类，再新增一个该产品对应的工厂即可，例如新增：匕首
增加：具体产品角色

1. package com.powernode.factory;
2. ​
3. /**
4. * @author 耀耀
5. * @version 1.0
6. * @className Dagger
7. * @since 1.0
8. **/
9. public class Dagger extends Weapon{
10.    @Override
11.    public void attack() {
12.        System.out.println("砍丫的！");
13.    }
14. }
15. ​

复制代码

增加：具体工厂角色

1. package com.powernode.factory;
2. ​
3. /**
4. * @author 耀耀
5. * @version 1.0
6. * @className DaggerFactory
7. * @since 1.0
8. **/
9. public class DaggerFactory implements WeaponFactory{
10.    @Override
11.    public Weapon get() {
12.        return new Dagger();
13.    }
14. }
15. ​

复制代码

我们可以看到在进行功能扩展的时候，不需要修改之前的源代码，显然工厂方法模式符合OCP原则。
工厂方法模式的优点：

• 一个调用者想创建一个对象，只要知道其名称就可以了。
  
• 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
  
• 屏蔽产品的具体实现，调用者只关心产品的接口。
  

工厂方法模式的缺点：

• 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
  

2，Bean的实例化方式

Spring为Bean提供了多种实例化方式，通常包括4种方式。（也就是说在Spring中为Bean对象的创建准备了多种方案，目的是：更加灵活）
第一种：通过构造方法实例化

默认情况下，会调用Bean的无参数构造方法
第二种：通过简单工厂模式实例化

第一步：定义一个Bean

1. package com.powernode.spring6.bean;
2. ​
3. /**
4. * @author 耀耀
5. * @version 1.0
6. * @className Vip
7. * @since 1.0
8. **/
9. public class Vip {
10. }
11. ​

复制代码

第二步：编写简单工厂模式当中的工厂类

1. package com.powernode.spring6.bean;
2. ​
3. /**
4. * @author 耀耀
5. * @version 1.0
6. * @className VipFactory
7. * @since 1.0
8. **/
9. public class VipFactory {
10.    public static Vip get(){
11.        return new Vip();
12.    }
13. }
14. ​

复制代码

第三步：在Spring配置文件中指定创建该Bean方法（使用factory-method属性指定）

1. [/code]第四步：编写测试程序
2. [code]@Test
3. public void testSimpleFactory(){
4.    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
5.    Vip vip = applicationContext.getBean("vipBean", Vip.class);
6.    System.out.println(vip);
7. }

复制代码

 
第三种：通过factory-bean实例化

这种方式本质上是：通过工厂方法模式经行实例化。
第一步：定义一个Bean

1. package com.powernode.spring6.bean;
2. ​
3. /**
4. * @author 耀耀
5. * @version 1.0
6. * @className Order
7. * @since 1.0
8. **/
9. public class Order {
10. }
11. ​

复制代码

第二步：定义具体工厂类，工厂类中定义实力方法

1. package com.powernode.spring6.bean;
2. ​
3. /**
4. * @author 耀耀
5. * @version 1.0
6. * @className OrderFactory
7. * @since 1.0
8. **/
9. public class OrderFactory {
10.    public Order get(){
11.        return new Order();
12.    }
13. }
14. ​

复制代码

第三步：在Spring配置文件中指定factory-bean以及factory-method

1. [/code]第四步：编写测试程序
2. [code]@Test
3. public void testSelfFactoryBean(){
4.    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
5.    Order orderBean = applicationContext.getBean("orderBean", Order.class);
6.    System.out.println(orderBean);
7. }

复制代码

第四种：通过FactoryBean接口实例化

以上的第三种方式中，factory-bean是我们自定义的，factory-method也是我们自己定义的。
在Spring中，当你编写的类直接实现FactoryBean接口之后，factory-bean不需要指定了，factory-method也不需要指定了。
factory-bean会自动指向实现FactoryBean接口的类，factory-method会自动指向getObject()方法。
第一步：定义一个Bean

1. package com.powernode.spring6.bean;
2. ​
3. /**
4. * @author 耀耀
5. * @version 1.0
6. * @className Person
7. * @since 1.0
8. **/
9. public class Person {
10. }
11. ​

复制代码

第二步：编写一个类实现FactoryBean接口

1. package com.powernode.spring6.bean;
2. ​
3. import org.springframework.beans.factory.FactoryBean;
4. ​
5. /**
6. * @author 耀耀
7. * @version 1.0
8. * @className PersonFactoryBean
9. * @since 1.0
10. **/
11. public class PersonFactoryBean implements FactoryBean<Person> {
12. ​
13.    @Override
14.    public Person getObject() throws Exception {
15.        return new Person();
16.    }
17. ​
18.    @Override
19.    public Class<?> getObjectType() {
20.        return null;
21.    }
22. ​
23.    @Override
24.    public boolean isSingleton() {
25.        // true表示单例
26.        // false表示原型
27.        return true;
28.    }
29. }
30. ​

复制代码

第三步：在Spring配置文件中配置FactoryBean

1. [/code]测试程序
2. [code]@Test
3. public void testFactoryBean(){
4.    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
5.    Person personBean = applicationContext.getBean("personBean", Person.class);
6.    System.out.println(personBean);
7. ​
8.    Person personBean2 = applicationContext.getBean("personBean", Person.class);
9.    System.out.println(personBean2);
10. }

复制代码

FactoryBean在Spring中是一个接口。被称为“工厂Bean”。“工厂Bean”是一种特殊的Bean。所有的“工厂Bean”都是用来协助Spring框架来创建其他Bean对象的
6.5 BeanFactory 和 FactoryBean的区别

BeanFactory
Spring IoC容器的顶级对象，BeanFactory被翻译为“Bean工厂”，在Spring的IoC容器中，"Bean工厂"负责创建Bean对象。
FactoryBean
FactoryBean：它是一个Bean，是一个能够辅助Spring实例化其它Bean对象的一个Bean。
在Spring中，Bean可以分为两类：

• 第一类：普通Bean
  
• 第二类：工厂Bean（记住：工厂Bean也是一种Bean，只不过这种Bean比较特殊，它可以辅助Spring实例化其它Bean对象。）
  

3，Bean的生命周期

3.1 什么是Bean的生命周期

Spring其实就是一个管理Bean对象的工厂。它负责对象的创建，对象的销毁等。
所谓的生命周期就是：对象从创建开始到最终销毁的整个过程。
什么时候创建Bean对象？
创建Bean对象的前后会调用什么方法？
Bean对象什么时候销毁？
Bean对象的销毁前后调用什么方法？
3.2 为什么要知道Bean的生命周期

其实生命周期的本质是：在哪个时间节点上调用了哪个类的哪个方法。
我们需要充分的了解在这个生命线上，都有哪些特殊的时间节点。
只有我们知道了特殊的时间节点都在哪，到时我们才可以确定代码写到哪。
我们可能需要在某个特殊的时间点上执行一段特定的代码，这段代码就可以放到这个节点上。当生命线走到这里的时候，自然会被调用。
3.3 Bean的生命周期之五步

Bean生命周期的管理，可以参考Spring的：AbstractAutowireCapableBeanFactory类的doCreateBean()方法。
Bean生命周期可以粗略的划分为五大步：

• 第一步：实例化Bean
  
• 第二步：Bean属性赋值
  
• 第三步：初始化Bean
  
• 第四步：使用Bean
  
• 第五步：销毁Bean
  

代码测试一下

1. package com.powernode.spring6.bean;
2. ​
3. /**
4. * @author 耀耀
5. * @version 1.0
6. * @className User
7. * @since 1.0
8. **/
9. public class User {
10.    private String name;
11. ​
12.    public User() {
13.        System.out.println("1.实例化Bean");
14.    }
15. ​
16.    public void setName(String name) {
17.        this.name = name;
18.        System.out.println("2.Bean属性赋值");
19.    }
20. ​
21.    public void initBean(){
22.        System.out.println("3.初始化Bean");
23.    }
24. ​
25.    public void destroyBean(){
26.        System.out.println("5.销毁Bean");
27.    }
28. ​
29. }
30. ​

复制代码

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
5. ​
6.    
7.    <bean id="userBean"  init-method="initBean" destroy-method="destroyBean">
8.        <property name="name" value="zhangsan"/>
9.    </bean>
10. ​
11. </beans>

复制代码

测试程序

1. package com.powernode.spring6.test;
2. ​
3. import com.powernode.spring6.bean.User;
4. import org.junit.Test;
5. import org.springframework.context.ApplicationContext;
6. import org.springframework.context.support.ClassPathXmlApplicationContext;
7. ​
8. /**
9. * @author 耀耀
10. * @version 1.0
11. * @className BeanLifecycleTest
12. * @since 1.0
13. **/
14. public class BeanLifecycleTest {
15.    @Test
16.    public void testLifecycle(){
17.        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
18.        User userBean = applicationContext.getBean("userBean", User.class);
19.        System.out.println("4.使用Bean");
20.        // 只有正常关闭spring容器才会执行销毁方法
21.        ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
22.        context.close();
23.    }
24. }
25. ​

复制代码

注意事项：

• 第一：只有正常关闭的spring容器，bean的销毁才会被调用。
  
• 第二：ClassPathXmlApplicationContex类才有ckose（）方法。
  
• 第三：配置文件中的int-method指定初始化方法。destroy-method指定销毁方法。
  

3.4 Bean生命周期之七步走

在以上的5步中，第3步是初始化Bean，如果你还想在初始化前和初始化后添加代码，可以加入“Bean后处理器”。
编写一个类实现BeanPostProcessor类，并且重写before和after方法：

1. package com.powernode.spring6.bean;
2. ​
3. import org.springframework.beans.BeansException;
4. import org.springframework.beans.factory.config.BeanPostProcessor;
5. ​
6. /**
7. * @author 耀耀
8. * @version 1.0
9. * @className LogBeanPostProcessor
10. * @since 1.0
11. **/
12. public class LogBeanPostProcessor implements BeanPostProcessor {
13.    @Override
14.    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
15.        System.out.println("Bean后处理器的before方法执行，即将开始初始化");
16.        return bean;
17.    }
18. ​
19.    @Override
20.    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
21.        System.out.println("Bean后处理器的after方法执行，已完成初始化");
22.        return bean;
23.    }
24. }
25. ​

复制代码

在spring.xml文件中配置“Bean后处理器”：

1. [/code][b]一定要注意：在spring.xml文件中配置的Bean后处理器将作用于当前配置文件中所有的Bean。[/b]
2. [img=1015,170]https://img2023.cnblogs.com/blog/3103434/202304/3103434-20230401121532529-1308575846.png[/img]
4. [size=5]4，Bean的循环依赖问题[/size]
6. [size=4]4.1什么是Bena的循环依赖[/size]
8. A对象中有B属性。B对象中有A属性。这就是循环依赖。我依赖你，你也依赖我。
9. 比如：丈夫类Husband，妻子类Wife。Husband中有Wife的引用。Wife中有Husband的引用。
10. [code]package com.powernode.spring6.bean;
11. ​
12. /**
13. * @author 耀耀
14. * @version 1.0
15. * @className Husband
16. * @since 1.0
17. **/
18. public class Husband {
19.    private String name;
20.    private Wife wife;
21. }
22. ​

复制代码

1. package com.powernode.spring6.bean;
2. ​
3. /**
4. * @author 耀耀
5. * @version 1.0
6. * @className Wife
7. * @since 1.0
8. **/
9. public class Wife {
10.    private String name;
11.    private Husband husband;
12. }
13. ​

复制代码

在singleton + set注入的情况下，循环依赖是没有问题的。Spring可以解决这个问题。
当循环依赖的所有Bean的scope="prototype"的时候，产生的循环依赖，Spring是无法解决的，会出现BeanCurrentlyInCreationException异常。
大家可以测试一下，以上两个Bean，如果其中一个是singleton，另一个是prototype，是没有问题的。
 
构造方法注入会导致**实例化对象的过程和对象属性赋值的过程没有分离开，必须在一起完成导致的。**
 
Spring为什么可以解决set + singleton模式下循环依赖？
根本的原因在于：这种方式可以做到将“实例化Bean”和“给Bean属性赋值”这两个动作分开去完成。
实例化Bean的时候：调用无参数构造方法来完成。此时可以先不给属性赋值，可以提前将该Bean对象“曝光”给外界。
给Bean属性赋值的时候：调用setter方法来完成。
两个步骤是完全可以分离开去完成的，并且这两步不要求在同一个时间点上完成。
也就是说，Bean都是单例的，我们可以先把所有的单例Bean实例化出来，放到一个集合当中（我们可以称之为缓存），所有的单例Bean全部实例化完成之后，以后我们再慢慢的调用setter方法给属性赋值。这样就解决了循环依赖的问题。
那么在Spring框架底层源码级别上是如何实现的呢？请看：


在以上类中包含三个重要的属性：

• *Cache of singleton objects: bean name to bean instance.* 单例对象的缓存：key存储bean名称，value存储Bean对象【一级缓存】
  
• *Cache of early singleton objects: bean name to bean instance.* 早期单例对象的缓存：key存储bean名称，value存储早期的Bean对象【二级缓存】
  
• *Cache of singleton factories: bean name to ObjectFactory.* 单例工厂缓存：key存储bean名称，value存储该Bean对应的ObjectFactory对象【三级缓存】
  

这三个缓存其实本质上是三个Map集合。
我们再来看，在该类中有这样一个方法addSingletonFactory()，这个方法的作用是：将创建Bean对象的ObjectFactory对象提前曝光。


从源码中可以看到，spring会先从一级缓存中获取Bean，如果获取不到，则从二级缓存中获取Bean，如果二级缓存还是获取不到，则从三级缓存中获取之前曝光的ObjectFactory对象，通过ObjectFactory对象获取Bean实例，这样就解决了循环依赖的问题。
总结：
Spring只能解决setter方法注入的单例bean之间的循环依赖。ClassA依赖ClassB，ClassB又依赖ClassA，形成依赖闭环。Spring在创建ClassA对象后，不需要等给属性赋值，直接将其曝光到bean缓存当中。在解析ClassA的属性时，又发现依赖于ClassB，再次去获取ClassB，当解析ClassB的属性时，又发现需要ClassA的属性，但此时的ClassA已经被提前曝光加入了正在创建的bean的缓存中，则无需创建新的的ClassA的实例，直接从缓存中获取即可。从而解决循环依赖问题。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！