Spring AOP底层实现原理（动态代理）

灰太狼 2022-06-09 14:47 167阅读 0赞

AOP (Aspect Oriented Programing) ：面向切面编程，它是一种编程思想。AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码的编写方式（可用于性能监视、事务管理、安全检查、缓存,日志记录等）。

AOP就是要对目标进行代理对象的创建，Spring AOP是基于动态代理的，基于两种动态代理机制：JDK动态代理和CGLIB动态代理。

动态代理和静态代理区别？  
动态代理：在虚拟机内部，运行的时候，动态生成代理类(运行时生成，runtime生成) ，并不是真正存在的类。

静态代理：存在代理类 （例如：struts2 Action的代理类 ActionProxy）

JDK代理：基于接口的代理，一定是基于接口，会生成目标对象的接口类型的子对象。

Cglib代理：基于类的代理，不需要基于接口，会生成目标对象类型的子对象。

# JDK动态代理 #

接口

public interface UserService {
    
        void save();
    
        int select();
    
    }

接口实现类

public class UserServiceImpl implements UserService {
    
        @Override
        public void save() {
            System.out.println("保存用户信息成功");
        }
    
        @Override
        public int select() {
            System.out.println("查询用户信息成功");
            return 10;
        }
    }

JDK动态代理工厂类

public class JdkProxyFactory implements InvocationHandler {
    
        private Object target;
    
        public JdkProxyFactory(Object target) {
            this.target = target;
        }
    
        /**
         * 获取代理对象，当前类继承InvocationHandler
         *
         * @return
         */
        public Object getProxyObject() {
            return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //添加功能
            System.out.println("增强代码，添加日志功能");
            //执行原有方法
            return method.invoke(target, args);
        }
    }

测试JDK动态代理

@Test
        public void JdkProxyTest() {
            //创建目标对象
            UserService userService = new UserServiceImpl();
            //创建工厂对象
            JdkProxyFactory jdkProxyFactory = new JdkProxyFactory(userService);
            UserService proxy = (UserService) jdkProxyFactory.getProxyObject();
            proxy.save();
            System.out.println("=========================");
            proxy.select();
        }

# CGLIB动态代理 #

需生成代理对象的类

public class OrderService {
    
        public void save() {
            System.out.println("保存订单成功");
        }
    
        public int select() {
            System.out.println("查询订单成功");
            return 10;
        }
    }

CGLIB动态代理工厂类

public class CglibProxyFactory implements MethodInterceptor {
    
        private Object target;
    
        public CglibProxyFactory(Object target) {
            this.target = target;
        }
    
        /**
         * 获取代理对象
         *
         * @return
         */
        public Object getProxyObject() {
            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("增强代码，添加日志功能");
            //执行原有方法
            return method.invoke(target, objects);
        }
    }

测试CGLIB动态代理

@Test
        public void CglibProxyTest() {
            //创建目标对象
            OrderService orderService = new OrderService();
            //创建工厂对象
            CglibProxyFactory cglibProxyFactory = new CglibProxyFactory(orderService);
            OrderService proxy = (OrderService) cglibProxyFactory.getProxyObject();
            proxy.save();
            System.out.println("=========================");
            proxy.select();
        }

Spring AOP底层实现原理（动态代理）

发表评论取消回复

还没有评论，来说两句吧...

相关阅读