面试问烂的SpringAOP，再搞不懂没脸回家过年了……

AOP可以通过代理模式来实现。下面介绍几种常见的代理模式

代理模式

静态代理

静态代理指的是在编译期就对目标对象的方法进行增强。例如我们程序中有如下接口：

public class Order {

    interface OrderService{
        /**
         * 购买商品
         * @param goods
         */
        void payForGoods(String goods);
    }

    static class OrderServiceImpl implements OrderService{
        
        @Override
        public void payForGoods(String goods) {
            System.out.println("下单 " + goods + " 商品成功！");
        }
    }

    public static void main(String[] args) {
        OrderService orderService = new OrderServiceImpl();
        orderService.payForGoods("牛奶");
    }
    
}


如果想在购买商品时获取当前时间，可以通过静态代理增添代理类对 payForGoods 方法进行增强：

public class Order {

    interface OrderService{
        /**
         * 购买商品
         * @param goods
         */
        void payForGoods(String goods);
    }

    static class OrderServiceImpl implements OrderService{

        @Override
        public void payForGoods(String goods) {
            System.out.println("下单 " + goods + " 商品成功！");
        }
    }

    static class OrderProxy implements OrderService {
        

        private OrderService orderService;

        public OrderProxy(OrderService orderService) {
            this.orderService = orderService;
        }

        @Override
        public void payForGoods(String goods) {
            System.out.println("当前时间：" + LocalDateTime.now());
            orderService.payForGoods(goods);
        }
    }

    public static void main(String[] args) {
        OrderService orderProxy = new OrderProxy(new OrderServiceImpl());
        orderProxy.payForGoods("牛奶");
    }

}


JDK动态代理

JDK动态代理主要涉及到 java.lang.reflect 包中的两个类 Proxy 和 InvocationHandler。

InvocationHandler 是一个接口，通过实现该接口定义横切逻辑，并通过 反射机制 调用目标类的代码，动态将横切逻辑和业务逻辑放在一起。

Proxy 利用 InvocationHandler 动态创建一个符合某一接口的实例，生成目标类的代理对象。实现代码如下：

public class Order {

    interface OrderService{
        /**
         * 购买商品
         * @param goods
         */
        void payForGoods(String goods);
    }

    static class OrderServiceImpl implements OrderService{

        @Override
        public void payForGoods(String goods) {
            System.out.println("下单 " + goods + " 商品成功！");
        }
    }

    public static void main(String[] args) {
        OrderService orderService = new OrderServiceImpl();
        OrderService orderProxy = (OrderService) Proxy.newProxyInstance(OrderServiceImpl.class.getClassLoader(),
                OrderServiceImpl.class.getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("当前时间：" + LocalDateTime.now());
                        Object result = method.invoke(orderService, args);
                        return result;
                    }
                });
        orderProxy.payForGoods("牛奶");
    }
    
}


CGLib动态代理

CGLib 全称为 Code Generation Library，是一个强大的高性能的 代码生成类库，可以在运行期间扩展 Java 类与实现 Java 接口，CGLib 封装了ASM，可以在运行期间生成新的 class。

相对于 JDK动态代理 中只能为实现了接口的目标类创建实例，CGLib对于没有通过接口定义业务方法的类也可以创建动态代理。

public class Order {

    static class OrderServiceImpl{

        public void payForGoods(String goods) {
            System.out.println("下单 " + goods + " 商品成功！");
        }
    }

    public static void main(String[] args) {
        OrderServiceImpl orderService = new OrderServiceImpl();
        OrderServiceImpl orderProxy = (OrderServiceImpl) Enhancer.create(orderService.getClass(), new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("当前时间：" + LocalDateTime.now());
                Object result = methodProxy.invokeSuper(o, objects);
                return result;
            }
        });
        orderProxy.payForGoods("牛奶");
    }

}


上面三种代理方式对比如下：

Spring AOP

Spring中的AOP功能为我们提供更加简单便捷的代理实现方式：

@Aspect
@Component
public class OrderAspect {
    
    @Before("execution(public com.project.springaop.test.Order.payForGoods(..))")
    public void getLocalDateTimeBefore(){
        System.out.println("当前时间：" + LocalDateTime.now());
    }

    @After("execution(public com.project.springaop.test.Order.payForGoods(..))")
    public void getLocalDateTimeAfter(){
        System.out.println("当前时间：" + LocalDateTime.now());
    }
}


相关术语

源码分析

Spring提供了 JDK 和 CGLib 两种方式来生成代理对象，具体使用哪种方式生成由AopProxyFactory 根据 AdvisedSupport 对象的配置来决定。

默认的策略是，如果目标类实现了接口，则使用JDK动态代理技术，否则使用Cglib来生成代理。

在 Spring Bean的生命周期中，代理对象的创建发生在初始化方法initializeBean后期的后置处理器中。

即BeanPostProcessor.postProcessAfterInitialization 方法中。

相关源码

Advice注解

@Before 前置通知

前置通知会在目标方法执行前执行

@Before("execution(public com.project.springaop.test.Order.payForGoods(..))")
public void before(JoinPoint joinPoint){
    System.out.println("执行前置通知，目标方法：" + joinPoint.getSignature().getName() + "，方法参数：" + joinPoint.getArgs());
}


@After 后置通知

后置通知会在目标方法执行后执行，此通知无论如何都会执行，即使目标方法执行出现了异常。

@After("execution(public com.project.springaop.test.Order.payForGoods(..))")
public void after(JoinPoint joinPoint){
    System.out.println("执行后置通知，目标方法：" + joinPoint.getSignature().getName() + "，方法参数：" + joinPoint.getArgs());
}


@AfterReturning 返回通知

返回通知会在目标方法成功执行后执行，如果目标方法出现了异常，则该通知不执行。

@AfterReturning(value = "execution(public com.project.springaop.test.Order.payForGoods(..))", returning = "result")
public void afterReturning(JoinPoint joinPoint, Object result){
    System.out.println("执行返回通知，目标方法：" + joinPoint.getSignature().getName() + "，方法参数：" + joinPoint.getArgs() + "，执行结果" + result);
}


@AfterThrowing 异常通知

异常通知会在目标方法出现异常后执行，如果目标方法未出现异常则不执行。

@AfterThrowing(value = "execution(public com.project.springaop.test.Order.payForGoods(..))", throwing = "e")
public void afterThrowing(JoinPoint joinPoint, Exception e){
    System.out.println("执行异常通知，目标方法：" + joinPoint.getSignature().getName() + "，方法参数：" + joinPoint.getArgs() + "，执行异常" + e);
}


@Around 环绕通知

包围一个连接点的通知，可以完成其他四种通知的所有功能。

@Around(value = "execution(public com.project.springaop.test.Order.payForGoods(..))")
public Object around(ProceedingJoinPoint joinPoint, Exception e){
    Object result = null;
    try{
        System.out.println("执行前置通知");
        result = joinPoint.proceed();
        System.out.println("执行返回通知");
    } catch (Throwable throwable) {
        System.out.println("执行异常通知");
    } finally {
        System.out.println("执行后置通知");
    }
    return result;
}


一个方法被 Aspect类拦截时，执行顺序如下：

@Around > @Before > 原方法 > @Around > @After > @AfterReturing / @AfterThrowing

多个 Aspect 的执行顺序可以通过 @Order 注解或者实现 Ordered 接口来控制

本文转载自微信公众号「贰予三四」，可以通过以下二维码关注。转载本文请联系贰予三四公众号。

网站题目：面试问烂的SpringAOP，再搞不懂没脸回家过年了……
当前地址：http://www.shufengxianlan.com/qtweb/news15/383765.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网页设计公司知识

各行业网站

重庆外贸网站建设　　 　腾讯免备案主机　　 　腾讯云免备案空间　　 　重庆电商网站建设　　 　成都网站建设公司　　 　力比特机械　　 　网站建设改版　　 　广告媒介投放　　 　免备案虚拟主机　　 　内江做网站　　 　成都铺面装修　　 　成都免费建站　　 　自适应网站设计　　 　h5页面制作　　 　南宁旺客科技　　 　响应式网站　　 　网页改版　　 　成都营销网站建设　　 　成都网站建设公司　　 　UI设计