简单理解代理模式--动态代理

简单理解代理模式–动态代理

• 动态代理实现分为两种类型：JDK 相关API动态代理和CGLIB动态代理，这两种代理方式是有区别的。注意的是，学习动态代理前，最好是学习过反射的知识。因为使用动态代理时，需要通过反射机制动态生成代理类的字节码，并加载到JVM中，从而创建代理对象。如果没学过也不要紧，这篇文章也只是简单的描述动态代理，代码理解起来不会有什么太大的困难

JDK 相关API动态代理

首先定义一个接口，可以看到里面就是简单地增删改查四个抽象方法

public interface UserDao {

    void addUser();
    void deleteUser(int id);
    void updateUser();
    void queryUser();
}

实现抽象类

public class UserDaoImpl implements UserDao {

    public String userName = "root";

    @Override
    public void addUser() {
        System.out.println("添加.....");
    }

    @Override
    public void deleteUser(int id) {
        System.out.println("删除.....");
    }

    @Override
    public void updateUser() {
        System.out.println("修改.....");
    }

    @Override
    public void queryUser() {
        System.out.println("查询.....");
    }
}

代理类

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


public class ProxyFactory implements InvocationHandler {
	
	// 委托对象
    private Object target;

    public Object creatProxy(Object target) {

        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader() , target.getClass().getInterfaces() , this);
    }



    public Object invoke(Object proxy , Method method , Object[] args) throws Throwable {

        Object result = null;

        String methodName = method.getName();

        if( methodName.equals("addUser") ) {

            System.out.println("前置通知：动态代理了add方法....");
            result = method.invoke(target , args);
            System.out.println("后置通知：动态代理了add方法....");

        } else if( methodName.startsWith("delete") ) {

            System.out.println("前置通知：动态代理了deleteUser方法....");
            result = method.invoke(target , args);
            System.out.println("后置通知：动态代理了deleteUser方法....");

        } else {

            System.out.println("不可执行  " + methodName);

        }

        return result;


    }

}

注意：使用JDK 相关API实现动态代理的方式，代理类需要实现的接口是InvocationHandler。没有像静态代理一样，去实现和UserDao接口，所以也就不用全部重写其中的抽象方法。但是，使用JDK 相关API实现动态代理的方式要求目标对象必须是实现了接口的！！！
在代理类中，creatProxy方法就是获取代理对象，参数就是需要被代理的对象，就是想要被增强的类的对象。
return Proxy.newProxyInstance(target.getClass().getClassLoader() , target.getClass().getInterfaces() , this); 就是反射的知识了。 target.getClass().getClassLoader()就是获取委托对象的类加载器，用于加载代理类；target.getClass().getInterfaces() 就是获取委托类的接口列表，用于确定代理类需要实现哪些接口；
this就是一个实现了InvocationHandler接口的实例。
上面就是简单描述了一下各个参数的意思。

invoke方法中String methodName = method.getName();就是获取方法名称，也就是addUser等方法名；
method.invoke(target , args);可以理解为放行。在我的代理类中，放行的逻辑是methodName.equals("addUser") if( methodName.startsWith("delete") )的方法名称，才可以被放行，也就是才可以执行UserDaoImpl中原有的逻辑，也就是输出对应的语句。不满足的方法，语句都不会输出，因为在else { System.out.println("不可执行 " + methodName); }中，没有执行method.invoke(target , args);。所以，不满足条件的方法，UserDaoImpl中原有的输出语句都不会执行。System.out.println("前置通知：动态代理了add方法....");就是在原有的基础上，我们增强的功能，这里我们只是简单的输出了一下语句。

测试一下

import aop.ProxyFactory;
import dao.UserDao;
import impl.UserDaoImpl;

public class UserTest {

    public static void main(String[] args)
    {
        UserDao userDao = new UserDaoImpl();

        userDao = (UserDao)new ProxyFactory().creatProxy(userDao);

        userDao.addUser();
        userDao.deleteUser(10);
        userDao.queryUser();
        userDao.updateUser();

    }
}

结果符合我们的预期

CGLIB动态代理

首先，我们需要导入依赖

<dependencies>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.3.4</version>
    </dependency>
</dependencies>

public class UserImpl {

    public void add() {
        System.out.println("add方法执行了....");
    }

    public void delete() {
        System.out.println("delete方法执行了....");
    }
}

注意，这里UserImpl是没有实现接口的，这点就已经可以看出CGLIB实现的动态代理与JDK实现的动态代理之间的区别了。

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CGLIBProxyFactory implements MethodInterceptor {

    Object target = null;

    public Object creatProxy(Object target) {

        this.target = target;

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

        return enhancer.create();
    }


    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        Object result = null;

        String methodName = method.getName();

        if( methodName.equals("delete") ) {
            System.out.println("进入了动态代理" + methodName);
            result = method.invoke(target , objects);
        } else {
            System.out.println("不允许执行" + methodName);
        }

        return result;
    }
}

CGLIBProxyFactory实现的就不是InvocationHandler，而是MethodInterceptor。在创建代理对象时，也不是使用Proxy.newProxyInstance(target.getClass().getClassLoader() , target.getClass().getInterfaces() , this);，而是使用enhancer.create();来创建。剩下的代码就大差不差了，我们测试一下：

public class Test {
    public static void main(String[] args) {
        UserImpl user = new UserImpl();

        user = (UserImpl) new CGLIBProxyFactory().creatProxy(user);

        user.add();
        user.delete();
    }
}

结果符合预期

如果我的这篇文章有什么错误或不足，希望各位大佬指正