JAVA动态代理

gavinaa123aah

已于 2022-07-28 10:39:40 修改

阅读量433

点赞数 1

分类专栏： java基础后端 java后端文章标签：代理模式 java

于 2022-03-28 21:23:34 首次发布

本文链接：https://blog.csdn.net/qq_32740259/article/details/123791441

版权

java后端同时被 3 个专栏收录

14 篇文章 0 订阅

订阅专栏

java基础

13 篇文章 0 订阅

订阅专栏

后端

7 篇文章 0 订阅

订阅专栏

1 什么是代理模式（What?）

1.1 代理模式定义

代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。简言之，代理模式就是设置一个中间代理来控制访问原目标对象，以达到增强原对象的功能和简化访问方式。代理模式又分为静态代理和动态代理两种。代理模式UML图如下所示：

1.2 什么是静态代理

需要代理对象和目标对象实现一样的接口，可以在不修改目标对象的前提下扩展目标对象的功能。

1.3 什么是动态代理

动态代理利用Java 反射，动态地在内存中构建代理对象，从而实现对目标对象的代理功能，动态代理又被称为JDK代理或接口代理。

2 为什么需要动态代理(WHY?)

场景：在不侵入原有代码的前提下，给某些对象方法访问前后增加访问日志

3 静态代理实现方式（HOW）

接口类

package com.proxy;

public interface IUserDao {
    public void save();
}

目标对象

package com.proxy;

public class UserDao implements IUserDao{

    @Override
    public void save() {
        System.out.println("保存数据");
    }
}

静态代理对象：UserDapProxy 需要实现IUserDao接口！

package com.proxy;

public class UserDaoProxy implements IUserDao{

    private IUserDao target;
    public UserDaoProxy(IUserDao target) {
        this.target = target;
    }
    
    @Override
    public void save() {
        System.out.println("开启事务");//扩展了额外功能
        target.save();
        System.out.println("提交事务");
    }
}

测试类

package com.proxy;

import org.junit.Test;

public class StaticUserProxy {
    @Test
    public void testStaticProxy(){
        //目标对象
        IUserDao target = new UserDao();
        //代理对象
        UserDaoProxy proxy = new UserDaoProxy(target);
        proxy.save();
    }
}

输出结果

开启事务
保存数据
提交事务

4 动态两种不同的实现方式（HOW?）

4.1 JDK动态代理

代理接口

package org.example.dynamicproxy;

/**
 * @author LJD
 * @date 2022-03-28 8:36 下午
 */
public interface HelloService {

    void foo();
}

实现类

package org.example.dynamicproxy;

/**
 * @author LJD
 * @date 2022-03-28 8:46 下午
 */
public class HelloServiceImpl implements HelloService{

    @Override
    public void foo() {
        System.out.println("foo....bar...");
    }
}

代理类

package org.example.dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author LJD
 * @date 2022-03-28 8:48 下午
 */
public class HelloServiceProxy {

    private Object target;

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

    public Object getProxyInstance(){

        Object ret = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("before");
                Object returnVal = method.invoke(target, args);
                System.out.println("after");
                return returnVal;
            }
        });

        return ret;
    }
}

测试类

package org.example.dynamicproxy;

/**
 * @author LJD
 * @date 2022-03-28 8:47 下午
 */
public class Main {

    public static void main(String[] args) {
        HelloService target = new HelloServiceImpl();
        System.out.println(target.getClass());

        HelloService proxy = (HelloService) new HelloServiceProxy(target).getProxyInstance();
        System.out.println(proxy.getClass());
        proxy.foo();
    }
}

输出

class org.example.dynamicproxy.HelloServiceImpl
class com.sun.proxy.$Proxy0
before
foo....bar...
after

4.2 CGLIB动态代理

目标接口

package org.example.dynamicproxy.cglib;

/**
 * @author LJD
 * @date 2022-03-28 9:13 下午
 */
public interface HelloServiceCglib {

    Integer bar(int a, int b);
}

目标实现类

package org.example.dynamicproxy.cglib;

/**
 * @author LJD
 * @date 2022-03-28 9:14 下午
 */
public class HelloServiceCglibImpl implements HelloServiceCglib{
    @Override
    public Integer bar(int a, int b) {
        int ret = a + b;
        System.out.println("hello bar, result:" + ret);
        return ret;
    }
}

代理类

package org.example.dynamicproxy.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @author LJD
 * @date 2022-03-28 9:10 下午
 */
public class HelloServiceCglibProxy implements MethodInterceptor {
    private Object target;

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

    public Object getProxyInstance(){

        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before...");
        Object returnValue = method.invoke(target, objects);
        System.out.println("after...");
        return returnValue;
    }
}

测试类

package org.example.dynamicproxy.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @author LJD
 * @date 2022-03-28 9:10 下午
 */
public class HelloServiceCglibProxy implements MethodInterceptor {
    private Object target;

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

    public Object getProxyInstance(){

        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before...");
        Object returnValue = method.invoke(target, objects);
        System.out.println("after...");
        return returnValue;
    }
}

输出

class org.example.dynamicproxy.cglib.HelloServiceCglibImpl
class org.example.dynamicproxy.cglib.HelloServiceCglibImpl$$EnhancerByCGLIB$$298cda84
before...
hello bar, result:11
after...