谈谈Spring中的Advisor和PointcutAdvior
aop的术语
aop的术语AOP（面向切面编程）是一种软件开发技术，它通过将可重用的横切关注点（cross-cutting concerns）从业务逻辑中划分出来，来提高软件的可维护性、可扩展性和可重用性。
为了让大家更好地了解AOP，下面是一些AOP的术语的中文解释。
1. Aspect（切面）切面代表了一个模块化的关注点，这个关注点会跨越多个点切入到应用中的对象中。
切面是一个模块化横切关注点的实现。
2. Advice（通知）通知是一个行为，是一个切面在具体的连接点处执行的代码。
通知有五种类型：前置通知、后置通知、异常通知、最终通知和环绕通知。
3. Join point（连接点）连接点是指程序执行过程中的各个点，例如一个方法的执行或一个异常的抛出等。
4. Pointcut（切点）切点定义了从连接点中选择哪些特定的点来应用通知。
切面织入是指将切面代码插入到目标对象的代码流程中，使切面中的通知能够在连接点处执行。
6. Weaving time（织入时间）织入时间指的是切面代码被应用到目标对象代码的时间。
有AOP织入前、织入时和织入后三种织入时间。
织入前指在应用程序的编译阶段，将切面代码植入到目标对象代码之前。
织入时指在应用程序的运行时期，将切面代码植入到目标对象代码和目标对象逻辑的中间。
织入后指在应用程序运行的最后阶段，将切面代码植入到目标对象代码之后。
引入允许一个切面向一个现有的类添加方法和属性，而不需要修改类的源代码。
8. Object（对象）对象是指应用程序中的实例化类，AOP中对对象的定义不仅包括了普通的Java对象，也包括了Bean、拦截器等。
9. Advisor（切面设定器）切面设定器指的是Advice和Pointcut的组合。
它定义了通知在何处以及何时应用。
10. Interceptor（拦截器）拦截器是一个特定的通知，用来控制调用目标对象的过程。
拦截器可以将通知集成到AOP框架中，来实现跟踪、安全性和事务等方面的需要。
Spring源代码解析(五)：Spring AOP获取Proxy
Spring源代码解析(五）：Spring AOP获取Proxy下面我们来看看Spring的AOP的一些相关代码是怎么得到Proxy的，让我们我们先看看AOP和Spring AOP的一些基本概念：Advice：通知，制定在连接点做什么，在Sping中，他主要描述Spring围绕方法调用注入的额外的行为，Spring提供的通知类型有：beforeadvice,AfterReturningAdvice,ThrowAdvice,MethodBeforeAdvice，这些都是Spring AOP定义的接口类，具体的动作实现需要用户程序来完成。
Pointcut:切点，其决定一个advice应该应用于哪个连接点，也就是需要插入额外处理的地方的集合，例如，被某个advice作为目标的一组方法。
Spring pointcut 通常意味着标示方法，可以选择一组方法调用作为pointcut,Spring提供了具体的切点来给用户使用，比如正则表达式切点 JdkRegexpMethodPointcut通过正则表达式对方法名进行匹配，其通过使用 AbstractJdkRegexpMethodPointcut 中的对MethodMatcher接口的实现来完成pointcut功能：Java代码1.public final boolean matches(Method method, Class targetClass){2. //这里通过放射得到方法的全名3. String patt = method.getDeclaringClass().getName() + "." +method.getName();4. for (int i = 0; i < this.patterns.length; i++) {5. // 这里是判断是否和方法名是否匹配的代码6. boolean matched = matches(patt, i);7. if (matched) {8. for (int j = 0; j < this.excludedPatterns.length; j++) {9. boolean excluded = matchesExclusion(patt, j);10. if(excluded) {11. return false;12. }13. }14. return true;15. }16. }17. return false;18.}在JDKRegexpMethodPointcut中通过JDK中的正则表达式匹配来完成pointcut 的最终确定：Java代码1.protected boolean matches(String pattern, int patternIndex) {2. Matcher matcher = piledPatterns[patternIndex].matcher(pattern);3. return matcher.matches();4.}Advisor：当我们完成额外的动作设计（advice)和额外动作插入点的设计（pointcut)以后,我们需要一个对象把他们结合起来，这就是通知器 - advisor,定义应该在哪里应用哪个通知。
java abstractpointcutadvisor使用案例
java abstractpointcutadvisor使用案例在Spring框架中，切面（Aspect）是一种非常重要的概念，它允许开发者在特定的连接点（Joinpoint）上定义一系列的行为，比如方法拦截、事务管理等。
在切面中，Pointcut（切点）决定了哪些连接点会被拦截，而Advice（建议）则定义了在这些连接点上执行的具体逻辑。
AbstractPointcutAdvisor是一个抽象的切面通知器，它提供了一种便捷的方式来创建自定义的切面。
通过继承AbstractPointcutAdvisor，并实现相关的方法，我们可以快速定义一个自己的切面。
下面是一个使用AbstractPointcutAdvisor的示例代码：```javaimport org.springframework.aop.Pointcut;import org.springframework.aop.support.AbstractPointcutAdvisor;public class MyPointcutAdvisor extends AbstractPointcutAdvisor {private Pointcut pointcut;private MyAdvice advice;public MyPointcutAdvisor(Pointcut pointcut, MyAdvice advice) {this.pointcut = pointcut;this.advice = advice;}@Overridepublic Pointcut getPointcut() {return this.pointcut;}@Overridepublic Advice getAdvice() {return this.advice;}}```在上述代码中，我们首先导入了`org.springframework.aop.Pointcut`和`org.springframework.aop.support.AbstractPointcutAdvisor`类。
java spring 入门教程
java spring 入门教程Java Spring是一个开源的轻量级Java开发框架，是当今Java企业级应用开发的首选框架之一。
它提供了一个全面的编程和配置模型，可以帮助开发者更加高效地构建可靠的、灵活的、可扩展的企业级应用。
首先，Java Spring框架的核心概念是控制反转（IoC）和面向切面编程（AOP）。
控制反转是指将对象的创建、组装和管理等工作交给Spring容器来完成，而不是由开发者手动创建和管理。
这样做的好处是降低了开发复杂度，提高了代码的可测试性和可维护性。
面向切面编程是指通过横切关注点将应用程序业务逻辑与系统级服务（如日志记录、事务管理等）进行解耦，从而提高代码的可重用性和可维护性。
其次，Java Spring框架提供了一系列的容器和模块，用于支持不同层次的应用开发。
其中，核心容器包括BeanFactory和ApplicationContext，用于管理和控制对象的生命周期。
数据访问模块提供了对数据库访问的支持，包括对JDBC、ORM框架如Hibernate、MyBatis和Spring Data等的集成。
还有Web开发模块，提供了对Servlet、WebSocket、RESTful服务等的支持。
此外，还有安全性、消息队列、缓存等模块可以根据需要进行集成和使用。
此外，Java Spring还采用了一种基于注解的开发模式，使得开发者可以通过简单的注解配置和元数据来实现各种功能。
比如，使用@Component注解可以将一个Java类标记为一个可被Spring容器管理的Bean；使用@Autowired注解可以自动装配Bean之间的依赖关系；使用@Controller和@RequestMapping注解可以实现Web请求的处理等。
这种开发方式提高了开发效率，同时使得代码更加清晰和易于维护。
最后，Java Spring框架还提供了一系列的特性和工具，用于提高应用的性能和可用性。
比如，Spring Boot是一个快速构建应用程序的工具，通过自动配置和约定大于配置的原则，极大地简化了项目的搭建和部署。
SpringBoot系列之AOP实现的两种方式
SpringBoot系列之AOP实现的两种方式AOP常用的实现方式有两种，一种是采用声明的方式来实现（基于XML），一种是采用注解的方式来实现（基于AspectJ）。
首先复习下AOP中一些比较重要的概念：Joinpoint（连接点）：程序执行时的某个特定的点，在Spring 中就是某一个方法的执行。
Pointcut（切点）：说的通俗点，spring中AOP的切点就是指一些方法的集合，而这些方法是需要被增强、被代理的。
一般都是按照一定的约定规则来表示的，如正则表达式等。
切点是由一类连接点组成。
Advice（通知)：还是说的通俗点，就是在指定切点上要干些什么。
Advisor（通知器)：其实就是切点和通知的结合。
一、基于XML配置的Spring AOP采用声明的方式实现（在XML文件中配置），大致步骤为：配置文件中配置pointcut, 在java中用编写实际的aspect 类, 针对对切入点进行相关的业务处理。
业务接口：package com.springboottime.time.service;public interface AdviceService {/*查找用户*/public String findUser();/*添加用户*/public void addUser();}业务实现:package com.springboottime.time.service.serviceImpl;import com.springboottime.time.service.AdviceService;import lombok.Data;@Datapublic class AdviceServiceImpl implements AdviceService { private String name;@Overridepublic String findUser() {System.out.println("***************执行业务方法findUser,查找的用户名字为:"+name+"****************");return name;}@Overridepublic void addUser() {System.out.println("***************执行业务方法addUser****************");throw new RuntimeException();}}切面类：package com.springboottime.time.aop;import ng.JoinPoint;import ng.ProceedingJoinPoint;public class AopAspect {/*** 前置通知：目标方法调用之前执行的代码* @param jp*/public void doBefore(JoinPoint jp){System.out.println("===========执行前置通知============");}/*** 后置返回通知：目标方法正常结束后执行的代码* 返回通知是可以访问到目标方法的返回值的* @param jp* @param result*/public void doAfterReturning(JoinPoint jp,String result){System.out.println("===========执行后置通知============");System.out.println("返回值result==================="+result);}/*** 最终通知：目标方法调用之后执行的代码（无论目标方法是否出现异常均执行）* 因为方法可能会出现异常，所以不能返回方法的返回值* @param jp*/public void doAfter(JoinPoint jp){System.out.println("===========执行最终通知============");}/**** 异常通知：目标方法抛出异常时执行的代码* 在目标方法执行的时候,如果抛出异常,立即进入此方法* 可以访问到异常对象* @param jp* @param ex*/public void doAfterThrowing(JoinPoint jp,Exception ex){System.out.println("===========执行异常通知============");}/*** 环绕通知：目标方法调用前后执行的代码，可以在方法调用前后完成自定义的行为。
Spring技术内幕——深入解析Spring架构与设计原理(二)AOP
Spring技术内幕——深入解析Spring架构与设计原理（二）AOPAOP联盟定义的AOP体系结构把与AOP相关的概念大致分为了由高到低、从用法到实现的三个层次。
关于这个体系结构，个人的理解是这样的，从上往下，最高层是语言和开发环境，在这个环境中可以看到几个重要的概念：base可以视为待增加对象，或者说目标对象；aspect指切面，通常包含对于base的增加应用；configuration可以看成是一种编织或者说配置，通过在AOP体系中提供这个configuration配置环境，可以把base和aspect结合起来，从而完成切面向目标对象的编织实现。
对Spring平台或者说生态系统来说，AOP是Spring框架的核心功能模块之一。
AOP与IOC容器的结合用法, 为应用开发或者Spring自身功能的扩展都提供了许多方便。
Spring AOP的实现和其他特性的实现一样，十分丰盛，除了可以用法Spring本身提供的AOP实现之外，还封装了业界优秀的AOP解决计划AspectJ来让应用用法。
在这里，主要对Spring自身的AOP实现原理做一些解析；在这个AOP实现中，Spring 充分利用了IOC容器Proxy代理对象以及AOP拦截器的功能特性，通过这些对AOP基本功能的封装机制，为用户提供了AOP的实现框架。
所以，要了解这些AOP的基本实现，需要我们对Java 的Proxy机制有一些基本了解。
AOP实现的基本线索 AOP实现中，可以看到三个主要的步骤，一个是代理对象的生成，然后是拦截器的作用，然后是Aspect编织的实现。
AOP框架的丰盛，很大程度体现在这三个详细实现中，所具有的丰盛的技术挑选，以及如何实现与IOC容器的无缝结合。
究竟这也是一个十分核心的模块，需要满足不同的应用需求带来的解决计划需求。
在Spring AOP的实现原理中，我们主要举ProxyFactoryBean的实现作为例子和实现的基本线索举行分析；很大一个缘由，是由于ProxyFactoryBean是在Spring IoC环境中，创建AOP应用的最底层办法，从中，可以看到一条实现AOP的基本线索。
spring中几个英文单词
zero_exception exception;
v_num1 number;
v_num2 number;
v_result number;
begin
v_num1 :=10;
v_num2 :=0;
if v_num2=0 then
raise zero_exception;
aspect ：切面
joinPoint：加入点
pointCut：切入点
advice ：说明在开始事务后还是开启事务前执行,提示拦截器
target 目标对象 w Nhomakorabeaave:植入事务
proxy:代理对象，在开启事务前执行，或关闭事务后执行
spring通过2中方式产生代理：jdk动态代理
为了同步开始，使用conn=DataSourceUtils.getConnection(dataSource);
traintent 对象序列化，而被此修饰的不参与序列
-----------------------------
pl/sql
set serveroutput on
代理对象，对象接口，对象拦截器
jdck动态代理：不需要实现任何接口
用tx：advice的方法配置拦截器
`requires_new无论有么有事务都建新的事务
isolation="defalut" 解决脏读
定义切点，把切面植入到切点上面
end;
select distinct object_name,object_type from user_objects;
create or replace procedure proc_hello(name varchar2)
Spring的AOP源码解析（一）
Spring的AOP源码解析（⼀）Spring AOP 使⽤介绍，从前世到今⽣前⾯写过 Spring IOC 的源码分析，很多读者希望可以出⼀个 Spring AOP 的源码分析，不过 Spring AOP 的源码还是⽐较多的，写出来不免篇幅会⼤些。
本⽂不介绍源码分析，⽽是介绍 Spring AOP 中的⼀些概念，以及它的各种配置⽅法，涵盖了 Spring AOP 发展到现在出现的全部 3 种配置⽅式。
由于 Spring 强⼤的向后兼容性，实际代码中往往会出现很多配置混杂的情况，⽽且居然还能⼯作，本⽂希望帮助⼤家理清楚这些知识。
本⽂使⽤的测试源码已上传到 Github: 。
⽬录：AOP, AspectJ, Spring AOP我们先来把它们的概念和关系说说清楚。
AOP 要实现的是在我们原来写的代码的基础上，进⾏⼀定的包装，如在⽅法执⾏前、⽅法返回后、⽅法抛出异常后等地⽅进⾏⼀定的拦截处理或者叫增强处理。
AOP 的实现并不是因为 Java 提供了什么神奇的钩⼦，可以把⽅法的⼏个⽣命周期告诉我们，⽽是我们要实现⼀个代理，实际运⾏的实例其实是⽣成的代理类的实例。
作为 Java 开发者，我们都很熟悉 AspectJ 这个词，甚⾄于我们提到 AOP 的时候，想到的往往就是 AspectJ，即使你可能不太懂它是怎么⼯作的。
这⾥，我们把 AspectJ 和 Spring AOP 做个简单的对⽐：Spring AOP：它基于动态代理来实现。
默认地，如果使⽤接⼝的，⽤JDK 提供的动态代理实现，如果没有接⼝，使⽤CGLIB 实现。
⼤家⼀定要明⽩背后的意思，包括什么时候会不⽤ JDK 提供的动态代理，⽽⽤ CGLIB 实现。
Spring 3.2 以后，spring-core 直接就把 CGLIB 和 ASM 的源码包括进来了，这也是为什么我们不需要显式引⼊这两个依赖Spring 的 IOC 容器和 AOP 都很重要，Spring AOP 需要依赖于 IOC 容器来管理。
详解Spring框架中切入点pointcut表达式的常用写法
详解Spring框架中切⼊点pointcut表达式的常⽤写法⾃从使⽤ AspectJ 风格切⾯配置，使得 spring 的切⾯配置⼤⼤简化，但是 AspectJ 是另外⼀个开源项⽬，其规则表达式的语法也稍稍有些怪异。
下⾯给出⼀些常见⽰例的写法，例如，下⾯是⼀个对 Service 包上所有⽅法的切⾯配置：<aop:config><aop:pointcut id="serviceOperation" expression="execution(* *..service*..*(..))"/><aop:advisor pointcut-ref="serviceOperation" advice-ref="txAdvice"/></aop:config>表达式所处位置如上pointcut的位置。
配置这个是为了更好控制切⾯上的事务，下⾯是⼀个事物配置的简单例⼦：<tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><tx:method name="delete*" rollback-for="Exception"/><tx:method name="save*" rollback-for="Exception"/><tx:method name="update*" rollback-for="Exception"/><tx:method name="*" read-only="true" rollback-for="Exception"/></tx:attributes></tx:advice>通过切⾯、通知的配置，就为所有的以delete、save和update开头的⽅法添加上了⼀致性事务，对其他⽅法添加上了只读事务。
SpringAOP中pointcutexpression表达式解析及匹配多个条件
SpringAOP中pointcutexpression表达式解析及匹配多个条件Pointcut 是指那些⽅法需要被执⾏"AOP",是由"Pointcut Expression"来描述的.Pointcut可以有下列⽅式来定义或者通过&& || 和!的⽅式进⾏组合.args()@args()execution()this()target()@target()within()@within()@annotation其中 execution 是⽤的最多的,其格式为:execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern)throws-pattern?)returning type pattern,name pattern, and parameters pattern是必须的.ret-type-pattern:可以为*表⽰任何返回值,全路径的类名等.name-pattern:指定⽅法名,*代表所以,set*,代表以set开头的所有⽅法.parameters pattern:指定⽅法参数(声明的类型),(..)代表所有参数,(*)代表⼀个参数,(*,String)代表第⼀个参数为任何值,第⼆个为String类型.举例说明:任意公共⽅法的执⾏：execution(public * *(..))任何⼀个以“set”开始的⽅法的执⾏：execution(* set*(..))AccountService 接⼝的任意⽅法的执⾏：execution(* com.xyz.service.AccountService.*(..))定义在service包⾥的任意⽅法的执⾏：execution(* com.xyz.service.*.*(..))定义在service包和所有⼦包⾥的任意类的任意⽅法的执⾏：execution(* com.xyz.service..*.*(..))定义在pointcutexp包和所有⼦包⾥的JoinPointObjP2类的任意⽅法的执⾏：execution(* com.test.spring.aop.pointcutexp..JoinPointObjP2.*(..))")***> 最靠近(..)的为⽅法名,靠近.*(..))的为类名或者接⼝名,如上例的JoinPointObjP2.*(..))<aop:config><aop:pointcut expression="execution(* boy.dao..*.find*(..)) ||execution(* boy.dao..*.query*(..))"id="findCachePointcut" /><aop:advisor advice-ref="jdbcInterceptor" pointcut-ref="findCachePointcut" /></aop:config>在多个表达式之间使⽤ || , or 表⽰或，使⽤ && , and 表⽰与，！表⽰⾮.上⾯的代码也可以改写成<aop:config><aop:pointcut expression=" ( execution(* boy.dao..*.find*(..))) or(execution(* boy.dao..*.query*(..)))"id="findCachePointcut" /><aop:advisor advice-ref="jdbcInterceptor" pointcut-ref="findCachePointcut" /></aop:config>注意上⾯两中⽅法的不同点出了将 || 改成了 or ，还有就是每个execution都被（）包含起来，建议为了区分不同的表达式最好都是⽤（）包装。
SpringAOP切点表达式用法总结
SpringAOP切点表达式⽤法总结1. 简介⾯向对象编程，也称为OOP（即Object Oriented Programming）最⼤的优点在于能够将业务模块进⾏封装，从⽽达到功能复⽤的⽬的。
通过⾯向对象编程，不同的模板可以相互组装，从⽽实现更为复杂的业务模块，其结构形式可⽤下图表⽰：⾯向对象编程解决了业务模块的封装复⽤的问题，但是对于某些模块，其本⾝并不独属于摸个业务模块，⽽是根据不同的情况，贯穿于某⼏个或全部的模块之间的。
例如登录验证，其只开放⼏个可以不⽤登录的接⼝给⽤户使⽤（⼀般登录使⽤拦截器实现，但是其切⾯思想是⼀致的）；再⽐如性能统计，其需要记录每个业务模块的调⽤，并且监控器调⽤时间。
可以看到，这些横贯于每个业务模块的模块，如果使⽤⾯向对象的⽅式，那么就需要在已封装的每个模块中添加相应的重复代码，对于这种情况，⾯向切⾯编程就可以派上⽤场了。
⾯向切⾯编程，也称为AOP（即Aspect Oriented Programming），指的是将⼀定的切⾯逻辑按照⼀定的⽅式编织到指定的业务模块中，从⽽将这些业务模块的调⽤包裹起来。
如下是其结构⽰意图：2. AOP的各个扮演者2.1 AOP的主要⾓⾊切⾯：使⽤切点表达式表⽰，指定了当前切⾯逻辑所要包裹的业务模块的范围⼤⼩；Advice：也即切⾯逻辑，指定了当前⽤于包裹切⾯指定的业务模块的逻辑。
2.2 Advice的主要类型@Before：该注解标注的⽅法在业务模块代码执⾏之前执⾏，其不能阻⽌业务模块的执⾏，除⾮抛出异常；@AfterReturning：该注解标注的⽅法在业务模块代码执⾏之后执⾏；@AfterThrowing：该注解标注的⽅法在业务模块抛出指定异常后执⾏；@After：该注解标注的⽅法在所有的Advice执⾏完成后执⾏，⽆论业务模块是否抛出异常，类似于finally的作⽤；@Around：该注解功能最为强⼤，其所标注的⽅法⽤于编写包裹业务模块执⾏的代码，其可以传⼊⼀个ProceedingJoinPoint⽤于调⽤业务模块的代码，⽆论是调⽤前逻辑还是调⽤后逻辑，都可以在该⽅法中编写，甚⾄其可以根据⼀定的条件⽽阻断业务模块的调⽤；@DeclareParents：其是⼀种Introduction类型的模型，在属性声明上使⽤，主要⽤于为指定的业务模块添加新的接⼝和相应的实现。
Spring AOP面向方面编程原理：AOP概念
Spring AOP面向方面编程原理：AOP概念[关键字：spring，AOP概念，面向切面编程，事务管理（Transaction Management）]OP(Aspect Oriented Programming)，也就是面向方面编程的技术。
AOP基于IoC基础，是对OOP的有益补充。
AOP将应用系统分为两部分，核心业务逻辑（Core business concerns）及横向的通用逻辑，也就是所谓的方面Crosscutting enterprise concerns，例如，所有大中型应用都要涉及到的持久化管理（Persistent）、事务管理（Transaction Management）、安全管理（Security）、日志管理（Logging）和调试管理（Debugging）等。
AOP正在成为软件开发的下一个光环。
使用AOP，你可以将处理aspect的代码注入主程序，通常主程序的主要目的并不在于处理这些aspect。
AOP可以防止代码混乱。
Spring framework是很有前途的AOP技术。
作为一种非侵略性的、轻型的AOP framework，你无需使用预编译器或其他的元标签，便可以在Java程序中使用它。
这意味着开发团队里只需一人要对付AOP framework，其他人还是像往常一样编程。
AOP概念让我们从定义一些重要的AOP概念开始。
—方面（Aspect）：一个关注点的模块化，这个关注点实现可能另外横切多个对象。
事务管理是J2EE应用中一个很好的横切关注点例子。
方面用Spring的Advisor或拦截器实现。
—连接点（Joinpoint）：程序执行过程中明确的点，如方法的调用或特定的异常被抛出。
—通知（Advice）：在特定的连接点，AOP框架执行的动作。
各种类型的通知包括“around”、“before”和“throws”通知。
通知类型将在下面讨论。
许多AOP框架包括Spring都是以拦截器做通知模型，维护一个“围绕”连接点的拦截器链。
spr4
示例
8
Spring2.0
运行
9
Spring2.0
RegexpMethodPointcutAdvisor
Spring 提供的
org.springframework.aop.support.RegexpMethodPointcutAdvisor
使用Regular expression 来编写Pointcut表达式，其值为 “pattern”属性值
在mappedName属性上，指定了 “*Newbie”,所以执行helloNewbie() 方法时，应用logBeforeAdvice的 逻辑 6
使用PointcutAdvisor提供Pointcut Spring2.0 实例
运行
7
Spring2.0
在上例中增加方法helloMaster执行时，执行logAfterAdvice?
提供静态的Pointcut实例，使用表达式指定Advice应用目 标上的方法名称，或者用*来指定。 注意：PointcutAdvisor为Advisor的子接口
4
Spring2.0
示例
已知下列接口：希望在方法helloNewbie执行前执行 LogBeforeAdvice
5
Spring2.0
代码分析
第四章
Spring AOP-II
Spring2.0
回顾
熟悉逻辑术语Cross-cutting concerns 理解AOP编程思想，着重在Aspect的设计上以及 与应用程序的织入 学会使用Spring AOP
2
Spring2.0
目标
继续熟悉各种Advice的设计与配置 学会使用Pointcut 熟练掌握AOP编程
abstractpointcutadvisor简书
abstractpointcutadvisor简书AbstractPointcutAdvisor是Spring AOP中的一个抽象实现类，它实现了PointcutAdvisor接口。
PointcutAdvisor接口定义了两个方法：getPointcut()
和advice()。
getPointcut()方法用于返回一个Pointcut对象，该对象定义了切点（pointcut），即哪些方法应该被增强（advice）。
Pointcut对象由ClassFilter 和MethodMatcher组成，ClassFilter用于定位到具体的类上，MethodMatcher用于定位到具体的方法上。
通过Pointcut，我们可以将增强
织入到特定类的特定方法上。
advice()方法用于返回一个Advice对象，该对象定义了增强（advice），即当匹配的方法被调用时应该执行的操作。
Advice对象可以是前置通知（Before）、后置通知（After）、异常抛出通知（AfterThrowing）或返回通知
（AfterReturning）。
AbstractPointcutAdvisor抽象类提供了对PointcutAdvisor接口的基本实现，包括对getPointcut()和advice()方法的默认实现。
开发者可以通过继承AbstractPointcutAdvisor类并实现getPointcut()和advice()方法来创建自
己的切面（advisor）。
Spring3系列10-SpringAOP——Pointcut，Advisor拦截指定方法
Spring3系列10-SpringAOP——Pointcut，Advisor拦截指定⽅法上⼀篇的Spring AOP Advice例⼦中，Class（CustomerService）中的全部method都被⾃动的拦截了。
但是⼤多情况下，你只需要⼀个⽅法去拦截⼀两个method。
这样就引⼊了Pointcut（切⼊点）的概念，它允许你根据method的名字去拦截指定的method。
另外，⼀个Pointcut必须结合⼀个Advisor来使⽤。
在Spring AOP中，有3个常⽤的概念，Advices、Pointcut、Advisor，解释如下，Advices：表⽰⼀个method执⾏前或执⾏后的动作。
Pointcut：表⽰根据method的名字或者正则表达式去拦截⼀个method。
Advisor：Advice和Pointcut组成的独⽴的单元，并且能够传给proxy factory 对象。
下边来回顾⼀下上⼀篇例⼦中的代码CustomerService.javapackage com.lei.demo.aop.advice;public class CustomerService {private String name;private String url;public void setName(String name) { = name;}public void setUrl(String url) {this.url = url;}public void printName() {System.out.println("Customer name : " + );}public void printURL() {System.out.println("Customer website : " + this.url);}public void printThrowException() {throw new IllegalArgumentException();}}配置⽂件Spring-AOP-Advice.xml：<beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd"><bean id="customerService" class="com.lei.demo.aop.advice.CustomerService"><property name="name" value="LeiOOLei" /><property name="url" value="/leiOOlei/" /></bean><bean id="hijackAroundMethodBean" class="com.lei.demo.aop.advice.HijackAroundMethod" /><bean id="customerServiceProxy" class="org.springframework.aop.framework.ProxyFactoryBean"><property name="target" ref="customerService" /><property name="interceptorNames"><list><value>hijackAroundMethodBean</value></list></property></bean></beans>HijackAroundMethod.javapackage com.lei.demo.aop.advice;import java.util.Arrays;import org.aopalliance.intercept.MethodInterceptor;import org.aopalliance.intercept.MethodInvocation;public class HijackAroundMethod implements MethodInterceptor {public Object invoke(MethodInvocation methodInvocation) throws Throwable {System.out.println("Method name : "+ methodInvocation.getMethod().getName());System.out.println("Method arguments : "+ Arrays.toString(methodInvocation.getArguments()));// 相当于 MethodBeforeAdviceSystem.out.println("HijackAroundMethod : Before method hijacked!");try {// 调⽤原⽅法，即调⽤CustomerService中的⽅法Object result = methodInvocation.proceed();// 相当于 AfterReturningAdviceSystem.out.println("HijackAroundMethod : After method hijacked!");return result;} catch (IllegalArgumentException e) {// 相当于 ThrowsAdviceSystem.out.println("HijackAroundMethod : Throw exception hijacked!");throw e;}}}运⾏如下App.javapackage com.lei.demo.aop.advice;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class App {public static void main(String[] args) {ApplicationContext appContext = new ClassPathXmlApplicationContext(new String[] { "Spring-AOP-Advice.xml" });System.out.println("使⽤Spring AOP 如下");CustomerService cust = (CustomerService) appContext.getBean("customerServiceProxy"); System.out.println("*************************");cust.printName();System.out.println("*************************");cust.printURL();System.out.println("*************************");try {cust.printThrowException();} catch (Exception e) {}}}运⾏结果：使⽤Spring AOP 如下*************************Method name : printNameMethod arguments : []HijackAroundMethod : Before method hijacked!Customer name : LeiOOLeiHijackAroundMethod : After method hijacked!*************************Method name : printURLMethod arguments : []HijackAroundMethod : Before method hijacked!Customer website : /leiOOlei/HijackAroundMethod : After method hijacked!*************************Method name : printThrowExceptionMethod arguments : []HijackAroundMethod : Before method hijacked!HijackAroundMethod : Throw exception hijacked!上边的结果中，CustomerService.java中，全部的method⽅法全部被拦截了，下边我们将展⽰怎样利⽤Pointcuts只拦截printName()。
AOP之Pointcut、Advisor
AOP之Pointcut、Advisor上篇的所定义的Advice都是直接织入至代理接口执行前后的，或者在执行方法过程中出现异常的时候织入。
事实上还有更加细致的织入时机。
Pointcut定义了感兴趣的Jointpoint（Advice的应用时机）。
在spring中，使用PointcutAdvisor提供的Pointcut实例，具体结合Advice，Spring内建的Pointcut都有对应的PointcutAdvisor。
官方文档解释：在Spring里，一个advisor是一个仅仅包含一个通知对象和与之关联的切入点表达式的切面。
除了引入这种特殊形式，任何advisor都可以和任何通知一起工作。
org.springframework.aop.support.DefaultPointcutAdvisor是最常用的advisor类。
例如，它可以和： MethodInterceptor，BeforeAdvice 或者 ThrowsAdvice一起使用。
在Spring里有可能在同一个AOP代理里模糊advisor和通知类型。
例如，你可以在一个代理配置里使用一个interception环绕通知，一个异常通知和一个前置通知：Spring将负责自动创建所需的拦截器链。
我的通俗解释：就是将一个advice和对应不同的规则进行匹配，就是将advice 给包装升级了，使用的时候和advice一样使用1、NameMatchMethodPointcoutAdvisor（这里是一个织入时机的更加细致的处理，通过名字来对应，这样很明显的一个好处就是，我可以针对要代理类中的部分方法进行织入，而不是每个方法都进行织入）view plaincopy to clipboardprint?<bean id="beforeAdvice"class="com.itcast.advice.LogBeforeAdvice"></bean><bean id="afterAdvice"class="com.itcast.advice.LogAfterAdvice"></bean><bean id="helloProxy"class="org.springframework.aop.framework.ProxyFactoryBean"><property name="target" ref="helloSpeaker"></property><property name="interceptorNames"><list><value>helloAdvise</value></list></property></bean><!--helloAdvise的名字匹配的方式来匹配要进行advice处理的方法--><bean id="helloAdvise"class="MatchMethodPointcutAdvisor "><property name="mappedName" value="hello*"></property><property name="advice" ref="beforeAdvice"></property></bean><bean id="beforeAdvice"class="com.itcast.advice.LogBeforeAdvice"></bean><bean id="afterAdvice"class="com.itcast.advice.LogAfterAdvice"></bean><bean id="helloProxy"class="org.springframework.aop.framework.ProxyFactoryBean"><property name="target" ref="helloSpeaker"></property><property name="interceptorNames"><list><value>helloAdvise</value></list></property></bean><!--helloAdvise的名字匹配的方式来匹配要进行advice处理的方法--><bean id="helloAdvise"class="MatchMethodPointcutAdvisor "><property name="mappedName" value="hello*"></property><property name="advice" ref="beforeAdvice"></property></bean>或者还可以定义成如下方式：view plaincopy to clipboardprint?<!--helloAdvise直接指定要引入的advice方法的那些类文件中的具体方法列表--><bean id="helloAdvise"class="MatchMethodPointcutAdvisor "><property name="mappedNames" ><list><value>helloAaa</value><value>helloBbb</value></list></property><property name="advice" ref="beforeAdvice"></property></bean><!--helloAdvise直接指定要引入的advice方法的那些类文件中的具体方法列表--><bean id="helloAdvise"class="MatchMethodPointcutAdvisor "><property name="mappedNames" ><list><value>helloAaa</value><value>helloBbb</value></list></property><property name="advice" ref="beforeAdvice"></property></bean>2、RegExpMethodPointcutAdvisor（这里是通过正则表达式来编写Pointcut的表示式）定义的时候可以使用的符号：. 符合任何单一字符+ 符合前一个字符一次或者多次* 符合前一个字符零次或者多次\ Escape任何Regular expression_r使用到的符号写法例如：view plaincopy to clipboardprint?<bean id="beforeAdvice"class="com.itcast.advice.LogBeforeAdvice"></bean><bean id="afterAdvice"class="com.itcast.advice.LogAfterAdvice"></bean><bean id="helloProxy"class="org.springframework.aop.framework.ProxyFactoryBean"><property name="target" ref="helloSpeaker"></property><property name="interceptorNames"><list><value>regAdvise</value></list></property></bean><bean id="regAdvise"class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"> <property name="advice" ref="afterAdvice"></property><property name="pattern" value=".*Bbb"></property></bean><bean id="beforeAdvice"class="com.itcast.advice.LogBeforeAdvice"></bean><bean id="afterAdvice"class="com.itcast.advice.LogAfterAdvice"></bean><bean id="helloProxy"class="org.springframework.aop.framework.ProxyFactoryBean"><property name="target" ref="helloSpeaker"></property><property name="interceptorNames"><list><value>regAdvise</value></list></property></bean><bean id="regAdvise"class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"> <property name="advice" ref="afterAdvice"></property><property name="pattern" value=".*Bbb"></property></bean>这里是根据正则表达式来完成对于相关要进行advisor的方法。
Spring 2中Pointcut的定义
Spring 2.0中Pointcut的定义在Spring1.2或之前的版本中，实现AOP的传统方式就是通过实现Spring的AOP API来定义Advice，并设置代理对象。
Spring根据Adivce加入到业务流程的时机的不同，提供了四种不同的Advice：Before Advice、After Advice、Around Advice、Throw Advice。
1、Before Advice顾名思义，Before Advice会在目标对象的方法执行之前被调用，您可以通过实现org.springframework.aop.MethodBeforeAdvice接口来实现Before Advice的逻辑，接口定义如下：java 代码1.package org.springframework.aop;2.3.public interface MethodBeforeAdvice extends BeforeAdvice {4.void before(Method method, Object[] args, Object target) throws Throwable;5.}其中BeforeAdvice继承自Adivce接口，这两者都是标签接口，并没有定义任何具体的方法。
before方法会在目标对象的指定方法执行之前被执行，在before方法种，你可以取得指定方法的Method实例、参数列表和目标对象，在before方法执行完后，目标对象上的方法将会执行，除非在before方法种抛出异常。
下面通过例子来说明Before Advice的使用方法。
首先定义目标对象所要实现的接口：java 代码1.package com.savage.aop2.3.public interface MessageSender {4.void send(String message);5.}接着实现MessageSender接口：java 代码1.package com.savage.aop;2.3.public class HttpMessageSender implements MessageSender {4.public void send(String message) {5.System.out.println("Send Message[" + message + "] by http.");6.}7.}OK，我们的业务代码实现完了，现在如果要在不改变我们的业务代码的前提下，在执行业务代码前要记录一些日志，这时就可以通过实现MethodBeforeAdvice接口来实现，如：java 代码1.package com.savage.aop;2.3.import ng.reflect.Method;4.5.import org.springframework.aop.framework.MethodBeforeAdvice;6.7.public class LogBeforeAdvice implements MethodAdvice {8.public void before(Method method, Object[] args, Object target) throws Throwable {9.System.out.println("Log before " + method + " by LogBeforeAdvice.");10.}11.}然后再在XML进行如下定义：xml 代码1.<?xml version="1.0" encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xsi:schemaLocation="/schema/beans5./schema/beans/spring-beans-2.0.xsd">6.7. <bean id="messageSenderImpl" class="com.savage.aop.HttpMessageSender"></bean>8.9. <bean id="logBeforeAdvice" class="com.savage.aop.LogBeforeAdvice"></bean>10.11. <bean id="messageSender" class="org.springframework.aop.framework.ProxyFactoryBean">12. <property name="proxyInterfaces" value="com.savage.aop.MessageSender"/>13. <property name="target" ref="messageSenderImpl"/>14. <property name="interceptorNames">15. <list>16. <value>logBeforeAdvice</value>17. </list>18. </property>19. </bean>20.</beans>这样我们就为MessageSender对象指定了Before Advice对象。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
谈谈Spring中的Advisor和PointcutAdvior
Advisor是用来持有(hold)一种advice的,它有一个getAdvice()方法,专门来得到其所持有的advice而pointcutAdvior继承自Advisor接口,同时本身又提供了一个getPointcut方法,这十分明确地说明:pointcutAdvior是用来组装advice和pointcut这两个切面的重要组成元素的,因此我们说pointcutAdvisor才是一个切面的实例模块,而不是有些书上说的Advisor!
理论上讲:我们想实现自己的一个切面,只要需提供一
个实现advisor接口的类和一个实现pointcut接口的类,然后用一个pointcutAdvisor接口的实现类来把把来个类组装起来就构成了我们自己的切面实例.但是事实上spring框架为我们提供了很多的子接口和实现类,来简化我们的工作,
这包括:
1.advice:AfterAdvice AfterReturningAdvice MethodBeforeAdvice 等接口
2.pointcut:NameMatchMethodPointcut(最常用),还有与之相对应的DynamicMethodMatcherPointcut
3.pointcutAdvisor:在框架里每有一个pointcut,就会有一个与之对应的pointcutAdvisot例如上面提到的
NameMatchMethodPointcut就有一个对其对应的StaticMethodMatcherPointcut.另外还有一种功能十分强大的正则表达式
pointcutAdvisor:RegexpMethodPointcutAdvisor(注意:这个pointcutAdvisor是没有
与其对应的pointcut存在的.也说是没有RegexpMethodPointcut这么一个类),它使用正则表达式来描述
它的pointcut. 最后提到的一个就
是:DefaultPointcutAdvisor这是一个使用频率很高的PointcutAdvisor,一般来说我们就是用它来组装我们写好的advice和pointcut!
它有两个属性:advice和pointcut正好用来接受我们提供给它的dvice和pointcut.
关于pointcutAdvisot的使用:两种情况:一种是我们定义自己的advice,又定义了一个pointcut,那么, 显然,这时我们应该使用DefaultPointcutAdvisor来装配我们的Dvice和pointcut.第二种情况是:
我们其实可以只定义自己的advice,然后直接选用一种pointcutAdvisor来装配,至于pointcut,则是
通过设置这种pointcutAdvisor的一个pattern属性来在这个ointcutAdvisor的内部自动生成一个
pointcut.这种方法较第一种要简洁不少,代码的书写量也少了很多(因为不用专门去写一个pointcut类和其对就的配制了),缺点是这个装配的过程显得有点"古怪",原为看起来好像少了pointcut.
最后再次强调的时:如果采取第二种方式,那么我们应该首选:RegexpMethodPointcutAdvisor.它通过正则表达式来指定切入点,其若能是十分强大而方便的.。