【设计模式-工厂方法】想象力和创造力：你考虑过自动化实现工厂吗？

本文链接：https://blog.csdn.net/Ginny97/article/details/129759048

无限思维-想象力和创造力：自动化实现工厂方法

前言
一、《大话设计模式》对应的Java版本工厂方法
二、想象力：创新型思维+解决思路
三、创造力：通过创造力加以实现！
总结升华
- 小测试：你无限思维的去思考问题了吗？

前言

设计模式之工厂方法，你能不能通过无限思维去考虑，提出一些想象力创造力的问题：
如果后期要动态的添加无数个运算类怎么办？
我们能不能让计算机帮我们实现自动化的添加运算类？
我们程序员手动添加的类和代码，能不能让计算机帮我们自动生成代码呢？
最重要的是你会提出来这样的问题吗？
…
我们做软件开发的需要有想象力和创造力，这是需要在学习代码过程中不断的去培养和提高的一个过程：
创新型思考+解决思路+实现！！！

一、《大话设计模式》对应的Java版本工厂方法

类图先行：

在这里插入图片描述
需要注意类图的规范：类、接口以及六大关系的线:

类图中的接口：
①接口名要加上<>
②接口中的方法必须是斜体的
抽象类：
①抽象类的名称必须是斜体的；
②抽象类中的抽象方法必须是斜体的，非抽象方法是不用斜体的。

对于类图画图规范有需要复习或者了解的，请移步博主的博客：
链接: 类图的作用与画图规范

代码实现：

客户端代码：

/**
 * @Author: Ariel(huan)
 * @Description:客户端
 * @CreateDate: 2023/3/24 22:37
 */
public class Client {
    public static void main(String[] args) {
        IOperationFactory operationFactory=new OperationAddFactory();
        Operation operation=operationFactory.createOperation();
        operation.setNumberOne(1);
        operation.setNumberTwo(2);
        double result = operation.getResult();
        System.out.println("result:"+result);
    }
}

运算类代码：

/**
 * @Author: Ariel(huan)
 * @Description:抽象类-算法类
 * @CreateDate: 2023/3/24 22:24
 */
public abstract class Operation {
    private double numberOne;
    private double numberTwo;

    public double getNumberOne() {
        return numberOne;
    }

    public double getNumberTwo() {
        return numberTwo;
    }

    public void setNumberOne(double numberOne) {
        this.numberOne = numberOne;
    }

    public void setNumberTwo(double numberTwo) {
        this.numberTwo = numberTwo;
    }
    public abstract double getResult();
}

/**
 * @Author: Ariel(huan)
 * @Description:加法类
 * @CreateDate: 2023/3/24 22:27
 */
public class OperationAdd extends Operation {
    @Override
    public double getResult() {
        return getNumberOne()+getNumberTwo();
    }
}

/**
 * @Author: Ariel(huan)
 * @Description:减法类
 * @CreateDate: 2023/3/24 22:28
 */
public class OperationSub extends Operation {
    @Override
    public double getResult() {
        return getNumberOne()-getNumberTwo();
    }
}

/**
 * @Author: Ariel(huan)
 * @Description:乘法类
 * @CreateDate: 2023/3/24 22:29
 */
public class OperationMul extends Operation {
    @Override
    public double getResult() {
        return getNumberOne()*getNumberTwo();
    }
}

/**
 * @Author: Ariel(huan)
 * @Description:除法类
 * @CreateDate: 2023/3/24 22:29
 */
public class OperationDiv extends Operation {
    @Override
    public double getResult() {
        if (getNumberTwo()!=0){
            return getNumberOne()/getNumberTwo();
        }else {
            System.out.println("除数不可以为0");
        }
        return 0;
    }
}

运算工厂类代码:

/**
 * @Author: Ariel(huan)
 * @Description:算法工厂接口
 * @CreateDate: 2023/3/24 22:25
 */
public interface IOperationFactory {
   Operation createOperation();
}

/**
 * @Author: Ariel(huan)
 * @Description: 创建加法类的工厂类
 * @CreateDate: 2023/3/24 22:33
 */
public class OperationAddFactory implements IOperationFactory{
    @Override
    public Operation createOperation() {
        return new OperationAdd();
    }
}

/**
 * @Author: Ariel(huan)
 * @Description: 创建减法类的工厂类
 * @CreateDate: 2023/3/24 22:34
 */
public class OperationSubFactory implements IOperationFactory {
    @Override
    public Operation createOperation() {
        return new OperationSub();
    }
}

/**
 * @Author: Ariel(huan)
 * @Description:创建乘法类的工厂类
 * @CreateDate: 2023/3/24 22:35
 */
public class OperationMulFactory implements IOperationFactory{
    @Override
    public Operation createOperation() {
        return new OperationMul();
    }
}

/**
 * @Author: Ariel(huan)
 * @Description:创建除法类的工厂类
 * @CreateDate: 2023/3/24 22:36
 */
public class OperationDivFactory implements IOperationFactory{
    @Override
    public Operation createOperation() {
        return new OperationDiv();
    }
}

思考升华：

书本上的工厂方法，学习并思考，提出问题：
工厂方法为什么叫工厂方法？简单工厂为什么叫简单工厂？
在代码中怎么体现的？一定要对应到代码上，不能模棱两可。
工厂方法对比简单工厂有哪些优化和好处？
工厂方法的出现有哪些革命性的意义？
工厂方法还存在什么问题，还可以怎么优化？
工厂方法还可以怎么实现？…

二、想象力：创新型思维+解决思路

战略上：以无限思维的角度去想问题：

1、后期动态的添加无数个运算类怎么办？
2、能不能让计算机帮我们自动生成代码呢？
3、后期动态添加的运算类能不能在程序运行过程中添加并执行运算？——不重启运行

部署上：将需求、问题等进行拆分：

1、我们程序员去创建新的运算类、运算工厂以及Client类是一个重复有规律的过程，能不能交给程序去完成，让计算机自动生成运算类、运算工厂类或者Client可不可以？
2、如果程序帮我们生成了对应的运算类、工厂以及Client我们要怎么在程序运行过程中，调用对应的运算方法进行运算呢？

战术上：每一部分具体怎么实现：

1、我们怎么让计算机自动生成运算类、运算工厂类或者Client？——提供模板，让计算机根据模板去动态的创建
2、如果程序帮我们生成了对应的运算类、工厂以及Client我们要怎么在程序运行过程中，调用对应的运算方法进行运算呢？——动态编译+反射执行
3、后期动态添加的类在运行过程中添加并执行运行？——对于新增的类进行动态注册或者扫描+动态编译+反射执行

升华：

想象力和创造力：凡是我们能干的事情，计算机都能干；凡是软件能干的事情，硬件都能干…
最重要的是你会从无限思维的角度思考问题吗？

三、创造力：通过创造力加以实现！

一步一步思考和实现的过程如下：

新手上路——需求1：已有算法类，写一段程序让计算机自动化生成算法工厂类以及对应的客户端类

方案：扫描——扫描算法类

1、实现思路：

①通过扫描算法类包，获取到所有的算法类文件，并获取到各类名；
②读取工厂类模板和客户端模板，获取到.java文件对应的模板内容；
③替换模板中的模板“占位符”，替换为我们对应的算法类名和算法符号；
④通过I/O输入输出流，创建新的.java文件，即算法工厂类和算法客户端类

2、类图：

3、项目结构图：

在这里插入图片描述

4、代码：

工厂接口：

/**
 * @Author: Ariel(huan)
 * @Description:工厂接口
 * @CreateDate: 2023/3/14 11:23
 */
public interface IFactory {
    Operation createOperation();
}

运算类-抽象类：

/**
 * @Author: Ariel(huan)
 * @Description:算法抽象类
 * @CreateDate: 2023/3/14 11:37
 */
public abstract class Operation {
    private double numberA=0;
    private double numberB=0;

    public double getNumberA() {
        return numberA;
    }

    public double getNumberB() {
        return numberB;
    }

    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }

    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }

    public abstract double getResult();
}

运算类包operation下的运算类：

/**
 * @Author: Ariel(huan)
 * @Description:加法类
 * @CreateDate: 2023/3/14 11:51
 */
public class OperationAdd extends Operation {

    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA() + getNumberB();
        return result;
    }
}

/**
 * @Author: Ariel(huan)
 * @Description:减法类
 * @CreateDate: 2023/3/15 19:56
 */
public class OperationSub extends Operation {
    @Override
    public double getResult() {
        double result=0;
        result=getNumberA()-getNumberB();
        return result;
    }
}

/**
 * @Author: Ariel(huan)
 * @Description:乘法类
 * @CreateDate: 2023/3/15 20:01
 */
public class OperationMul extends Operation {
    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA() * getNumberB();
        return result;
    }
}

/**
 * @Author: Ariel(huan)
 * @Description:除法类
 * @CreateDate: 2023/3/15 19:57
 */
public class OperationDiv extends Operation {
    @Override
    public double getResult() {
        double result=0;
        try {
            if (getNumberB() == 0) {
                throw new Exception("除数不能为0");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        result=getNumberA()/getNumberB();
        return result;
    }
}

工厂模板：

/**
 * @Author: Ariel(huan)
 * @Description: 工厂模板类
 * @CreateDate: 2023/3/15 22:10
 */
public class FactoryTemplate implements IFactory {
    @Override
    public Operation createOperation() {
        return new OperationAdd();//这个模板里以 new OperationAdd为例
    }
}

客户端模板：

/**
 * @Author: Ariel(huan)
 * @Description:运算器的客户端模板类
 * @CreateDate: 2023/3/16 9:18
 */
public class OperationClientTemplate {
    public static void main(String[] args) {
        IFactory operFactory=new FactoryTemplate();
        Operation operation = operFactory.createOperation();
        operation.setNumberA(1);
        operation.setNumberB(2);
        double result = operation.getResult();
        System.out.println("result是:"+result);

    }
}

程序启动的客户端：

public class Client {
    public static void main(String[] args) throws IOException {
        //拿到算法类的类名集合
        ClassNameUtil classUtil = new ClassNameUtil();
        List<String> classNameList = classUtil.getClassNameList();

        //读取FactoryTemplate模板类.java文件，获取到内容，然后遍历classNameList进行类名的替换并指定路径生成Factory类
        String operationContent = readTemplateContent();
        for (int i = 0; i < classNameList.size(); i++) {
            String className = classNameList.get(i);
            String operationContentNew= operationContent.replace("FactoryTemplate",className+"Factory").replaceAll("OperationAdd", className);
            String filePath="E:\\Study\\TGB学习资料\\06设计模式研究\\李欢\\design-pattern\\newStudyHuan\\src\\com\\tfjy" +
                    "\\architecture\\factoryAutoCreate\\operationFactory\\"+className+"Factory.java";
            FileUtil.append(filePath,operationContentNew);
        }

        //读取 OperationClientTemplate模板类文件，获取到内容，然后遍历classNameList进行类名的替换并指定路径生成 OperationClient 类
        String OperClientTemContent = OperationClientTemplate();
        for (int i = 0; i < classNameList.size(); i++) {
            String className = classNameList.get(i);
            String OperClientTemContentNew= OperClientTemContent.replace("OperationClientTemplate",className+"Client").replaceAll("FactoryTemplate", className+"Factory");
            String filePath="E:\\Study\\TGB学习资料\\06设计模式研究\\李欢\\design-pattern\\newStudyHuan\\src\\com\\tfjy" +
                    "\\architecture\\factoryAutoCreate\\operationClient\\"+className+"Client.java";
            FileUtil.append(filePath,OperClientTemContentNew);
        }

    }

    private static String readTemplateContent() throws IOException {
        // 识别 FactoryTemplate.java文件
        String filePath = "E:\\Study\\TGB学习资料\\06设计模式研究\\李欢\\design-pattern\\newStudyHuan\\src\\com\\tfjy" +
                "\\architecture\\factoryAutoCreate\\operationFactory\\FactoryTemplate.java";
        FileInputStream fin = new FileInputStream(filePath);
        InputStreamReader reader = new InputStreamReader(fin);
        BufferedReader buffReader = new BufferedReader(reader);
        String strTmp = "";
        // FactoryTemplate.java文件中的文本内容
        StringBuffer operationContent = new StringBuffer();
        // 读一行文字，未读取任何字符的情况下到达流末尾，则不进行输出操作
        while((strTmp = buffReader.readLine())!=null){
            // 识别到了所有父类和子类的文本内容
            operationContent.append(strTmp);
            operationContent.append("\n");
        }
        buffReader.close();
        return operationContent.toString();
    }

    private static String OperationClientTemplate() throws IOException {
        // 识别 FactoryTemplate.java文件
        String filePath = "E:\\Study\\TGB学习资料\\06设计模式研究\\李欢\\design-pattern\\newStudyHuan\\src\\com\\tfjy" +
                "\\architecture\\factoryAutoCreate\\operationClient\\OperationClientTemplate.java";
        FileInputStream fin = new FileInputStream(filePath);
        InputStreamReader reader = new InputStreamReader(fin);
        BufferedReader buffReader = new BufferedReader(reader);
        String strTmp = "";
        // FactoryTemplate.java文件中的文本内容
        StringBuffer operationContent = new StringBuffer();
        // 读一行文字，未读取任何字符的情况下到达流末尾，则不进行输出操作
        while((strTmp = buffReader.readLine())!=null){
            // 识别到了所有父类和子类的文本内容
            operationContent.append(strTmp);
            operationContent.append("\n");
        }
        buffReader.close();
        return operationContent.toString();
    }

}

工具类：FileUtil 和 ClassNameUtil

/**
 * @Author: Ariel(huan)
 * @Description: 输入输出，生成新文件的工具类
 * @CreateDate: 2023/3/16 8:46
 */
public class FileUtil {

    /**
     * append:将一个字符写入一个已有的文件中，通过追加的方法追加到内容的末尾；
     * @author Bool
     * @param filePath
     * @param data
     */
    public static synchronized void append(String filePath , String data){

        String s;
        StringBuffer sb=new StringBuffer();

        try {

            //创建文件夹
            String dirPath=filePath.substring(0,filePath.lastIndexOf("/")+1);
            File dir=new File(dirPath);

            if(!dir.exists()){
                dir.mkdirs();
            }

            File f = new File(filePath);
            if (!f.exists()) {
                f.createNewFile();

                BufferedReader input = new BufferedReader(new FileReader(f));
                while ((s = input.readLine()) != null) {
                    sb.append(s);
                    sb.append("\n");
                }
                input.close();
                sb.append(data);
                BufferedWriter output = new BufferedWriter(new FileWriter(f));
                output.write(sb.toString());
                output.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


/**
 * @Author: Ariel(huan)
 * @Description: 扫描operation包下的所有类
 * @CreateDate: 2023/3/15 21:36
 */
public class ClassNameUtil {
    private static Set<Class<?>> classList;

    static {
        classList = getClasses("com.tfjy.architecture.factoryAutoCreate.operation");
    }

    /**
     * 从包package中获取所有的Class
     *
     * @param pack
     * @return
     */
    public static Set<Class<?>> getClasses(String pack) {

        // 第一个class类的集合
        Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
        // 是否循环迭代
        boolean recursive = true;
        // 获取包的名字 并进行替换
        String packageName = pack;
        String packageDirName = packageName.replace('.', '/');
        // 定义一个枚举的集合 并进行循环来处理这个目录下的things
        Enumeration<URL> dirs;
        try {
            dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
            // 循环迭代下去
            while (dirs.hasMoreElements()) {
                // 获取下一个元素
                URL url = dirs.nextElement();
                // 得到协议的名称
                String protocol = url.getProtocol();
                // 如果是以文件的形式保存在服务器上
                if ("file".equals(protocol)) {
                    // System.err.println("file类型的扫描");
                    // 获取包的物理路径
                    String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                    // 以文件的方式扫描整个包下的文件 并添加到集合中
                    findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
                } else if ("jar".equals(protocol)) {
                    // 如果是jar包文件
                    // 定义一个JarFile
                    // System.err.println("jar类型的扫描");
                    JarFile jar;
                    try {
                        // 获取jar
                        jar = ((JarURLConnection) url.openConnection()).getJarFile();
                        // 从此jar包 得到一个枚举类
                        Enumeration<JarEntry> entries = jar.entries();
                        // 同样的进行循环迭代
                        while (entries.hasMoreElements()) {
                            // 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
                            JarEntry entry = entries.nextElement();
                            String name = entry.getName();
                            // 如果是以/开头的
                            if (name.charAt(0) == '/') {
                                // 获取后面的字符串
                                name = name.substring(1);
                            }
                            // 如果前半部分和定义的包名相同
                            if (name.startsWith(packageDirName)) {
                                int idx = name.lastIndexOf('/');
                                // 如果以"/"结尾 是一个包
                                if (idx != -1) {
                                    // 获取包名 把"/"替换成"."
                                    packageName = name.substring(0, idx).replace('/', '.');
                                }
                                // 如果可以迭代下去 并且是一个包
                                if ((idx != -1) || recursive) {
                                    // 如果是一个.class文件 而且不是目录
                                    if (name.endsWith(".class") && !entry.isDirectory()) {
                                        // 去掉后面的".class" 获取真正的类名
                                        String className = name.substring(packageName.length() + 1, name.length() - 6);
                                        try {
                                            // 添加到classes
                                            classes.add(Class.forName(packageName + '.' + className));
                                        } catch (ClassNotFoundException e) {
                                            // log
                                            // .error("添加用户自定义视图类错误
                                            // 找不到此类的.class文件");
                                            e.printStackTrace();
                                        }
                                    }
                                }
                            }
                        }
                    } catch (IOException e) {
                        // log.error("在扫描用户定义视图时从jar包获取文件出错");
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return classes;
    }

        /**
         * 以文件的形式来获取包下的所有Class
         *
         * @param packageName
         * @param packagePath
         * @param recursive
         * @param classes
         */
        public static void findAndAddClassesInPackageByFile(String packageName, String packagePath,final boolean recursive, Set<Class<?>> classes){
            // 获取此包的目录 建立一个File
            File dir = new File(packagePath);
            // 如果不存在或者 也不是目录就直接返回
            if (!dir.exists() || !dir.isDirectory()) {
                // log.warn("用户定义包名 " + packageName + " 下没有任何文件");
                return;
            }
            // 如果存在 就获取包下的所有文件 包括目录
            File[] dirfiles = dir.listFiles(new FileFilter() {
                // 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
                public boolean accept(File file) {
                    return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
                }
            });
            // 循环所有文件
            for (File file : dirfiles) {
                // 如果是目录 则继续扫描
                if (file.isDirectory()) {
                    findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive,classes);
                } else {
                    // 如果是java类文件 去掉后面的.class 只留下类名
                    String className = file.getName().substring(0, file.getName().length() - 6);
                    try {
                        // 添加到集合中去
                        // classes.add(Class.forName(packageName + '.' +
                        // className));
                        // 经过回复同学的提醒，这里用forName有一些不好，会触发static方法，没有使用classLoader的load干净
                        classes.add(
                                Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));
                    } catch (ClassNotFoundException e) {
                        // log.error("添加用户自定义视图类错误 找不到此类的.class文件");
                        e.printStackTrace();
                    }
                }
            }
        }


    public List<String> getClassNameList(){
        List<String> classNameList = new ArrayList<>();
        Object[] ts =   classList.toArray();
        for(Object t:ts){
            Class<?> tt = (Class<?>) t;
            System.out.println(tt.getName());
            //截取最后一个.后边的类名: 字符串.substring(字符串.lastIndexOf(".")+1)；
            String className = tt.getName().substring(tt.getName().lastIndexOf(".") + 1);
            classNameList.add(className);
        }
       return classNameList;
    }
}

Readme 说明：
这一版实现的功能：
1、通过ClassNameUtil类扫描operation包下的所有类，通过反射拿到所有的全路径类名，并通过截取获得所有运算类的类名放到集合中
2、通过写两个模板，并识别模板文件内容，
3、通过遍历集合中的类名，替换需要替换的类名以及内容
4、通过FileUtil中的方法，替换并创建新的类文件
=========================================
该版待优化：
功能上：
1、只是实现了可以自动生成对应算法类的工厂和client，并没有编译新生成的工厂类和客户端类，也正常运行运算过程
2、还需要自动执行运算过程
3、需要让用户输入运算符来实现动态添加运算类、对应的预算工厂和Client
4、根据用户输入的运算符来动态的运算结果
代码上：
1、代码重复未抽象、封装、复用
2、常量未封装抽出来，应该放到配置文件中
============================================
注：
1、实现扫描获取operation包下所有类的工具类ClassNameUtil以及里边方法都可以自行修改或替换，且涉及到的包名要修改为自己的
2、程序启动的客户端类Client中涉及到绝对路径，需要修改为自己的文件路径

小试牛刀——需求2：让计算机帮我们自动生成算法类、算法工厂类以及对应的客户端类，并且进行编译和运算（最终目的是要运算出结果）

方案一：注册

1、实现思路：

①让用户从控制台输入要进行的运算类的类名和运算符号
②读取运算类模板（这里OperationAdd类作为运算类模板）、工厂类模板（FactoryTemplate）、运算客户端类模板（OperationClientTemplate）
③将模板中的运算类名和运算符替换为用户输入的
④生成运算类.java（MulClient）、运算工厂类.java（MulFactory）、运算客户端类.java（MulClient）
⑤调用JavaCompiler（动态编译机制），将生成的三个类进行动态编译.class文件
⑥通过反射执行运算客户端MulCilent中的运算方法（getResult方法）

关于动态编译机制的参考资料：
链接: 动态编译（JavaCompiler）

2、类图：

3、项目结构图：

在这里插入图片描述

4、代码：

运算抽象类（父类）：

/**
 * @Author: Ariel(huan)
 * @Description:算法抽象类
 * @CreateDate: 2023/3/14 11:37
 */
public abstract class Operation {
    private double numberA=0;
    private double numberB=0;
    public double getNumberA() {
        return numberA;
    }
    public double getNumberB() {
        return numberB;
    }
    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }
    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }

    public abstract double getResult();
}

工厂接口：

/**
 * @Author: Ariel(huan)
 * @Description:工厂接口
 * @CreateDate: 2023/3/14 11:23
 */
public interface IFactory {
    Operation createOperation();
}

运算类模板类：（这里是OperationAdd作为模板）

/**
 * @Author: Ariel(huan)
 * @Description:加法类
 * @CreateDate: 2023/3/14 11:51
 */
public class OperationAdd extends Operation {

    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA() + getNumberB();
        return result;
    }
}

运算工厂类模板：

/**
 * @Author: Ariel(huan)
 * @Description: 工厂模板类
 * @CreateDate: 2023/3/15 22:10
 */
public class FactoryTemplate implements IFactory {

    @Override
    public Operation createOperation() {
        return new OperationAdd();
    }
}

运算客户端类模板：

/**
 * @Author: Ariel(huan)
 * @Description:运算器的客户端模板类
 * @CreateDate: 2023/3/16 9:18
 */
public class OperationClientTemplate {
    public static void main(String[] args) {
        IFactory operFactory=new FactoryTemplate();
        Operation operation = operFactory.createOperation();
        operation.setNumberA(1);
        operation.setNumberB(2);
        double result = operation.getResult();
        System.out.println("result是:"+result);
    }
}

程序启动客户端：

/**
 * @Author: Ariel(huan)
 * @Description: 注册（触发实现）
 * @CreateDate: 2023/3/15 21:23
 */
public class Client {
    public static void main(String[] args) throws Exception {
        while (true){   //这里表示一直可以循环让用户在控制台输入，便于运行中用户随时多次添加运算类
            //让用户输入要进行的运算
            Scanner scanner=new Scanner(System.in);
            System.out.println("请输入想要运算的算法类名（Add、Sub、Mul、Div）:");
            String className=scanner.nextLine();
            System.out.println("请输入想要运算的算法符号（+、-、*、/）:");
            String character=scanner.nextLine();
            //根据用户输入的运算，生成对应的类并编译
            createCompilerFile(className, character);
            //反射执行
            reflectInvoke(className);//注释掉为手动
        }

    }

    //根据用户输入的运算，生成对应的类
    private static void createCompilerFile(String className, String character) throws Exception {
        //调用一个编译源码的方法，将创建出的.java文件编译成.class文件
        Compiler compiler=new Compiler();

        //扫描算法类模板 OperationAdd.java文件，生成对应的算法类
        String operationContent = FileUtil.readTemplateContent(Constant.OPERATION_PATH+"\\OperationAdd.java");
        String operationContentNew= operationContent.replace("OperationAdd","Operation"+className).replace("+", character);
        String operationFilePath=Constant.OPERATION_PATH+"\\Operation"+className+".java";
        FileUtil.append(operationFilePath,operationContentNew);
        System.out.println("算法类生成："+"Operation"+className);
        //调用一个编译源码的方法，将创建出的.java文件编译成.class文件
        compiler.compiler(operationFilePath);//注释掉为手动


        //扫描工厂类模板 FactoryTemplate.java文件，生成对应的算法工厂类
        String operFactoryContent = FileUtil.readTemplateContent(Constant.FACTORY_PATH+"\\FactoryTemplate.java");
        String operFactoryContentNew= operFactoryContent.replace("FactoryTemplate",className+"Factory").replaceAll("OperationAdd", "Operation"+className);
        String operFactoryFilePath=Constant.FACTORY_PATH+"\\"+className+"Factory.java";
        FileUtil.append(operFactoryFilePath,operFactoryContentNew);
        System.out.println("算法工厂类生成："+className+"Factory");
        //调用一个编译源码的方法，将创建出的.java文件编译成.class文件
        compiler.compiler(operFactoryFilePath);//注释掉为手动

        //扫描工厂类模板 OperationClientTemplate.java文件，生成对应的算法客户端类
        String operClientContent = FileUtil.readTemplateContent(Constant.CLIENT_PATH+"\\OperationClientTemplate.java");
        String operClientContentNew= operClientContent.replace("OperationClientTemplate",className+"Client").replaceAll("FactoryTemplate", className+"Factory");
        String operClientFilePath=Constant.CLIENT_PATH+"\\"+className+"Client.java";
        FileUtil.append(operClientFilePath,operClientContentNew);
        System.out.println("算法客户端生成："+className+"Client");
        //调用一个编译源码的方法，将创建出的.java文件编译成.class文件
        compiler.compiler(operClientFilePath);//注释掉为手动

    }

    /**
     * 通过反射，执行自动生成的客户端
     */
    private static void reflectInvoke(String className) throws Exception {
        //客户端类
        String compilerClassName="com.tfjy.architecture.factoryAutoCreateLogon.operationClient."+className+"Client";
        Class<?> classLoaderClass = Class.forName(compilerClassName);
        Method method = classLoaderClass.getMethod("main",String[].class);
        method.invoke(null,(Object)new String[]{""});

    }
}

涉及到的工具类：FileUtil


/**
 * @Author: Ariel(huan)
 * @Description:读模板文件和创建文件的工具类
 * @CreateDate: 2023/3/16 8:46
 */
public class FileUtil {

    /**
     * 扫描模板类文件
     */
    public static String readTemplateContent(String filePath) throws IOException {
        // 识别 .java文件
        FileInputStream fin = new FileInputStream(filePath);
        InputStreamReader reader = new InputStreamReader(fin);
        BufferedReader buffReader = new BufferedReader(reader);
        String strTmp = "";
        //文件中的文本内容
        StringBuffer operationContent = new StringBuffer();
        // 读一行文字，未读取任何字符的情况下到达流末尾，则不进行输出操作
        while((strTmp = buffReader.readLine())!=null){
            // 识别到了所有父类和子类的文本内容
            operationContent.append(strTmp);
            operationContent.append("\n");
        }
        buffReader.close();
        return operationContent.toString();
    }


    /**
     * append:将一个字符写入一个已有的文件中，通过追加的方法追加到内容的末尾；
     * @author Bool
     * @param filePath
     * @param data
     */
    public static synchronized void append(String filePath , String data){

        String s;
        StringBuffer sb=new StringBuffer();
        try {

            //创建文件夹
            String dirPath=filePath.substring(0,filePath.lastIndexOf("/")+1);
            File dir=new File(dirPath);

            if(!dir.exists()){
                dir.mkdirs();
            }

            File f = new File(filePath);
            //当文件不存在时，创建文件并写入内容
            if (!f.exists()) {
                f.createNewFile();

                BufferedReader input = new BufferedReader(new FileReader(f));
                while ((s = input.readLine()) != null) {
                    sb.append(s);
                    sb.append("\n");
                }
                input.close();
                sb.append(data);
                BufferedWriter output = new BufferedWriter(new FileWriter(f));
                output.write(sb.toString());
                output.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

编译器编译：

/**
 * @Author: Ariel(huan)
 * @Description：动态编译
 * @CreateDate: 2023/3/19 12:38
 */
public class Compiler extends ClassLoader{
    public void compiler(String filePath){
        System.out.println("开始编译并运行");
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        int status = compiler.run(null, null, null, "-d",
                "E:\\Study\\TGB学习资料\\06设计模式研究\\李欢\\design-pattern\\out\\production\\newStudyHuan", filePath);
        if (status != 0) {
            System.out.println("没有编译成功！");
        }
    }
  }

路径常量类：这部分涉及到的绝对路径需要修改为自己项目实例的路径呦~~~~

/**
 * @Author: Ariel(huan)
 * @Description:路径常量类
 * @CreateDate: 2023/3/20 17:09
 */
public class Constant {
    //算法模板类的路径
    public static final String OPERATION_PATH="E:\\Study\\TGB学习资料\\06设计模式研究\\李欢\\design-pattern\\newStudyHuan\\src\\com" +
            "\\tfjy\\architecture\\factoryAutoCreateLogon\\operation";
    //factory模板类的路径
    public static final String FACTORY_PATH="E:\\Study\\TGB学习资料\\06设计模式研究\\李欢\\design-pattern\\newStudyHuan" +
            "\\src\\com\\tfjy\\architecture\\factoryAutoCreateLogon\\operationFactory";
    //client模板类的路径
    public static final String CLIENT_PATH="E:\\Study\\TGB学习资料\\06设计模式研究\\李欢\\design-pattern\\newStudyHuan" +
            "\\src\\com\\tfjy\\architecture\\factoryAutoCreateLogon\\operationClient";
    
}

5、运行效果：

在这里插入图片描述

方案二：扫描——扫描运算类包

1、实现思路：

①通过扫描算法类包，获取到所有的算法类文件，并获取到各类名；
②读取运算类模板（这里OperationAdd类作为运算类模板）、工厂类模板（FactoryTemplate）、运算客户端类模板（OperationClientTemplate）
③将模板中的运算类名和运算符替换为运算类包下的扫描到的运算类名以及其运算符号
④生成运算类.java（MulClient）、运算工厂类.java（MulFactory）、运算客户端类.java（MulClient）
⑤调用JavaCompiler（动态编译机制），将生成的三个类进行动态编译.class文件
⑥通过反射执行运算客户端MulCilent中的运算方法（getResult方法）

2、类图：

3、项目结构图：

在这里插入图片描述

4、代码：

注：
工厂接口IFactory、运算抽象类（父类）Operation、
运算类模板OperationAdd、运算工厂类FactoryTemplate、运算客户端模板类OperationClientTemplate以及FileUtil类和Compiler类的代码都是一样的，不同的是程序启动客户端内的逻辑——改为了扫描（获取）包下的所有运算类：

//程序启动客户端
public class ScanApplication {
    public static void main(String[] args) throws Exception {
        Scan scan = new Scan();
        scan.scan();
    }
}

核心业务类：

/**
 * 扫描业务类：获取所有的运算类并生成对应的工厂类和客户端类，并且编译执行
 */
public class Scan {
    public void scan() throws Exception {
        String packagePath = "E:\\Study\\TGB学习资料\\06设计模式研究\\李欢\\design-pattern\\newStudyHuan\\src\\com\\tfjy" +
                "\\architecture\\factoryAutoCreateSaomiao\\operation";

        File file = new File(packagePath);
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            Map<Object, Method> map = new HashMap<>();
            for (File f : files) {
                String fileName = f.getAbsolutePath();
                if (fileName.endsWith(".java")) {
                    String fullyClassName = fileName.substring(fileName.indexOf("com"), fileName.indexOf(".java"));
                    String className = fullyClassName.replace("com\\tfjy\\architecture\\factoryAutoCreateSaomiao" +
                            "\\operation\\", "");


                    //调用一个编译源码的方法，将创建出的.java文件编译成.class文件
                    String operationFilePath=Constant.OPERATION_PATH +"\\" + className+".java";
                    Compiler compilerOperation = new Compiler();
                    compilerOperation.compiler(operationFilePath);


                    //扫描工厂类模板 FactoryTemplate.java文件，生成对应的算法工厂类
                    String operFactoryContent = FileUtil.readTemplateContent(Constant.FACTORY_PATH +
                            "\\FactoryTemplate.java");
                    String operFactoryContentNew = operFactoryContent.replace("FactoryTemplate", className + "Factory"
                    ).replaceAll("OperationAdd", className);
                    String operFactoryFilePath = Constant.FACTORY_PATH + "\\" + className + "Factory.java";
                    FileUtil.append(operFactoryFilePath, operFactoryContentNew);
                    System.out.println("算法工厂类生成：" + className + "Factory");
                    //调用一个编译源码的方法，将创建出的.java文件编译成.class文件
                    Compiler compilerFactory = new Compiler();
                    compilerFactory.compiler(operFactoryFilePath);

                    //扫描工厂类模板 OperationClientTemplate.java文件，生成对应的算法客户端类
                    String operClientContent = FileUtil.readTemplateContent(Constant.CLIENT_PATH +
                            "\\OperationClientTemplate.java");
                    String operClientContentNew = operClientContent.replace("OperationClientTemplate", className +
                            "Client").replaceAll("FactoryTemplate", className + "Factory");
                    String operClientFilePath = Constant.CLIENT_PATH + "\\" + className + "Client.java";
                    FileUtil.append(operClientFilePath, operClientContentNew);
                    System.out.println("算法客户端生成：" + className + "Client");

                    //调用一个编译源码的方法，将创建出的.java文件编译成.class文件
                    Compiler compilerClient = new Compiler();
                    compilerClient.compiler(operClientFilePath);
                    //反射执行
                    String compileClassName = "com.tfjy.architecture.factoryAutoCreateSaomiao.operationClient." + className + "Client";
                    Class<?> classLoaderClass = Class.forName(compileClassName);
//                    Object instance = classLoaderClass.getConstructor().newInstance();
                    Method method = classLoaderClass.getMethod("main", String[].class);
                    method.invoke(null, (Object) new String[]{""});
//                    map.put(instance,method);
                }
            }
        }
        System.out.println("测试");
    }
}

无限思维：如何在程序运行过程中实时添加运算类且编译运行？

如果要在运行过程中，手动添加一个运算类到operation包下，那么这个新的运算类如何在不重启项目的情况下，及时的编译并生成对象的工厂和运算客户端类，并且执行运算？？？——热加载实现动态的扩充类以及动态的编译、加载

目前考虑的方案：写个线程定时的去扫描

代码：

/**
 * @Author: Ariel(huan)
 * @Description:自动扫描的启动类
 * @CreateDate: 2023/3/23 8:24
 */
public class AutoScanApplication {
    public static void main(String[] args) throws Exception {
        AutoScan autoScan = new AutoScan();
        autoScan.run();
    }
}

/**
 * @Author: Ariel(huan)
 * @Description:自动扫描_线程池
 * @CreateDate: 2023/3/23 8:24
 */
public class AutoScan {
    public void run() {
        Scan scan = new Scan();
        // 需要定时执行的任务
        Runnable runnable = () -> {
            try {
                scan.scan();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        };
        ScheduledExecutorService ses = Executors.newSingleThreadScheduledExecutor();
        //立即执行，并且每5秒执行一次
        ses.scheduleAtFixedRate(runnable, 0, 15000, TimeUnit.MILLISECONDS);
    }
}

继续无限思维的思考：一直扫描则会一直占用资源，那么怎么样可以即实时，又能不一直占用资源呢？

方案思路：（先浅浅的透露一下吧）考虑通过事件与委托，简单的说就是考虑注册和扫描这两个方案相结合，代码还在优化中，敬请期待

总结升华

为什么要写一段代码，能够实现自动化工厂？
A.重复的逻辑自动化实现，减少重复造轮子，提高效率
B.无限思维看待问题，变——不断增加，不停的增加，那么我们就需要经常添加新的类。
无限思维不仅在于多，更在于变，在于创造。
比如：一条直线两头无限延伸，会变弯曲以及相交。
C. 动态扩充+热加载，降低后期的开发成本（扩充和维护）——注意前期的开发成本是高的，因为要求开发者的开发素质能力很高，以及要为了后期拓展打基础所以开发成本高。
什么叫维护？维护应该是用户来做的，通过用户的需求，动态的扩充和维护系统功能。
可变包括两个可变：维护可变、扩充可变。
把重复性有规律性的内容交给程序去完成，降低开发和维护的成本，减少了人为操作出错的情况。