java工厂模式实例

目录

java工厂模式

工厂模式其实又分为三种

1.简单工厂模式：

简单工厂模式(非静态)

 简单工厂模式（静态）：

2.工厂方法模式：

3.抽象工厂模式：

---

java工厂模式

开篇声明，此理解为作者自身理解，不一定正确，如有错误请大佬们指正。

工厂模式，在作者看来，从现实生活来说，就是一个工厂，里面有N个车间，

每个车间会生产不同的产品，而租户只需要告诉这个工厂的老板我需要一个

什么产品，老板会去找到对应的车间返回给租户使用。

画个图理解：

如果使用java语言来描述则是，对具有相同动作，不同动作执行过程的一

类方法抽象出一个接口类，然后不同的实现类对接口类中的接口进行不同的

实现，并且编写一个工厂类，根据传入获取不同的实现类实例返回给调用者，调用者使用得到的实例

执行具体的方法。画个图（简单的加减乘除做示例，没怎么画过UML图，如果有错误，请见谅）：

TestServiceImpl为业务逻辑实现类，MathFactory为工厂类，MathOperation为算法抽象接口类，

xxxOpreation为算法具体实现类，Class为java原生类，主要是要使用反射机制，会用到

工厂模式其实又分为三种

1.简单工厂模式：

简单工厂模式(非静态)

       就是提供一个接口interface，然后不同的实现类实现interface，再提供一个

工厂类，在工厂类中通过if条件判断，new出具体的实现类给调用者使用。

抽象接口

public interface MathOperation {
    double apply(int a, int b);
}

抽象接口实现 

import com.liu.test.math.MathOperation;

public class AddOperation implements MathOperation {
    @Override
    public double apply(int a, int b) {
        return (double) a + b;
    }
}

import com.liu.test.math.MathOperation;

public class SubOperation implements MathOperation {
    @Override
    public double apply(int a, int b) {
        return (double) a - b;
    }
}

 工厂类

import com.liu.test.math.operation.AddOperation;
import com.liu.test.math.operation.SubOperation;

public class MatchFactory {

    /**
      * 获得具体的操作类型
      * @author kevin
      * @param operator :
      * @return java.util.Optional
      * @date 2021/1/25 11:36
      */
    public static Optional getOperation(String operator) {
        MathOperation result = null;
        if("add".equals(operator)){
            result = new AddOperation();
        }else if("sub".equals(operator)){
            result = new SubOperation();
        }
        return Optional.ofNullable(result);
    }
}

使用类

        MathOperation operation = MathFactory.getOperation(operator).orElseThrow(() ->
                new IllegalArgumentException("未知的操作"));
        result = operation.apply(first, second);
        return result;

 简单工厂模式（静态）：

       就是在第一步的基础之上，将new的动作提出来，放到static块中执行，然后

将产生的实现类实例存放到静态的map中，用户调用的时候，直接从map中get对应的实例。

此模式不符合java的闭环原则（对扩展开放，对修改关闭）

静态只需调整工厂类即可，其他不变

import com.liu.test.math.operation.AddOperation;
import com.liu.test.math.operation.DivideOperation;
import com.liu.test.math.operation.MultiplyOperation;
import com.liu.test.math.operation.SubOperation;

import java.util.HashMap;
import java.util.Map;

public class MatchFactory {
    static Map operationMap = new HashMap<>();
    static {
        operationMap.put("add", new AddOperation());
        operationMap.put("sub", new SubOperation());
    }

    public static Optional getOperation(String operator) {
        return Optional.ofNullable(operationMap.get(operator));
    }
}

2.工厂方法模式：

为了解决第一种简单工厂模式的缺陷，产生了工厂方法模式，把工厂方法再次进行抽象，

为不同的实现类，提供不同的工厂，通过实现抽象工厂接口类的方法，实现不同工厂获取

业务实现类的不同实例，调用的时候，通过判断，使用不同的工厂（在简单工厂模式基础上）

抽象一个工厂接口

import java.util.Optional;

public interface MathFactoryInterface {

    Optional getOperation(String operator) ;
}

工厂接口实现

import com.liu.test.math.operation.AddOperation;

import java.util.Optional;

public class AddFactory implements MathFactoryInterface {
    @Override
    public Optional getOperation(String operator) {
        return Optional.of(new AddOperation());
    }
}

import com.liu.test.math.operation.SubOperation;

import java.util.Optional;

public class SubFactory implements MathFactoryInterface{
    @Override
    public Optional getOperation(String operator) {
        return Optional.of(new SubOperation());
    }
}

将原有的工厂类MathFactory删除，使用类中调整-增加方法：

    private MathFactoryInterface getFactory(String operator){
        MathFactoryInterface result = null;
        if("add".equals(operator)){
            result = new AddFactory();
        }else if("sub".equals(operator)){
            result = new SubFactory();
        }
        return Optional.ofNullable(result).orElseThrow(() -> new IllegalArgumentException("未知的操作"));
    }

使用类中调整-更改调用方式：

        MathFactoryInterface factory = getFactory(operator);
        return factory.getOperation().orElseThrow(() ->
                new IllegalArgumentException("未知的操作")).apply(first, second);

3.抽象工厂模式：

       就是将操作归类，然后分别提供接口，同类下的具体事物实现同一个接口。然后抽象一个工厂接口，

按照不同类别，提供不同的待实现工厂方法；再提供具体的工厂实现类，实现抽象的工厂接口，并在不

同的方法（同一类事物的获取方法）中根据入参返回同类事物中具体的事物，最后给到调用者执行。

比如，将加减与乘除分开：

首先定义加减抽象接口：

public interface AddAndSub {
    double apply(int first, int second);
}

实现加减接口：

import com.liu.test.math.AddAndSub;

public class Add implements AddAndSub {
    @Override
    public double apply(int first, int second) {
        return (double) first + first;
    }
}

import com.liu.test.math.AddAndSub;

public class Sub implements AddAndSub {
    @Override
    public double apply(int first, int second) {
        return (double) first - first;
    }
}

定义乘除抽象接口：

public interface MultiplyAndDivide {
    double apply(int first, int second);
}

实现乘除接口：

import com.liu.test.math.MultiplyAndDivide;

public class Multiply implements MultiplyAndDivide {
    @Override
    public double apply(int first, int second) {
        return (double) first * second;
    }
}

import com.liu.test.math.MultiplyAndDivide;

public class Divide implements MultiplyAndDivide {
    @Override
    public double apply(int first, int second) {
        return (double) first / second;
    }
}

定义工厂抽象接口：

public interface AbstractOperation {
    AddAndSub createAddOrSub(String operator);
    MultiplyAndDivide createMultiplyOrDivide(String operator);
}

实现工厂抽象接口：

import com.liu.test.math.AbstractOperationFactory;
import com.liu.test.math.AddAndSub;
import com.liu.test.math.MultiplyAndDivide;

import java.util.Optional;

public class MatchFactory implements AbstractOperationFactory {
    @Override
    public AddAndSub createAddOrSub(String operator) {
        AddAndSub result = null;
        if("add".equals(operator)){
            result = new Add();
        }else if("sub".equals(operator)){
            result = new Sub();
        }
        return Optional.ofNullable(result).orElseThrow(() -> new IllegalArgumentException("未知的操作"));
    }

    @Override
    public MultiplyAndDivide createMultiplyOrDivide(String operator) {
        MultiplyAndDivide result = null;
        if("multiply".equals(operator)){
            result = new Multiply();
        }else if("divide".equals(operator)){
            result = new Divide();
        }
        return Optional.ofNullable(result).orElseThrow(() -> new IllegalArgumentException("未知的操作"));
    }
}

通过调用不同的抽象工厂的实现获得具体的实例，执行方法得到想要的结果。

        double result = Integer.MIN_VALUE;
        AbstractOperationFactory factory = new MatchFactory();
        if("add".equals(operator) || "sub".equals(operator)){
            AddAndSub operation= factory.createAddOrSub(operator);
            result = operation.apply(first, second);
        }else if("multiply".equals(operator) || "divide".equals(operator)){
            MultiplyAndDivide operation= factory.createMultiplyOrDivide(operator);
            result = operation.apply(first, second);
        }

        return result;