java自动生成类热加载（注册和扫描）

Circ.

已于 2023-08-16 21:11:55 修改

阅读量334

点赞数

分类专栏：设计模式文章标签： java jvm servlet

于 2023-03-22 10:32:57 首次发布

本文链接：https://blog.csdn.net/weixin_45706856/article/details/129703625

版权

设计模式专栏收录该内容

16 篇文章 0 订阅

订阅专栏

背景

从简单工厂到工厂方法（参考大话设计模式）
将实际的业务封装到了具体的子类中，但是如果无法生成各个子工厂的代码，这种封装还是缺点意思。于是现在想直接根据operation子类生成工厂部分的代码。

实操

在这里插入图片描述

1、扫描方式

package PassivehotLoad;

import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.file.*;
import java.util.*;

/**
 * @BelongsProject: JAVAtest
 * @BelongsPackage: hotLoad
 * @Author: GuoYuan.Zhao
 * @CreateTime: 2023-03-18  10:17
 * @Description: TODO
 * @Version: 1.0
 */

public class MyManagerHot {

    static String className = "";
    static String operation = "";
    static List<String>allName ;

    public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException, IOException {
        //首先去扫描OperationAll包下是不是多了类，如果类变多了，从类中提起关键字 如Add，然后将值赋值给变量，然后按照下面的步骤进行
        String pathPackage = "E:\\zy\\TGB-zgy-2022\\米老师设计模式课相关资料必须留着\\米老师设计模式课小例子\\JAVAtest\\Factory\\src\\main\\java\\MoreAutoFactory\\OperationAll";
        File file = new File(pathPackage);
        if (file.isDirectory()){
            List<String>allNameNew = null;
            File[] files = file.listFiles();
            for (File f : files) {
                String fileName = f.getAbsolutePath();
                if (fileName.endsWith(".java")) {
                    String className = fileName.substring(fileName.indexOf("MoreAutoFactory"), fileName.indexOf(".java"));
                    String replacedName = className.replace("MoreAutoFactory\\OperationAll\\Operation", "");
//                    allNameNew.add(replacedName);
                    create(replacedName);
                    reflect(replacedName);
                }
            }

        }

    }



    public static void create(String className) throws IOException {


        Scanner scanner = new Scanner(System.in);
//        System.out.println("请输入要创建的算法的模式：");
//        className = scanner.nextLine();

        if(className.equals("Add")){
            operation = "+";
        }else if (className.equals("Sub")){
            operation = "-";
        }else if (className.equals("Mul")){
            operation = "*";
        }else if (className.equals("Div")){
            operation = "/";
        }
        String srcOperationCode =
                "package MoreAutoFactory.OperationAll;\n" +
                        "\n" +
                        "\n" +
                        "import MoreAutoFactory.Operation;\n" +
                        "\n" +
                        "public class Operation"+className+" extends Operation {\n" +
                        "    @Override\n" +
                        "    public  double getResult(){\n" +
                        "        double result = 0;\n" +
                        "        result  = getNumberA()"+operation+"getNumberB();\n" +
                        "        return result;\n" +
                        "    }\n" +
                        "\n" +
                        "}";


        //要创建文件的路径
        String path1 = "E:\\zy\\TGB-zgy-2022\\米老师设计模式课相关资料必须留着\\米老师设计模式课小例子\\JAVAtest\\Factory\\src\\main\\java\\MoreAutoFactory\\OperationAll\\Operation"+ className+".java";
        File file1 = new File(path1);
        if (!file1.exists()) {
            if (file1.createNewFile()) {
                System.out.println("新类型算法文件创建成功");
                FileWriter fileWriter = new FileWriter(path1);
                BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
                bufferedWriter.write(srcOperationCode);
                bufferedWriter.close();
                //编译文件
                Compiler(System.getProperty("user.dir")+"\\Factory\\target\\classes",path1);
            }
        }


        String srcFactoryCode =
                "package MoreAutoFactory.FactoryAll;\n" +
                        "\n" +
                        "import MoreAutoFactory.IFactory;\n" +
                        "import MoreAutoFactory.Operation;\n" +
                        "import MoreAutoFactory.OperationAll.Operation"+className+";\n" +
                        "\n" +
                        "public class "+className+"Factory implements IFactory {\n" +
                        "    @Override\n" +
                        "    public Operation createOperation() {\n" +
                        "        return new Operation"+className+"();\n" +
                        "    }\n" +
                        "}";

        //要创建文件的路径
        String path = "E:\\zy\\TGB-zgy-2022\\米老师设计模式课相关资料必须留着\\米老师设计模式课小例子\\JAVAtest\\Factory\\src\\main\\java\\MoreAutoFactory\\FactoryAll\\" + className + "Factory.java";
        File file = new File(path);
        if (!file.exists()) {
            if (file.createNewFile()) {
                System.out.println("新类型工厂文件创建成功");
                FileWriter fileWriter = new FileWriter(path);
                BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
                bufferedWriter.write(srcFactoryCode);
                bufferedWriter.close();
                //编译文件
                Compiler(System.getProperty("user.dir")+"\\Factory\\target\\classes",path);
            }
        }

        String srcClientCode =
                "package MoreAutoFactory.ClientAll;\n" +
                        "\n" +
                        "import MoreAutoFactory.FactoryAll."+className+"Factory;\n" +
                        "import MoreAutoFactory.IFactory;\n" +
                        "import MoreAutoFactory.Operation;\n" +
                        "\n" +
                        "public class "+className+"Client {\n" +
                        "  public  void getEndResult() throws Exception {\n" +
                        "      IFactory operFactory = new "+className+"Factory();\n" +
                        "      Operation oper = operFactory.createOperation();\n" +
                        "       oper.setNumberA(2);\n" +
                        "       oper.setNumberB(2);\n" +
                        "       double result = oper.getResult();\n" +
//                        "        System.out.println("+className+");\n" +
                        "        System.out.println(result);\n" +
                        "    }\n" +
                        "}";


        //要创建文件的路径
        String pathClient = "E:\\zy\\TGB-zgy-2022\\米老师设计模式课相关资料必须留着\\米老师设计模式课小例子\\JAVAtest\\Factory\\src\\main\\java\\MoreAutoFactory\\ClientAll\\" + className + "Client.java";
        File fileClient = new File(pathClient);
        if (!fileClient.exists()) {
            if (fileClient.createNewFile()) {
                System.out.println("新类型客户端文件创建成功");
                FileWriter fileWriter = new FileWriter(pathClient);
                BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
                bufferedWriter.write(srcClientCode);
                bufferedWriter.close();
                //编译文件
                Compiler(System.getProperty("user.dir")+"\\Factory\\target\\classes",pathClient);
            }
        }
    }

    public static void reflect(String className) throws ClassNotFoundException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {

//            String str = "MoreAutoFactory.Client"+className+"Client";
//            System.out.println(str);
        Class classClient = Class.forName("MoreAutoFactory.ClientAll."+className+"Client");
        Object object = classClient.newInstance();
        Method getEndResultMethod = classClient.getMethod("getEndResult");
        getEndResultMethod.invoke(object,null);
    }

    public static void Compiler(String compilerPath,String javaPath){
        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
        int status = javac.run(null, null, null, "-d",

                compilerPath,javaPath);
        if(status!=0){
            System.out.println("没有编译成功！");
        }

    }



}

2、注册方式

package twoMethodCreateClass.Register;

import hotLoad.BaseManager;

import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Scanner;

/**
 * @BelongsProject: JAVAtest
 * @BelongsPackage: hotLoad
 * @Author: GuoYuan.Zhao
 * @CreateTime: 2023-03-18  10:17
 * @Description: TODO
 * @Version: 1.0
 */


public class MyManagerHot {

    public static void main(String[] args) throws IOException, ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
        create();
        reflect();
    }


        static String className = "";
        static String operation = "";


    public static void create() throws IOException {


        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要创建的算法的模式：");
        className = scanner.nextLine();

        if(className.equals("Add")){
            operation = "+";
        }else if (className.equals("Sub")){
            operation = "-";
        }else if (className.equals("Mul")){
            operation = "*";
        }else if (className.equals("Div")){
            operation = "/";
        }
        String srcOperationCode =
                "package MoreAutoFactory.OperationAll;\n" +
                        "\n" +
                        "\n" +
                        "import MoreAutoFactory.Operation;\n" +
                        "\n" +
                        "public class Operation"+className+" extends Operation {\n" +
                        "    @Override\n" +
                        "    public  double getResult(){\n" +
                        "        double result = 0;\n" +
                        "        result  = getNumberA()"+operation+"getNumberB();\n" +
                        "        return result;\n" +
                        "    }\n" +
                        "\n" +
                        "}";


        //要创建文件的路径
        String path1 = "E:\\zy\\TGB-zgy-2022\\米老师设计模式课相关资料必须留着\\米老师设计模式课小例子\\JAVAtest\\Factory\\src\\main\\java\\MoreAutoFactory\\OperationAll\\Operation"+ className+".java";
        File file1 = new File(path1);
        if (!file1.exists()) {
            if (file1.createNewFile()) {
                System.out.println("新类型算法文件创建成功");
                FileWriter fileWriter = new FileWriter(path1);
                BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
                bufferedWriter.write(srcOperationCode);
                bufferedWriter.close();

                //编译文件
                Compiler(System.getProperty("user.dir")+"\\Factory\\target\\classes",path1);
            }
        }


        String srcFactoryCode =
                "package MoreAutoFactory.FactoryAll;\n" +
                        "\n" +
                        "import MoreAutoFactory.IFactory;\n" +
                        "import MoreAutoFactory.Operation;\n" +
                        "import MoreAutoFactory.OperationAll.Operation"+className+";\n" +
                        "\n" +
                        "public class "+className+"Factory implements IFactory {\n" +
                        "    @Override\n" +
                        "    public Operation createOperation() {\n" +
                        "        return new Operation"+className+"();\n" +
                        "    }\n" +
                        "}";

        //要创建文件的路径
        String path = "E:\\zy\\TGB-zgy-2022\\米老师设计模式课相关资料必须留着\\米老师设计模式课小例子\\JAVAtest\\Factory\\src\\main\\java\\MoreAutoFactory\\FactoryAll\\" + className + "Factory.java";
        File file = new File(path);
        if (!file.exists()) {
            if (file.createNewFile()) {
                System.out.println("新类型工厂文件创建成功");
                FileWriter fileWriter = new FileWriter(path);
                BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
                bufferedWriter.write(srcFactoryCode);
                bufferedWriter.close();
                //编译文件
                Compiler(System.getProperty("user.dir")+"\\Factory\\target\\classes",path);
            }
        }

        String srcClientCode =
                "package MoreAutoFactory.ClientAll;\n" +
                        "\n" +
                        "import MoreAutoFactory.FactoryAll."+className+"Factory;\n" +
                        "import MoreAutoFactory.IFactory;\n" +
                        "import MoreAutoFactory.Operation;\n" +
                        "\n" +
                        "public class "+className+"Client {\n" +
                        "  public  void getEndResult() throws Exception {\n" +
                        "      IFactory operFactory = new "+className+"Factory();\n" +
                        "      Operation oper = operFactory.createOperation();\n" +
                        "       oper.setNumberA(2);\n" +
                        "       oper.setNumberB(2);\n" +
                        "       double result = oper.getResult();\n" +
                        "        System.out.println(result);\n" +
                        "    }\n" +
                        "}";


        //要创建文件的路径
        String pathClient = "E:\\zy\\TGB-zgy-2022\\米老师设计模式课相关资料必须留着\\米老师设计模式课小例子\\JAVAtest\\Factory\\src\\main\\java\\MoreAutoFactory\\ClientAll\\" + className + "Client.java";
        File fileClient = new File(pathClient);
        if (!fileClient.exists()) {
            if (fileClient.createNewFile()) {
                System.out.println("新类型客户端文件创建成功");
                FileWriter fileWriter = new FileWriter(pathClient);
                BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
                bufferedWriter.write(srcClientCode);
                bufferedWriter.close();
                //编译文件
                Compiler(System.getProperty("user.dir")+"\\Factory\\target\\classes",pathClient);
            }
        }
    }

        public static void reflect() throws ClassNotFoundException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {

//            String str = "MoreAutoFactory.Client"+className+"Client";
//            System.out.println(str);
            Class classClient = Class.forName("MoreAutoFactory.ClientAll."+className+"Client");
            Object object = classClient.newInstance();
            Method getEndResultMethod = classClient.getMethod("getEndResult");
            getEndResultMethod.invoke(object,null);
        }

        public static void Compiler(String compilerPath,String javaPath){
            JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
            int status = javac.run(null, null, null, "-d",

 compilerPath,javaPath);
            if(status!=0){
                System.out.println("没有编译成功！");
            }

        }



}

总结

代码分为三种
源码
字节码
机器码

我们可以通过改变源码的方式去操纵机器码，这也是实现自动化的关键

反射：

反射是一种编程语言特性，允许程序在运行时获取对象的类型信息以及访问和操作对象的属性、方法和构造函数等。在Java等面向对象编程语言中，反射机制允许程序在编译时不需要知道类的具体信息，而是在运行时动态获取。反射可以用于执行诸如创建对象、调用方法、访问字段等操作，这对于编写通用、灵活的代码和框架非常有用。

反射的一些常见用途包括：

在运行时创建对象实例，而不是在编译时硬编码。
动态地调用对象的方法，无需提前知道方法名。
检查和操作类的属性和方法。
在不了解类结构的情况下对类进行操作，如序列化和反序列化。
尽管反射提供了灵活性，但它也可能降低代码的可读性和性能，因为它在一定程度上绕过了编译时的类型检查和优化。因此，在使用反射时需要权衡其优劣，并遵循最佳实践。

设计模式：

设计模式是一些被广泛接受的解决特定问题的通用设计思想。它们是经过多年实践总结的在特定情景下有效的解决方案，能够提高代码的可维护性、可扩展性和重用性。

设计模式可以分为多个类别，包括创建型模式（如工厂模式、单例模式）、结构型模式（如适配器模式、装饰器模式）、行为型模式（如观察者模式、策略模式）等。每种模式都有其独特的用途和实现方式。

使用设计模式的好处包括：

提供了经过验证的解决方案，减少了重复劳动。
促进了代码的模块化和可扩展性。
提高了代码的可读性，因为采用了通用的设计思想。
为团队成员提供了共同的设计词汇，有助于更好的沟通。
然而，设计模式也需要根据实际情况进行选择。不是每个问题都适合应用设计模式，过度使用模式可能会使代码变得复杂，难以理解。因此，理解每个模式的用途和适用情景非常重要，以便在需要时恰当地应用它们。

总之，反射和设计模式是面向对象编程和软件设计中的两个关键概念，它们都能够在不同层面上提高代码的灵活性、可维护性和可重用性。

反射的实现原理：

在编程语言中，反射通常是通过元数据（metadata）来实现的，元数据包含了有关代码中的类型、结构和成员的信息。在Java中，反射是通过Class类和相关的反射类来实现的。当程序加载类时，JVM会为每个类创建一个Class对象，这个对象包含了关于类的元数据信息。通过这个Class对象，可以获取类的构造函数、方法、字段等信息，并在运行时动态操作这些元素。

反射的主要原理包括以下步骤：

加载类：类在被首次引用时由类加载器加载到内存中，JVM会为该类创建一个对应的Class对象。
获取Class对象：通过类名、对象实例或类加载器等方式，可以获取到表示类的Class对象。
访问元数据：通过Class对象，可以访问类的构造函数、方法、字段等元数据信息。
操作类元素：使用反射API，可以在运行时创建对象实例、调用方法、访问字段等。
虽然反射提供了动态性和灵活性，但它在一定程度上会带来性能损失，因为它需要在运行时进行类型检查和访问，而不是在编译时进行。因此，使用反射时需要权衡灵活性和性能。

设计模式的原理：

设计模式是一种在特定情况下解决问题的通用方法。设计模式的原理是通过总结实践中的最佳实践，提供一种可重用的解决方案，用于创建可扩展、可维护、可读性高的代码结构。

设计模式的原理包括：

问题抽象化：每个设计模式都解决一类特定的问题，它们抽象了问题的本质，忽略了问题中的不相关细节。
通用解决方案：每个设计模式提供了一种通用的、经过验证的解决方案，可以在不同场景下使用。
设计原则：每个设计模式遵循一些基本的设计原则，如单一职责原则、开闭原则、依赖倒置原则等。
模式结构：每个设计模式都有特定的结构和角色，包括一些参与者（类和对象）以及它们之间的关系。
实现方法：设计模式提供了一种模板化的方式来实现特定的解决方案，开发人员可以根据模式的指导来实现代码。
设计模式有助于提高代码的可维护性和可扩展性，同时也提供了一种共享的设计词汇，使得开发人员更容易理解和交流代码结构。

总之，反射和设计模式都是在不同层面上提供灵活性和可重用性的方法。反射关注于在运行时获取和操作对象的信息，而设计模式关注于提供在特定情况下的通用解决方案，以提高代码的设计质量。