设计模式之工厂模式Factory

字数 1213阅读 113

前言

本文分别介绍工厂模式和抽象工厂模式,放一起讲有助于大家对他们的区分。
会以同一个例子从工厂模式到抽象工厂模式递进。

工厂模式(Factory Pattern)

是 Java 中最常用的设计模式之一,这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。

优点:

1.一个调用者想创建一个对象,只要知道其名称就可以了
2.扩展性高,如果想增加一个产品,只要扩展一个工厂类就可以
3.屏蔽产品的具体实现,调用者只关心产品的接口

优点很好的体现了开闭原则里的闭。

缺点:
工厂模式在开发中又被分为简单工厂模式,工厂方法,

1. 简单工厂中,每次增加一个产品时,都需要增加一个具体类和 修改对工厂类里的创建方法,违背了 “不修改代码”的原则
2. 工厂方法中,每次增加一个产品族时,都需要增加一个具体类和对象实现工厂,使得系统中类的个数成倍增加,在一定程度 上增加了系统的复杂度,同时也增加了系统具体类的依赖。这并不是什么好事。

所以,创建复杂对象时适合使用工厂模式,而简单对象,特别是只需要通过 new 就可以完成创建的对象,就不要使用工厂模式了,只会增加系统的复杂度

使用场景

在我们明确地知道不同条件下创建功能类似的不同实例时,而每个实例对象内部是复杂的实现,就适合使用工厂模式了。比如下面Shape例子,每个Shape子类的绘制都是复杂的实现,而这些逻辑不需要暴露给使用者,使用者只要在不同情况下明确要使用的实例就可以了。

1.日志记录器:记录可能记录到本地硬盘、系统事件、远程服务器等,用户可以选择记录日志到什么地方
2.数据库访问,当用户不知道最后系统采用哪一类数据库,以及数据库可能有变化时
3.设计一个连接服务器的框架,需要三个协议,"POP3"、"IMAP"、"HTTP",可以把这三个作为产品类,共同实现一个接口

工厂模式实现

最经典的就是 《21中设计模式》中的例子了,我们引用上面的 创建Shape的例子。类的关系如图:

factory

定义图形接口 Shape,一个draw方法供子类Circle,Square,Rectangle实现。通过工厂类ShapeFactory创建指定的Shape子类。

public interface Shape {
   void draw();
}

子类实现

public class Rectangle implements Shape {

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

public class Square implements Shape {

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

public class Circle implements Shape {

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

工厂对象ShapeFactory实现,

public class ShapeFactory {
    
   //使用 getShape 方法获取形状类型的对象
   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;
   }
}

这就是工厂模式,包含了简单工厂,工厂方法。因为现在只有一个产品 Shape所以,缺点还没有暴露出来,而简单工厂的缺点就已经可以看到了。
每当增加一个shape子类都需要修改Shape工厂的创建。不过我们可以结合反射,我们可以优化创建的方法,规避这个缺点

public class ShapeFactory {
    public static Object getClass(Class<?extends Shape> clazz) {
        Object obj = null;

        try {
            obj = Class.forName(clazz.getName()).newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return obj;
    }
}

抽象工厂模式(Abstract Factory Pattern)

理解了工厂模式后,抽象工厂模式是在工厂模式的基础上对工厂进行抽象的一种模式。
在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类 每个生成的工厂都能按照工厂模式提供对象。

优点:
当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。

缺点:
产品族扩展非常困难,要增加一个系列的某一产品,既要在抽象的 Creator 里加代码,又要在具体工厂的里面加代码。

使用场景

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口,无需指定它们具体的类情况下创建需要使用的接口实现。
当我们开发的系统产品有多于一个的产品族,而系统某些功能只消费其中某一族的各种产品,这时候就适合用抽象工厂模式

抽象工厂模式实现

还是以经典的Shape为例,类关系图:

abstract factory

这里我们Shape工厂类没有变化,新增了一个产品族Color,对应的产品类Red,Green,Blue以及对应的工厂类 ColorFactory。 到这里就是工厂方法的体现了,每当增加一个产品族时就会增加很多类,增加了系统复杂度。

public interface Color {
   void fill();
}

public class Red implements Color {

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

public class Green implements Color {

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

public class Blue implements Color {

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

把ShapeFactory, ColorFactory当做一个产品使用工厂模式,对Shape工厂, Color工厂进行抽象

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

然后让它们各自实现抽象出来的接口,实现创建产品的方法

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
   Color getColor(String color) {
      return null;
   }
}

public class ColorFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      return null;
   }
   
   @Override
   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;
   }
}

测试

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

验证输出。
Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
Inside Red::fill() method.
Inside Green::fill() method.
Inside Blue::fill() method.

这样就实现了抽象工厂模式,所以在掌握了工厂模式后,其实抽象工厂模式大家也就掌握了。

总结

实际上工厂模式不难掌握,难的是在什么时候使用这种模式,什么时候才能判断对象是不是复杂对象,这个就很考验我们面向对象设计的能力了。

推荐阅读更多精彩内容