工厂模式

原文地址 https://www.jianshu.com/p/ec991512f83b

生产对象的一种模式，通过增加一个工厂类使创建产品的时候延迟到子类
工厂模式是理解依赖倒置的法宝，

依赖倒置
1，高层组件不依赖底层组件
2，他们都依赖于抽象

工厂模式里的工厂是高级组件，产品是低级组件，要想建立产品你就需要实现工厂的产品接口，也就是高层组件不依赖底层组件
工厂类和产品类都是依赖，抽象工厂和产品接口的所以他们都是依赖于抽象

工厂模式可分为以下5种
拿女娲造人为例，造人的炉子是工厂，人是产品，分为黑种人，黄种人，白种人

第一种，抽象工厂

抽象工厂类图.png

 

1，首先我们创建抽象工厂
这里使用了泛型，参数传入class字节码用于反射创建产品对象

public abstract class AbstractHumanFactory {
    public abstract <T extends Human> T createHuman(Class<T> c);
}

2，创建人类接口
人类接口有颜色，也可以说话

public interface Human {
    void getColor();
    void talk();
}

3，抽象接口都实现了我们来创建实例了，产品类，三种人如下

public class BlackHuman implements Human{
    @Override
    public void getColor() {
        System.out.println("黑种人");
    }

    @Override
    public void talk() {
        System.out.println("我是黑种人");
    }
}

public class WhiteHuman implements Human{
    @Override
    public void getColor() {
        System.out.println("白种人");
    }

    @Override
    public void talk() {
        System.out.println("我是白种人");
    }
}

public class YellowHuman implements Human{
    @Override
    public void getColor() {
        System.out.println("黄种人");
    }

    @Override
    public void talk() {
        System.out.println("我是黄种人");
    }
}

4，创建工厂类

public class HumanFactory extends AbstractHumanFactory{
    @Override
    public <T extends Human> T createHuman(Class<T> c) {
        Human human = null;
        try {
            human = (T)Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("生成人种错误");
        }
        return (T)human;
    }
}

5，好了准备工作都做完了现在可以调用工厂类生产人类了，如果我们想更换人类只需要更换入参class就可以了，其他位置不需要修改

    public static void main(String[] args){
        AbstractHumanFactory humanFactory = new HumanFactory();
        Human human = humanFactory.createHuman(YellowHuman.class);
        human.getColor();
        human.talk();
    }

---

第二种，简单工厂叫静态工厂更好理解我感觉

他与抽象工厂的区别就是简单工厂不使用抽象类，使用静态方法生成产品，在调用工厂的时候变得简单了，但也失去了开放关闭原则，不好实现扩展
1，抽像产品类同1中
2，产品类同1中
3，去掉抽象工厂类，修改生成产品的工厂类，如下

public class HumanFactory{

    public static <T extends Human> T createHuman(Class<T> c) {
        Human human = null;
        try {
            human = (T)Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("生成人种错误");
        }
        return (T)human;
    }
}

4，调用工厂

public class Main {
    public static void main(String[] args){
        Human human = HumanFactory.createHuman(YellowHuman.class);
        human.getColor();
        human.talk();
    }
}

---

第三种，多工厂

他与抽象工厂的区别是分别生产对应的产品工厂，专门生产黑人的黑人工厂，白人工厂，黄人工厂
1，产品抽象同1
2，产品类同1
3，修改抽象工厂类，去掉入参，因为他的子类都是生成对应的产品了

public abstract class AbstractHumanFactory {
    public abstract Human createHuman();
}

4，生产各个工厂

public class BlackHumanFactory extends AbstractHumanFactory{
    @Override
    public Human createHuman() {
        return new BlackHuman();
    }
}

public class WhiteHumanFactory extends AbstractHumanFactory{
    @Override
    public Human createHuman() {
        return new WhiteHuman();
    }
}

public class YellowHumanFactory extends AbstractHumanFactory{
    @Override
    public Human createHuman() {
        return new YellowHuman();
    }
}

5，调用工厂

public class Main {
    public static void main(String[] args){
        Human human = new YellowHumanFactory().createHuman();
        human.getColor();
        human.talk();
    }
}

我们看大这种方式逻辑比较清晰，但问题是如果我们需要扩展产品类也同时需要扩展工厂类

---

第三种，单例工厂

我们可以通过工厂，反射生成单例类，当然别人也可以反射生成单例，这样就需要组内协商了
1，构造单例类

public class Single {
    private Single(){}

    public void talk() {
        System.out.println("我是Single");
    }

}

2，构造单例工厂

public class SingleFactory {
    private static Single INSTANCE;
    static {
        try {
            Class cl = Class.forName(Single.class.getName());
            //获得构造函数
            Constructor constructor = cl.getDeclaredConstructor();
            //设置无参构造可以访问
            constructor.setAccessible(true);
            //产生一个实例对象
            INSTANCE = (Single) constructor.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Single getInstance(){
        return INSTANCE;
    }
}

3，调用工厂

public class Main {
    public static void main(String[] args){
       SingleFactory.getInstance().talk();
    }
}

这里我们通过反射调用无参构造函数创建了一个单例，这个单例是饿汉式单例

---

第四种，延迟初始化工厂，我觉得这个叫缓存工厂更贴切一点

他是在创建对象的时间将对象存储到map中，在下一次获取对象的时候先在缓存map中取，如果没有在创建对象，一下是代码
1，产品接口同1
2，产品类同1
3，修改工厂类增加map缓存

public class HumanFactory {
    private static final Map<String,Human> humanMap = new HashMap<>();
    public static synchronized Human createHuman(String type){
        Human human = null;
        if (humanMap.containsKey(type)){
            human = humanMap.get(type);
        } else {
            if (type.equals("yellow")){
                human = new YellowHuman();
            } else if (type.equals("black")){
                human = new BlackHuman();
            } else {
                human = new WhiteHuman();
            }
            humanMap.put(type,human);
        }
        return human;
    }
}

4，调用工厂

public class Main {
    public static void main(String[] args){
        Human human1 = pattern.factory.five.HumanFactory.createHuman("yellow");
        human1.getColor();
        human1.talk();
        Human human2 = pattern.factory.five.HumanFactory.createHuman("yellow");
        human2.getColor();
        human2.talk();
        Human human3 = pattern.factory.five.HumanFactory.createHuman("yellow");
        human3.getColor();
        human3.talk();  
    }
}