JavaSE反射与动态代理详细代码示例_Java

一、引言

在java生态中，反射与动态代理是支撑框架设计的基石，无论是spring中的aop，还是mybatis的mapper接口，都离不开这两项技术。在学习之前先了解反射和动态代理分别可以做什么，简单说反射赋予程序“看清类结构”的功能，通过反射可以知道类中构造方法，成员方法，成员变量等信息；动态代理则实现了“无侵入式增强”，二者相辅相成，让代码具备灵活性与扩展性。

二、java反射：探索类的“隐藏世界”

2.1 反射的定义

在java中，反射（reflection）是一种强大的机制，允许程序在运行时检查或修改其自身的结构和行为。通过反射，你可以查询类的元数据（如类名、方法、字段、注解等），动态地进行创建对象，调用方法，访问字段等操作。

2.2反射的核心api

java反射的核心操作集中在java.lang.reflect包中，其中关键类包括class、method、field、constructor，核心操作分为“获取class对象”“操作类成员”两步

(1)如何获取类对象?

首先在这里定义一个user类

public class user {
    private string name;
    public integer age;
    public user(){}
    private user(string name) {
        this.name = name;
    }
    public string getname() {
        return name;
    }
    private void setage(integer age) {
        this.age = age;
    }
}

获取类对象有三种方式分别是：类名.class，对象.getclass()，class.forname(“全类名”)

        //1.类名.class(编译时确定，最高效)
        class<?> class1 = user.class;
        system.out.println(class1); //class user
        //2.对象.getclass() (运行时获取，需要实例化)
        user user = new user();
        class<?> class2 = user.getclass();
        system.out.println(class2); //class user
        //3.class.forname("全类名") (运行时加载，最灵活)
        class<?> class3 = class.forname("user");
        system.out.println(class3); //class user
        //判断上面三种方法获取的是否是同一个对象
        system.out.println(class1.equals(class2)); //true

(2) 利用反射操作类

得到类成员后就可以利用反射操作类的构造方法，成员方法，成员变量等元数据，核心api也很易懂

示例1. 构造器

//1.获取类
        class<user> userclass = user.class;
        //2.获取构造器
        //2.1获取公共构造器
        constructor<?>[] publicconstructors = userclass.getconstructors();
        system.out.println(arrays.tostring(publicconstructors)); //[public user()]
        //2.2获取所有构造器
        constructor<?>[] declaredconstructors = userclass.getdeclaredconstructors();
        system.out.println(arrays.tostring(declaredconstructors)); //[public user(), private user(java.lang.string)]
        //2.3获取一个公共构造器 (可以传递参数，参数是构造器中的形参类)
        constructor<user> constructor = userclass.getconstructor();
        system.out.println(constructor); //public user()
        //2.4获取一个构造器 (可以传递参数，参数是构造器中的形参类)
        constructor<user> declaredconstructor = userclass.getdeclaredconstructor(string.class);
        system.out.println(declaredconstructor); // private user(java.lang.string)

然后可以对获得的构造器进行操作:

//2.4获取一个构造器
		constructor<user> declaredconstructor = userclass.getdeclaredconstructor(string.class);
        system.out.println(declaredconstructor); // private user(java.lang.string)
		//3.constructor类常用方法
        //3.1获取构造器的权限修饰符
        int modifiers = declaredconstructor.getmodifiers();
        system.out.println(declaredconstructor + "的构造方法的修饰符为" + modifiers);//private user(java.lang.string)的构造方法的修饰符为2(对应private)
        //3.2获取构造器的形参类型
        class<?>[] types = declaredconstructor.getparametertypes();
        system.out.println(declaredconstructor + "的形参类型有" + arrays.tostring(types)); //private user(java.lang.string)的形参类型有[class java.lang.string]
        //3.3通过constructor实例化对象
        //因为获取的是私有方法，所以需要暴力反射
        declaredconstructor.setaccessible(true);//将私有构造器设置为可访问状态
        user user = declaredconstructor.newinstance( "无止境"); 
        system.out.println(user.getname()); //无止境

在 java 中，java.lang.reflect.constructor类的getmodifiers()方法返回一个整数，该整数是构造器修饰符的位掩码（bitmask）。每个修饰符对应一个二进制位，不同修饰符通过按位或（or）组合成最终的整数值。

获取字段，方法等api与获取构造器类似，演示一下通过反射操作私有成员

    //1.获取类
        class<user> userclass = user.class;
        //2.实例私有构造器
        constructor<user> privateconstructor = userclass.getdeclaredconstructor(string.class);
        privateconstructor.setaccessible(true);
        user user = privateconstructor.newinstance("无止境");
        //3.调用私有化方法setage
        method setage = userclass.getdeclaredmethod("setage", integer.class);
        setage.setaccessible(true);
        setage.invoke(user, 18);
        system.out.println(user.getname() + "的年龄为" + user.getage()); //无止境的年龄为18
        //4.获取私有属性 name
        field namefield = userclass.getdeclaredfield("name");
        namefield.setaccessible(true);
        string name = (string)namefield.get(user);
        system.out.println("利用反射获取的私有属性" + name); //利用反射获取的私有属性无止境

method类中invoke()方法比较常用，传递的参数表示1:调用方法的对象， 2:调用方法传递的参数；返回值就是原方法返回值

三、动态代理，无侵入式增强的实现利器

3.1动态代理定义

动态代理是一种设计模式，允许程序在运行时动态生成代理类，代理类会包裹目标对象，在不修改目标代码的情况下，对目标方法进行增强。java中动态代理主要分为两种jdk动态代理和cglib动态代理。

3.2jdk动态代理(接口增强)

(1)核心组件

invocationhandler：定义代理逻辑，所有代理方法的调用都会委托给该接口的invoke方法。
proxy：用于创建动态代理类和实例的工厂

(2)实现步骤

定义接口：目标类需实现接口
实现invocationhandler：处理方法调用逻辑
生成代理对象：通过proxy.newproxyinstance()创建代理

(3)示例代码

定义接口：目标类需实现接口

//目标接口
public interface userservice {
    void adduser(string name);
    void deleteuser(integer id);
}
//目标实现类
public class userserviceimpl implements userservice {
   @override
    public void adduser(string name) {
        system.out.println("执行添加姓名为 : " + name + " 用户的操作");
    }
    @override
    public void deleteuser(integer id) {
        system.out.println("执行删除id为 : " + id + " 用户的操作");
    }
}

实现invocationhandler：处理方法调用逻辑

public class loginvocationhandler implements invocationhandler {
    private object target; //目标对象
    public loginvocationhandler(object target) {
        this.target = target;
    }
    /**
     *
     * @param proxy 代理对象
     * @param method 目标方法
     * @param args 方法参数
     * @return 方法返回值
     * @throws throwable
     */
    @override
    public object invoke(object proxy, method method, object[] args) throws throwable {
        //前置日志,记录日志
        system.out.println("【日志】 开始调用方法 : " + method.getname() + ",方法参数为 : " + arrays.tostring(args));
        //调用目标方法
        object result = method.invoke(target, args);
        //后置日志，记录方法完成
        system.out.println("【日志】方法调用结束 : " + method.getname());
        return result;
    }
}

生成代理对象：通过proxy.newproxyinstance()创建代理

public static void main(string[] args) {
        //1.创建目标对象
        userserviceimpl target = new userserviceimpl();
        //2.创建invocationhandler实例
        loginvocationhandler handler = new loginvocationhandler(target);
        //3.生成动态代理对象
        userservice proxy = (userservice) proxy.newproxyinstance(
                target.getclass().getclassloader(), //类加载器
                target.getclass().getinterfaces(), //目标实现的接口
                handler
        );
        //4.调用代理对象的方法
        proxy.adduser("无止境");
        proxy.deleteuser(1001);
    }

最后控制台输出结果

【日志】开始调用方法 : adduser,方法参数为 : [无止境]
执行添加姓名为 : 无止境用户的操作
【日志】方法调用结束 : adduser
【日志】开始调用方法 : deleteuser,方法参数为 : [1001]
执行删除id为 : 1001 用户的操作
【日志】方法调用结束 : deleteuser

至此就完成了一个简单的日志增强效果

(4)核心api用法

public object invoke(object proxy, method method, object[] args)：三个参数分别是代理对象本身（通常不需要使用）；被调用的目标方法；方法参数数组。
public static object newproxyinstance(
classloader loader,
class<?>[] interfaces,
invocationhandler h
)：里面要传递三个参数分别是类加载器（通常使用目标接口的类加载器）；目标接口数组（至少一个接口）；代理逻辑处理器。

3.3cflib实现动态代理(类增强)

(1)核心组件

methodinterceptor：拦截目标类的方法调用，定义增强逻辑
enhancer：生成代理类和实例的工具

(2)实现步骤

引入cglib依赖
定义无接口的目标类
实现methodinterceptor
生成cglib代理对象：利用enhancer.create()方法

(3)示例代码

引入cglib依赖(maven)

<dependency>
            <groupid>cglib</groupid>
            <artifactid>cglib</artifactid>
            <version>3.3.0</version>
        </dependency>

public class orderservice {
    //模拟创建订单方法
    public void createorder(string orderno) {
        system.out.println("创建订单，订单号为 : " + orderno);
    }
}

自定义类实现methodinterceptor，处理方法调用逻辑

public class transactionmethodinterceptor implements methodinterceptor {
    /**
     *
     * @param o 目标对象
     * @param method 目标方法
     * @param objects 方法参数
     * @param methodproxy 方法代理对象
     * @return 方法返回值
     * @throws throwable
     */
    @override
    public object intercept(object o, method method, object[] objects, methodproxy methodproxy) throws throwable {
        //前置增强：开启事务
        system.out.println("【事务】开启数据事务");
        //调用目标方法(通过methodproxy提高性能)
        object result = methodproxy.invokesuper(o, objects);
        //后置增强：提交事务
        system.out.println("【事务】提交数据事务");
        return result;
    }
}

通过enhancer.create()生成代理对象

public class cglibproxydemo {
    public static void main(string[] args) {
        //1.创建enhancer实例(cglib核心)
        enhancer enhancer = new enhancer();
        enhancer.setsuperclass(orderservice.class); //设置目标类
        enhancer.setcallback(new transactionmethodinterceptor()); //设置增强器
        //2.生成动态代理对象
        orderservice proxy = (orderservice) enhancer.create();
        //3.调用代理对象方法
        proxy.createorder("order_112233");
    }
}

最终输出结果:

【事务】开启数据事务
创建订单，订单号为 : order_112233
【事务】提交数据事务

(4)核心api用法

public void setsuperclass(class<?> superclass); 指定目标类
public void setcallback(callback callback); 设置拦截器
public object create(); 生成代理实例
public object intercept(
object obj,
method method,
object[] args,
methodproxy proxy
)：参数分别是obj：代理对象（通常不需要使用）；method：被调用的目标方法；args：方法参数数组；proxy：methodproxy 对象，比反射调用更高效

3.3jdk动态代理和cglib动态代理横向对比

组件	jdk动态代理	cglib动态代理
接口	invocationhandler	methodinterceptor
生成代理方式	proxy.newproxyinstance	enhancer.create()
目标类型	接口	类
调用目标方法	method.invoke(target, args)	proxy.invoksuper(obj, args)

四、反射与动态代理的实际应用

(1)反射的实际应用

spring 框架：spring 使用反射来创建和管理 bean。例如，通过配置文件（如 xml 或注解）指定要创建的类，spring 容器利用反射机制根据类名动态加载类，并调用其构造函数创建对象实例。
junit：junit 利用反射来发现和执行测试方法。它通过反射遍历测试类中的方法，根据特定的注解（如@test）识别出测试方法，并动态调用这些方法来执行测试。例如，在一个测试类中定义了多个测试方法，junit 通过反射获取这些方法并依次执行，从而实现对代码的自动化测试。

(2) 动态代理的实际应用

spring aop：spring aop 大量使用动态代理来实现切面功能。例如，在一个企业级应用中，可能需要对业务方法进行日志记录、事务管理等操作。通过动态代理，可以在不修改目标业务类代码的前提下，为目标方法添加这些额外的功能。spring 会为目标对象创建动态代理对象，当调用代理对象的方法时，会先执行切面逻辑（如记录日志），然后再调用目标对象的实际方法，最后还可以在方法调用后执行一些清理或补充逻辑（如事务提交）。
在数据库事务管理中，动态代理可以用于管理事务的开启、提交和回滚。以一个银行转账操作的业务方法为例，动态代理可以在方法调用前开启事务，方法执行过程中如果没有异常则提交事务，若出现异常则回滚事务。这样可以将事务管理的逻辑从业务代码中分离出来，提高代码的可维护性和复用性。