java动态代理实现

最新推荐文章于 2023-11-26 17:41:29 发布

zlk_blogs

最新推荐文章于 2023-11-26 17:41:29 发布

阅读量184

点赞数

分类专栏： java 文章标签： java aop

本文链接：https://blog.csdn.net/qq_34553637/article/details/109367347

版权

java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

java动态代理实现

动态代理：使用反射和字节码技术，在运行期间创建指定接口或者类的子类以及其实例对象的技术。（动态代理，切面增强）

JDK原生动态代理：是由java内部的反射机制来实现的，需要目标类（被代理对象）实现统一的接口。

CGLIB动态代理：借助asm来实现;可以通过将asm生成的类进行缓存，解决asm生成类过程低效问题。
              不需要目标类（被代理对象）实现统一的接口，但是需要引入cglib的jar包。

动态代理前

动态代理后

pom.xml

<!--lombok--> 	
<dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
</dependency>
 
<!--cglib动态代理--> 	
<dependency>
	<groupId>cglib</groupId>
	<artifactId>cglib</artifactId>
	<version>${cglib.version}</version>
</dependency>

1 JDK原生动态代理

是由java内部的反射机制来实现的，需要目标类（被代理对象）实现统一的接口。

Proxy：调用静态newProxyInstance()方法，用于创建被代理对象的实例。

InvocationHandler（被代理对象构造方法注入）:每个动态代理都关联一个InvocationHandler，被代理对象实例（Proxy.newProxyInstance()）调用具体方法时，
                                         会转到InvocationHandler下的invoke()方法。invoke方法可以反射调用具体方法，
                                         并可以做前置处理（安全、权限、参数校验、条件更改-如sql）与后置增强(如操作完成后的日志输出)。

示例代码：

实体User，业务类UserServiceImpl必须实现接口UserService

/**
 * @Description: 用户实体
 * @Author: ZhouLiKuan
 * @Date: 2020/10/29 10:52
 */
@Data
public class User {
    private Long id;

    private String name;

    public User() {
    }

    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }
}


/**
 * @Description: 用户服务接口
 * @Author: ZhouLiKuan
 * @Date: 2020/10/29 10:22
 */
public interface UserService {
    List<User> queryUserList(User user);

    User queryUserById(Long id);
}


/**
 * @Description: 被代理对象：用户业务实现类；jdk动态代理需要实现统一的接口（强制）
 * @Author: ZhouLiKuan
 * @Date: 2020/10/29 10:27
 */
public class UserServiceImpl implements UserService{
    @Override
    public List<User> queryUserList(User user) {
        List<User> userList = new ArrayList<>();
        userList.add(new User(1001L,"用户1001"));
        userList.add(new User(1002L,"用户1002"));
        return userList;
    }

    @Override
    public User queryUserById(Long id) {
        return new User(id,"用户:"+id);
    }
}

jdk方式的动态代理，需要实现InvocationHandler接口，重写invoke方法。被代理对象通过构造方法注入。

/**
 * @Description: jdk方式实现动态代理器-需要实现InvocationHandler接口，重写invoke方法。
 * @Author: ZhouLiKuan
 * @Date: 2020/10/29 10:46
 */
@Slf4j
public class MyInvocationHandler<T> implements InvocationHandler {
    /**被代理对象,实现统一接口的实现类（UserServiceImpl）*/
    private  Object target;

    /**
     * 构造方法注入被代理对象
     * @param target
     */
    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // proxy 为MyInvocationHandler
        // method 当前被代理对象执行的具体方法
        // args 当前被代理对象执行的具体方法的入参

        //前置处理，条件处理、字段校验、安全等
        if( args != null &&args[0] instanceof User){
            log.info("前置处理：条件处理、字段校验、安全等");
        }

        //调用方法
        T result = (T) method.invoke(target, args);

        //后置增强，日志输出等
        log.info("后置增强：处理日志。。。。。");

        return result;
    }
}

测试类，使用Proxy创建被代理对象实例并实现动态代理。

/**
 * @Description: 测试jdk原生动态代理;  被代理对象必须有统一实现的接口
 * @Author: ZhouLiKuan
 * @Date: 2020/10/29 14:46
 */
public class Test {

    public static void main(String[] args) {
        //需要被代理的对象。该类必须有接口实现
        UserService userService = new UserServiceImpl();
        //注入被代理对象
        MyInvocationHandler<User>  invocationHandler = new MyInvocationHandler<>(userService);

        //Proxy.newProxyInstance（）生成被代理实例对象（参数：接口ClassLoader，实现类，代理器）
        UserService userServiceProxy = (UserService) Proxy.newProxyInstance(UserService.class.getClassLoader(), userService.getClass().getInterfaces(), invocationHandler);

        //调用方法queryUserList()
        List<User> users = userServiceProxy.queryUserList(new User());
        System.out.println(users);

        System.out.println("=============");

        //调用方法queryUserById()
        User user = userServiceProxy.queryUserById(1001L);
        System.out.println(user);
    }
}

测试结果

17:28:07.968 [main] INFO com.zlk.practice.dynamicproxy.jdk.MyInvocationHandler - 前置处理：条件处理、字段校验、安全等
17:28:07.970 [main] INFO com.zlk.practice.dynamicproxy.jdk.MyInvocationHandler - 后置增强：处理日志。。。。。
[User(id=1001, name=用户1001), User(id=1002, name=用户1002)]
=============
17:28:07.971 [main] INFO com.zlk.practice.dynamicproxy.jdk.MyInvocationHandler - 后置增强：处理日志。。。。。
User(id=1001, name=用户:1001)

2 CGLIB动态代理

借助asm来实现;可以通过将asm生成的类进行缓存，解决asm生成类过程低效问题。不需要目标类（被代理对象）实现统一的接口。但是需要单独引入jar包

Enhancer：指定代理对象与被代理对象，调用create()创建被被代理对象实例。

MethodInterceptor：被代理对象调用方法时，转到intercept方法下。 
                   并可以做前置处理（安全、权限、参数校验、条件更改-如sql）与后置增强(如操作完成后的日志输出)。

代码示例

user实体类，被代理对象UserService。不需要实现接口

/**
 * @Description: 用户实体
 * @Author: ZhouLiKuan
 * @Date: 2020/10/29 10:52
 */
@Data
public class User {
    private Long id;

    private String name;

    public User() {
    }

    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }
}

/**
 * @Description: 被代理对象：用户业务实现类；cglib动态代理不需要实现统一的接口
 * @Author: ZhouLiKuan
 * @Date: 2020/10/29 10:27
 */
public class UserService {
    public List<User> queryUserList(User user) {
        List<User> userList = new ArrayList<>();
        userList.add(new User(1001L,"用户1001"));
        userList.add(new User(1002L,"用户1002"));
        return userList;
    }

    public User queryUserById(Long id) {
        return new User(id,"用户:"+id);
    }
}

cglib方式实现动态代理器，需要实现MethodInterceptor 接口，重写intercept方法。

/**
 * @Description: cglib方式实现动态代理器-需要实现MethodInterceptor 接口，重写intercept方法。
 * @Author: ZhouLiKuan
 * @Date: 2020/10/29 10:46
 */
@Slf4j
public class CglibProxy implements MethodInterceptor {

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        // methodProxy 为方法代理
        // method 当前代理对象执行的具体方法
        // objects 当前代理对象执行的具体方法的入参
        // o 被代理对象(service)

        log.info("方法名称："+method.getName());

        //前置处理，条件处理、字段校验、安全等
        if( objects != null &&objects[0] instanceof User){
            log.info("前置处理：条件处理、字段校验、安全等");
        }

        //调用方法
        Object result = methodProxy.invokeSuper(o, objects);
        //后置增强，日志输出等
        log.info("后置增强：处理日志。。。。。");

        return result;
    }

}

测试类

/**
 * @Description: 测试cglib动态代理;  需要单独引入包，被代理对象不需要强制实现接口
 * @Author: ZhouLiKuan
 * @Date: 2020/10/29 14:46
 */
public class Test {

    public static void main(String[] args) {
        CglibProxy cglibProxy  = new CglibProxy();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);
        enhancer.setCallback(cglibProxy);

        //enhancer.create() 创建被代理对象实例
        UserService userService = (UserService) enhancer.create();

        //调用方法queryUserList()
        List<User> users = userService.queryUserList(new User());
        System.out.println(users);

        System.out.println("=============");

        //调用方法queryUserById()
        User user = userService.queryUserById(1001L);
        System.out.println(user);
    }
}

测试结果

19:38:37.671 [main] INFO com.zlk.practice.dynamicproxy.cglib.CglibProxy - 方法名称：queryUserList
19:38:37.672 [main] INFO com.zlk.practice.dynamicproxy.cglib.CglibProxy - 前置处理：条件处理、字段校验、安全等
19:38:37.682 [main] INFO com.zlk.practice.dynamicproxy.cglib.CglibProxy - 后置增强：处理日志。。。。。
[User(id=1001, name=用户1001), User(id=1002, name=用户1002)]
=============
19:38:37.682 [main] INFO com.zlk.practice.dynamicproxy.cglib.CglibProxy - 方法名称：queryUserById
19:38:37.682 [main] INFO com.zlk.practice.dynamicproxy.cglib.CglibProxy - 后置增强：处理日志。。。。。
User(id=1001, name=用户:1001)

完整代码示例见： https://github.com/zlk-github/general-item/tree/master/practice/src/main/java/com/zlk/practice/dynamicproxy

zlk_blogs

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java动态代理实现

### 10 动态代理的几种实现与优缺点动态代理：使用反射和字节码技术，在运行期间创建指定接口或者类的子类以及其实例对象的技术。（动态代理，切面增强） JDK原生动态代理：是由java内部的反射机制来实现的，需要目标类（被代理对象）实现统一的接口。 CGLIB动态代理：借助asm来实现;可以通过将asm生成的类进行缓存，解决asm生成类过程低效问题。不需要目标类（被代理对象）实现统一的接口，但是需要引入cglib的jar包。动态...
复制链接

扫一扫