Class生成

已于 2024-10-20 17:06:01 修改
阅读量889 收藏 18
点赞数 24
CC 4.0 BY-SA版权
分类专栏： java基础 文章标签： java
于 2024-10-20 17:05:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/joeyhhhhh/article/details/143095136

文章目录


当前java版本: 17.0.7

类定义

public final class Class<T> implements java.io.Serializable,
                              GenericDeclaration,
                              Type,
                              AnnotatedElement,
                              TypeDescriptor.OfField<Class<?>>,
                              Constable {
	// ...
}

GenericDeclaration接口

Java 反射 API 中的一个接口，用于表示可以声明泛型类型参数的类。Java 泛型系统的一部分，它主要用于描述声明类型参数的元素，比如类、接口、方法和构造函数。它的常见实现类包括 Class、Method 和 Constructor。

public interface GenericDeclaration extends AnnotatedElement {

	/**
	 * 返回该元素声明的泛型类型参数; 返回一个TypeVariable<?>[]对象数组，按声明顺序表示此GenericDeclaration对象所表示泛型类型参数。
	 * 如果基础泛型声明没有声明类型变量，则返回长度为0的数组。
	 */
    public TypeVariable<?>[] getTypeParameters();
}

例如，如果某个类声明为 public class MyClass<T> {…}，则该getTypeParameters方法会返回一个 TypeVariable 数组，其中包含一个代表 T 的类型变量。

import java.lang.reflect.*;

public class GenericDeclarationExample<T> {
    public <U> void sampleMethod() {
        // 空方法
    }

    public static void main(String[] args) throws NoSuchMethodException {
        // 获取类的声明类型参数
        GenericDeclarationExample<String> example = new GenericDeclarationExample<>();
        Class<?> clazz = example.getClass();
        
        // 获取类的泛型参数（这里是 <T>）
        TypeVariable<?>[] typeParameters = clazz.getTypeParameters();
        System.out.println("Class Type Parameters:");
        for (TypeVariable<?> typeVariable : typeParameters) {
            System.out.println(typeVariable.getName());
        }

        // 获取方法的泛型参数（这里是 <U>）
        Method method = clazz.getMethod("sampleMethod");
        TypeVariable<?>[] methodTypeParameters = method.getTypeParameters();
        System.out.println("Method Type Parameters:");
        for (TypeVariable<?> typeVariable : methodTypeParameters) {
            System.out.println(typeVariable.getName());
        }
    }
}

运行结果

Class Type Parameters:
T
Method Type Parameters:
U

AnnotatedElement 接口

AnnotatedElement 是 Java 反射 API 中的另一个接口，GenericDeclaration 继承了它。AnnotatedElement 提供了操作和访问注解的相关方法，因此 GenericDeclaration 可以同时处理注解和泛型声明。

常见的 AnnotatedElement 方法包括：

• isAnnotationPresent(Class<? extends Annotation> annotationClass): 判断是否存在某个注解。

• getAnnotation(Class<A> annotationClass): 获取指定类型的注解。

Type接口

作用：Type 接口是 Java 反射 API 中的一个基础接口，用来表示 Java 中所有类型。它被用来获取和表示在运行时可访问的类型信息，比如类、接口、数组、原始类型、泛型类型等。

实现类：

• Class<?>：表示具体的类或接口类型。

• ParameterizedType：表示泛型类或接口类型（例如 List<String>）。

• GenericArrayType：表示泛型数组类型（例如 T[]）。

• WildcardType：表示泛型通配符类型（例如 ? extends Number）。

• TypeVariable：表示类型变量（例如 T）。

在 Class 中的作用：Class 实现了 Type 接口，因此它可以表示所有的类和接口。通过 Type，你可以访问更为详细的类型信息，特别是在处理泛型时，例如通过反射 API 获取泛型类型参数的信息。

获取Class类的方法

1.通过.class

1.int.class、Integer.class、Enum.class
@Test
    void primitiveType() {
        Class<Integer> intClass = int.class;
        Class<Integer> integerClass1 = Integer.class;

        System.out.println(intClass == integerClass1);  // false

        Integer a = 1;
        System.out.println(a.getClass() == integerClass1);  // true
        System.out.println(intClass);   // int
        System.out.println(a.getClass());   // class java.lang.Integer

        Class<? super Integer> intSuperclass = intClass.getSuperclass();
        Type intGenericSuperclass = intClass.getGenericSuperclass();
        Class<?>[] intInterfaces = intClass.getInterfaces();
        Type[] intGenericInterfaces = intClass.getGenericInterfaces();
        System.out.println("int:superclass:" + intSuperclass);   // null
        System.out.println("int:genericSuperclass:" + intGenericSuperclass); // null
        System.out.println("int:interfaces:" + intInterfaces);   // [Ljava.lang.Class;@568bf312
        System.out.println("int:genericInterfaces:" + intGenericInterfaces); // [Ljava.lang.Class;@ca263c2

        Class<? super Integer> superclass = integerClass1.getSuperclass();
        Type genericSuperclass = integerClass1.getGenericSuperclass();
        Class<?>[] interfaces = integerClass1.getInterfaces();
        Type[] genericInterfaces = integerClass1.getGenericInterfaces();
        System.out.println("integer:superclass:" + superclass);  // class java.lang.Number
        System.out.println("integer:genericSuperclass:" + genericSuperclass);   // class java.lang.Number
        System.out.println("integer:interfaces:" + interfaces); // [Ljava.lang.Class;@8e0379d
        System.out.println("integer:genericInterfaces:" + genericInterfaces);   // [Ljava.lang.reflect.Type;@341b80b2
    }

枚举类

@AllArgsConstructor
@Getter
public enum YesNo {

    YES(1, "是"),
    NO(0, "否");

    private final Integer code;

    private final String desc;

}

@Test
    void enumTest() {
        Class<? extends YesNo> aClass = YesNo.YES.getClass();
        System.out.println(aClass); // class per.qiao.myutils.enums.YesNo
        System.out.println(aClass.isEnum());    // true

        // 获取所有的枚举元素
        YesNo[] enumConstants = aClass.getEnumConstants();
        Arrays.stream(enumConstants).forEach(System.out::println);  // YES NO

        Map<String, ? extends YesNo> stringMap = EnumUtils.enum2Map(aClass);
        for (Map.Entry<String, ? extends YesNo> me : stringMap.entrySet()) {
            System.out.println(me.getKey() + ":" + me.getValue());
        }
        Map<String, YesNo> stringYesNoMap = EnumUtils.enum2Map(YesNo.class);
        for (Map.Entry<String, YesNo> stringYesNoEntry : stringYesNoMap.entrySet()) {
            System.out.println(stringYesNoEntry.getKey() + ":" + stringYesNoEntry.getValue());
        }

        YesNo enumBypProperties = EnumUtils.getEnumBypProperties(YesNo.class, YesNo::getCode, 1);
        System.out.println(enumBypProperties);
        String desc = EnumUtils.getValByKey(YesNo.class, YesNo::getCode, YesNo::getDesc, 0);
        System.out.println(desc);
    }

枚举工具类
public class EnumUtils {

    private static final Map<Class<?>, Map<String, ?>> ENUM_MAP = new ConcurrentHashMap<>();

    /**
     * 将枚举类转换为map; key:枚举类的名称 value:枚举类对象
     * <blockquote><pre>{@code
         Map<String, YesNo> stringYesNoMap = EnumUtils.enum2Map(YesNo.class);
    for (Map.Entry<String, YesNo> me : stringYesNoMap.entrySet()) {
    System.out.println(me.getKey() + ":" + me.getValue());
    }
     * }</pre></blockquote>
     * @param clazz 枚举类class
     * @return  枚举类map
     * @param <T>   枚举类类型
     */
    @SuppressWarnings("unchecked")
    public static <T extends Enum<?>> Map<String, T> enum2Map(Class<T> clazz) {
        Map<String, T> result = new HashMap<>();
        if (!clazz.isEnum()) {
            return result;
        }
        if (ENUM_MAP.containsKey(clazz)) {
            return (Map<String, T>) ENUM_MAP.get(clazz);
        }
        Enum<?>[] enumConstants = clazz.getEnumConstants();
        for (Enum<?> enumConstant : enumConstants) {
            result.put(enumConstant.name(), (T) enumConstant);
        }
        ENUM_MAP.put(clazz, result);
        return result;
    }

    /**
     * 根据属性获取枚举, 默认返回null
     * <pre>
     *   EnumUtils.getEnumBypProperties(YesNo.class, YesNo::getCode, 1);
     * </pre>
     * @param clazz 枚举类型
     * @param valFunc   属性的获取方法
     * @param val   属性值
     * @return  枚举对象
     * @param <T>   枚举类型
     * @param <V>   属性值类型
     */
    @SuppressWarnings("unchecked")
    public static <T extends Enum<?>, V> T getEnumBypProperties(Class<T> clazz, Function<T, V> valFunc, V val) {
        Enum<?>[] enumConstants = clazz.getEnumConstants();
        for (Enum<?> enumConstant : enumConstants) {
            T t = (T) enumConstant;
            V obj = valFunc.apply(t);
            if (val.getClass().isPrimitive()) {
                if (obj == val) {
                    return t;
                }
            } else {
                if (obj != null && obj.equals(val)) {
                    return t;
                }
            }
        }
        return null;
    }

    /**
     * 根据key获取枚举值, 默认返回null
     * <pre>
     *     EnumUtils.getValByKey(YesNo.class, YesNo::getCode, YesNo::getDesc, 0);
     * </pre>
     * @param clazz 枚举类型
     * @param keyFunc   key的获取方法
     * @param valFunc   值的获取方法
     * @param keyParam  key参数
     * @return  key对应的值
     * @param <T>   枚举类型
     * @param <K>   key类型
     * @param <V>   值类型
     */
    @SuppressWarnings("unchecked")
    public static <T extends Enum<?>, K, V> V getValByKey(Class<T> clazz, Function<T, K> keyFunc, Function<T, V> valFunc, K keyParam) {
        Enum<?>[] enumConstants = clazz.getEnumConstants();
        for (Enum<?> enumConstant : enumConstants) {
            T t = (T) enumConstant;
            K key = keyFunc.apply(t);
            if (keyParam.getClass().isPrimitive()) {
                if (keyParam == key) {
                    return valFunc.apply(t);
                }
            } else {
                if (key != null && key.equals(keyParam)) {
                    return valFunc.apply(t);
                }
            }
        }
        return null;
    }
}

注解类

@Test
    void annotationTest() {
        Class<AllArgsConstructor> userInfoClass = AllArgsConstructor.class;
        System.out.println(userInfoClass);  // interface lombok.AllArgsConstructor
        System.out.println(userInfoClass.isAnnotation());   // true
    }

数组类型

@Test
    void arrayTest() {
        int[] arr1 = {1, 2, 3};
        Class<? extends int[]> aClass = arr1.getClass();
//        Class<int[]> nowDimArrayClass = int[].class;
        System.out.println(aClass);     // class [I
        System.out.println(aClass.isArray());   // true

        // 获取数组的元素类型
        System.out.println(aClass.getComponentType());  // int

        int[][] arr2 = {{1, 2}, {3, 4}};
        Class<? extends int[][]> aClass1 = arr2.getClass(); // class [[I
        System.out.println(aClass1);
        System.out.println(aClass1.isArray());  // true
        System.out.println(aClass1.getComponentType()); // class [I

        Class<?> componentType = aClass1.getComponentType();
        Class<?> componentType1 = componentType.getComponentType();
        // 二维数组的元素类型
        System.out.println(componentType1);
    }

void类型

@Test
    void voidTest() {
        Class<Void> voidClass = void.class;
        System.out.println(voidClass);
        System.out.println(voidClass == void.class);    // true
        System.out.println(voidClass.isPrimitive());    // true
    }

Class.forName

通过反射

public class TempClass implements Serializable {

    private static final long serialVersionUID = 1L;

    static {
        System.out.println("静态代码块执行了");
    }

    private String firstName;

    public TempClass() {
        System.out.println("TempClass类实例化了");
    }

    public void hello() {
        System.out.println("hello world");
    }

    public static String getName(String name) {
        return "getName" + name;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getFirstName() {
        return firstName;
    }
}

@Test
    void classForNameTest() {
        try {
            // 获取class; 默认会执行类的静态代码块
            Class.forName("per.qiao.myutils.clazz.TempClass");
            ClassLoader platformClassLoader = this.getClass().getClassLoader();
            // 使用参数指定需不需要执行静态代码块
            Class<?> aClass = Class.forName("per.qiao.myutils.clazz.TempClass", false, platformClassLoader);
            System.out.println("是否为编译器自动生成的类:" + aClass.isSynthetic()); // false
//            System.out.println(aClass);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

类加载器获取Class对象

@Test
    void classLoadTest() throws Exception {
        // 获取class; 不会执行类的静态代码块
        Class<?> aClass = ClassGenerateTest.class.getClassLoader().loadClass("per.qiao.myutils.clazz.TempClass");
    }

使用 MethodHandles.Lookup.defineClass 定义类

/**
     * 使用 MethodHandles.Lookup.defineClass 定义类
     * @throws Throwable
     */
    @Test
    void MethodHandlesLookupDefineClassTest() throws Throwable {
        Path path = Paths.get("/Users/qiaoyueping/project/myproject/myutils/target/classes/per/qiao/myutils/clazz/TempClass.class");
        // 类的字节码
        byte[] bytecodes = Files.readAllBytes(path);

        // 加密
        String classStr = Base64.getEncoder().encodeToString(bytecodes);
        // 解密
//        byte[] classInBytes = Base64.getDecoder().decode(classStr);
        System.out.println(classStr);

        MethodHandles.Lookup lookup = MethodHandles.lookup();
        Class<?> dynamicClass = lookup.defineClass(bytecodes);
        System.out.println("是否为编译器自动生成的类:" + dynamicClass.isSynthetic()); // false
        System.out.println("类名:" + dynamicClass.getName());

        // 输出类有哪些函数
        for(Method method : dynamicClass.getDeclaredMethods()) {
            System.out.println("方法名:" + method.getName());
        }

        // 非静态方法要这么使用; 使用 privateLookupIn 获取 TempClass 的专属权限
        MethodHandles.Lookup privateLookupIn = MethodHandles.privateLookupIn(dynamicClass, lookup);

        // 创建 TempClass 的实例
        Object tempClassInstance = dynamicClass.getDeclaredConstructor().newInstance();

        // 2. 调用hello函数(普通方法)
        MethodHandle mh = privateLookupIn.findSpecial(dynamicClass, "hello", MethodType.methodType(void.class), dynamicClass);
        mh.invoke(tempClassInstance);

        // 调用静态方法
        MethodHandle getName = privateLookupIn.findStatic(dynamicClass, "getName", MethodType.methodType(String.class, String.class));
        Object obj = getName.invoke("动态类型测试");
        System.out.println(obj);
//        getName.invokeExact("动态类型测试");
        Object obj2 = getName.invokeWithArguments("动态类型测试2");
        System.out.println(obj2);
    }

隐藏类

/**
     * 生成隐藏类; 隐藏类不能被其它类型调用, 只能用在当前session
     * @throws Throwable
     */
    @Test
    void MethodHandlesLookupDefineHiddenClass() throws Throwable {
        Path path = Paths.get("/Users/qiaoyueping/project/myproject/myutils/target/classes/per/qiao/myutils/clazz/TempClass.class");
        // 类的字节码
        byte[] classBytes = Files.readAllBytes(path);

        MethodHandles.Lookup lookup = MethodHandles.lookup();
        Class<?> hiddenClass = lookup.defineHiddenClass(classBytes, true, MethodHandles.Lookup.ClassOption.NESTMATE)
                .lookupClass();
        System.out.println("是否为编译器自动生成的类:" + hiddenClass.isSynthetic()); // false
        System.out.println("类名:" + hiddenClass.getName());
        System.out.println("toGenericString:" + hiddenClass.toGenericString());
        System.out.println("是否为隐藏类:" + hiddenClass.isHidden()); // true
        for (Method method : hiddenClass.getDeclaredMethods()) {
            System.out.println("方法名:" + method.getName());
        }

        // 调用hello方法
        Object tempClassInstance = hiddenClass.getDeclaredConstructor().newInstance();
        MethodHandle hello = lookup.findVirtual(hiddenClass, "hello", MethodType.methodType(void.class));
        hello.invoke(tempClassInstance);

        // 使用findSpecial
        MethodHandles.Lookup privateLookupIn = MethodHandles.privateLookupIn(hiddenClass, lookup);
        MethodHandle mh = privateLookupIn.findSpecial(hiddenClass, "hello", MethodType.methodType(void.class), hiddenClass);
        mh.invoke(tempClassInstance);
    }

序列化与反序列化生成Class

@Test
    void serializableTest() throws Exception {
        TempClass tempClass = new TempClass();
        tempClass.setFirstName("qiao");
        System.out.println(tempClass.getFirstName());
//        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("temp.txt"));
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(byteArrayOutputStream);
        oos.writeObject(tempClass);
        oos.close();

//        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("temp.txt"));
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(byteArrayInputStream);
        // 这里并不会调用构造器
        Object o = ois.readObject();
        System.out.println("是否为编译器自动生成的类:" + o.getClass().isSynthetic()); // false
        TempClass tempClass1 = (TempClass) o;
        System.out.println(tempClass1.getFirstName());
    }

动态代理

public interface Hello {
    void sayHello();

    default void sayHi() {
        System.out.println("hi");
    }
}

/**
     * 动态代理;动态生成的代理类会通过类加载器加载。
     * 实际上，JVM 在内部会使用 java.lang.reflect.Proxy 类来生成这个动态代理的字节码，并将其加载为 Class 对象
     */
    @Test
    void proxyTest() {
        Hello proxy = (Hello) Proxy.newProxyInstance(
                Hello.class.getClassLoader(),
                new Class<?>[] { Hello.class },
                (obj, method, args) -> {
                    if (method.isDefault()) {
                        return InvocationHandler.invokeDefault(obj, method, args);
                    } else if ("sayHello".equals(method.getName())) {
                        System.out.println("Hello from sayHello!");
                        return null;
                    }
                    return method.invoke(obj, args);
                });
        proxy.sayHi();
        proxy.sayHello();
        System.out.println(proxy.getClass().isSynthetic()); // false
    }

类加载器获取

/**
 * 自定义类加载器
 */
public class MyClassLoader extends ClassLoader {

    private String path;

    public MyClassLoader(String path) {
        this.path = path;
    }

    @Override
    public Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            String replaceName = name.replace('.', File.separatorChar);
            FileInputStream fis = new FileInputStream(path + replaceName + ".class");
            byte[] bytes = new byte[fis.available()];
            fis.read(bytes);
            fis.close();
            return defineClass(name, bytes, 0, bytes.length);
        } catch (IOException e) {
            throw new ClassNotFoundException("Class not found: " + name, e);
        }
    }
}

@Test
    void defineClassTest() throws Exception {
        MyClassLoader myClassLoader = new MyClassLoader("/Users/qiaoyueping/project/myproject/myutils/target/classes/");
        Class<?> clazz = myClassLoader.findClass("per.qiao.myutils.clazz.TempClass");
        System.out.println(clazz.getName());
        System.out.println(clazz.isSynthetic());    // false
    }

字节码操作库

使用asm动态创建对象

@Test
    void asmTest() throws Exception {
        // 创建 ClassWriter，指定自动计算栈和局部变量大小
        ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);


        String packagePath = "per/qiao/myutils/clazz/proxy";
        String className = "HelloWorld";
        String fullClassName = packagePath + "/" + className; // 类的完整路径

        // 定义类的基本信息：版本号，访问标志，类名，签名，父类，接口
        classWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, fullClassName, null, "java/lang/Object", null);

        // 创建默认构造函数
        MethodVisitor constructor = classWriter.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
        constructor.visitCode();
        constructor.visitVarInsn(Opcodes.ALOAD, 0);
        constructor.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
        constructor.visitInsn(Opcodes.RETURN);
        constructor.visitMaxs(0, 0);
        constructor.visitEnd();

        // 创建 sayHello 方法
        MethodVisitor method = classWriter.visitMethod(Opcodes.ACC_PUBLIC, "sayHello", "()V", null, null);
        method.visitCode();
        method.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
        method.visitLdcInsn("Hello, World!");
        method.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
        method.visitInsn(Opcodes.RETURN);
        method.visitMaxs(0, 0);
        method.visitEnd();

        // 结束类的创建
        classWriter.visitEnd();


        // 将生成的字节码写入文件
        String path = "/Users/qiaoyueping/project/myproject/myutils/target/classes/";
        String filePath = path + packagePath + "/" + className + ".class";
        File file = new File(filePath);
        if (!file.exists()) {
            file.createNewFile();
        }

        // 将生成的字节码写入文件
        byte[] byteCode = classWriter.toByteArray();
        try (FileOutputStream fos = new FileOutputStream(file)) {
            fos.write(byteCode);
        }

        System.out.println("Class generated: HelloWorld");

        String packageName = fullClassName.replace('/', '.');
        // 加载动态生成的 HelloWorld 类
        Class<?> helloWorldClass = Class.forName(packageName);
        Object helloWorldInstance = helloWorldClass.getDeclaredConstructor().newInstance();
        helloWorldClass.getMethod("sayHello").invoke(helloWorldInstance);   // Hello, World!
    }

Java Compiler API

@Test
    void JavaCompilerAPITest() throws Exception {
        // 1. 源代码字符串，直接在内存中定义
        String sourceCode = """
                import java.util.*;
                public class HelloWorld {
                    public void sayHello() {
                        System.out.println("Hello, In-Memory World!");
                    }
                    public void aa() {
                        List<String> list = new ArrayList<>();
                        list.add("aa");
                        list.add("bb");
                        System.out.println(list);
                    }
                }
                """;

        // 2. 创建一个内存中的 JavaFileObject，表示源代码
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        InMemoryJavaFileObject javaFileObject = new InMemoryJavaFileObject("HelloWorld", sourceCode);

        // 3. 创建一个内存管理器，用于处理编译结果
        InMemoryFileManager fileManager = new InMemoryFileManager(compiler.getStandardFileManager(null, null, null));

        // 4. 编译源代码
        StringWriter writer = new StringWriter();
        Boolean success = compiler.getTask(writer, fileManager, null, null, null, Arrays.asList(javaFileObject)).call();

        if (!success) {
            System.out.println("Compilation failed: " + writer);
            return;
        }

        // 5. 从内存中加载生成的类
        Class<?> helloWorldClass = fileManager.getClassLoader(null).loadClass("HelloWorld");

        // 6. 创建实例并调用方法
        Object instance = helloWorldClass.getDeclaredConstructor().newInstance();
        Method sayHelloMethod = helloWorldClass.getMethod("sayHello");
        sayHelloMethod.invoke(instance);  // 输出 "Hello, In-Memory World!"
        Method aaMethod = helloWorldClass.getMethod("aa");
        aaMethod.invoke(instance);
    }


    // 自定义 JavaFileObject 实现，用于表示内存中的源代码
    static class InMemoryJavaFileObject extends SimpleJavaFileObject {
        private final String sourceCode;

        public InMemoryJavaFileObject(String className, String sourceCode) {
            super(URI.create("string:///" + className + Kind.SOURCE.extension), Kind.SOURCE);
            this.sourceCode = sourceCode;
        }

        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) {
            return sourceCode;
        }
    }

    // 自定义 JavaFileObject 实现，用于存储编译后的字节码
    static class InMemoryClassFileObject extends SimpleJavaFileObject {
        private final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

        public InMemoryClassFileObject(String className, Kind kind) {
            super(URI.create("mem:///" + className + kind.extension), kind);
        }

        @Override
        public OutputStream openOutputStream() {
            return byteArrayOutputStream;
        }

        public byte[] getBytecode() {
            return byteArrayOutputStream.toByteArray();
        }
    }

    // 内存中的 FileManager，用于管理 JavaFileObjects
    static class InMemoryFileManager extends ForwardingJavaFileManager<StandardJavaFileManager> {
        private final Map<String, InMemoryClassFileObject> classFileObjects = new HashMap<>();

        public InMemoryFileManager(StandardJavaFileManager standardManager) {
            super(standardManager);
        }

        @Override
        public JavaFileObject getJavaFileForOutput(Location location, String className, JavaFileObject.Kind kind, FileObject sibling) {
            InMemoryClassFileObject classFileObject = new InMemoryClassFileObject(className, kind);
            classFileObjects.put(className, classFileObject);
            return classFileObject;
        }

        @Override
        public ClassLoader getClassLoader(Location location) {
            return new ClassLoader() {
                @Override
                protected Class<?> findClass(String name) throws ClassNotFoundException {
                    InMemoryClassFileObject classFileObject = classFileObjects.get(name);
                    if (classFileObject != null) {
                        byte[] byteCode = classFileObject.getBytecode();
                        return defineClass(name, byteCode, 0, byteCode.length);
                    }
                    return super.findClass(name);
                }
            };
        }
    }

总结

通过 Class 类的静态方法获取已加载类的 Class 对象。例如，String.class 可以直接获取 String 类的 Class 对象，而不需要通过类加载器。

Java获取泛型的Class对象
学无止境
10-31 5万+
在做解析excel的时候，想通过泛型把解析和转java bean的过程封装起来，后面发现java里面只能获取到父类的泛型Class。这样的话，就意味着如果获取泛型Class来实例化bean对象，那么每出现一种excel模板就需要定义一个空实现，把具体的bean Class通过泛型传过去。最后决定增加一个Class参数来传递bean Class。这里记录一下Java获取泛型的Class对象的demo
动态生成class
东湖畔
10-16 210
ASM 进行动态生成class import org.objectweb.asm.ClassWriter; import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes; public class HelloWorld extends ClassLoader implements Opcodes{ ...
面试总结：生成class方法有几种
木卫
10-26 348
1.通过class的方式创建Class实例：类名.class 2.通过对象的getClass()方法获得。 3.通过Class类的forName()方法来获得。 单例模式的创建方法： 懒汉模式（线程安全，调用效率高，但是不能延时加载） public class Singleton { private static Singleton instance; private Singleton (){} public static synchronized Singleto
获取泛型的class
yuyeshahun的博客
12-06 8092
获取泛型的实际类型的类型（小记）public class BaseDaoImpl<T>{ //私有化Class，用来获取T的class private Class classt; //构造函数 public BaseDaoImpl(){ //this指BaseDaoImpl的实例 //返回表示此 Class 所表示的实体（类、接口、基本
Java 获得泛型类中的泛型类型 T.class
nvd11的专栏
10-16 8722
假如我们写了1个泛型类MyBase我想写1个getEClass 的方法， 获取泛型符号E的Class对象。直接用E.class E.getClass()都是不合法的， 因为E只是个符号， 没有被实例化。
JAVA的JAR或Class生成Delphi的Native Bridge File工具
11-23
Java的JAR或Class生成Delphi的Native Bridge File工具是一种技术解决方案，用于在Delphi环境中调用Java的类库和方法。在跨平台开发中，尤其是使用FireMonkey框架进行移动应用开发时，这样的桥接工具变得尤为重要。它...
JSONToKotlinClass:Intellij Idea，Android Studio插件，用于从JSON生成Kotlin数据类。 有助于避免为模型类编写样板代码。 支持Gson，Moshi，Jackson的注释
05-27
JSONToKotlinClass Intellij Idea，Android Studio插件。 插件从JSON文本生成Kotlin...右键单击包->从JSON生成类->复制json，键入类名->检查字段名称和类型->生成 执照 麻省理工学院执照 版权所有（c）2017 Mighty16
dart_dataclass:Dart 数据类（equals、hashCode、toString、copyWith）方法生成器
05-29
DataClass 生成器使用以下方法为您的数据类生成基类： 等于（运算符 ==） hashCode 字符串 复制与 入门 0. 将依赖添加到 pubspec.yaml dependencies : dataclass : latest_version dev_dependencies : data...
解析WordPress中的post_class与get_post_class函数
01-20
post_class 是 WordPress 内置的一个用于显示文章 class 名称的函数，该函数通常会为每一篇文章生成独一无二的 clss 值，如果你需要制作你自己的主题，而且还需要一点个性的话，那你最好驻足一下，使用该函数并配合...
Xml文件自动生成C# Class类
04-11
"Xml文件自动生成C# Class类"这个主题就涉及到了这一过程。这里我们将详细探讨如何实现这一功能，以及它在实际开发中的应用。 首先，XML文件是一种基于文本的数据存储格式，具有良好的可读性和结构化特性。它可以...
java获取泛型的class
ACMer_AK的博客
12-04 5627
介绍 java泛型使用“擦拭法” , 导致java的泛型不能直接获取到自身声明的泛型类型 使用的测试类public class Main { static class C {} static class A<T> { protected List<T> list = new ArrayList<>(); protected A<C> a = new A
Java获取泛型T的类型 T.class
ZERO
03-03 8123
直接上代码： public interface CrudRepository<T> { Iterable<T> findAll(); } public class BaseImpl <T> implements CrudRepository<T> { @Override public Iterable<T> findAll() { Class<T> c = getTClass();
编写高质量代码:改善Java程序的151个建议(第7章:泛型和反射___建议98~101)
weixin_33936401的博客
10-08 241
建议98：建议的采用顺序是List中泛型顺序依次为T、?、Object 　　List&lt;T&gt;、List&lt;?&gt;、List&lt;Object&gt;这三者都可以容纳所有的对象，但使用的顺序应该是首选List&lt;T&gt;，次之List&lt;?&gt;，最后选择List&lt;Object&gt;，原因如下： (1)、List&lt;T&gt;是确定的某一个类型 　　
java获取泛型class_Java 得到泛型中得到T.class
weixin_32369749的博客
02-15 1365
Class entityClass = (Class ) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];getGenericInterfaces()和getGenericSuperclass()getInterfaces()和getSuperclass()先来看看这两个方法都...
ParameterizedType应用，java反射，获取参数化类型的class实例
热门推荐
datouniao1的博客
12-21 1万+
ParameterizedType是一个接口，这个类可以用来检验泛型是否被参数化 比如: class Dao { public Dao(){ } }上面的这个类，也就是泛型类，当有子类集成它的时候，子类也许会将其参数化，当然也可能不进行参数化 比如我们在这样的子类中: class Subcried
获取Java集合中泛型的Class对象
учёба
01-07 4934
获取Java集合中泛型的Class对象
JAVA一种获得泛型类泛型参数Class对象的方法
什么乱七八糟的
03-15 6585
java通过泛型类特化子类获得泛型参数class对象的方法
关于Java的泛型在所声明的对象中如何获取class或者实例的方法的总结
weixin_30576859的博客
08-30 288
前段时间写过JSON字符串解析的代码，大部分工作都是在重复的写相同逻辑的代码，心血来潮打算用泛型解决这个重复的过程，结果可想而知一路上到处遇到问题，不过还好最后还是找到了解决办法。下面总结一下，一是自己备忘一下，二是分享一下。 总得说有两种方式可以解决这个问题，一种看上去技术含量很低，但是效果很好，也很简单，另一种要高一点，而且也很麻烦，在显示开发的时候也要不停的建造子类。 技术含量比较的...
java生成class文件
最新发布
04-01
<think>好的，我现在需要回答用户关于如何通过Java生成class文件的问题。首先，我应该回忆一下自己了解的Java编译过程。Java源代码文件是以.java为扩展名的，编译后会生成.class文件，这是Java虚拟机可以执行的字节码文件。 用户的问题集中在生成.class文件的方法上。根据提供的引用资料，我需要整合不同的方法。首先，最常见的方法应该是使用JDK中的javac命令。用户可能已经安装了JDK，所以第一步是确认安装，然后使用命令行工具执行编译。引用[1]提到需要安装JDK，并且从官网下载，这应该是基础步骤。然后引用[4]详细说明了使用javac命令的具体例子，比如编译PackageTest.java文件，这可能涉及到包结构的处理，需要注意目录结构。 接下来，用户可能想知道IDE中的编译方法，比如IntelliJ IDEA。引用[3]提到在IDEA中将Java文件设置为source文件，这样编译时会自动生成.class文件。这对于使用IDE的用户来说是一个方便的方法，不需要手动输入命令。 另外，动态编译也是一个有趣的点，引用[5]提到了从数据库读取Java内容并动态编译到JVM中。这可能涉及到JavaCompiler类的使用，属于高级话题，适合需要运行时编译的场景，比如某些框架或插件系统。 还有.class文件的命名规则，引用[2]讨论了生成的.class文件的命名方式，通常与类名一致，但内部类或匿名类会有不同的规则。这部分虽然用户没有直接提问，但可能作为相关问题出现，所以应该包含在相关问题里。 需要确保回答结构清晰，分步骤说明不同的方法，并引用正确的资料。比如，命令行方法、IDE自动编译、动态编译工具等。同时，要注意LaTeX格式的要求，行内公式用$...$，独立公式用$$...$$，但在这个问题中可能用不到数学公式，但需要检查是否有变量或代码块需要正确格式化。 最后，生成相关问题，考虑用户可能的后续疑问，比如性能优化、命名规则、动态编译应用等。确保引用标记正确，比如[^1]、[^2]等对应到相应的引用内容。 现在整理回答，确保每个步骤明确，代码示例正确，并自然融入引用。同时，检查是否符合用户的所有要求，包括中文回答、LaTeX格式正确、相关问题的生成等。</think>### 如何通过Java生成class文件？ Java程序需要通过编译将`.java`文件转换为`.class`文件（字节码文件），以下是具体方法： --- #### **方法1：使用命令行工具`javac`** 1. **安装JDK** 从[Oracle官网](https://www.oracle.com/java/)下载并安装JDK，确保配置环境变量`JAVA_HOME`和`PATH`[^1]。 2. **编写Java文件** 创建`.java`文件，例如`HelloWorld.java`： ```java public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } } ``` 3. **执行编译命令** 在命令行中运行： ```bash javac HelloWorld.java ``` 成功后会生成`HelloWorld.class`文件。若文件包含包名，需按目录结构存放并指定路径（如`javac -d . PackageTest.java`）[^4]。 --- #### **方法2：通过IDE自动编译** - **IntelliJ IDEA** 1. 将Java文件标记为`Sources Root`（右键目录 → Mark Directory as → Sources Root）[^3]。 2. 点击菜单栏的`Build` → `Build Project`，IDE会自动编译所有Java文件并生成`.class`文件，存放于`out`或`target`目录。 --- #### **方法3：动态编译（编程实现）** 使用`JavaCompiler`类动态编译代码，适用于运行时生成类： ```java import javax.tools.JavaCompiler; import javax.tools.ToolProvider; public class DynamicCompiler { public static void main(String[] args) { JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); int result = compiler.run(null, null, null, "HelloWorld.java"); System.out.println(result == 0 ? "编译成功" : "编译失败"); } } ``` 此方法常用于规则引擎或插件系统，支持从数据库加载代码并编译[^5]。 --- #### **注意事项** - **命名规则** `.class`文件名默认与类名一致。若包含内部类或匿名类，会生成类似`Outer$Inner.class`的文件。 - **依赖管理** 若项目依赖外部库，需通过`-cp`参数指定类路径，如`javac -cp lib/*.jar MyClass.java`。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

uncleqiao

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值