Spring-Aop核心技术

原创 已于 2023-03-01 09:51:09 修改 · 389 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #java #spring boot

于 2023-02-27 22:11:45 首次发布
本文介绍了Spring中的AOP核心技術，特别是使用ProxyFactory进行方法级的代理。通过示例展示了如何使用ProxyFactory和MethodBeforeAdvice在创建和支付订单方法前插入逻辑。进一步讨论了如何通过PointcutAdvisor实现特定方法的代理，并引入了DefaultAdvisorAutoProxyCreator简化配置，实现了自动代理ioc容器中匹配方法的类。

前言

spring一直以来都是我们Java开发中最核心的一个技术，其中又以ioc和aop为主要技术，本篇文章主要讲一下aop的核心技术，也就是ProxyFactory技术的使用，而基本的jdk动态代理和cglib代理技术并不涉及，如有需要，请自行寻找资料

背景

package com.zxc.boot.proxy;

public class OrderService {
    
    public void create() {
        System.out.println("创建订单");
    }
    
    public void payOrder() {
        System.out.println("支付订单");
    }
}

假设你有如上的对象，需要对两个方法前面都插入生成订单号的逻辑，如果是传统的方式就可以直接加入，但是过于麻烦，如果使用spring的话，就可以借助如下的工具类，如

ProxyFactory

package com.zxc.boot.proxy;

import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.aop.framework.ProxyFactory;

import java.lang.reflect.Method;

public class Main {

    public static void main(String[] args) {

        //被代理对象
        OrderService orderService = new OrderService();

        ProxyFactory proxyFactory = new ProxyFactory();
        //设置代理对象
        proxyFactory.setTarget(orderService);
        //添加代理逻辑
        proxyFactory.addAdvice(new MethodBeforeAdvice() {
            @Override
            public void before(Method method, Object[] objects, Object o) throws Throwable {
                System.out.println("-----生成订单号------");
            }
        });

        //获取代理对象
        OrderService orderServiceProxy = (OrderService) proxyFactory.getProxy();

        orderServiceProxy.create();
        orderServiceProxy.payOrder();
    }
}

生成的结果如下(注：这里没有接口，肯定是使用cglib生成的代理对象)

是不是很简单呢，底层逻辑都是spring帮我们实现的，而MethodBeforeAdvice就是进行的代理逻辑，它的父接口是

Advice

这个简单理解就是对象被代理的逻辑，主要有以下的实现，如

MethodBeforeAdvice、AfterReturningAdvice、MethodInterceptor等等见名思义

但是这里有一个问题，我们两个方法都被进行了代理，那么是否有办法实现只代理某个方法，而某些方法不进行代理呢，答案是有的，代码如下

package com.zxc.boot.proxy;

import org.aopalliance.aop.Advice;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.aop.Pointcut;
import org.springframework.aop.PointcutAdvisor;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.StaticMethodMatcherPointcut;

import java.lang.reflect.Method;

public class Main2 {

    public static void main(String[] args) {

        //被代理对象
        OrderService orderService = new OrderService();

        ProxyFactory proxyFactory = new ProxyFactory();
        //设置代理对象
        proxyFactory.setTarget(orderService);
        //添加代理逻辑
        proxyFactory.addAdvisor(new PointcutAdvisor() {
            @Override
            public Pointcut getPointcut() {
                //哪些方法进行代理
                return new StaticMethodMatcherPointcut() {
                    @Override
                    public boolean matches(Method method, Class<?> aClass) {
                        //方法名为create进行代理
                        return method.getName().equals("create");
                    }
                };
            }

            //代理逻辑
            @Override
            public Advice getAdvice() {
                return new MethodBeforeAdvice() {
                    @Override
                    public void before(Method method, Object[] objects, Object o) throws Throwable {
                        System.out.println("-----创建订单-----");
                    }
                };
            }

            @Override
            public boolean isPerInstance() {
                return false;
            }
        });

        //获取代理对象
        OrderService orderServiceProxy = (OrderService) proxyFactory.getProxy();

        orderServiceProxy.create();
        orderServiceProxy.payOrder();
    }
}

可以看到，只有创建订单的方法才会添加代理逻辑，而支付订单并不会加入这段逻辑，而核心的功能点就是依赖于Pointcut对象

Pointcut

Pointcut简单理解就是切掉，也就是用于判断要在哪些方法或者哪些类注入代理逻辑用的

Advisor

而Advisor简单理解就是Advice和Pointcut的组合，spring当中进行代理的逻辑也是用Advisor为维度进行处理的

以上，就是使用ProxyFactory进行代理逻辑的spring工具类，但是很明显这样使用相对来说还是比较麻烦的，所以spring提供了简易的方式让我们使用这种逻辑

TargetSource

上面在注入被代理对象的时候是直接使用Target的，正常来说我们只会代理一个，而TargetSource可以支持你在返回的时候使用不同的类型，里面有一个getTarget方法，你可以根据当时的情况返回需要被代理的对象

Spring提供的代理支持

ProxyFactoryBean

package com.zxc.boot.proxy;

import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.aop.framework.ProxyFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import java.lang.reflect.Method;

@Configuration
@ComponentScan("com.zxc.boot.proxy")
public class AppConfig {

    @Bean
    public ProxyFactoryBean proxyFactoryBean() {

        ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
        proxyFactoryBean.setTarget(new OrderService());
        proxyFactoryBean.addAdvice(new MethodBeforeAdvice() {
            @Override
            public void before(Method method, Object[] objects, Object o) throws Throwable {
                System.out.println("-------创建订单-------");
            }
        });
        return proxyFactoryBean;
    }
}
package com.zxc.boot.proxy;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class SpringApplication {

    public static void main(String[] args) {

        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        OrderService orderService = applicationContext.getBean(OrderService.class);

        orderService.create();
        orderService.payOrder();

    }
}

只要进行如上的配置，就可以识别到了，这种方式其实跟原有的差不多，只不过spring帮我们处理了最终会返回对应的代理bean回去，但是还有更简单的方式，如下

DefaultPointcutAdvisor

package com.zxc.boot.proxy;

import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.aop.support.NameMatchMethodPointcut;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import java.lang.reflect.Method;

@Configuration
@ComponentScan("com.zxc.boot.proxy")
public class AppConfig2 {

    @Bean
    public OrderService orderService() {
        return new OrderService();
    }

    @Bean
    public DefaultPointcutAdvisor defaultPointcutAdvisor() {

        //方法名称蓝机器
        NameMatchMethodPointcut nameMatchMethodPointcut = new NameMatchMethodPointcut();
        nameMatchMethodPointcut.addMethodName("create");

        //设置拦截和代理逻辑
        DefaultPointcutAdvisor defaultPointcutAdvisor = new DefaultPointcutAdvisor();
        defaultPointcutAdvisor.setPointcut(nameMatchMethodPointcut);
        defaultPointcutAdvisor.setAdvice(new MethodBeforeAdvice() {
            @Override
            public void before(Method method, Object[] args, Object target) throws Throwable {
                System.out.println("-------创建订单------");
            }
        });
        return defaultPointcutAdvisor;
    }

    //核心类，一个BeanPostProccess后置处理器，用于把扫描到的Advisor进行代理
    @Bean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        return new DefaultAdvisorAutoProxyCreator();
    }
}
package com.zxc.boot.proxy;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class SpringApplication {

    public static void main(String[] args) {

        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig2.class);
        OrderService orderService = applicationContext.getBean(OrderService.class);

        orderService.create();
        orderService.payOrder();

    }
}

不用我们多做其他处理，就可以对ioc容器中方法有create的类进行代理，你可以再添加一个类，如下

package com.zxc.boot.proxy;

public class UserService {

    public void create() {
        System.out.println("用户service哦哦哦");
    }
}

package com.zxc.boot.proxy;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class SpringApplication {

    public static void main(String[] args) {

        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig2.class);
        OrderService orderService = applicationContext.getBean(OrderService.class);

        orderService.create();
        orderService.payOrder();

        UserService userService = applicationContext.getBean(UserService.class);
        userService.create();

    }
}

这样的方式就方便多了

优化处理

其实DefaultAdvisorAutoProxyCreator只是需要导入到ioc容器中，所以配置类可以使用import进行处理，效果是一样的，如下

package com.zxc.boot.proxy;

import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.aop.support.NameMatchMethodPointcut;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

import java.lang.reflect.Method;

@Configuration
@ComponentScan("com.zxc.boot.proxy")
@Import(DefaultAdvisorAutoProxyCreator.class)
public class AppConfig2 {

    @Bean
    public UserService userService() {
        return new UserService();
    }

    @Bean
    public OrderService orderService() {
        return new OrderService();
    }

    @Bean
    public DefaultPointcutAdvisor defaultPointcutAdvisor() {

        //方法名称蓝机器
        NameMatchMethodPointcut nameMatchMethodPointcut = new NameMatchMethodPointcut();
        nameMatchMethodPointcut.addMethodName("create");

        //设置拦截和代理逻辑
        DefaultPointcutAdvisor defaultPointcutAdvisor = new DefaultPointcutAdvisor();
        defaultPointcutAdvisor.setPointcut(nameMatchMethodPointcut);
        defaultPointcutAdvisor.setAdvice(new MethodBeforeAdvice() {
            @Override
            public void before(Method method, Object[] args, Object target) throws Throwable {
                System.out.println("-------创建订单------");
            }
        });
        return defaultPointcutAdvisor;
    }

//    //核心类，一个BeanPostProccess后置处理器，用于把扫描到的Advisor进行代理
//    @Bean
//    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
//        return new DefaultAdvisorAutoProxyCreator();
//    }
}

如果你不导入DefaultAdvisorAutoProxyCreator对象，那么代理逻辑就不会生效，本质就是DefaultAdvisorAutoProxyCreator类就是一个BeanPostProcessor处理器，它会针对所有类进行判断然后处理

总结

到这里本篇文章就结束了，spring的aop核心技术就是最终会利用到这个对象进行代理，而这里先把底层的代理逻辑进行讲明，后面对整个aop流程进行理解就方便多了

spring-aop-4.2.6.RELEASE.zip
09-25
在IT行业中，Spring框架无疑是Java开发领域的中流砥柱，而Spring AOP则是其核心组件之一。本资料包"spring-aop-4.2.6.RELEASE.zip"正是针对Spring AOP的一个重要版本，它与"spring-framework.zip"一同构成了强大的...
Spring-AOP相关
最新发布
08-12
在Spring中，AOP是通过动态代理实现的，其核心概念包括连接点（Join Point）、切点（Pointcut）、通知（Advice）、切面（Aspect）和织入（Weaving）。 1. 连接点（Join Point）：在Spring AOP中，连接点指的是可以...
Spring核心技术--AOP
congyh的专栏
04-11 1514
Spring核心技术–AOP在OOP中, 模块化的单位是class, 在AOP中, 模块化的单位是aspect.Spring IoC容器并不直接与AOP模块耦合, AOP模块是作为一个中间件方案提供给IoC容器使用的.声明式事务管理就是AOP在Spring框架中的一个典型实现, 另外, 池化也是一个典型的应用.对于Spring AOP编程来说, 推荐使用能够完成需求功能的最小Advice种类进行实现
聊聊Spring的两大核心技术之一AOP
Hi~ 土拨鼠
02-26 706
1、什么是AOP？ AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术，就是在不影响原来业务的情况下动态的新增功能。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合...
Spring 核心技术之一 AOP
王如霜
03-26 485
什么是AOP &amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;AOP:(Aspect Oriented Programming),面向切面编程,是一个概念，并没有设定具体语言的实现 AOP的作用 &amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nb
Spring核心之AOP
Wangliaiguo的博客
09-08 186
Spring-AOP 代理，增强 目标类 + 额外功能 = 代理类 比如：日志处理/事务处理/异常处理/性能分析…Redis 非关系型数据 通过spring AOP的代理功能，给代码增加额外的通用功能 业务逻辑就专心的处理实际需求，通用的增强功能独立出来 代理的专业术语 额外功能叫 增强 目标类叫 切入点 或 切面 将增强 加入到 切入点，叫编织 AOP是面向切面编程的一种实现
Spring的核心技术 IOC AOP
gtrbr的博客
02-24 410
Spring的核心技术： Spring的核心技术分别是 IOC(控制反转)，AOP（面向切面编程）他们能实现模块之间，类之间的解耦合 Spring的第一个核心功能 IOC（控制反转）: ioc控制反转是一个理论，是一个概念，是一个思想。 描述的是：把对象的创建，赋值，管理工作都交给代码之外的容器来实现，也就是把对象的创建都交给外部资源来完成。 控制：是创建对象，对象的赋值，对象之间的关系管理 反转：是把原来的开发人员管理，创建对象的权限...
2024-spring-aop学习项目
01-26
本项目资料旨在帮助开发者全面、深入地掌握Spring AOP的核心概念与实践技巧，为2024年春季的学习之旅提供坚实的理论基础和技术支持。 一、Spring AOP概述 Spring AOP是Spring框架中的一个关键特性，它通过将关注点...
spring-AOP源码分析
01-10
Spring框架中的面向切面编程（Aspect-Oriented Programming，AOP）是一个为分散在应用各处的对象提供集中化服务的技术。AOP允许开发者通过切面来组织代码，从而实现横切关注点（cross-cutting concerns）的模块化。...
Spring-AOP原理及拦截器.doc
04-28
Spring-AOP（面向方面编程）是基于依赖注入（IoC）的编程范式，作为面向对象编程（OOP）的补充，将应用系统分为核心业务逻辑和横切关注点（如持久化管理、事务管理、安全管理等），利用AOP可以将通用逻辑代码注入主...
Spring--SpringAOP核心类
qq_33259067的博客
09-28 563
换句话来讲：引入增强的意思即假如项目中一个Java类没有实现某个接口而不具备某些功能，这个时候我们可以使用引入增强（Introduction Advice）在不修改这个类的前提下，使该类具备某个接口的功能。该类可以配置当前代理的Adivsiors、目标对象、代理的接口，以及获取对应代理方法对应有效的拦截器链。该类的作用是使用AOP代理包装每个合格的Bean，并在调用Bean之前委派指定的拦截器。用于创建代理的配置类，以确保所有代理创建者具有一致的属性。该类主要为AOP代理对象工厂实现类提供基本的配置属性。
Spring（三）spring核心技术——aop
krain的博客
07-16 407
一、AOP简介   AOP是Aspect Orient Programming的缩写，即面向切面编程。基于动态代理的，可以使用jdk和cglib两种代理方式。 Aspect: 切面，给你的目标类增加的功能，就是切面。像上面用的日志，事务都是切面。切面的特点：一般都是非业务方法，独立使用的。 Orient：面向，对着。 Programming：编程   AOP就是动态代理的规范化，把动态代理的实现步骤，方式都定义好了，让开发人员用一种统一的方式，使用动态代理。 作用： 在目标类不修改的情况
（Spring）Spring框架的核心功能之AOP技术
Jadan-Z的博客
05-28 436
AOP的概述     １、什么是AOP的技术？？？            *   AOP为Aspect  Oriented  Programming的缩写，意为：面向切面编程            *   AOP是一种编程范式，隶属于软工范畴，指导开发者如何组织程序结构            *   AOP最早由AOP联盟的组织提出的，制定了一套规范。Spring将AOP思想引入到框架中，必须遵守...
Spring 源码分析(三) —— AOP（一）AOP原理
孤云博客
08-15 374
随时随地阅读更多技术实战干货，获取项目源码、学习资料，请关注源代码社区公众号(ydmsq666)、博主微信（guyun297890152）、QQ技术交流群(183198395)。 from：https://my.oschina.net/kaywu123/blog/626135 AOP概论 AOP（Aspect-Oriented Programming，面向切面的编程），谈...
spring核心之一 AOP
qq_30136729的博客
05-15 280
AOP 一.概念： 面向切编程：使用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各个之间的耦合度降低，提高程序的可重用性，提高了开发效率。 不通过修改代码方式，添加新的功能（新功能单独写一个模块，通过方式加入其中，不改变原来的模块代码） 二.底层原理： 1.Aop底层使用动态代理 有两种情况： 有接口情况，使用JDK代理 创建接口实现类代理对象，增强类的方法 没有接口情况，使用CGLIB动态代理 创建子类的代理对象，增强类的方法 2.JDK动态代理过程 使用Proxy类里面的方法创建代理
Spring 核心技术——AOP 简介
黄解颐的博客
03-26 1216
AOP 简介 AOP 概念 1 AOP 简介 面向切面编程（Aspect-Oriented Programming, AOP）通过提供一种思考程序结构的途经，来弥补面向对象编程（Object Oriented Programming, OOP）的不足。在 OOP 中模块化的关键单元是类，而在 AOP 中模块化的单元中切面。切面能对关注点进行模块化，例如横切多个类型和对象的事务管理。在
【Spring】AOP之面向切面编程
HR的博客
05-12 579
AOP之面向切面编程AOP概述AOP编程术语AspectJ 对 AOP 的实现@Before@AfterReturning@Around@AfterThrowing@After AOP概述 AOP（Aspect Orient Programming），面向切面编程。面向切面编程是从动态角度考虑程 序运行过程。 AOP 底层，就是采用动态代理模式实现的。采用了两种代理：JDK 的动态代理，与 CGLIB 的动态代理。 AOP 为 Aspect Oriented Programming 的缩写，意为
Spring 框架的核心功能之AOP技术
weixin_33768481的博客
10-23 134
1. AOP 的概述 AOP, Aspect Oriented Programming, 面向切面编程; 通过预编译方式和运行期动态代理实现程序功能的统一维护的技术; AOP 采取横向抽取机制,取代了传统纵向继承体系重复性代码(性能监视,事务管理,安全检查,缓存); AOP 可以在不修改源代码的前提下,对程序进行增强; 2. AOP 的底层实现 Spring 框架的AOP技术底层采用的是代理...
spring 核心技术详解 包括AOP 原理
long_chuanren的专栏
08-09 230
http://blog.chinaunix.net/u/10921/showart_2276023.html
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值