bean的作用域

ioc容器默认bean是单例的（singleton）。

bean对象的创建是在初始化上下文的时候就创建了，每一次调用getBean()时，都返回那个单例对象。

// 这行代码会创建配置里面的bean对象
ApplicationContext context = new FileSystemXmlApplicationContext("D:/applicationContext.xml");

那如何把bean设置成多例的？

// 由于这个bean是多例模式，这行代码不会创建bean对象。而是在调用getBean（）时创建对象
ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml","spring-dao.xml");
// 这行代码才会创建bean对象
Object user=  context.getBean("sb");

自定义scope

自定义Scope（实现Scope接口）
- spring内置了线程范围类： org.springframework.context.support.SimpleThreadScope
添加配置信息

GoF之工厂模式

工厂模式的三种形态

简单工厂模式（Simple Factory）：又叫静态工厂方法模式。是工厂方法模式的一种特殊实现。
工厂方法模式（Factory Method）
抽象工厂模式（Abstract Factory）

简单工厂模式

简单工厂模式包括三个角色：抽象产品、具体产品、工厂类。代码如下：

抽象产品类

// 抽象产品角色
public abstract class Weapon {
	public abstract void attack();
}

具体产品

// 具体产品角色：匕首
public class Dagger extends Weapon{
    @Override
    public void attack() {
        System.out.println("匕首攻击...");
    }
}

// 具体产品角色：战斗机
public class Fighter extends Weapon{
    @Override
    public void attack() {
        System.out.println("战斗机攻击...");
    }
}

// 具体产品角色：坦克
public class Tank extends Weapon{
    @Override
    public void attack() {
      System.out.println( "坦克攻击。。。");
    }
}

工厂类角色

// 工厂类角色
public class WeaponFactory {
    /**
     * 静态方法：根据传入的参数获取相应的武器
     * @return
     */
    public static Weapon get(String type){
        switch (type){
            case "Tank":
                return new Tank();
            case "Fighter":
                return new Fighter();
            case "Dagger":
                return new Dagger();
            default:
                return null;
        }
    }
}

测试代码：

public class Main {
    public static void main(String[] args) {
        // 简单工厂模式达到职责分离。客户端不关心产品生产的细节
        // 客户端只负责消费，工厂类负责生产。这就是简单工厂模式的作用。
        Weapon weapon1 = WeaponFactory.get("Tank");
        weapon1.attack();
        Weapon weapon2 = WeaponFactory.get("Fighter");
        weapon2.attack();
        Weapon weapon3 = WeaponFactory.get("Dagger");
        weapon3.attack();
    }
}

优缺点：

优点：实现职责分离。

缺点：假如要添加新产品。需要修改工厂类代码。显然违反了ocp原则。

工厂类责任重大。一旦瘫痪，这个系统必然瘫痪。

工厂方法模式

工厂方法模式保留了简单工厂模式的优点。同时解决了简单工厂模式的缺点。

解决方法是：一个工厂对应一个产品。符合ocp原则。

优点：扩展性高。要想增加一个产品。只要扩展一个工厂类就可以。

	屏蔽产品具体实现。调用者只关心产品的接口。

缺点：会使类的数量成倍增加，增加系统复杂度。

工厂方法模式的角色包括：

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

代码如下：

// 抽象产品角色
public abstract class Weapon {
    public abstract void attack();
}

// 具体产品角色：匕首
public class Dagger extends Weapon {
    @Override
    public void attack() {
        System.out.println("匕首攻击...");
    }
}

// 具体工厂类：枪械工厂
public class GunFactory extends WeaponFactory{
    @Override
    public Weapon get() {
        return new Gun();
    }
}

// 抽象工厂类
public abstract class WeaponFactory {

    public abstract Weapon get();
}

// 具体工厂类：匕首工厂
public class DaggerFactory extends WeaponFactory{
    @Override
    public Weapon get() {
        return new Dagger();
    }
}

// 具体工厂类：枪械工厂
public class GunFactory extends WeaponFactory{
    @Override
    public Weapon get() {
        return new Gun();
    }
}

测试代码：

public static void main(String[] args) {
    WeaponFactory weaponFactory = new DaggerFactory();
    Weapon dagger = weaponFactory.get();
    dagger.attack();

    WeaponFactory weaponFactory1 = new GunFactory();
    Weapon gun = weaponFactory1.get();
    gun.attack();
}

bean的实例化

spring为bean提供了多种实例化的方式，通常包括4种方式。

通过构造方法实例化
通过简单工厂模式实例化
通过factory-bean实例化
通过FactoryBean接口实例化

通过构造方法实例化

通过简单工厂模式实例化

// 工厂类
public class StarFactory {
    public static Star createStar() {
        return new Star();
    }
}

通过factory-bean实例化

// 工厂方法模式中的具体产品类
public class Gun {
    public Gun() {
        System.out.println("无参数构造器：Gun()");
    }
}

// 工厂方法模式中的具体工厂类
public class GunFactory {
    public Gun get(){
        return new Gun();
    }
}

通过FactoryBean接口实例化

通过factory-bean实例化的方式需要我们自定义factory-bean和factory-method。

在spring中，当自己的类实现了FactoryBean接口后factory-bean和factory-method就不需要指定了。factory-bean会自动指向实现FactoryBean接口的类，factory-method会自动指向getObject()方法。

public class PersonFactoryBean implements FactoryBean {
    @Override
    public Person getObject() throws Exception {
        // 手动创建对象
        return new Person();
    }

    @Override
    public Class getObjectType() {
        return null;
    }

}

BeanFactory和FactoryBean的区别

BeanFactory：spring ioc容器的顶级对象，负责创建bean对象。BeanFactory是工厂

FactoryBean：本质是一个bean。能够辅助spring实例化其他bean对象。

spring6-工厂设计模式与bean的实例化方式