My logo
Published on

factory 工厂模式（重要）

假设有N个client都new了一个ProductImpl出来，结果，到了后面某一天，你要把ProductImpl换成ProductNewImpl了，完全换一套实现逻辑，这个时候就坑了。你需要在N个client里，都修改new ProductImpl()这个方法，简直是一场灾难啊。尤其如果调用你的类的是别人呢？别人还得来care这个事情？

所以一般都是用工厂的思想来提供所有实现类实例，然后调用方面向接口来编程即可，接口不变，调用方代码不用变。

而在真正的企业开发中，现在我们都很少自己做工厂实现了，因为有spring ，spring 的容器其实本质上就是个大工厂的概念，这个工厂里什么对象都有，你需要什么，自己去找spring 要就好了，非常方便。所以我们队工厂模式的体验，就在这个阶段，通过spring的容器使用来给大家实践。

spring会基于xml或者是注解，根据一些配置，去创建出来所有我们需要的这个类的实例，此时spring就相当于是个工厂。

一般工厂模式：

一般模式编写：

package wang.jinggo.basics.zhss.factory;

/**
 * @author: wangyj
 * @create: 2021-10-19
 * @version: 1.0.0
 **/
public class WithoutFactoryPatternDemo {

    //	public static class Product {
//
//		private String name;
//
//		public Product(String name) {
//			super();
//			this.name = name;
//		}
//
//		public String getName() {
//			return name;
//		}
//
//		public void setName(String name) {
//			this.name = name;
//		}
//
//		@Override
//		public String toString() {
//			return "Product [name=" + name + "]";
//		}
//
//	}

    public static class Product2 {

        private String name;

        public Product2(String name) {
            super();
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "Product [name=" + name + "]";
        }
    }

    public static void main(String[] args) {
        Product2 product = new Product2("测试产品");
        System.out.println(product);

        // 如果你直接面向一个类来编程，new来创建类的实例的话，后面会很难维护
        // 我们如果对Product，要更换一个类，换一个类的实现
        // 此时就必须在创建这个类实例的地方，都要修改一下这个代码
        // 如果你有100个地方，都创建了Product这个类的实例
        // 你需要在100个地方都去修改这个new Product()的这段代码
    }
}

设计模式编写：

package wang.jinggo.basics.zhss.factory;

/**
 * @author: wangyj
 * @create: 2021-10-20
 * @version: 1.0.0
 **/
public class FactoryPatternDemo {

    public static void main(String[] args) {
        Product product = ProductFactory.create();
        product.execute();

        // 如果此时有100个地方都需要获取Product的实例
        // 但是此时Product实现类改了
        // 我们只要修改一个地方即可，就是ProductFacory中
    }

    //	public static class ProductImpl1 implements Product {
//
//		public void execute() {
//			System.out.print("产品1的功能实现");
//		}
//
//	}

    public interface Product {

        void execute();

    }

    public static class ProductImpl2 implements Product {

        public void execute() {
            System.out.print("产品1的功能实现");
        }

    }

    public static class ProductFactory {

        public static Product create() {
            return new ProductImpl2();
        }

    }
}

模板方法模式+简单工厂模式：

factory method模式：模板方法模式+简单工厂模式，简单工厂模式稍微复杂一点的变种

场景：

  1. 我们现在要生产的产品有多种；
  2. 每种产品的生产过程，都有一些是共同的逻辑，但是也有一些是特殊的逻辑；
  3. 现在要生产出来各种产品。

这种设计模式算是较为复杂一点的了，适用的是比较复杂的场景了一般就是在有复杂工厂生产场景的情况下，比如就是需要多种工厂生产不同的产品，但是产品都是类似的，同时不同的工厂有一定的相同逻辑，那么就用这种模式。

一般模式编写：

package wang.jinggo.basics.zhss.factory;

/**
 * @author: wangyj
 * @create: 2021-10-20
 * @version: 1.0.0
 **/
public class WithoutFactoryMethodPatternDemo {

    public static void main(String[] args) {
        Product product1 = Product1Factory.createProduct();
        Product product2 = Product2Factory.createProduct();
        Product product3 = Product3Factory.createProduct();

        product1.execute();
        product2.execute();
        product3.execute();

        // 跟模板方法模式的问题一模一样
        // 就是多个工厂类中，有生产产品的相同的通用逻辑，没有抽取出来，直接复制粘贴放多个工厂里了
        // 如果那段通用逻辑要修改
        // 就需要很麻烦到所有工厂中去修改代码；可能会忘记修改某个工厂的代码
    }

    public interface Product {

        void execute();

    }

    public static class Product1 implements Product {

        public void execute() {
            System.out.println("产品1的功能逻辑");
        }

    }

    public static class Product2 implements Product {

        public void execute() {
            System.out.println("产品2的功能逻辑");
        }

    }

    public static class Product3 implements Product {

        public void execute() {
            System.out.println("产品3的功能逻辑");
        }

    }

    public static class Product1Factory {

        public static Product createProduct() {
            System.out.println("生产产品的通用逻辑，修改");
            System.out.println("生产产品1的特殊逻辑");
            return new Product1();
        }

    }

    public static class Product2Factory {

        public static Product createProduct() {
            System.out.println("生产产品的通用逻辑，修改");
            System.out.println("生产产品2的特殊逻辑");
            return new Product2();
        }

    }

    public static class Product3Factory {

        public static Product createProduct() {
            System.out.println("生产产品的通用逻辑");
            System.out.println("生产产品3的特殊逻辑");
            return new Product3();
        }

    }
}

设计模式编写：

package wang.jinggo.basics.zhss.factory;

/**
 * @author: wangyj
 * @create: 2021-10-20
 * @version: 1.0.0
 **/
public class FactoryMethodPatternDemo {

    public interface Product {

        void execute();

    }

    public static class Product1 implements Product {

        public void execute() {
            System.out.println("产品1的功能逻辑");
        }

    }

    public static class Product2 implements Product {

        public void execute() {
            System.out.println("产品2的功能逻辑");
        }

    }

    public static class Product3 implements Product {

        public void execute() {
            System.out.println("产品3的功能逻辑");
        }

    }

    public static abstract class AbstractProductFactory {

        public Product createProduct() {
            commonCreate();
            return specificCreate();
        }

        private void commonCreate() {
            System.out.println("生产产品的通用逻辑，修改");
        }

        protected abstract Product specificCreate();

    }

    public static class Product1Factory extends AbstractProductFactory {

        private static final Product1Factory instance = new Product1Factory();

        private Product1Factory() {

        }

        public static Product1Factory get() {
            return instance;
        }

        public Product specificCreate() {
            System.out.println("生产产品1的特殊逻辑");
            return new Product1();
        }

    }

    public static class Product2Factory extends AbstractProductFactory {

        private static final Product2Factory instance = new Product2Factory();

        private Product2Factory() {

        }

        public static Product2Factory get() {
            return instance;
        }

        public Product specificCreate() {
            System.out.println("生产产品2的特殊逻辑");
            return new Product2();
        }

    }

    public static class Product3Factory extends AbstractProductFactory {

        private static final Product3Factory instance = new Product3Factory();

        private Product3Factory() {

        }

        public static Product3Factory get() {
            return instance;
        }

        public Product specificCreate() {
            System.out.println("生产产品3的特殊逻辑");
            return new Product3();
        }

    }
}

abstract factory模式 -> 简单工厂模式的变种 -> 最复杂的一个变种

场景：

  1. 就是我们现在要生产的不是一个一个产品，而一个一个的产品组合；
  2. 比如说我们有产品ABC，现在第一种产品组合是A+B，第二种产品组合是B+C，第三种产品组合是A+C；
  3. 就是要对工厂模式进行进一步的增强。

这种模式就更复杂了，在实际开发场景中，更加少见了。因为其核心思想是，如果需要一个工厂，这个工厂可以生产出相关联的一批产品，然后不同的工厂实现，会生产出一批不同的产品组合。

一般模式编写：

package wang.jinggo.basics.zhss.factory;

/**
 * @author: wangyj
 * @create: 2021-10-20
 * @version: 1.0.0
 **/
public class WithoutAbstractFactoryPatternDemo {

    public static void main(String[] args) {
        // 我们现在要创建产品A1+产品B1的组合
        //		ProductA productA1 = new ProductA1();
        //		ProductB productB1 = new ProductB1();
        //
        //		productA1.execute();
        //		productB1.execute();

        // 变成产品A1+产品B3的组合
        ProductA productA1 = new ProductA1();
        ProductB otherProductB3 = new ProductB3();

        productA1.execute();
        otherProductB3.execute();

        // 问题来了，调整产品组合的这个行为，如果你手动创建产品组合的代码，有100个地方，A1+B1
        // 一旦要调整，就是要对100个地方的代码，手动一点一点的去修改，组合的逻辑
        // 不可维护，不可扩展

        // 我们现在要创建产品A2+产品B2的组合
        ProductA productA2 = new ProductA2();
        ProductB productB2 = new ProductB2();

        productA2.execute();
        productB2.execute();

        // 我们现在要创建产品A3+产品B3的组合
        ProductA productA3 = new ProductA3();
        ProductB productB3 = new ProductB3();

        productA3.execute();
        productB3.execute();
    }

    public interface ProductA {

        void execute();

    }

    public static class ProductA1 implements ProductA {

        public void execute() {
            System.out.println("产品A1的功能逻辑");
        }

    }

    public static class ProductA2 implements ProductA {

        public void execute() {
            System.out.println("产品A2的功能逻辑");
        }

    }

    public static class ProductA3 implements ProductA {

        public void execute() {
            System.out.println("产品A3的功能逻辑");
        }

    }

    public interface ProductB {

        void execute();

    }

    public static class ProductB1 implements ProductB {

        public void execute() {
            System.out.println("产品B1的功能逻辑");
        }

    }

    public static class ProductB2 implements ProductB {

        public void execute() {
            System.out.println("产品B2的功能逻辑");
        }

    }

    public static class ProductB3 implements ProductB {

        public void execute() {
            System.out.println("产品B3的功能逻辑");
        }

    }

}

设计模式编写：

package wang.jinggo.basics.zhss.factory;

/**
 * @author: wangyj
 * @create: 2021-10-20
 * @version: 1.0.0
 **/
public class AbstractFactoryPatternDemo {

    public interface ProductA {

        void execute();

    }

    public static class ProductA1 implements ProductA {

        public void execute() {
            System.out.println("产品A1的功能逻辑");
        }

    }

    public static class ProductA2 implements ProductA {

        public void execute() {
            System.out.println("产品A2的功能逻辑");
        }

    }

    public static class ProductA3 implements ProductA {

        public void execute() {
            System.out.println("产品A3的功能逻辑");
        }

    }

    public interface ProductB {

        void execute();

    }

    public static class ProductB1 implements ProductB {

        public void execute() {
            System.out.println("产品B1的功能逻辑");
        }

    }

    public static class ProductB2 implements ProductB {

        public void execute() {
            System.out.println("产品B2的功能逻辑");
        }

    }

    public static class ProductB3 implements ProductB {

        public void execute() {
            System.out.println("产品B3的功能逻辑");
        }

    }

    public interface Factory {

        ProductA createProductA();
        ProductB createProductB();

    }

    public static class Factory1 implements Factory {

        private static final Factory1 instance = new Factory1();

        private Factory1() {

        }

        public static Factory get() {
            return instance;
        }

        public ProductA createProductA() {
            return new ProductA1();
        }

        public ProductB createProductB() {
            return new ProductB3();
        }

    }

    public static class Factory2 implements Factory {

        private static final Factory2 instance = new Factory2();

        private Factory2() {

        }

        public static Factory get() {
            return instance;
        }

        public ProductA createProductA() {
            return new ProductA2();
        }

        public ProductB createProductB() {
            return new ProductB2();
        }

    }

    public static class Factory3 implements Factory {

        private static final Factory3 instance = new Factory3();

        private Factory3() {

        }

        public static Factory get() {
            return instance;
        }

        public ProductA createProductA() {
            return new ProductA3();
        }

        public ProductB createProductB() {
            return new ProductB3();
        }

    }
}