禅与计算机
sharkchili
2022-12-12
目录

来聊聊Java的反射机制

# 写在文章开头

反射算是现代Java企业级应用中大型框架都会用到的一个特性，最经典的应用就是Spring，而笔者近期也将过去关于反射的稿件进行梳理，来针对反射这一特性进行深入的分析和讲解，希望对你有所帮助。

Hi，我是 sharkChili ，是个不断在硬核技术上作死的技术人，是 CSDN的博客专家 ，也是开源项目 Java Guide 的维护者之一，熟悉 Java 也会一点 Go ，偶尔也会在 C源码 边缘徘徊。写过很多有意思的技术博客，也还在研究并输出技术的路上，希望我的文章对你有帮助，非常欢迎你关注我的公众号： 写代码的SharkChili 。

同时也非常欢迎你star我的开源项目mini-redis:https://github.com/shark-ctrl/mini-redis (opens new window)

因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注 “加群” 即可和笔者和笔者的朋友们进行深入交流。

# 详解java中的反射

# 反射中的基本概念

反射是各类大型开源框架的灵魂，这其中Spring等框架需要获取注解上的bean名称等都会用到反射技术。

反射中涉及一个重要的概念，即Class，每一个类都只会有一个Class对象。

对应的我们给出如下代码示例，可以看到，无论何种方式获取Class对象进行比较，得到的结果都是true，这是为什么呢？

public static void main(String[] args) {
        //第一种方式获取Class对象
        User user = new User();
        Class userClass = user.getClass();//获取Class对象
        System.out.println(userClass.getName());

        //第二种方式获取Class对象
        Class userClass1 = User.class;
        System.out.println(userClass == userClass1);//判断第一种方式获取的Class对象和第二种方式获取的是否是同一个

        //第三种方式获取Class对象
        try {
            Class userClass2 = Class.forName("com.sharkchili.User");//注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
            System.out.println(userClass1 == userClass2);//判断三种方式是否获取的是同一个Class对象
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

实际上JVM在加载每个类时都会为每个类通过类加载器中的defineClass 去创建一个Class对象，而且只创建一次，所以后续我们无论通过何种方式获取到的某个类的Class对象都是一样的。

# 通过反射获取构造方法

为了演示项目，我们提供了一个学生类

public class Student {

    //---------------构造方法-------------------
    //（默认的构造方法）
    Student(String str){
        System.out.println("(默认)的构造方法 s = " + str);
    }

    //无参构造方法
    public Student(){
        System.out.println("调用了公有、无参构造方法执行了。。。");
    }

    //有一个参数的构造方法
    public Student(char name){
        System.out.println("姓名：" + name);
    }

    //有多个参数的构造方法
    public Student(String name ,int age){
        System.out.println("姓名："+name+"年龄："+ age);//这的执行效率有问题，以后解决。
    }

    //受保护的构造方法
    protected Student(boolean n){
        System.out.println("受保护的构造方法 n = " + n);
    }

    //私有构造方法
    private Student(int age){
        System.out.println("私有的构造方法   年龄："+ age);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

对应的我们也给出几个获取构造方法的方式介绍

1. public Constructor[] getConstructors()：所有"公有的"构造方法
2. public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
3. public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法：
4. public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；
1
2
3
4

代码示例如下，可以看到我们通过Class 类获取到对应的对象

public class Constructors {

    public static void main(String[] args) throws Exception {
        //1.加载Class对象
        Class clazz = Class.forName("com.guide.reflect.Student");


        //2.获取所有公有构造方法
        System.out.println("**********************所有公有构造方法*********************************");
        Constructor[] conArray = clazz.getConstructors();
        for(Constructor c : conArray){
            System.out.println(c);
        }


        System.out.println("************所有的构造方法(包括：私有、受保护、默认、公有)***************");
        conArray = clazz.getDeclaredConstructors();
        for(Constructor c : conArray){
            System.out.println(c);
        }

        System.out.println("*****************获取公有、无参的构造方法*******************************");
        Constructor con = clazz.getConstructor(null);
        //1>、因为是无参的构造方法所以类型是一个null,不写也可以：这里需要的是一个参数的类型，切记是类型
        //2>、返回的是描述这个无参构造函数的类对象。

        System.out.println("con = " + con);
        //调用构造方法
        Object obj = con.newInstance();
        //	System.out.println("obj = " + obj);
        //	Student stu = (Student)obj;

        System.out.println("******************获取私有构造方法，并调用*******************************");
        con = clazz.getDeclaredConstructor(char.class);
        System.out.println(con);
        //调用构造方法
        con.setAccessible(true);//暴力访问(忽略掉访问修饰符)
        obj = con.newInstance('男');
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

输出结果:

**********************所有公有构造方法*********************************
public com.guide.reflect.Student(java.lang.String,int)
public com.guide.reflect.Student(char)
public com.guide.reflect.Student()
************所有的构造方法(包括：私有、受保护、默认、公有)***************
private com.guide.reflect.Student(int)
protected com.guide.reflect.Student(boolean)
public com.guide.reflect.Student(java.lang.String,int)
public com.guide.reflect.Student(char)
public com.guide.reflect.Student()
com.guide.reflect.Student(java.lang.String)
*****************获取公有、无参的构造方法*******************************
con = public com.guide.reflect.Student()
调用了公有、无参构造方法执行了。。。
******************获取私有构造方法，并调用*******************************
public com.guide.reflect.Student(char)
姓名：男
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 通过反射获取成员变量

public class StudentField {
    public StudentField(){

    }
    //**********字段*************//
    public String name;

    protected int age;

    char sex;

    private String phoneNum;

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", sex=" + sex
                + ", phoneNum=" + phoneNum + "]";
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

示例代码如下所示，用到了Class 对象的getFields方法

    public static void main(String[] args) throws Exception {
        //1.获取Class对象
        Class stuClass = Class.forName("com.shark.wiki.interview.javaBase.refect.StudentField");
        //2.获取字段
        System.out.println("************获取所有公有的字段********************");
        Field[] fieldArray = stuClass.getFields();
        for(Field f : fieldArray){
            System.out.println(f);
        }
        System.out.println("************获取所有的字段(包括私有、受保护、默认的)********************");
        fieldArray = stuClass.getDeclaredFields();
        for(Field f : fieldArray){
            System.out.println(f);
        }
        System.out.println("*************获取公有字段**并调用***********************************");
        Field f = stuClass.getField("name");
        System.out.println(f);
        //获取一个对象
        Object obj = stuClass.getConstructor().newInstance();//产生Student对象--》Student stu = new Student();
        //为字段设置值
        f.set(obj, "刘德华");//为Student对象中的name属性赋值--》stu.name = "刘德华"
        //验证
        StudentField stu = (StudentField)obj;
        System.out.println("验证姓名：" + stu.name);


        System.out.println("**************获取私有字段****并调用********************************");
        f = stuClass.getDeclaredField("phoneNum");
        System.out.println(f);
        f.setAccessible(true);//暴力反射，解除私有限定
        f.set(obj, "18888889999");
        System.out.println("验证电话：" + stu);


        f = stuClass.getDeclaredField("age");
        System.out.println(f);
        f.setAccessible(true);//暴力反射，解除私有限定
        f.set(obj, 18);
        System.out.println("验证保护变量年龄：" + stu);

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

# 通过反射获取方法

我们给出StudentMethod 类并定义几个核心方法，下文将通过反射计数调用这几个方法：


public class StudentMethod {

    //**************成员方法***************//
    public void show1(String s){
        System.out.println("调用了：公有的，String参数的show1(): s = " + s);
    }
    protected void show2(){
        System.out.println("调用了：受保护的，无参的show2()");
    }
    void show3(){
        System.out.println("调用了：默认的，无参的show3()");
    }
    private String show4(int age){
        System.out.println("调用了，私有的，并且有返回值的，int参数的show4(): age = " + age);
        return "abcd";
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

可以看到通过Class 对象的getMethod获取到对应方法:



public class GetMethod {

    public static void main(String[] args) throws Exception {
        //1.获取Class对象
        Class stuClass = Class.forName("com.shark.wiki.interview.javaBase.refect.StudentMethod");
        //2.获取所有公有方法
        System.out.println("***************获取所有的”公有“方法*******************");
        Method[] methodArray = stuClass.getMethods();
        for(Method m : methodArray){
            System.out.println(m);
        }
        System.out.println("***************获取所有的方法，包括私有的*******************");
        methodArray = stuClass.getDeclaredMethods();
        for(Method m : methodArray){
            System.out.println(m);
        }
        System.out.println("***************获取公有的show1()方法*******************");
        Method m = stuClass.getMethod("show1", String.class);
        System.out.println(m);
        //实例化一个Student对象
        Object obj = stuClass.getConstructor().newInstance();
        m.invoke(obj, "刘德华");

        System.out.println("***************获取私有的show4()方法******************");
        m = stuClass.getDeclaredMethod("show4", int.class);
        System.out.println(m);
        m.setAccessible(true);//解除私有限定
        Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参
        System.out.println("返回值：" + result);

        System.out.println("***************获取私有的show3()方法******************");
        m = stuClass.getDeclaredMethod("show3");
        System.out.println(m);
        m.setAccessible(true);//解除私有限定
        Object result2 = m.invoke(obj);
        System.out.println("返回值：" + result2);


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

# 一个有趣的实验，通过反射调用main

public class StudentMain {
    public static void main(String[] args) {
        System.out.println("main方法执行了。。。");
    }
}
1
2
3
4
5
6

对应的反射示例代码如下：



    public static void main(String[] args) {
        try {
            //1、获取Student对象的字节码
            Class clazz = Class.forName("com.shark.wiki.interview.javaBase.refect.StudentMain");

            //2、获取main方法
            Method methodMain = clazz.getMethod("main", String[].class);//第一个参数：方法名称，第二个参数：方法形参的类型，
            //3、调用main方法
            // methodMain.invoke(null, new String[]{"a","b","c"});
            //第一个参数，对象类型，因为方法是static静态的，所以为null可以，第二个参数是String数组，这里要注意在jdk1.4时是数组，jdk1.5之后是可变参数
            //这里拆的时候将  new String[]{"a","b","c"} 拆成3个对象。。。所以需要将它强转。
            methodMain.invoke(null, (Object)new String[]{"a","b","c"});//方式一
            // methodMain.invoke(null, new Object[]{new String[]{"a","b","c"}});//方式二

        } catch (Exception e) {
            e.printStackTrace();
        }


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 通过反射完成泛型擦除

我们都知道java是一门伪泛型语言，泛型仅仅是在编译器会进行检查，一旦过了编译泛型就会被擦除，所以假如某些情况下我们不能修改某个类的泛型，且需要为这个为这个指定泛型的变量赋一个非泛型的值时，我们就可以使用反射技术，如下所示：

public class ModifyGenerics {
    public static void main(String[] args) throws Exception {

        ArrayList<String> strList = new ArrayList<>();
        strList.add("aaa");
        strList.add("bbb");

        //	strList.add(100);
        //获取ArrayList的Class对象，反向的调用add()方法，添加数据
        Class listClass = strList.getClass(); //得到 strList 对象的字节码 对象
        //获取add()方法
        Method m = listClass.getMethod("add", Object.class);
        //调用add()方法
        m.invoke(strList, 100);

        //遍历集合
        for (Object obj : strList) {
            System.out.println(obj);
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 反射的工作原理(重点)

先来了解一下new的基本过程，首先是查看方法区有没有关于class解析的对象的信息，如果没有则先去加载，完成后拿着这些信息完成对象创建。 而反射则是通过方法区在堆区创建一个对应类的唯一一个Class对象，通过这个对象获取类中各种信息并封装成一个个Method、Field等对象使用。

# 总结反射的优缺点

反射的优点：

  1. 运行期动态加载，提高代码的灵活度。
  2. 通过反射可实现代理模式，通过反射的特性针对对象进行动态增强，保证业务功能和动态拓展的解耦。

反射的缺点： 3. 反射实质上就是一堆解释操作，即通知JVM做各种操作，这远远比运行机器码要慢得多。这正是为什么《effective java》中要求我们接口优于反射。

1.你失去了编译时类型检查的所有好处， 包括异常检查。如果一个程序试图反射性地调用一个不存在的或不可访问的方法，它将在运行时失败，除非你采取了特殊的预防措施。

2.执行反射访问所需的代码既笨拙又冗长。 写起来很乏味，读起来也很困难。 3.性能降低。 反射方法调用比普通方法调用慢得多。到底慢了多少还很难说，因为有很多因素在起作用。在我的机器上，调用一个没有输入参数和返回 int 类型的方法时，用反射执行要慢 11 倍。

# 详解反射的两种代理模式

静态代理说起来很简单，他就是通过编码的形式，将被代理对象以成员变量的形式出现在代理对象中。从JVM的角度来看，之所以我们叫他静态代理，正是因为他会在编译的时候，将上述的一个个类编译成一个个的class文件。

对此我们给出静态代理类的代理类的实现类：

/**
 * 通过接口抽象代理类和被代理类的动作
 */
public interface SmsService {
    String send(String message);
}

/**
 * 被代理类
 */
public class SmsServiceImpl implements SmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

可以看到静态拓展即在在运行前通过编码的方式将代理对象以成员变量的方式组合到代理类中，然后在代理对象的方法调用前后增加增强的功能：

/**
 * 代理类
 */
public class SmsProxy implements SmsService {

    /**
     * 通过关联关系将被代理对象以成员变量形式组合到代理类中
     */
    private final SmsService smsService;

    public SmsProxy(SmsService smsService) {
        this.smsService = smsService;
    }

    @Override
    public String send(String message) {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method send()");
        smsService.send(message);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method send()");
        return null;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

相比与静态代理，动态代理则相对灵活一些，它可以在运行时候动态的生成被代理类的字节码并加载到JVM中，而且与静态代理相比它无需创建接口类去规范代理类的方法(如果被代理类没有实现接口完全可以使用CGLIB来实现)。

我们还是给出被代理类的接口和实现：

public interface SmsService {
    String send(String message);
}


public class SmsServiceImpl implements SmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}
1
2
3
4
5
6
7
8
9
10
11

完成这些动作之后我们给出JDK代理的动态增强代码示例，可以看到我们通过继承InvocationHandler 完成运行时动态的针对代理对象进行功能拓展：


public class DebugInvocationHandler implements InvocationHandler {
    /**
     * 代理类中的真实对象
     */
    private final Object target;

    public DebugInvocationHandler(Object target) {
        this.target = target;
    }


    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object result = method.invoke(target, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
        return result;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

对应的我们也给出使用示例：



/**
 * jdk代理类 可以看到Obj对象类型任意，真正实现了代码解耦
 */
public class JdkProxyFactory {
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(), // 目标类的类加载
                target.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个
                new DebugInvocationHandler(target)   // 代理对象对应的自定义 InvocationHandler
        );
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

对应我们也给出下面这段使用示例：



    public static void main(String[] args) {
        SmsService smsService = (SmsService) JdkProxyFactory.getProxy(new SmsServiceImpl());
        smsService.send("java");

    }
1
2
3
4
5
6
7
8
9

需要补充的是cglib是动态生成代理对象，所以无法为final或者private方法进行处理



/**
 * 需要被代理的类
 */
public class AliSmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

增强器代码示例



/**
 * 自定义MethodInterceptor
 */
public class DebugMethodInterceptor implements MethodInterceptor {


    /**
     * @param o           代理对象（增强的对象）
     * @param method      被拦截的方法（需要增强的方法）
     * @param args        方法入参
     * @param methodProxy 用于调用原始方法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object object = methodProxy.invokeSuper(o, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
        return object;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

代码示例：


import net.sf.cglib.proxy.Enhancer;

/**
 * 代理类
 */
public class CglibProxyFactory {

    public static Object getProxy(Class<?> clazz) {
        // 创建动态代理增强类
        Enhancer enhancer = new Enhancer();
        // 设置类加载器
        enhancer.setClassLoader(clazz.getClassLoader());
        // 设置被代理类
        enhancer.setSuperclass(clazz);
        // 设置方法拦截器
        enhancer.setCallback(new DebugMethodInterceptor());
        // 创建代理类
        return enhancer.create();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

测试代码：


public class Main {
    public static void main(String[] args) {
        AliSmsService aliSmsService = (AliSmsService) CglibProxyFactory.getProxy(AliSmsService.class);
        aliSmsService.send("java");

    }
}
1
2
3
4
5
6
7
8
9

# 常见面试题

# 什么是反射机制？为什么反射慢

反射就是运行时通过类的名字反向获取类信息的一种技术手段，而反射慢的原因是：

  1. 反射涉及动态类型解析即通知JVM进行各种操作而非直接运行机器码，因为各种未知性JIT无法针对这些执行进行优化。
  2. 通过反射创建对象时必须通过类型检查、参数检查等操作，这些额外的开销就是导致执行效率低的原因。
  3. 反射调用方法时会从方法数组中遍历查找，并会检查类型可见性。
  4. 使用反射时，参数类型需要先包装成object[]数组，执行时有需要拆包成实际的类型，频繁的拆箱和装箱也是导致性能低下的原因，而且这过程中还会产生各种冗余对象，导致频繁GC。

# 对于动态代理的使用你有什么看法？

在《精通spring4.x》一书中，我们可以知道，jdk生成的代理对象性能远远差于cglib生成代理对象，但cglib创建代理对象花费的时间却远远高于jdk代理创建的对象。所以在spring框架的使用中，如果是单例的bean需要实现aop等操作，我们建议是使用cglib动态代理技术：

# Java中实现回调方式有几种？

  1. 就是我们反射，这种性能有点差，不太推荐
/**
 * 基于反射实现回调1
 */
public class Demo1 {

    public static void main(String[] args) {
        Request request=new Request();
        new Thread(()->{
            try {
                request.send(CallBackClass.class,CallBackClass.class.getMethod("process"));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
    }
}


class Request {

    private static Logger logger = LoggerFactory.getLogger(Request.class);

    public void send(Class clazz, Method method) throws Exception {
        // 模拟等待响应
        Thread.sleep(3000);
        logger.info("收到用户的请求，处理业务逻辑后发起回调");
        method.invoke(clazz.newInstance());
        logger.info("回调结束");
    }
}


class CallBackClass {
    private static Logger logger = LoggerFactory.getLogger(CallBackClass.class);

    public void process() {
        logger.info("这个是回调方法哦");

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
  1. 直接将回调方法封装成一个对象传入：
/**
 * 直接调用，耦合度比较高
 */
public class Demo2 {
    public static void main(String[] args) {
        Request1 request=new Request1();
        new Thread(()->{
            try {
                request.send(new CallBackClass1());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
    }


}


class Request1 {

    private static Logger logger = LoggerFactory.getLogger(Request.class);

    public void send(CallBackClass1 callBackClass) throws Exception {
        // 模拟等待响应
        Thread.sleep(3000);
        logger.info("收到用户的请求，处理业务逻辑后发起回调");
        callBackClass.process();
        logger.info("回调结束");
    }
}


class CallBackClass1 {
    private static Logger logger = LoggerFactory.getLogger(CallBackClass.class);

    public void process() {
        logger.info("这个是回调方法哦");

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
  1. 将回调行为抽成一个接口作为参数，真正的回调继承接口实现就好了
/**
 * 接口调用
 */
public class Demo3 {
    public static void main(String[] args) {

        CallBackInterface callBackInterface=new CallBackImpl();
        Request2 request2=new Request2();
        new Thread(()->{
            try {
                request2.send(callBackInterface);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
    }

}


class Request2 {

    private static Logger logger = LoggerFactory.getLogger(Request.class);

    public void send(CallBackInterface CallBackInterface) throws Exception {
        // 模拟等待响应
        Thread.sleep(3000);
        logger.info("收到用户的请求，处理业务逻辑后发起回调");
        CallBackInterface.process();
        logger.info("回调结束");
    }
}

interface CallBackInterface{
    void process();
}

class CallBackImpl implements CallBackInterface{

    private static Logger logger = LoggerFactory.getLogger(CallBackImpl.class);
    @Override
    public void process() {
        logger.info("处理回调");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
  1. 准确来说并不是第4种方法，这种就是基于方法3的接口用lambda实现而已
/**
 * lambda处理回调
 */
public class Demo4 {
    private static Logger logger = LoggerFactory.getLogger(Demo4.class);
    public static void main(String[] args) {
        CallBackInterface callBackInterface=new CallBackImpl();
        Request2 request2=new Request2();
        new Thread(()->{
            try {
                request2.send(()->{logger.info("lambda处理回调");});
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# java中创建对象有哪些种方式

  1. 继承Cloneable 接口通过克隆的方式创建对象：
@Data
public class Person implements Cloneable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 重写 clone() 方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }



    public static void main(String[] args) {
        try {
            Person original = new Person("张三", 30);
            System.out.println("原始对象: " + original);

            Person cloned = (Person) original.clone();
            System.out.println("克隆对象: " + cloned);

            // 修改克隆对象的属性
            cloned.setName("李四");
            cloned.setAge(25);

            System.out.println("修改后的克隆对象: " + cloned);
            System.out.println("原始对象: " + original);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
  1. 通过反序列化将物理文件中序列化文件通过反序列化的方式生成对象：
 // 反序列化对象从文件
            FileInputStream fis = new FileInputStream("person.ser");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Person deserialized = (Person) ois.readObject();
            ois.close();
            fis.close();
1
2
3
4
5
6
  1. 通过new关键字创建对象
  2. 通过反射创建对象

# Java的动态代理如何实现

  1. 通过Proxy的InvocationHandler接口对目标类型进行拦截和拓展。
  2. 通过CGLIB在运行时通过字节码操作动态生成子类对象对目标对象进行拓展。

# 小结

自此我们基于诸多实践完成了反射的核心知识讲解，希望对你有帮助。

我是 sharkchili ，CSDN Java 领域博客专家，mini-redis的作者，我想写一些有意思的东西，希望对你有帮助，如果你想实时收到我写的硬核的文章也欢迎你关注我的公众号： 写代码的SharkChili 。

同时也非常欢迎你star我的开源项目mini-redis:https://github.com/shark-ctrl/mini-redis (opens new window)

因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注 “加群” 即可和笔者和笔者的朋友们进行深入交流。

# 参考文献

Reflection：Java反射机制的应用场景：https://segmentfault.com/a/1190000010162647?utm_source=tuicool&utm_medium=referral (opens new window)

Java基础之—反射（非常重要）：https://blog.csdn.net/sinat_38259539/article/details/71799078 (opens new window)

Effective Java 第3版:https://book.douban.com/subject/30412517/ (opens new window)

精通Spring4.x:https://book.douban.com/subject/26952826/ (opens new window)

Java回调的四种写法（反射、直接调用、接口调用、Lamda表达式）:https://cloud.tencent.com/developer/article/1676582 (opens new window)

长篇图解java反射机制及其应用场景:https://segmentfault.com/a/1190000042318592 (opens new window)

方法区（Method Area）详解:https://blog.csdn.net/qq_43684005/article/details/119615972 (opens new window)

Java8中的JVM元空间是不是方法区？:https://www.zhihu.com/question/358312524 (opens new window)

编辑 (opens new window)
上次更新: 2026/03/26, 01:05:31
万字长文带你细聊Java注解本质
深入解析 Java 泛型的魅力与机制

← 深入解析 Java 泛型的魅力与机制→

最近更新
01
基于EasyExcel实现高效导出
03-25
02
从开源框架中学习那些实用的位运算技巧
03-25
03
浅谈分布式架构设计思想和常见优化手段
03-25
更多文章>
Theme by Vdoing | Copyright © 2025-2026 Evan Xu | MIT License | 桂ICP备2024034950号 | 桂公网安备45142202000030
×
×