第15章《抽象工厂模式》

1、工厂模式和抽象工厂模式的区别：

工厂模式适合具体功能类ConcreteProductX只有一个系列的情况；

抽象工厂模式适合一个具体功能类ConcreteProductX有至少两个系列的情况。

2、抽象工厂模式准确定义：

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

3、抽象工厂模式的优点：

3.1、易于交换产品系列，这是最大的优点。通过改变具体的工厂，就可使用不同的产品配置。

3.2、它让具体的创建过程和客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户端代码中。

3.3、是开放-封闭原则、依赖倒转原则的良好运用。其实，这一点和工厂模式 一样。

4、抽象工厂模式UML图：



5、例子：

5.1、场景：某公司有两个系列的产品，1系列和2系列。对应的每个 系列中，包含所有的不同类型的产品。假设产品类型为A和B。故1系列中有产品；A1、B1；2系列中有产品：A2、B2。每个生产清单只生产一个系列的所有产品。比如：生产清单X只生产1系列的所有产品，包括：A1、B1。因此针对不同的生产清单需要生产不同系列的产品。当客户端收到一个生产清单时，就要生产一个系列的产品。

5.2、下面给出针对上述需求的代码，采用的设计模式演化过程为：工厂模式->抽象工厂模式->简单工厂模式+抽象工厂模式->反射+抽象工厂模式->配置文件+抽象工厂模式。通过设计模式的一步步演化，实现了抽象工厂模式的优化。

(1)工厂模式

代码结构为：

package designmodel.fifteenthchapter.工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 21:56
* @ProjectName: JavaBaseTest
*/
public class Client {
public static void main(String[] args) {
//建立工厂A1
ConcreteFactoryA1 cfa1=new ConcreteFactoryA1();
//生成产品A1
ConcreteProductA1 pa1=(ConcreteProductA1)cfa1.getProduct();
//对产品A1的crud操作
pa1.create(new ConcreteProductA1());
pa1.retrieve();
pa1.update(new ConcreteProductA1());
pa1.delete("1");

System.out.println("--------分隔线--------");

//建立工厂A2
ConcreteFactoryA2 cfa2=new ConcreteFactoryA2();
//生成产品A2
ConcreteProductA2 pa2=(ConcreteProductA2)cfa2.getProduct();
//对产品A2的crud操作
pa2.create(new ConcreteProductA2());
pa2.retrieve();
pa2.update(new ConcreteProductA2());
pa2.delete("1");

}
}

package designmodel.fifteenthchapter.工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 21:40
* @ProjectName: JavaBaseTest
*/
public class ConcreteFactoryA1 implements Factory {
@Override
public ProductA getProduct() {
return new ConcreteProductA1();
}
}

package designmodel.fifteenthchapter.工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 21:48
* @ProjectName: JavaBaseTest
*/
public class ConcreteFactoryA2 implements Factory {
@Override
public ProductA getProduct() {
return new ConcreteProductA2();
}
}

package designmodel.fifteenthchapter.工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 21:40
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductA1 implements ProductA {
@Override
public void create(ProductA product) {
System.out.println("增加一条ProductA1的信息");
}

@Override
public ProductA retrieve() {
System.out.println("查找一条ProductA1的信息");
return null;
}

@Override
public boolean update(ProductA product) {
System.out.println("更新一条ProductA1的信息");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条ProductA1的信息");
return false;
}
}

package designmodel.fifteenthchapter.工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 21:41
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductA2 implements ProductA {
@Override
public void create(ProductA product) {
System.out.println("增加一条ProductA2的信息");
}

@Override
public ProductA retrieve() {
System.out.println("查找一条ProductA2的信息");
return null;
}

@Override
public boolean update(ProductA product) {
System.out.println("更新一条ProductA2的信息");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条ProductA2的信息");
return false;
}
}

package designmodel.fifteenthchapter.工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 21:39
* @ProjectName: JavaBaseTest
*/
public interface Factory {
ProductA getProduct();
}

package designmodel.fifteenthchapter.工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 21:40
* @ProjectName: JavaBaseTest
*/
public interface ProductA {
//crud
void create(ProductA product);
ProductA retrieve();
boolean update(ProductA product);
boolean delete(String id);
}

(2)抽象工厂模式

代码结构为：

package designmodel.fifteenthchapter.抽象工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 23:08
* @ProjectName: JavaBaseTest
*/
public class Client {
public static void main(String[] args) {
//使用1类型工厂,创建1类型的产品A和B(当然,也可以使用类型2,写法一致)

//创建工厂实例和产品实例
ConcreteFactory1 cf1=new ConcreteFactory1();
ConcreteProductA1 a1=(ConcreteProductA1)cf1.getA();
ConcreteProductB1 b1=(ConcreteProductB1)cf1.getB();
//调用A1产品的crud方法
a1.create(new ConcreteProductA1());
a1.retrieve();
a1.update(new ConcreteProductA1());
a1.delete("1");
//调用B1产品的crud方法
b1.create(new ConcreteProductB1());
b1.retrieve();
b1.update(new ConcreteProductB1());
b1.delete("1");
}
}

package designmodel.fifteenthchapter.抽象工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 23:05
* @ProjectName: JavaBaseTest
*/
public class ConcreteFactory1 implements Factory{

@Override
public ProductA getA() {
return new ConcreteProductA1();
}

@Override
public ProductB getB() {
return new ConcreteProductB1();
}
}

package designmodel.fifteenthchapter.抽象工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 23:05
* @ProjectName: JavaBaseTest
*/
public class ConcreteFactory2 implements Factory {
@Override
public ProductA getA() {
return new ConcreteProductA2();
}

@Override
public ProductB getB() {
return new ConcreteProductB2();
}
}

package designmodel.fifteenthchapter.抽象工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 21:40
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductA1 implements ProductA {
@Override
public void create(ProductA product) {
System.out.println("增加一条ProductA1的信息");
}

@Override
public ProductA retrieve() {
System.out.println("查找一条ProductA1的信息");
return null;
}

@Override
public boolean update(ProductA product) {
System.out.println("更新一条ProductA1的信息");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条ProductA1的信息");
return false;
}
}

package designmodel.fifteenthchapter.抽象工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 21:41
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductA2 implements ProductA {
@Override
public void create(ProductA product) {
System.out.println("增加一条ProductA2的信息");
}

@Override
public ProductA retrieve() {
System.out.println("查找一条ProductA2的信息");
return null;
}

@Override
public boolean update(ProductA product) {
System.out.println("更新一条ProductA2的信息");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条ProductA2的信息");
return false;
}
}

package designmodel.fifteenthchapter.抽象工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 22:17
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductB1 implements ProductB {
@Override
public void create(ProductB product) {
System.out.println("增加一条ProductB1记录");
}

@Override
public ProductA retrieve() {
System.out.println("查找一条ProductB1记录");
return null;
}

@Override
public boolean update(ProductB product) {
System.out.println("更新一条ProductB1记录");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条ProductB1记录");
return false;
}
}

package designmodel.fifteenthchapter.抽象工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 22:19
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductB2 implements ProductB {
@Override
public void create(ProductB product) {
System.out.println("增加一条ProdctB2记录");
}

@Override
public ProductA retrieve() {
System.out.println("查询一条ProdctB2记录");
return null;
}

@Override
public boolean update(ProductB product) {
System.out.println("更新一条ProdctB2记录");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条ProdctB2记录");
return false;
}
}

package designmodel.fifteenthchapter.抽象工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 22:48
* @ProjectName: JavaBaseTest
*/
public interface Factory {
ProductA getA();
ProductB getB();
}

package designmodel.fifteenthchapter.抽象工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 22:43
* @ProjectName: JavaBaseTest
*/
public interface ProductA {
//crud
void create(ProductA product);
ProductA retrieve();
boolean update(ProductA product);
boolean delete(String id);
}

package designmodel.fifteenthchapter.抽象工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 22:58
* @ProjectName: JavaBaseTest
*/
public interface ProductB {
//crud
void create(ProductB product);
ProductA retrieve();
boolean update(ProductB product);
boolean delete(String id);
}

(3)简单工厂模式+抽象工厂模式

代码结构为：

package designmodel.fifteenthchapter.抽象工厂模式and简单工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 23:31
* @ProjectName: JavaBaseTest
*/
public class Client {
public static void main(String[] args) {
ProductA productA=Factory.getProductA("1");
ProductB productB=Factory.getProductB("1");
//A产品的crud操作
productA.create(new ConcreteProductA1());
productA.retrieve();
productA.update(new ConcreteProductA1());
productA.delete("1");

System.out.println("-------分隔线---------");

//B产品的crud操作
productB.create(new ConcreteProductB1());
productB.retrieve();
productB.update(new ConcreteProductB1());
productB.delete("1");
}
}

package designmodel.fifteenthchapter.抽象工厂模式and简单工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 23:38
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductA1 implements ProductA {
@Override
public void create(ProductA a) {
System.out.println("新增一条ConcreteA1记录");
}

@Override
public ProductA retrieve() {
System.out.println("查找一条ConcreteA1记录");
return null;
}

@Override
public boolean update(ProductA a) {
System.out.println("更新一条ConcreteA1记录");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条ConcreteA1记录");
return false;
}
}

package designmodel.fifteenthchapter.抽象工厂模式and简单工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 23:41
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductA2 implements ProductA {

@Override
public void create(ProductA a) {
System.out.println("添加一条ConcreteA2记录");
}

@Override
public ProductA retrieve() {
System.out.println("查询一条ConcreteA2记录");
return null;
}

@Override
public boolean update(ProductA a) {
System.out.println("更新一条ConcreteA2记录");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条ConcreteA2记录");
return false;
}
}

package designmodel.fifteenthchapter.抽象工厂模式and简单工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 23:43
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductB1 implements ProductB {
@Override
public void create(ProductB b) {
System.out.println("新增一条ConcreteB1记录");
}

@Override
public ProductB retrieve() {
System.out.println("查询一条ConcreteB1记录");
return null;
}

@Override
public boolean update(ProductB b) {
System.out.println("更新一条ConcreteB1记录");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条ConcreteB1记录");
return false;
}
}

package designmodel.fifteenthchapter.抽象工厂模式and简单工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 23:45
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductB2 implements ProductB {
@Override
public void create(ProductB b) {
System.out.println("新增一条B2产品记录");
}

@Override
public ProductB retrieve() {
System.out.println("查询一条B2产品记录");
return null;
}

@Override
public boolean update(ProductB b) {
System.out.println("更新一条B2产品记录");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条B2产品记录");
return false;
}
}

package designmodel.fifteenthchapter.抽象工厂模式and简单工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/14 09:52
* @ProjectName: JavaBaseTest
*/
public class Factory {
//获取产品A系列某一个产品
public static ProductA getProductA(String type){
switch (type){
case "1":
return new ConcreteProductA1();
case "2":
return new ConcreteProductA2();
}
return null;
}
//获取产品B系列某一个产品
public static ProductB getProductB(String type){
switch (type){
case "1":
return new ConcreteProductB1();
case "2":
return new ConcreteProductB2();
}
return null;
}
}

package designmodel.fifteenthchapter.抽象工厂模式and简单工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 23:34
* @ProjectName: JavaBaseTest
*/
public interface ProductA {
//crud
void create(ProductA a);
ProductA retrieve();
boolean update(ProductA a);
boolean delete(String id);
}

package designmodel.fifteenthchapter.抽象工厂模式and简单工厂模式;

/**
* @Author: cxh
* @CreateTime: 18/1/13 23:36
* @ProjectName: JavaBaseTest
*/
public interface ProductB {
//crud
void create(ProductB b);
ProductB retrieve();
boolean update(ProductB b);
boolean delete(String id);
}

(4)反射+抽象工厂模式

代码结构为： 

package designmodel.fifteenthchapter.抽象工厂模式and反射;

/**
* @Author: cxh
* @CreateTime: 18/1/14 10:27
* @ProjectName: JavaBaseTest
*/
public class Client {
public static void main(String[] args) throws Exception{
ProductA productA=Factory.getProductA();
ProductB productB=Factory.getProductB();

//产品A的crud操作
productA.create(productA.getClass().newInstance());
productA.retrieve();
productA.update(productA.getClass().newInstance());
productA.delete("1");

System.out.println("------分隔线----------");

//产品B的crud操作
productB.create(productB.getClass().newInstance());
productB.retrieve();
productB.update(productB.getClass().newInstance());
productB.delete("1");
}
}

package designmodel.fifteenthchapter.抽象工厂模式and反射;

/**
* @Author: cxh
* @CreateTime: 18/1/14 10:32
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductA1 implements ProductA{
@Override
public void create(ProductA productA) {
System.out.println("新增一条ConcreteProductA1记录");
}

@Override
public ProductA retrieve() {
System.out.println("查询一条ConcreteProductA1记录");
return null;
}

@Override
public boolean update(ProductA productA) {
System.out.println("更新一条ConcreteProductA1记录");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条ConcreteProductA1记录");
return false;
}
}

package designmodel.fifteenthchapter.抽象工厂模式and反射;

/**
* @Author: cxh
* @CreateTime: 18/1/14 10:35
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductA2 implements ProductA {
@Override
public void create(ProductA productA) {
System.out.println("新增一条ConcreteProductA2记录");
}

@Override
public ProductA retrieve() {
System.out.println("新查询一条ConcreteProductA2记录");
return null;
}

@Override
public boolean update(ProductA productA) {
System.out.println("更新一条ConcreteProductA2记录");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条ConcreteProductA2记录");
return false;
}
}

package designmodel.fifteenthchapter.抽象工厂模式and反射;

/**
* @Author: cxh
* @CreateTime: 18/1/14 10:38
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductB1 implements ProductB{
@Override
public void create(ProductB productB) {
System.out.println("新增一条ConcreteProductB1记录");
}

@Override
public ProductB retrieve() {
System.out.println("查询一条ConcreteProductB1记录");
return null;
}

@Override
public boolean update(ProductB productB) {
System.out.println("更新一条ConcreteProductB1记录");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条ConcreteProductB1记录");
return false;
}
}

package designmodel.fifteenthchapter.抽象工厂模式and反射;

/**
* @Author: cxh
* @CreateTime: 18/1/14 10:42
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductB2 implements ProductB {
@Override
public void create(ProductB productB) {
System.out.println("新增一条ConcreteProductB2记录");
}

@Override
public ProductB retrieve() {
System.out.println("查询一条ConcreteProductB2记录");
return null;
}

@Override
public boolean update(ProductB productB) {
System.out.println("更新一条ConcreteProductB2记录");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条ConcreteProductB2记录");
return false;
}
}

package designmodel.fifteenthchapter.抽象工厂模式and反射;

/**
* @Author: cxh
* @CreateTime: 18/1/14 10:32
* @ProjectName: JavaBaseTest
* 利用反射,去除了简单工厂模式中的switch case语句
*/
public class Factory {
private static final String path="designmodel.fifteenthchapter.抽象工厂模式and反射";
private static final String type="1";

//利用反射,获取实例
public static ProductA getProductA() throws Exception{
return  (ProductA)Class.forName(path+".ConcreteProductA"+type).newInstance();
}
public static ProductB getProductB() throws Exception{
return  (ProductB)Class.forName(path+".ConcreteProductB"+type).newInstance();
}
}

package designmodel.fifteenthchapter.抽象工厂模式and反射;

/**
* @Author: cxh
* @CreateTime: 18/1/14 10:27
* @ProjectName: JavaBaseTest
*/
public interface ProductA {
//crud
void create(ProductA productA);
ProductA retrieve();
boolean update(ProductA productA);
boolean delete(String id);
}

package designmodel.fifteenthchapter.抽象工厂模式and反射;

/**
* @Author: cxh
* @CreateTime: 18/1/14 10:29
* @ProjectName: JavaBaseTest
*/
public interface ProductB {
//crud
void create(ProductB productB);
ProductB retrieve();
boolean update(ProductB productB);
boolean delete(String id);
}

(5)配置+抽象工厂模式 

代码结构为：

package designmodel.fifteenthchapter.抽象工厂模式and配置;

/**
* @Author: cxh
* @CreateTime: 18/1/14 11:22
* @ProjectName: JavaBaseTest
*/
public class Client {
public static void main(String[] args) throws Exception{
//获取配置文件信息
Factory.getType();

ProductA a=Factory.getProductA();
ProductB b=Factory.getProductB();
//A产品的crud操作
a.create(a.getClass().newInstance());
a.retrieve();
a.update(a.getClass().newInstance());
a.delete("1");

System.out.println("--------分隔线-------");

//B产品的crud操作
b.create(b.getClass().newInstance());
b.retrieve();
b.update(b.getClass().newInstance());
b.delete("1");
}
}

package designmodel.fifteenthchapter.抽象工厂模式and配置;

/**
* @Author: cxh
* @CreateTime: 18/1/14 11:25
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductA1 implements ProductA {
@Override
public void create(ProductA productA) {
System.out.println("新增一条ConcreteProductA1记录");
}

@Override
public ProductA retrieve() {
System.out.println("查询一条ConcreteProductA1记录");
return null;
}

@Override
public boolean update(ProductA productA) {
System.out.println("更新一条ConcreteProductA1记录");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条ConcreteProductA1记录");
return false;
}
}

package designmodel.fifteenthchapter.抽象工厂模式and配置;

/**
* @Author: cxh
* @CreateTime: 18/1/14 11:31
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductA2 implements ProductA {
@Override
public void create(ProductA productA) {
System.out.println("新增一条ConcreteProductA2记录");
}

@Override
public ProductA retrieve() {
System.out.println("查询一条ConcreteProductA2记录");
return null;
}

@Override
public boolean update(ProductA productA) {
System.out.println("更新一条ConcreteProductA2记录");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条ConcreteProductA2记录");
return false;
}
}

package designmodel.fifteenthchapter.抽象工厂模式and配置;

/**
* @Author: cxh
* @CreateTime: 18/1/14 11:33
* @ProjectName: JavaBaseTest
*/
public class ConcreteProductB1 implements ProductB {
@Override
public void create(ProductB productB) {
System.out.println("新增一条ConcreteProductB1记录");
}

@Override
public ProductB retrieve() {
System.out.println("查询一条ConcreteProductB1记录");
return null;
}

@Override
public boolean update(ProductB productB) {
System.out.println("更新一条ConcreteProductB1记录");
return false;
}

@Override
public boolean delete(String id) {
System.out.println("删除一条ConcreteProductB1记录");
return false;
}
}

<series>
<producta>1</producta>
<productb></productb>
</series>

package designmodel.fifteenthchapter.抽象工厂模式and配置;

import org.w3c.dom.Document;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

/**
* @Author: cxh
* @CreateTime: 18/1/14 11:35
* @ProjectName: JavaBaseTest
*/
public class Factory {
private static final String path="designmodel.fifteenthchapter.抽象工厂模式and配置";
private static String type;
public static void getType(){
DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
try{
DocumentBuilder db=dbf.newDocumentBuilder();
Document document=
db.parse("/Users/caoxiaohong/IdeaProjects/JavaBaseTest/src/designmodel/fifteenthchapter/抽象工厂模式and配置/config.xml");
NodeList list=document.getElementsByTagName("producta");
type=list.item(0).getFirstChild().getNodeValue();
}catch (Exception e){
System.out.println("解析xml文件出错!");
}
}
public static ProductA getProductA() throws Exception{
return (ProductA)Class.forName(path+".ConcreteProductA"+type).newInstance();
}
public static ProductB getProductB() throws Exception{
return (ProductB)Class.forName(path+".ConcreteProductB"+type).newInstance();
}
}

package designmodel.fifteenthchapter.抽象工厂模式and配置;

/**
* @Author: cxh
* @CreateTime: 18/1/14 11:21
* @ProjectName: JavaBaseTest
*/
public interface ProductA {
//crud操作
void create(ProductA productA);
ProductA retrieve();
boolean update(ProductA productA);
boolean delete(String id);
}

package designmodel.fifteenthchapter.抽象工厂模式and配置;

/**
* @Author: cxh
* @CreateTime: 18/1/14 11:21
* @ProjectName: JavaBaseTest
*/
public interface ProductB {
//crud
void create(ProductB productB);
ProductB retrieve();
boolean update(ProductB productB);
boolean delete(String id);
}

参考书籍：《大话设计模式》－程杰