设计模式08---设计模式之抽象工厂模式(Abstract Factory)

1.场景模拟

举个生活中常见的例子：组装电脑，我们在组装电脑的时候，通常要选择一系列的配件，比如选择CPU时候，需要注意品牌，型号，针脚数目，主频，只有这些都确定下来，才能确定一个CPU。同样，主板也是这样的。对于装机工程师而言，他只知道装一台电脑需要使用相应的配件，具体的配件，还是由客户说了算。

2.一般的解决方案（简单工厂）

2.1CPU接口

package demo06.abstractfactory.example1;

/**
* CPU的接口
*/
public interface CPUApi {
/**
* 示意方法，CPU具有运算的功能
*/
public void calculate();
}

2.2主板接口

package demo06.abstractfactory.example1;

/**
* 主板的接口
*/
public interface MainboardApi {
/**
* 示意方法，主板都具有安装CPU的功能
*/
public void installCPU();
}

2.3 Inter CPU实现

package demo06.abstractfactory.example1;

/**
* Intel的CPU实现
*/
public class IntelCPU implements CPUApi {
/**
* CPU的针脚数目
*/
private int pins = 0;

/**
* 构造方法，传入CPU的针脚数目
*
* @param pins
*            CPU的针脚数目
*/
public IntelCPU(int pins) {
this.pins = pins;
}

public void calculate() {
System.out.println("now in Intel CPU,pins=" + pins);
}
}

2.4 AMD的CPU实现

package demo06.abstractfactory.example1;

/**
* AMD的CPU实现
*/
public class AMDCPU implements CPUApi {
/**
* CPU的针脚数目
*/
private int pins = 0;

/**
* 构造方法，传入CPU的针脚数目
*
* @param pins
*            CPU的针脚数目
*/
public AMDCPU(int pins) {
this.pins = pins;
}

public void calculate() {
System.out.println("now in AMD CPU,pins=" + pins);
}
}

2.5技嘉的主板实现

package demo06.abstractfactory.example1;

/**
* 技嘉的主板
*/
public class GAMainboard implements MainboardApi {
/**
* CPU插槽的孔数
*/
private int cpuHoles = 0;

/**
* 构造方法，传入CPU插槽的孔数
*
* @param cpuHoles
*            CPU插槽的孔数
*/
public GAMainboard(int cpuHoles) {
this.cpuHoles = cpuHoles;
}

public void installCPU() {
System.out.println("now in GAMainboard,cpuHoles=" + cpuHoles);
}
}

2.6微星的主板

package demo06.abstractfactory.example1;

/**
* 微星的主板
*/
public class MSIMainboard implements MainboardApi {
/**
* CPU插槽的孔数
*/
private int cpuHoles = 0;

/**
* 构造方法，传入CPU插槽的孔数
*
* @param cpuHoles
*            CPU插槽的孔数
*/
public MSIMainboard(int cpuHoles) {
this.cpuHoles = cpuHoles;
}

public void installCPU() {
System.out.println("now in MSIMainboard,cpuHoles=" + cpuHoles);
}
}

2.7创建CPU工厂

package demo06.abstractfactory.example1;
/**
* 创建CPU的简单工厂
*/
public class CPUFactory {
/**
* 创建CPU接口对象的方法
* @param type 选择CPU类型的参数
* @return CPU接口对象的方法
*/
public static CPUApi createCPUApi(int type){
CPUApi cpu = null;
//根据参数来选择并创建相应的CPU对象
if(type==1){
cpu = new IntelCPU(1156);
}else if(type==2){
cpu = new AMDCPU(939);
}
return cpu;
}
}

2.8创建主板工厂

package demo06.abstractfactory.example1;

/**
* 创建主板的简单工厂
*/
public class MainboardFactory {
/**
* 创建主板接口对象的方法
*
* @param type
*            选择主板类型的参数
* @return 主板接口对象的方法
*/
public static MainboardApi createMainboardApi(int type) {
MainboardApi mainboard = null;
// 根据参数来选择并创建相应的主板对象
if (type == 1) {
mainboard = new GAMainboard(1156);
} else if (type == 2) {
mainboard = new MSIMainboard(939);
}
return mainboard;
}
}

2.9工程师实现代码

package demo06.abstractfactory.example1;

/**
* 装机工程师的类
*/
public class ComputerEngineer {
/**
* 定义组装机器需要的CPU
*/
private CPUApi cpu = null;
/**
* 定义组装机器需要的主板
*/
private MainboardApi mainboard = null;

/**
* 装机过程
*
* @param cpuType
*            客户选择所需CPU的类型
* @param mainboardType
*            客户选择所需主板的类型
*/
public void makeComputer(int cpuType, int mainboardType) {
// 1：首先准备好装机所需要的配件
prepareHardwares(cpuType, mainboardType);
// 2：组装机器

// 3：测试机器

// 4：交付客户
}

/**
* 准备装机所需要的配件
*
* @param cpuType
*            客户选择所需CPU的类型
* @param mainboardType
*            客户选择所需主板的类型
*/
private void prepareHardwares(int cpuType, int mainboardType) {
// 这里要去准备CPU和主板的具体实现，为了示例简单，这里只准备这两个
// 可是，装机工程师并不知道如何去创建，怎么办呢？

// 直接找相应的工厂获取
this.cpu = CPUFactory.createCPUApi(cpuType);
this.mainboard = MainboardFactory.createMainboardApi(mainboardType);

// 测试一下配件是否好用
this.cpu.calculate();
this.mainboard.installCPU();
}
}

2.90客户端测试

package demo06.abstractfactory.example1;

public class Client {
public static void main(String[] args) {
// 创建装机工程师对象
ComputerEngineer engineer = new ComputerEngineer();
// 告诉装机工程师自己选择的配件，让装机工程师组装电脑
engineer.makeComputer(1, 2);
}
}

3.问题：

问题出现了：如果client传入的参数时1,2，那么装机不匹配就会失败，所以就会出现问题，如何解决呢？

4.解决方法（抽象工厂模式）

4.1模式定义：

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

4.2模式的结构和说明

5.示例代码（抽象工厂模式）

5.1抽象工厂接口

package demo06.abstractfactory.example2;

/**
* 抽象工厂的接口，声明创建抽象产品对象的操作
*/
public interface AbstractFactory {
/**
* 示例方法，创建抽象产品A的对象
*
* @return 抽象产品A的对象
*/
public AbstractProductA createProductA();

/**
* 示例方法，创建抽象产品B的对象
*
* @return 抽象产品B的对象
*/
public AbstractProductB createProductB();
}

5.2产品Ａ接口

package demo06.abstractfactory.example2;

/**
* 抽象产品A的接口
*/
public interface AbstractProductA {
// 定义抽象产品A相关的操作
}

5.3产品B接口

package demo06.abstractfactory.example2;

/**
* 抽象产品B的接口
*/
public interface AbstractProductB {
// 定义抽象产品B相关的操作
}

5.4产品A实现

package demo06.abstractfactory.example2;

/**
* 产品A的具体实现
*/
public class ProductA1 implements AbstractProductA {
// 实现产品A的接口中定义的操作
}

package demo06.abstractfactory.example2;

/**
* 产品A的具体实现
*/
public class ProductA2 implements AbstractProductA {
// 实现产品A的接口中定义的操作
}

5.5产品B实现

package demo06.abstractfactory.example2;

/**
* 产品B的具体实现
*/
public class ProductB1 implements AbstractProductB {
// 实现产品B的接口中定义的操作
}

package demo06.abstractfactory.example2;

/**
* 产品B的具体实现
*/
public class ProductB2 implements AbstractProductB {
// 实现产品B的接口中定义的操作
}

5.6具体工厂实现

package demo06.abstractfactory.example2;

/**
* 具体的工厂实现对象，实现创建具体的产品对象的操作
*/
public class ConcreteFactory1 implements AbstractFactory {

public AbstractProductA createProductA() {
return new ProductA1();
}
public AbstractProductB createProductB() {
return new ProductB1();
}
}

package demo06.abstractfactory.example2;

/**
* 具体的工厂实现对象，实现创建具体的产品对象的操作
*/
public class ConcreteFactory2 implements AbstractFactory {

public AbstractProductA createProductA() {
return new ProductA2();
}
public AbstractProductB createProductB() {
return new ProductB2();
}
}

5.7客户端

package demo06.abstractfactory.example2;

public class Client {

public static void main(String[] args) {
// 创建抽象工厂对象
AbstractFactory af = new ConcreteFactory1();
// 通过抽象工厂来获取一系列的对象，如产品A和产品B
af.createProductA();
af.createProductB();
}
}

6.重写示例代码

6.1结构图

6.2抽象工厂接口

package demo06.abstractfactory.example3;

/**
* 抽象工厂的接口，声明创建抽象产品对象的操作
*/
public interface AbstractFactory {
/**
* 创建CPU的对象
*
* @return CPU的对象
*/
public CPUApi createCPUApi();

/**
* 创建主板的对象
*
* @return 主板的对象
*/
public MainboardApi createMainboardApi();
}

6.3装机方案一

package demo06.abstractfactory.example3;

/**
* 装机方案一：Intel 的CPU + 技嘉的主板 这里创建CPU和主板对象的时候，是对应的，能匹配上的
*/
public class Schema1 implements AbstractFactory {
public CPUApi createCPUApi() {
return new IntelCPU(1156);
}

public MainboardApi createMainboardApi() {
return new GAMainboard(1156);
}
}

6.4装机方案二

package demo06.abstractfactory.example3;

/**
* 装机方案二：AMD的CPU + 微星的主板 这里创建CPU和主板对象的时候，是对应的，能匹配上的
*/
public class Schema2 implements AbstractFactory {
public CPUApi createCPUApi() {
return new AMDCPU(939);
}

public MainboardApi createMainboardApi() {
return new MSIMainboard(939);
}
}

6.5装机工程师

package demo06.abstractfactory.example3;

/**
* 装机工程师的类
*/
public class ComputerEngineer {
/**
* 定义组装机器需要的CPU
*/
private CPUApi cpu = null;
/**
* 定义组装机器需要的主板
*/
private MainboardApi mainboard = null;

/**
* 装机过程
*
* @param schema
*            客户选择的装机方案
*/
public void makeComputer(AbstractFactory schema) {
// 1：首先准备好装机所需要的配件
prepareHardwares(schema);
// 2：组装机器

// 3：测试机器

// 4：交付客户
}

/**
* 准备装机所需要的配件
*
* @param schema
*            客户选择的装机方案
*/
private void prepareHardwares(AbstractFactory schema) {
// 这里要去准备CPU和主板的具体实现，为了示例简单，这里只准备这两个
// 可是，装机工程师并不知道如何去创建，怎么办呢？

// 使用抽象工厂来获取相应的接口对象
this.cpu = schema.createCPUApi();
this.mainboard = schema.createMainboardApi();

// 测试一下配件是否好用
this.cpu.calculate();
this.mainboard.installCPU();
}
}

6.6客户端使用

package demo06.abstractfactory.example3;

public class Client {
public static void main(String[] args) {
// 创建装机工程师对象
ComputerEngineer engineer = new ComputerEngineer();
// 客户选择并创建需要使用的装机方案对象
AbstractFactory schema = new Schema1();
// 告诉装机工程师自己选择的装机方案，让装机工程师组装电脑
engineer.makeComputer(schema);
}
}

7.抽象工厂模式讲解

7.1抽象工厂和DAO

DAO是数据访问对象，是J2EE中的一种标准的模式，是为了解决访问数据不同而产生的一种设计模式。这种设计模式简言之是：分层设计的思想。
在实现DAO模式的时候，多用工厂的策略，最常用的就是抽象工厂模式，当然最好结合工厂方法模式。

7.2抽象工厂的优缺点

优点：分离接口和实现

使得切换产品簇更加容易。

缺点：不太容易扩展新的产品

容易造成类层次复杂

7.3抽象工厂模式的本质

选择产品簇的实现