简单工厂

  • 使用工厂模式的目的是不让程序员自己手动new对象，而是通过工厂去获取一个对象的实例。这种方式的好处是：获取对象实例的程序员无需关心这个实例创建的过程，如果后续实例创建逻辑修改，那么无需改动引用工厂的代码，只需改动工厂中的创建逻辑即可。
  • 简单工厂就是仅仅实现了以上的目的。工厂的思想在Spring中运用的尤为广泛，每次我们@Autowired其实都是在从Spring为我们准备的IOC工厂中取出这个接口的实现类。
  • 简单工厂demo。
  1. public class FactoryPatternDemo {
  3.     public static void main(String[] args) {
  4.         Product product = ProductFactory.create();
  5.         product.execute();
  7.         // 如果此时有100个地方都需要获取Product的实例
  8.         // 但是此时Product实现类改了
  9.         // 我们只要修改一个地方即可，就是ProductFacory中
  10.     }
  12.     public interface Product {
  14.         void execute();
  16.     }
  18. //    public static class ProductImpl1 implements Product {
  19. //
  20. //        public void execute() {
  21. //            System.out.print("产品1的功能实现");  
  22. //        }
  23. //        
  24. //    }
  26.     public static class ProductImpl2 implements Product {
  28.         public void execute() {
  29.             System.out.print("产品1的功能实现");  
  30.         }
  32.     }
  34.     public static class ProductFactory {
  36.         public static Product create() {
  37.             return new ProductImpl2();
  38.         }
  40.     }
  42. }

工厂方法

  • 有时候在创建同一类对象时，这些对象难免有一些通用的创建逻辑。如果使用简单工厂实现，这些逻辑就会变成冗余的重复代码。这时就要引入工厂方法模式了。
  • 工厂方法模式可以看做模板+简单工厂的形式。
  • 创建工厂，令子类继承工厂中的通用方法，令子类重载工厂中的特殊抽象方法。
  1.     public static abstract class AbstractProductFactory {
  3.         public Product createProduct() {
  4.             commonCreate();
  5.             return specificCreate();
  6.         }
  8.         private void commonCreate() {
  9.             System.out.println("生产产品的通用逻辑，修改");  
  10.         }
  12.         protected abstract Product specificCreate();
  14.     }
  • 创建具象的工厂，继承抽象工厂，使自己单例并重载特殊逻辑。
  1.     public static class Product1Factory extends AbstractProductFactory {
  3.         private static final Product1Factory instance = new Product1Factory();
  5.         private Product1Factory() {
  7.         }
  9.         public static Product1Factory get() {
  10.             return instance;
  11.         }
  13.         @Override
  14.         public Product specificCreate() {
  15.             System.out.println("生产产品1的特殊逻辑");
  16.             return new Product1();
  17.         }
  19.     }
  21.     public static class Product2Factory extends AbstractProductFactory {
  23.         private static final Product2Factory instance = new Product2Factory();
  25.         private Product2Factory() {
  27.         }
  29.         public static Product2Factory get() {
  30.             return instance;
  31.         }
  33.         @Override
  34.         public Product specificCreate() {
  35.             System.out.println("生产产品2的特殊逻辑");
  36.             return new Product2();
  37.         }
  39.     }
  41.     public static class Product3Factory extends AbstractProductFactory {
  43.         private static final Product3Factory instance = new Product3Factory();
  45.         private Product3Factory() {
  47.         }
  49.         public static Product3Factory get() {
  50.             return instance;
  51.         }
  53.         @Override
  54.         public Product specificCreate() {
  55.             System.out.println("生产产品3的特殊逻辑");
  56.             return new Product3();
  57.         }
  59.     }
  • 测试
  1.     public static void main(String[] args) {
  2.         Product product1 = Product1Factory.get().createProduct();
  3.         Product product2 = Product2Factory.get().createProduct();
  4.         Product product3 = Product3Factory.get().createProduct();
  6.         product1.execute();
  7.         product2.execute();
  8.         product3.execute();
  9.     }

抽象工厂

  • 这种工厂模式适用于生产一组一组的产品，但是每组的产品组成也不一定一样。例如一个工厂只生产A和B两种产品，一开始它一直生产A1和B1这两种形式，后来他要生产A2和B3了。此时就可以通过修改工厂来改变产品生产种类。
  • 创建产品种类和产品形式
  1.     public interface ProductA {
  3.         void execute();
  5.     }
  7.     public static class ProductA1 implements ProductA {
  9.         public void execute() {
  10.             System.out.println("产品A1的功能逻辑");
  11.          }
  13.     }
  15.     public static class ProductA2 implements ProductA {
  17.         public void execute() {
  18.             System.out.println("产品A2的功能逻辑");
  19.          }
  21.     }
  23.     public static class ProductA3 implements ProductA {
  25.         public void execute() {
  26.             System.out.println("产品A3的功能逻辑");
  27.          }
  29.     }
  31.     public interface ProductB {
  33.         void execute();
  35.     }
  37.     public static class ProductB1 implements ProductB {
  39.         public void execute() {
  40.             System.out.println("产品B1的功能逻辑");
  41.          }
  43.     }
  45.     public static class ProductB2 implements ProductB {
  47.         public void execute() {
  48.             System.out.println("产品B2的功能逻辑");
  49.          }
  51.     }
  53.     public static class ProductB3 implements ProductB {
  55.         public void execute() {
  56.             System.out.println("产品B3的功能逻辑");
  57.          }
  59.     }
  • 创建工厂接口
  1.     /**
  2.      * 工厂的职责就是生产A和B两种产品
  3.      */
  4.     public interface Factory {
  6.         ProductA createProductA();
  7.         ProductB createProductB();
  9.     }
  • 创建各类工厂
  1.     public static class Factory1 implements Factory {
  3.         private static final Factory1 instance = new Factory1();
  5.         private Factory1() {
  7.         }
  9.         public static Factory get() {
  10.             return instance;
  11.         }
  13.         public ProductA createProductA() {
  14.             return new ProductA1();
  15.         }
  17.         public ProductB createProductB() {
  18.             return new ProductB3(); 
  19.         }
  21.     }
  23.     public static class Factory2 implements Factory {
  25.         private static final Factory2 instance = new Factory2();
  27.         private Factory2() {
  29.         }
  31.         public static Factory get() {
  32.             return instance;
  33.         }
  35.         public ProductA createProductA() {
  36.             return new ProductA2();
  37.         }
  39.         public ProductB createProductB() {
  40.             return new ProductB2(); 
  41.         }
  43.     }
  45.     public static class Factory3 implements Factory {
  47.         private static final Factory3 instance = new Factory3();
  49.         private Factory3() {
  51.         }
  53.         public static Factory get() {
  54.             return instance;
  55.         }
  57.         public ProductA createProductA() {
  58.             return new ProductA3();
  59.         }
  61.         public ProductB createProductB() {
  62.             return new ProductB3(); 
  63.         }
  65.     }
  • 测试
  1.     public static void main(String[] args) {
  2.         // 产品A1+产品B1 -> 产品A1+产品B3
  3.         ProductA firstProductA = Factory1.get().createProductA();
  4.         ProductB firstProductB = Factory1.get().createProductB();
  5.         firstProductA.execute();
  6.         firstProductB.execute();
  8.         // 产品A2+产品B2
  9.         ProductA secondProductA = Factory2.get().createProductA();
  10.         ProductB secondProductB = Factory2.get().createProductB();
  11.         secondProductA.execute();
  12.         secondProductB.execute();
  14.         // 产品A3+产品B3
  15.         ProductA thirdProductA = Factory3.get().createProductA();
  16.         ProductB thirdProductB = Factory3.get().createProductB();
  17.         thirdProductA.execute();
  18.         thirdProductB.execute();
  20.         // 哪怕你有100个地方定义了产品组合，要调整组合的逻辑，只要修改一个工厂就可以了
  21.     }