java设计模式之工厂模式

一、工厂模式简介
在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。这时就可以采用工厂模式。
工厂模式根据抽象程度的不同分为三种：简单工厂模式（也叫静态工厂模式）、普通工厂模式、以及抽象工厂模式。
工厂模式是编程中经常用到的一种模式。它的主要优点有：
1、可以使代码结构清晰，有效地封装变化。在编程中，产品类的实例化有时候是比较复杂和多变的，通过工厂模式，将产品的实例化封装起来，使得调用者根本无需关心产品的实例化过程，只需依赖工厂即可得到自己想要的产品。
2、对调用者屏蔽具体的产品类。如果使用工厂模式，调用者只关心产品的接口就可以了，至于具体的实现，调用者根本无需关心。即使变更了具体的实现，对调用者来说没有任何影响。
3、降低耦合度。产品类的实例化通常来说是很复杂的，它需要依赖很多的类，而这些类对于调用者来说根本无需知道，如果使用了工厂方法，我们需要做的仅仅是实例化好产品类，然后交给调用者使用。对调用者来说，产品所依赖的类都是透明的。
工厂方法模式有四个要素：
1、工厂接口。工厂接口是工厂方法模式的核心，与调用者直接交互用来提供产品。在实际编程中，有时候也会使用一个抽象类来作为与调用者交互的接口，其本质上是一样的。
2、工厂实现。在编程中，工厂实现决定如何实例化产品，是实现扩展的途径，需要有多少种产品，就需要有多少个具体的工厂实现。
3、产品接口。产品接口的主要目的是定义产品的规范，所有的产品实现都必须遵循产品接口定义的规范。产品接口是调用者最为关心的，产品接口定义的优劣直接决定了调用者代码的稳定性。同样，产品接口也可以用抽象类来代替，但要注意最好不要违反里氏替换原则。
4、产品实现。实现产品接口的具体类，决定了产品在客户端中的具体行为。
适用场景：
1、作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过new就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。
2、工厂模式是一种典型的解耦模式，迪米特法则在工厂模式中表现的尤为明显。假如调用者自己组装产品需要增加依赖关系时，可以考虑使用工厂模式。将会大大降低对象之间的耦合度。
3、由于工厂模式是依靠抽象架构的，它把实例化产品的任务交由实现类完成，扩展性比较好。也就是说，当需要系统有比较好的扩展性时，可以考虑工厂模式，不同的产品用不同的实现工厂来组装。
应用实例： 
1、假如需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。 
2、Hibernate 换数据库只需换方言和驱动就可以。
3、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 

下面结合具体事例来说。举例如下：（我们举一个发送邮件和短信的例子）
1、因为邮件和短信是不同的事物，但执行的操作类似。我们定义一个两者的共同接口。

public interface Sender {  
    public void Send();  //邮件和短信都需要进行发送操作
}  

2、实现邮件和短信类
邮件类

public class MailSender implements Sender {  
    @Override  
    public void Send() {  
        System.out.println("this is mailsender!");  
    }  
}  

短信类

public class SmsSender implements Sender {  
  
    @Override  
    public void Send() {  
        System.out.println("this is sms sender!");  
    }  
}  

下面来分别介绍三种工厂模式。


二、简单工厂模式
通过提供的不同的静态方法来创建相应的类实例。
定义工厂类

public class SendFactory {  
      
    //采用静态方法创建不同的类实例
    public static Sender produceMail(){  
        return new MailSender();  
    }  
      
    public static Sender produceSms(){  
        return new SmsSender();  
    }  
}  

测试

public class FactoryTest {  
  
    public static void main(String[] args) {      
        Sender sender = SendFactory.produceMail();//创建邮件类
        sender.Send();  
    }  
}  

三、普通工厂模式
通过传入不同的字符串来创建相应的类实例。
定义工厂类

public class SendFactory {  
    //通过传入的字符串参数决定初始化那个类实例
    public Sender produce(String type) {  
        if ("mail".equals(type)) {  
            return new MailSender();  
        } else if ("sms".equals(type)) {  
            return new SmsSender();  
        } else {  
            System.out.println("请输入正确的类型!");  
            return null;  
        }  
    }  
}  

测试

public class FactoryTest {  
  
    public static void main(String[] args) {  
        SendFactory factory = new SendFactory();  
        Sender sender = factory.produce("sms");//传入sms字符串，初始化一个短信类实例。
        sender.Send();  
    }  
}  

四、抽象工厂模式
将工厂类定义为一个接口，不同的类实例的创建需要实现这个接口，从而保证不同的工厂类创建不同的类实例。
首先定义一个工厂类的接口：

public interface Provider {  
    public Sender produce();  
}  

之后根据不同的类实例创建相应的工厂类：
邮件工厂类

public class SendMailFactory implements Provider {  
      
    @Override  
    public Sender produce(){  
        return new MailSender();  
    }  
}  

短信工厂类

public class SendSmsFactory implements Provider{  
  
    @Override  
    public Sender produce() {  
        return new SmsSender();  
    }  
}  

测试：

public class Test {  
  
    public static void main(String[] args) {  
        Provider provider1 = new SendMailFactory();//初始化邮件类工厂
        Sender sender1 = provider1.produce();//产生一个邮件类实例
        sender1.Send();  
        Provider provider2 = new SendMailFactory();//初始化短信类工厂
        Sender sender2 = provider2.produce();//产生一个短信类实例
        sender2.Send();  
    }  
}  

五、抽象工厂模式的复杂应用
事实上，抽象工厂模式可以更复杂。抽象工厂模式是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
下面来看一个较为复杂的例子：
我们将创建 Shape 和 Color 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义两个工厂类： ShapeFactory 和 ColorFactory，这两个工厂类都是扩展了 AbstractFactory接口。然后创建一个工厂创造器/生成器类 FactoryProducer，这个工厂可以生成ShapeFactory和ColorFactory。
1、shape接口

public interface Shape {
   void draw(); 
}

2、建立shape的三个实现类
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.");
   }
}

3、color接口

public interface Color {
   void fill();
}

4、建立三个color的实体类
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.");
   }
}

5、建立一个抽象工厂类

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

6、针对shape和color创建相应的工厂类，扩展自 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
   Color getColor(String color) {
      return null;
   }
}

ColorFactory.java

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

7、创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取相应的工厂。
FactoryProducer.java

public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("SHAPE")){
         return new ShapeFactory();//返回一个shape工厂类实例
      } else if(choice.equalsIgnoreCase("COLOR")){
         return new ColorFactory();//返回一个color工厂类实例
      }
      return null;
   }
}

8、测试：

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

五、总结
普通工厂模式：
一个抽象产品类，可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类可以创建多个具体产品类的实例。   
区别：
普通工厂模式只有一个抽象产品类，而抽象工厂模式有多个。   
普通工厂模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。