工厂模式

1、简单工厂模式

1.1、定义

简单工厂模式（Simple Factory Pattern）是指有一个工厂对象决定创建出哪一种产品类的实例，不属于23种设计模式。

简单工厂是产品的工厂

1.2、应用场景

简单工厂模式适用于工厂类创建的对象较少的场景，且客户端只需要传入工厂参数，对如何创建对象的逻辑不需要关心。

1.3、缺点

工厂类的职责相对过重，增加新的产品时需要修改工厂类的判断逻辑，违背了开闭原则。

不易于扩展过于复杂的产品结构。

1.4、实例

支付接口规范：

public interface IPay {
    void pay();
}

具体实现：

public class AliPay implements IPay {
    @Override
    public void pay() {
        System.out.println("支付宝支付");
    }
}
public class WxPay implements IPay {
    @Override
    public void pay() {
        System.out.println("微信支付");
    }
}
public class BankPay implements IPay {
    @Override
    public void pay() {
        System.out.println("银联支付");
    }
}

工厂：

public class PayFactory {
	// 使用反射机制继承接口规范，从而实现产品创建。
    public IPay create(Class<? extends IPay> clazz) {
        try {
            if (null != clazz) {
                return clazz.newInstance();
            }
        }catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        PayFactory payFactory = new PayFactory();
        IPay pay = payFactory.create(AliPay.class);
        pay.pay();
    }
}

2、工厂方法模式

2.1、定义

工厂方法模式（Factory Method Pattern）是指定义一个创建爱你对象的接口，但让视线这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。

属于创建型设计模式。

解决产品扩展问题。简单工厂模式的升级版本。

工厂方法是工厂的工厂

2.2、应用场景

创建对象需要大量重复的代码。

客户端（应用层）不依赖于产品类实例如何被创建、实现等细节。

一个类通过其子类来制定创建哪个对象。

2.3、优点

用户只需要关心所需产品对应的工厂，无需关心创建细节。

加入新产品符合开闭原则，提高了系统的可扩展性。

2.4、缺点

类个数容易过多，增加了代码结构的复杂度。

增加了系统的抽象性和理解难度。

2.5、实例

支付接口规范：

public interface IPay {
    void pay();
}

具体实现：

public class AliPay implements IPay {
    @Override
    public void pay() {
        System.out.println("支付宝支付");
    }
}
public class WxPay implements IPay {
    @Override
    public void pay() {
        System.out.println("微信支付");
    }
}
public class BankPay implements IPay {
    @Override
    public void pay() {
        System.out.println("银联支付");
    }
}

工厂方法：

public interface IPayFactory {
    IPay create();
}

具体实例工厂：

public class AliPayFactory implements IPayFactory {
    @Override
    public IPay create() {
        return new AliPay();
    }
}
public class WxPayFactory implements IPayFactory {
    @Override
    public IPay create() {
        return new WxPay();
    }
}
public class BankPayFactory implements IPayFactory {
    @Override
    public IPay create() {
        return new BankPay();
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        IPayFactory payFactory = new AliPayFactory();
        IPay pay = payFactory.create();
        pay.pay();
    }
}

3、抽象工厂模式

3.1、定义

抽象工厂模式（Abastract Factory Pattern）是指提供一个创建一系列相关或相互依赖对象的接口，无需指定他们具体的类。

属于创建型设计模式。

产品等级结构与产品族

**产品族：**一系列相关的产品，整合到一起使他们有关联性。

**产品等级：**相同的产品标准（即同一个继承体系），不同的特征区别。

3.2、应乙烯类相关的用场景

客户端（应用层）不依赖与产品类实例如何被创建、实现等细节。

强调一系列相关的产品对象（属于同一产品族）一起使用创建对象。需要大量重复的代码。

提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。

3.3、优点

具体产品在应用层代码隔离，无需关心创建细节

将一个系列的产品族统一到一起创建

3.4、缺点

规定了所有可能被创建的产品集合，产品族中扩展新的产品困难难，需要修改抽象工厂的 接口。

增加了系统的抽象性和理解难度。

数据连接池就是一个经典的工厂模式

3.5、实例

支付和收款接口规范：

public interface IPay {
    void pay();
}
public interface ICollect {
    void collect();
}

具体实现：

public class AliPay implements IPay {
    @Override
    public void pay() {
        System.out.println("支付宝支付");
    }
}
public class WxPay implements IPay {
    @Override
    public void pay() {
        System.out.println("微信支付");
    }
}
public class AliCollect implements ICollect {
    @Override
    public void collect() {
        System.out.println("支付宝到账");
    }
}
public class WxCollect implements ICollect {
    @Override
    public void collect() {
        System.out.println("微信到账");
    }
}

抽象工厂：

public abstract class Factory {
    public void init(){
        System.out.println("打开支付链接");
    }
    public abstract IPAay createPay();
    public abstract ICollect createCollect();

}

工厂实现：

public class AliFactory extends Factory {
    @Override
    public IPAay createPay() {
        return new AliPay();
    }

    @Override
    public ICollect createCollect() {
        return new AliCollect();
    }
}

public class WxFactory extends Factory {
    @Override
    public IPAay createPay() {
        return new WxPay();
    }

    @Override
    public ICollect createCollect() {
        return new WxCollect();
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        Factory factory = new AliFactory();
        factory.init();
        IPAay aliPay = factory.createPay();
        aliPay.pay();
        ICollect aliCollect = factory.createCollect();
        aliCollect.collect();

        Factory wxFactory = new WxFactory();
        wxFactory.init();
        IPAay wxPay = wxFactory.createPay();
        wxPay.pay();
        ICollect wxCollect = factory.createCollect();
        wxCollect.collect();

    }
}

4、总结

简单工厂：产品的工厂

工厂方法：工厂的工厂

抽象工厂：复杂产品的工厂，更关心的使产品族

Spring中的应用：

• AbastractFactory

• AnnotationApplicationContext 等等