设计模式3-工厂模式

工厂模式分为三种： 简单工厂模式（也叫静态工厂模式）、工厂方法模式、抽象工厂模式。以下会分别介绍这三种工厂模式。

一、概念

创建型模式

工厂模式提供了一种创建对象的最佳方式。它最关心的是最终创建的对象，而不关心创建的过程。

功能：

• 实例化对象，用工厂方法代替new，实现了创建者和调用者的分离；
• 将选择实现类、创建对象统一管理和控制，从而将调用者跟我们的实现类解藕。

二、分类

1、简单工厂模式（静态工厂模式）

用来产生同一等级结构中的任意产品。对于增加新的产品，需要修改已有代码。

效果：

• 工厂类一般使用静态方法，通过接收的参数来返回不同的对象实例；
• 增加产品必须修改代码（违反开闭原则OCP：修改关闭，对扩展开放）；

示例（以动物为例）：

public interface Animal
{
    void eat();  //吃东西
    void cry();  //发出声音
}

有两种动物猫和狗：

public class Cat implement Animal
{
    public void eat()
   {
         System.out.println("cat eat fish.");
    }
    
     public void cry()
     {
           System.out.println("cat cry:miaomiao.");
      }

}

public class Dog implement Animal
{
    public void eat()
   {
         System.out.println("dog eat meat.");
    }
    
     public void cry()
     {
           System.out.println("dog cry:汪汪.");
      }

}

有个宠物店，接收各种动物：

public class PetShop
{
    public static Animal getAnimal(String name)
    {
          if("cat".equalsIgnoreCase(name)
          {
               return new Cat();
          }
          else if("dog".equalsIgnoreCase(name)
          {
               return new Dog();
          }
          else
          {
             .......
          }
    }
}

调用示例：

public static void main(String[] args)
{
    Animal cat = PetShop.getAnimal("cat");
    cat.eat();
    Animal dog = PetShop.getAnimal("dog");
    dog.eat();
}

从示例中就可以看出，自己无需去new对象，通过PetShop就可以获取对象，这样使用方就和产品之间就降低了耦合度；

代码模块职责更明确了，有专门的消费模块，有专门的生产模块。

但若增加另一种动物，则必须修改PetShop中的代码，每增加一种都必须再PetShop中增加一个else if， 这样很是不便，对此我们可以将PetShop改为通过反射的方式获取对象：

public class PetShop
{
    public static Animal getAnimal(String namePath) throws Exception
    {
        Class<?> c = Class.forName(namePath);
        return (Animal)c.newInstance();       
    }
}

调用的地方改为：

public static void main(String[] args) throws Exception
{
    Animal dog = PetShop.getAnimal("com.frieda.animalFactory.Dog");
    dog.eat();
    Animal cat = PetShop.getAnimal("com.frieda.animalFactory.Cat");
    cat.cry();
}

但这样做的弊端是，项目重构，类路径，包路径改变，这样更改的地方有点多；但可以通过将所有的类路径放入inerface中后者properties文件或者xml文件中，后期遇到修改路径的， 直接修改改文件即可。

从设计模式的角度讲，这么修改也有很大的优点。现在不管我新增还是删除动物，宠物店（类工厂）都不用变了，只需要告诉工厂我需要哪种动物就够了，工厂自然会给调用者返回。这种写法，也是Spring的基础。

2、工厂方法模式

用来产生同一等级结构中的固定产品。支持增加任意产品。

效果：

• 避免简单工厂的缺点，但不完全满足OCP；
• 定义一个创建产品对象的工厂接口，将实际创建推迟到子类中（简单工厂中的具体工厂类拆成：抽象工厂类层+具体的工厂类层，即产品抽象，工厂也抽象）；
• 简单工厂模式VS工厂方法模式：
i. 结构复杂度：显然简单工厂模式占优，简单工厂模式只要一个工厂，而工厂方法模式的工厂类随着产品类个数增加而增加。

ii. 代码复杂度：代码复杂度与结构复杂度相反，简单工厂模式的工厂类随着产品增加需要增加更多方法（代码），而工厂方法模式每个具体工厂类只完成单一任务，代码简单。

iii. 客户端编程难度：工厂方法模式虽然满足了OCP，但客户端编码中需要对工厂实例化，而简单工厂模式的工厂类是一个静态类。

iv. 管理上的难度：工厂方法模式需要维护的工厂类过多，而简单工厂模式只有一个。
• 设计理论建议使用工厂方法模式，但实践中往往采用的是简单工厂模式。

借用下他人的图来看下工厂方法模式： 

 示例：

Car.java

1 public interface Car {
2 
3     void run();
4     
5 }

CarFactory.java

1 public interface CarFactory {
2 
3     Car createCar();
4     
5 }

Audi.java

1 public class Audi implements Car {
2 
3     @Override
4     public void run() {
5         System.out.println("奥迪在跑！");
6     }
7 
8 }

AudiFactory.java

1 public class AudiFactory implements CarFactory {
2 
3     @Override
4     public Car createCar() {
5         return new Audi();
6     }
7 
8 }

Jeep.java

1 public class Jeep implements Car {
2 
3     @Override
4     public void run() {
5         System.out.println("吉普在跑！");
6     }
7 
8 }

JeepFactory.java

1 public class JeepFactory implements CarFactory {
2 
3     @Override
4     public Car createCar() {
5         return new Jeep();
6     }
7 
8 }

调用示例：

 1 public class Client {
 2 
 3     public static void main(String[] args) {
 4         Car car1 = new AudiFactory().createCar();
 5         Car car2 = new JeepFactory().createCar();
 6         car1.run();
 7         car2.run();
 8     }
 9 
10 }

3、抽象工厂模式

用来生产不同产品族的全部产品。对于增加新的产品，无能为力：支持增加产品族。

效果：

抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种，业务分类时，通过抽象共产模式产生需要的对象时一种非常好的解决方式。

 示例：

Shape,java(interface)

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(interface)

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;
   }
}

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

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中的应用及解读

简单工厂模式在Java中的应用：

线程池

ThreadPoolExecutor类中有四个构造方法

public class ThreadPoolExecutor extends AbstractExecutorService {
    .....
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
        BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);
    ...
}

从构造方法的传参看到需要很多参数才能创建对象，但这里的部分参数尤其是后面3个参数基本上用默认值，而不需要每次传入。

再看下线程池的工厂模式（都是使用静态工厂模式创建对象）

Executors.newCachedThreadPool();       //创建一个无界限缓冲池，缓冲池容量大小为Integer.MAX_VALUE
Executors.newSingleThreadExecutor();   //创建容量为1的缓冲池
Executors.newFixedThreadPool(int);     //创建固定容量大小的缓冲池

具体实现如下：

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

是不是都已经传入一些默认值，这让我们无需再思考在构造函数中应该传入什么值而苦恼，而直接通过工厂模式获取一个对象。

工厂方法模式在Java中的应用： 

ThreadFactory，一个生产线程的接口；

public interface ThreadFactory {

    /**
     * Constructs a new {@code Thread}.  Implementations may also initialize
     * priority, name, daemon status, {@code ThreadGroup}, etc.
     *
     * @param r a runnable to be executed by new thread instance
     * @return constructed thread, or {@code null} if the request to
     *         create a thread is rejected
     */
    Thread newThread(Runnable r);
}

具体的线程工厂可以implements这个接口并实现newThread(Runnable r)方法，来生产具体线程工厂想要生产的线程。JDK在Executors给开发者提供了一个静态内部类DefaultThreadFactory，当然开发者也可以自行实现这个接口，写自定义的线程工厂。

抽象工厂模式在Java中的应用：

java.sql.Connection

public interface Connection {
    //提供一个执行对象
    Statement createStatement() throws SQLException;
    //提供一个支持预编译的执行对象
    PreparedStatement prepareStatement(String sql) throws SQLException;
    //提供一个支持存储过程的执行对象
    CallableStatement prepareCall(String sql) throws SQLException;
}

可以看的出来Connection就是一个经典的抽象工厂，而Statement,PreparedStatement,CallableStatement是这个抽象工厂提供的三个抽象产品，其中Driver起到Client的作用我们只需要把Driver注册进DriverManager就可以为我们生成需要的Connection每次操作数据库只需要使用java提供的这套接口就可以而不需要考虑我们使用的是什么SQL数据库(不考虑特殊SQL语法的情况下)。

 这些抽象工厂与抽象产品均由对应的数据库驱动实现，下面用MySQL与Oracle的驱动进行举例。

  

JDBC抽象工厂UML图