AOP实现原理之JDK动态代理-蒲公英云

AOP实现原理之JDK动态代理

男娘i 2022-02-09 14:39 418阅读 0赞

JDK动态代理

JDK动态代理是Spring AOP底层实现的方式之一。

JDK动态代理对“装饰者”设计模式简化。使用前提：必须有接口。

JDK动态代理实现

首先我们需要有target目标类，也就是我们需要接口+实现类

首先我们创建一个UserService的接口

public interface UserService {
    public void addUser();
    public void updateUser();
    public void deleteUser();
}

然后还有实现类UserServiceImpl

public class UserServiceImpl implements UserService{
    @Override
    public void addUser() {
        System.out.println("addUser()");
    }
    @Override
    public void updateUser() {
        System.out.println("updateUser()");
    }
    @Override
    public void deleteUser() {
        System.out.println("deleteUser()");
    }
}

然后我们需要切面类：用于存Advice通知的MyAspect类，也就是存放我们的增强方法

public class MyAspect {
    public void before(){
        System.out.println("----before()----");
    }
    public void after(){
        System.out.println("----after()----");
    }
}

然后我们还需要工厂类MyBeanFactory ，这个类的主要的工作就是将我们的Advice通知(增强的代码)跟我们的target目标类结合起来生成proxy代理对象。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class MyBeanFactory {
    public static UserService createService(){
        //1 目标类
        final UserService userService = new UserServiceImpl();
        //2切面类
        final MyAspect myAspect = new MyAspect();
        /* 3 代理类：将目标类（切入点）和 切面类（通知） 结合 --> 切面
         *     Proxy.newProxyInstance
         *         参数1：loader ，类加载器，动态代理类 运行时创建，任何类都需要类加载器将其加载到内存。
         *             一般情况：当前类.class.getClassLoader();
         *                     目标类实例.getClass().get...
         *         参数2：Class[] interfaces 代理类需要实现的所有接口
         *             方式1：目标类实例.getClass().getInterfaces()  ;注意：只能获得自己接口，不能获得父元素接口
         *             方式2：new Class[]{UserService.class}   
         *             例如：jdbc 驱动  --> DriverManager  获得接口 Connection
         *         参数3：InvocationHandler  处理类，接口，必须进行实现类，一般采用匿名内部
         *             提供 invoke 方法，代理类的每一个方法执行时，都将调用一次invoke
         *                 参数31：Object proxy ：代理对象
         *                 参数32：Method method : 代理对象当前执行的方法的描述对象（反射）
         *                     执行方法名：method.getName()
         *                     执行方法：method.invoke(对象，实际参数)
         *                 参数33：Object[] args :方法实际参数
         * 
         */
        UserService proxService = (UserService)Proxy.newProxyInstance(
                                MyBeanFactory.class.getClassLoader(),
                                userService.getClass().getInterfaces(),
                                new InvocationHandler() {
                                    @Override
                                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                                        //前执行
                                        myAspect.before();
                                        //执行目标类的方法
                                        Object obj = method.invoke(userService, args);
                                        //后执行
                                        myAspect.after();
                                        return obj;
                                    }
                                });
        return proxService;
    }
}

最后是测试

public class TestProxy {
    @Test
    public void demo01(){
        UserService userService = MyBeanFactory.createService();
        userService.addUser();
        userService.updateUser();
        userService.deleteUser();
    }
}