Java深入理解设计模式 - 工厂模式

设计模式

（二）工厂模式

1. 概念

在基类中定义创建对象的一个接口，让子类决定实例化哪个类。工厂方法让一个类的实例化延迟到子类中进行。

1.1 场景

1. 解耦：将对象的创建与使用分离。
2. 降低代码重复: 如果创建某个对象的过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。
3. 降低维护成本 ：由于创建过程都由工厂统一管理，所以发生业务逻辑变化，不需要找到所有需要创建某个对象的地方去逐个修正，只需要在工厂里修改即可，降低维护成本。

1.2 目标

在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

1.3 思路

对象的创建过程下放到子类中执行。

1.4 使用场景

1. JDBC中Connection对象的获取（DriverManager.getConnection()）。
2. Hibernate中SessionFactory创建Session，Mybatis中SqlSessionFactory创建SqlSession。
3. spring中IOC容器创建管理bean对象（BeanFactory）。
4. JDK中Calendar的getInstance方法。
5. XML解析时的DocumentBuilderFactory创建解析器对象。
6. 反射中Class对象的newInstance()。

2. 实现

（一）简单工厂模式（虽然某种程度不符合设计原则，但实际使用最多）

1. 创建接口

Shape.java

public interface Shape {
   void draw();
}

2. 实现接口

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.");
   }
}

3. 创建工厂

ShapeFactory.java

 public class ShapeFactory {
    
   //使用 getShape 方法获取形状类型的对象
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("Square")){
         return new Square();
      } else if(shapeType.equalsIgnoreCase("Rectangle")){
         return new Rectangle();
      }     return null;
   }
}

4. 构造对象

FactoryDemo.java

public class FactoryDemo {
 
   public static void main(String[] args) {
      ShapeFactory shapeFactory = new ShapeFactory();
 
      //获取 Square的对象，并调用它的 draw 方法
      Shape shape1 = shapeFactory.getShape("Square");
 
      //调用 Circle 的 draw 方法
      shape1.draw();
 
      //获取 Rectangle的对象，并调用它的 draw 方法
      Shape shape2 = shapeFactory.getShape("Rectangle");
 
      //调用 Rectangle 的 draw 方法
      shape2.draw();

}

优点：根据外界给定信息，创建具体得对象类，初步降低耦合性，明确区分各自得职责。
缺点：一旦增删产品，就要修改工厂逻辑，扩展困难。

（二）工厂方法模式（不修改已有类的前提下，通过增加新的工厂类实现扩展）

1. 创建接口

public interface Shape {
   void draw();
}

2. 创建工厂接口

public interface ShapeFactory {

    public Shape createDraw();
}

3. 实现工厂接口

public class RectangleFactory implements ShapeFactory {
 
   @Override
   public Shape createDraw() {
      return new Rectangle ();
   }
}

public class SquareFactory implements ShapeFactory {
 
   @Override
   public Shape createDraw() {
       return new Square ();
   }
}

4. 构造对象

FactoryDemo.java

public class FactoryDemo{ 
      public static void main(String[] args){
      ShapeFactory rectangle = new RectangleFactory (); 
      ShapeFactory square = new SquareFactory (); 
      Shape shape1 = rectangle.createDraw();
      Shape shape2 = square .createDraw();
      shape1.draw();
      shape2.draw();
      }
}

优点：解决了简单工厂模式得缺点，每个具体得工厂类只完成单一任务，提高了扩展性。
缺点：如果需要同时修改多个产品，会使得扩展麻烦，每增加一个产品，需要增加对应得子工厂。

（三）抽象工厂模式（不可以增加产品，可以增加产品族）

1. 创建形状接口

public interface Shape {
   void draw();
}

2. 实现接口
   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.");
   }
}

3. 创建颜色接口

public interface Color {
   void fill();
}

5. 实现接口
   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.");
   }
}

5. 为颜色和形状创建抽象类工厂

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

6. 形状实现工厂类

ShapeFactory.java

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

7. 颜色实现工厂类

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();
      } 
      return null;
   }
}

8. 创建工厂生产者

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

10. 构造对象

AbstractFactoryDemo.java

public class AbstractFactoryDemo {
   public static void main(String[] args) {
 
      //获取形状工厂
      AbstractFactory shapeFactory = FactoryProducer.getFactory("Shape");

    //获取形状为 Rectangle 的对象
      Shape shape1 = shapeFactory.getShape("Rectangle");
 
      //调用 Rectangle 的 draw 方法
      shape1.draw();
      
      //获取形状为 Square 的对象
      Shape shape2 = shapeFactory.getShape("Square");
 
      //调用 Square 的 draw 方法
      shape2.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();
} 

优点：抽象工厂隔离了具体类得生产，降低了模块间的耦合性，创建了一个完整的产品系列，利于产品得一致性。
缺点：难以支撑新产品（种类）得出现，抽象工厂几乎确定了可以被创建的产品集合，支持新种类的产品就需要扩展该工厂接口，这将涉及抽象工厂类及其所有子类的改变。