前言

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

一、《大话设计模式》对应的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. 动态扩充+热加载，降低后期的开发成本（扩充和维护）——注意前期的开发成本是高的，因为要求开发者的开发素质能力很高，以及要为了后期拓展打基础所以开发成本高。
什么叫维护？维护应该是用户来做的，通过用户的需求，动态的扩充和维护系统功能。
可变包括两个可变：维护可变、扩充可变。
把重复性有规律性的内容交给程序去完成，降低开发和维护的成本， 减少了人为操作出错的情况。

小测试：你无限思维的去思考问题了吗？