设计模式之工厂模式【Abstractfactory】(三)

抽象工厂

定义 ：抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定它们具体的类

创建型 ：创建型

适用场景：

• 客户端（应用层）不依赖于产品类实例如何被创建、实现等细节
• 强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量的重复代码
• 提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体的实现

优点：

• 具体产品在应用层的代码隔离，无需关心创建的细节
• 将一个系列的产品统一到一起创建

缺点：

• 规定了所有可能被创建的产品集合，产品簇中扩展新的产品困难；
• 增加了系统的抽象性和理解难度

UML类图：

Creator:产品族工厂，定义了一系列的产品生产行为

ConcreteCreator:具体的产品族工厂

Product:抽象产品接口

ProductA1/A2/B1/B2：都是具体的产品，实现了相应的产品接口

为了更好理解抽象工厂模式，需要先搞清楚产品等级和产品族的概念，举个粟子：手机有小米手机、华为手机，它们都是手机，这些具体的手机和抽象手机就构成了一个产品等级结构。同样的，路由器有小米路由器，华为路由器，这些具体的路由器和抽象路由器就构成了另外一个产品等级结构，实质上产品等级结构即产品的继承结构。小米手机位于手机产品等级结构中，小米路由器位于路由器的产品等级结构中，而小米手机和小米路由器都是小米公司生产的，就构成了一个产品族，同理，华为手机和华为路由器也构成了一个产品族 。划重点就是产品族中的产品都是由同一个工厂生产的，位于不同的产品等级结构

对比工厂方法，其针对的是产品等级结构，而抽象工厂是针对产品族。在二者的使用选择上，需要结合实际业务，对于产品等级数量相对固定的产品族，可以优先考虑抽象工厂模式，但是如果频繁变动，则不大适用，因为在现有的产品族中新增产品等级时，就需要修改产品族工厂，也就违背了开闭原则

示例

【取例自菜鸟教程】

为形状创建一个接口。

Shape.java

public interface Shape {
   void draw();
}

创建实现接口的实体类。

Rectangle.java

public class Rectangle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}

Square.java

public class Square implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}

Circle.java

public class Circle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

为颜色创建一个接口。

Color.java

public interface Color {
   void fill();
}

创建实现接口的实体类。

Red.java

public class Red implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Red::fill() method.");
   }
}

Green.java

public class Green implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Green::fill() method.");
   }
}

Blue.java

public class Blue implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Blue::fill() method.");
   }
}

为 Color 和 Shape 对象创建抽象类来获取工厂。

AbstractFactory.java

public abstract class AbstractFactory {
   public abstract Color getColor(String color);
   public abstract Shape getShape(String shape) ;
}

创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。

ShapeFactory.java

public class ShapeFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
   
   @Override
   public Color getColor(String color) {
      return null;
   }
}

ColorFactory.java

public class ColorFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      return null;
   }
   
   @Override
   public Color getColor(String color) {
      if(color == null){
         return null;
      }        
      if(color.equalsIgnoreCase("RED")){
         return new Red();
      } else if(color.equalsIgnoreCase("GREEN")){
         return new Green();
      } else if(color.equalsIgnoreCase("BLUE")){
         return new Blue();
      }
      return null;
   }
}

创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂。

FactoryProducer.java

public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("SHAPE")){
         return new ShapeFactory();
      } else if(choice.equalsIgnoreCase("COLOR")){
         return new ColorFactory();
      }
      return null;
   }
}

使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。

AbstractFactoryPatternDemo.java

public class AbstractFactoryPatternDemo {
   public static void main(String[] args) {
 
      //获取形状工厂
      AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
 
      //获取形状为 Circle 的对象
      Shape shape1 = shapeFactory.getShape("CIRCLE");
 
      //调用 Circle 的 draw 方法
      shape1.draw();
 
      //获取形状为 Rectangle 的对象
      Shape shape2 = shapeFactory.getShape("RECTANGLE");
 
      //调用 Rectangle 的 draw 方法
      shape2.draw();
      
      //获取形状为 Square 的对象
      Shape shape3 = shapeFactory.getShape("SQUARE");
 
      //调用 Square 的 draw 方法
      shape3.draw();
 
      //获取颜色工厂
      AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
 
      //获取颜色为 Red 的对象
      Color color1 = colorFactory.getColor("RED");
 
      //调用 Red 的 fill 方法
      color1.fill();
 
      //获取颜色为 Green 的对象
      Color color2 = colorFactory.getColor("Green");
 
      //调用 Green 的 fill 方法
      color2.fill();
 
      //获取颜色为 Blue 的对象
      Color color3 = colorFactory.getColor("BLUE");
 
      //调用 Blue 的 fill 方法
      color3.fill();
   }
}

执行程序，输出结果：

使用典范

• java.sql.Connection

public interface Connection  extends Wrapper, AutoCloseable {
	//...    	
    	//返回普通的sql执行器
        Statement createStatement() throws SQLException;
		//返回具有参数化预编译功能的sql执行器
    	PreparedStatement prepareStatement(String sql) throws SQLException;
    	//返回可以执行存储过程的sql执行器
        CallableStatement prepareCall(String sql) throws SQLException;   
    //...         
}

从上面的注释就可以看出，这就是典型的抽象工厂接口，描述了不同的产品等级Statement、PreparedStatement、CallableStatement，它们都位于抽象接口Statement产品等级结构中。我们可以继续寻找该抽象工厂接口的实现类

这里就以Mysql为例，可以找到Mysql对这个工厂接口的实现类ConnectionImpl，ConnectionImpl并不是直接实现了java.sql.Connection,而是通过实现自己扩展的MySQLConnection接口，该接口也是间接继承了java.sql.Connection

public class ConnectionImpl extends ConnectionPropertiesImpl implements MySQLConnection {
	//...

		 public java.sql.Statement createStatement() throws SQLException {
		        return createStatement(DEFAULT_RESULT_SET_TYPE, DEFAULT_RESULT_SET_CONCURRENCY);
		   }
		    
		   
		 public java.sql.PreparedStatement prepareStatement(String sql) throws SQLException {
		        return prepareStatement(sql, DEFAULT_RESULT_SET_TYPE, DEFAULT_RESULT_SET_CONCURRENCY);
		   }
		    
	    
		 public java.sql.CallableStatement prepareCall(String sql) throws SQLException {
		
		        return prepareCall(sql, DEFAULT_RESULT_SET_TYPE, DEFAULT_RESULT_SET_CONCURRENCY);
		   }
			
			
			//...
}

以createStatement为例，跟踪其调用代码可以看到StatementImpl这个类就是实现了java.sql.Statement的具体产品类

    public java.sql.Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
        checkClosed();

        StatementImpl stmt = new StatementImpl(getMultiHostSafeProxy(), this.database);
        stmt.setResultSetType(resultSetType);
        stmt.setResultSetConcurrency(resultSetConcurrency);

        return stmt;
    }

• mybatis中的SqlSessionFactory

/**
 * Creates an {@link SqlSession} out of a connection or a DataSource
 * 
 * @author Clinton Begin
 */
public interface SqlSessionFactory {

		  SqlSession openSession();
		
		  SqlSession openSession(boolean autoCommit);
		  SqlSession openSession(Connection connection);
		  SqlSession openSession(TransactionIsolationLevel level);
		
		  SqlSession openSession(ExecutorType execType);
		  SqlSession openSession(ExecutorType execType, boolean autoCommit);
		  SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);
		  SqlSession openSession(ExecutorType execType, Connection connection);
		
		  Configuration getConfiguration();

}

SqlSessionFactory也是抽象工厂接口，Configuration和SqlSession都是在不同的产品等级上。通过IDEA工具可以通过UML图清晰得看到SqlSessionFactory的工厂实现类

以上两个例子都和数据库操作相关，同样使用了抽象工厂模式。