springAOP

最新推荐文章于 2023-10-13 21:54:37 发布
最新推荐文章于 2023-10-13 21:54:37 发布
阅读量473 收藏
点赞数
分类专栏： Spring3.0 文章标签： SpringAOP springAOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jactionlin/article/details/8508646
版权

连接点joinpoint：可以织入代码的位置，方法前后，出异常时等位置

切点pointcut：用PointCut接口进行描述，切点功能上类似一个正则表达式，描述了哪些类的哪些方法符合条件，具体不到方法前还是方法后等连接点

增强advice：织入到连接点上的方法，定位了大致连接点（方法前，方法后，异常时等）和要织入的代码

目标对象target：要织入的代码的目标类

引介introduction:为目标类动态添加属性和方法，在spring中一般是为目标类动态的添加接口，使目标类成为某接口的实现类

织入weaving:将增强advice添加到目标类的具体连接点上的过程，有三种形式：编译器织入（aspectJ），类装载期织入（aspectJ），动态织入（spring）

代理proxy:融合了原类和增强逻辑的代理类

切面aspect:由切点和增强/引介组成

 

五种增强类型：

前置增强：方法执行前，用BeforeAdvice的子接口MethodBeforeAdvice

后置增强：AfterReturningAdvice

环绕增强：MethodInterceptor

异常抛出增强：ThrowsAdvice

引介增强：IntroductionInterceptor

org.springframework.aop.framework.ProxyFactoryBean是负责为其他Bean创建代理对象的类，其中的几个属性：

target:要代理的目标类对象

proxyInterfaces,别名interfaces:代理要实现的接口，可以是多个

interceptorNames:要织入的增强或引介bean列表，必须实现MethodInterceptor或Advisor

singleton：返回的代理是否单例

optimize：值为true就强制使用cglib，对单例的代理推荐cglib，其他推荐jdk代理，因为cglib创建慢运行起来快，jdk代理相反

proxyTargetClass：是否对类进行代理（而不是对接口），true的话使用cglib,设置proxyTargetClass=true就不需要设置optimize了

前置增强

[java] view plain copy print ?
  1. public class GreetingBeforeAdvice implements MethodBeforeAdvice { 
  2.     public void before(Method method, Object[] args, Object obj) throws Throwable { 
  3.         String clientName = (String)args[0]; 
  4.         System.out.println("How are you！Mr."+clientName+"."); 
  5.     } 
  6. }  
public class GreetingBeforeAdvice implements MethodBeforeAdvice {
	public void before(Method method, Object[] args, Object obj) throws Throwable {
		String clientName = (String)args[0];
		System.out.println("How are you！Mr."+clientName+".");
	}
}
[html] view plain copy print ?
  1. <bean id="target" class="com.baobaotao.advice.NaiveWaiter" /> 
  2. <bean id="greetingBefore" class="com.baobaotao.advice.GreetingBeforeAdvice" /> 
  3. <bean id="waiter"  class="org.springframework.aop.framework.ProxyFactoryBean" 
  4.         p:proxyInterfaces="com.baobaotao.advice.Waiter"  
  5.         p:target-ref="target" 
  6.         p:interceptorNames="greetingAdvice"/>  
<bean id="target" class="com.baobaotao.advice.NaiveWaiter" />
<bean id="greetingBefore" class="com.baobaotao.advice.GreetingBeforeAdvice" />
<bean id="waiter"  class="org.springframework.aop.framework.ProxyFactoryBean"
		p:proxyInterfaces="com.baobaotao.advice.Waiter" 
		p:target-ref="target"
		p:interceptorNames="greetingAdvice"/>

后置增强

[java] view plain copy print ?
  1. public class GreetingAfterAdvice implements AfterReturningAdvice { 
  2.     public void afterReturning(Object returnObj, Method method, Object[] args, 
  3.             Object obj) throws Throwable { 
  4.         System.out.println("Please enjoy yourself!"); 
  5.     } 
  6. }  
public class GreetingAfterAdvice implements AfterReturningAdvice {
	public void afterReturning(Object returnObj, Method method, Object[] args,
			Object obj) throws Throwable {
		System.out.println("Please enjoy yourself!");
	}
}
[html] view plain copy print ?
  1. <bean id="target" class="com.baobaotao.advice.NaiveWaiter" /> 
  2. <bean id="greetingBefore" class="com.baobaotao.advice.GreetingBeforeAdvice" /> 
  3. <bean id="greetingAfter" class="com.baobaotao.advice.GreetingAfterAdvice" /> 
  4. <bean id="waiter" 
  5.         class="org.springframework.aop.framework.ProxyFactoryBean" 
  6.         p:proxyInterfaces="com.baobaotao.advice.Waiter"  
  7.         p:target-ref="target" 
  8.         p:interceptorNames="greetingBefore,greetingAfter"/>  
<bean id="target" class="com.baobaotao.advice.NaiveWaiter" />
<bean id="greetingBefore" class="com.baobaotao.advice.GreetingBeforeAdvice" />
<bean id="greetingAfter" class="com.baobaotao.advice.GreetingAfterAdvice" />
<bean id="waiter"
		class="org.springframework.aop.framework.ProxyFactoryBean"
		p:proxyInterfaces="com.baobaotao.advice.Waiter" 
		p:target-ref="target"
		p:interceptorNames="greetingBefore,greetingAfter"/>

前置增强和后置增强都用到了

环绕增强

[java] view plain copy print ?
  1. public class GreetingInterceptor implements MethodInterceptor { 
  2.     public Object invoke(MethodInvocation invocation) throws Throwable { 
  3.         Object[] args = invocation.getArguments(); 
  4.         String clientName = (String)args[0]; 
  5.         System.out.println("How are you！Mr."+clientName+"."); 
  6.         Object obj = invocation.proceed(); 
  7.         System.out.println("Please enjoy yourself!"); 
  8.         return obj; 
  9.     } 
  10. }  
public class GreetingInterceptor implements MethodInterceptor {
	public Object invoke(MethodInvocation invocation) throws Throwable {
		Object[] args = invocation.getArguments();
		String clientName = (String)args[0];
		System.out.println("How are you！Mr."+clientName+".");
		Object obj = invocation.proceed();
		System.out.println("Please enjoy yourself!");
		return obj;
	}
}

配置文件同上

异常抛出增强

[java] view plain copy print ?
  1. public class TransactionManager implements ThrowsAdvice { 
  2.     public void afterThrowing(Method method, Object[] args, Object target, 
  3.             Exception ex) throws Throwable { 
  4.         System.out.println("-----------"); 
  5.         System.out.println("method:" + method.getName()); 
  6.         System.out.println("抛出异常:" + ex.getMessage()); 
  7.         System.out.println("成功回滚事务。"); 
  8.     } 
  9. }  
public class TransactionManager implements ThrowsAdvice {
	public void afterThrowing(Method method, Object[] args, Object target,
			Exception ex) throws Throwable {
		System.out.println("-----------");
		System.out.println("method:" + method.getName());
		System.out.println("抛出异常:" + ex.getMessage());
		System.out.println("成功回滚事务。");
	}
}
配置文件同上

引介增强，不是在方法周围织入增强，而是为目标类添加新的属性和方法，是类级别的，在spring中引介增强通过实现IntroductionInterceptor来实现，不过一般为了简单我们使用IntroductionInterceptor的实现类DelegatingIntroductionInterceptor

[java] view plain copy print ?
  1. package introduce2; 
  2. //要代理的目标类 
  3. public class Animal { 
  4.     public void eat(String food){ 
  5.         System.out.println("eat-"+food); 
  6.     } 
  7. }  
package introduce2;
//要代理的目标类
public class Animal {
	public void eat(String food){
		System.out.println("eat-"+food);
	}
}
[java] view plain copy print ?
  1. package introduce2; 
  2. //代理类要实现的接口 
  3. public interface Moveable { 
  4.     void move(); 
  5. }  
package introduce2;
//代理类要实现的接口
public interface Moveable {
	void move();
}
[java] view plain copy print ?
  1. package introduce2; 
  2. import org.aopalliance.intercept.MethodInvocation; 
  3. import org.springframework.aop.support.DelegatingIntroductionInterceptor; 
  4. //引介增强类 
  5. public class MyAdvice extends DelegatingIntroductionInterceptor implements Moveable{ 
  6.     @Override 
  7.     public void move() { 
  8.         System.out.println("advice-move"); 
  9.     } 
  10.     @Override 
  11.     public Object invoke(MethodInvocation mi) throws Throwable { 
  12.         System.out.println("invoke-start"); 
  13.         Object result=super.invoke(mi); 
  14.         System.out.println("invoke-end"); 
  15.         return result; 
  16.     } 
  17. }  
package introduce2;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.support.DelegatingIntroductionInterceptor;
//引介增强类
public class MyAdvice extends DelegatingIntroductionInterceptor implements Moveable{
	@Override
	public void move() {
		System.out.println("advice-move");
	}
	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		System.out.println("invoke-start");
		Object result=super.invoke(mi);
		System.out.println("invoke-end");
		return result;
	}
}
[html] view plain copy print ?
  1. <bean id="target" class="introduce2.Animal" /> 
  2. <bean id="introductionObj" class="introduce2.MyAdvice" /> 
  3. <bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean" 
  4.     p:interfaces="introduce2.Moveable"  
  5.     p:target-ref="target" 
  6.     p:interceptorNames="introductionObj"  
  7.     p:proxyTargetClass="true" /><!-- 由于一定要通过创建子类来实现，所以要用cglib，否则出错 -->  
	<bean id="target" class="introduce2.Animal" />
	<bean id="introductionObj" class="introduce2.MyAdvice" />
	<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean"
		p:interfaces="introduce2.Moveable" 
		p:target-ref="target"
		p:interceptorNames="introductionObj" 
		p:proxyTargetClass="true" /><!-- 由于一定要通过创建子类来实现，所以要用cglib，否则出错 -->
[java] view plain copy print ?
  1. public static void main(String[] args) { 
  2.         ApplicationContext ctx=new ClassPathXmlApplicationContext("introduce2/beans.xml"); 
  3.         Object obj=ctx.getBean("proxy"); 
  4.         Animal animal=(Animal)obj; 
  5.         animal.eat("青菜"); 
  6.         Moveable mo=(Moveable)obj; 
  7.         mo.move(); 
  8. }  
public static void main(String[] args) {
		ApplicationContext ctx=new ClassPathXmlApplicationContext("introduce2/beans.xml");
		Object obj=ctx.getBean("proxy");
		Animal animal=(Animal)obj;
		animal.eat("青菜");
		Moveable mo=(Moveable)obj;
		mo.move();
}

结果：

invoke-start
eat-青菜
invoke-end
invoke-start
advice-move
invoke-end

上面提到切面aspect由切点和增强/引介组成

从上面的例子可以看出，增强提供了连接点的方位信息，织入到方法前还是后等信息，如果要定位到哪些类的"哪些方法"上就要用到切点了。

org.springframework.aop.Pointcut描述切点，由ClassFilter和MethodMatcher组成，spring支持静态方法匹配器(匹配方法签名<方法名和参数列表>，只需要判断一次)和动态方法匹配器（可以判断方法中参数的值，每次调用方法都会判断，不常用）

切点类型 参考http://blog.csdn.net/a569433273/article/details/7800863  6种：

静态方法切点 org.springframework.aop.support.StaticMethodMatcherPointcut 默认匹配所有的类。包括两个子类：NameMatchMethodPointcut简单字符串匹配方法签名；AbstractRegexpMethodPointcut使用正则表达式匹配方法签名

动态方法切点 org.springframework.aop.support.DynamicMethodMatcherPointcut 默认匹配所有的类。2.0下已经过时，可以使用DefaultPointcutAdvisor和DynamicMethodMatcherPointcut动态方法匹配器替代

注解切点 org.springframework.aop.support.annotation.AnnotationMatchingPointcut 支持在Bean中直接通过注解标签定义的切点

表达式切点 0org.springframework.aop.support.ExpressionPointcut 支持AspectJ切点表达式而定义的切点

流程切点 org.springframework.aop.support.ControlFlowPointcut 根据程序执行堆栈的信息查看目标方法是否由某一个方法直接和间接发起调用，以此判断是否为匹配的连接点

复合切点 org.springframework.aop.support.ComposablePointcut 实现类是为创建多个切点而提供的方便操作类。它所有的方法都返回ComposablePointcut，这样，就可以使用连接表达式对切点进行操作，如：Pointcut pc = new ComposablePointcut().union(classFilter).intersection(methodMatcher).intersection(pointcut)

切面类型（3种）：

一般切面Advisor 仅仅包含一个Advice

具有切点的切面PointcutAdvisor，包含Advice和Pointcut两个类

引介切面IntroductionAdvisor，使用ClassFilter进行定义

具有切点的切面PointcutAdvisor的六个实现类：看http://book.51cto.com/art/200908/147223.htm中的PointcutAdvisor家族

1. DefaultPointcutAdvisor

DefaultPointcutAdvisor是PointcutAdvisor的"大弟子"，是最通用的PointcutAdvisor实现。除了不能为其指定Introduction类型的Advice之外，剩下的任何类型的Pointcut、任何类型的Advice都可以通过DefaultPointcutAdvisor来使用。我们可以在构造DefaultPointcutAdvisor的时候，就明确指定属于当前DefaultPointcutAdvisor实例的Pointcut和Advice，也可以在DefaultPointcut- Advisor实例构造完成后，再通过setPointcut以及setAdvice方法设置相应的Pointcut和Advice

[html] view plain copy print ?
  1. <bean id="pointcut" class="..."> ...</bean>   
  2. <bean id="advice" class="..."> ...</bean>   
  3. <bean id="advisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">   
  4.     <property name="pointcut" ref="pointcut"/>   
  5.     <property name="advice" ref="advice"/>   
  6. </bean>  
<bean id="pointcut" class="..."> ...</bean>  
<bean id="advice" class="..."> ...</bean>  
<bean id="advisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">  
    <property name="pointcut" ref="pointcut"/>  
    <property name="advice" ref="advice"/>  
</bean>
[html] view plain copy print ?
  1. <bean id="target" class="..." /> 
  2. <bean id="proxy"  
  3.     class="org.springframework.aop.framework.ProxyFactoryBean" 
  4.     p:interceptorNames="advisor"  
  5.     p:target-ref="target" 
  6.     p:proxyTargetClass="true" />  
<bean id="target" class="..." />
<bean id="proxy" 
	class="org.springframework.aop.framework.ProxyFactoryBean"
	p:interceptorNames="advisor" 
	p:target-ref="target"
	p:proxyTargetClass="true" />

pointcut可以是上面定义的6中类型，advice可以是上面5种中的前四种（无引介类型）

如果这里的pointcut是DynamicMethodMatcherPointcut,那么就创建了一个动态切面，这个pointcut即可进行静态检查，也可以进行动态检查，我们可以在静态检查中看那些连接点是不匹配的，动态检查中就不用检查这个了

[java] view plain copy print ?
  1. package com.baobaotao.advisor; 
  2. import java.lang.reflect.Method; 
  3. import java.util.ArrayList; 
  4. import java.util.List; 
  5. import org.springframework.aop.ClassFilter; 
  6. import org.springframework.aop.support.DynamicMethodMatcherPointcut; 
  7. public class GreetingDynamicPointcut extends DynamicMethodMatcherPointcut { 
  8.     private static List<String> specialClientList = new ArrayList<String>(); 
  9.     static { 
  10.         specialClientList.add("John"); 
  11.         specialClientList.add("Tom"); 
  12.     } 
  13.     public ClassFilter getClassFilter() { 
  14.         return new ClassFilter() { 
  15.             public boolean matches(Class clazz) { 
  16.                 System.out.println("调用getClassFilter()对"+clazz.getName()+"做静态检查."); 
  17.                 return Waiter.class.isAssignableFrom(clazz); 
  18.             } 
  19.         }; 
  20.     } 
  21.     public boolean matches(Method method, Class clazz) { 
  22.         System.out.println("调用matches(method,clazz)对"+clazz.getName()+"."+method.getName()+"做静态检查."); 
  23.         return "greetTo".equals(method.getName()); 
  24.     } 
  25.     public boolean matches(Method method, Class clazz, Object[] args) { 
  26.         System.out.println("调用matches(method,clazz,args)对"+clazz.getName()+"."+method.getName()+"做动态检查."); 
  27.         String clientName = (String) args[0]; 
  28.         return specialClientList.contains(clientName); 
  29.     } 
  30. }  
package com.baobaotao.advisor;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import org.springframework.aop.ClassFilter;
import org.springframework.aop.support.DynamicMethodMatcherPointcut;
public class GreetingDynamicPointcut extends DynamicMethodMatcherPointcut {
	private static List<String> specialClientList = new ArrayList<String>();
	static {
		specialClientList.add("John");
		specialClientList.add("Tom");
	}
	public ClassFilter getClassFilter() {
		return new ClassFilter() {
			public boolean matches(Class clazz) {
				System.out.println("调用getClassFilter()对"+clazz.getName()+"做静态检查.");
				return Waiter.class.isAssignableFrom(clazz);
			}
		};
	}
	public boolean matches(Method method, Class clazz) {
		System.out.println("调用matches(method,clazz)对"+clazz.getName()+"."+method.getName()+"做静态检查.");
		return "greetTo".equals(method.getName());
	}
	public boolean matches(Method method, Class clazz, Object[] args) {
		System.out.println("调用matches(method,clazz,args)对"+clazz.getName()+"."+method.getName()+"做动态检查.");
		String clientName = (String) args[0];
		return specialClientList.contains(clientName);
	}
}
[html] view plain copy print ?
  1. <bean id="waiterTarget" class="com.baobaotao.advisor.Waiter" /> 
  2. <bean id="sellerTarget" class="com.baobaotao.advisor.Seller" /> 
  3. <!-- 动态切面 --> 
  4. <bean id="dynamicAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor"> 
  5.     <property name="pointcut"> 
  6.         <bean class="com.baobaotao.advisor.GreetingDynamicPointcut" /> 
  7.     </property> 
  8.     <property name="advice"> 
  9.         <bean class="com.baobaotao.advisor.GreetingBeforeAdvice" /> 
  10.     </property> 
  11. </bean> 
  12.  
  13. <bean id="waiter2" class="org.springframework.aop.framework.ProxyFactoryBean" 
  14.     p:interceptorNames="dynamicAdvisor" p:target-ref="waiterTarget" 
  15.     p:proxyTargetClass="true" />  
	<bean id="waiterTarget" class="com.baobaotao.advisor.Waiter" />
	<bean id="sellerTarget" class="com.baobaotao.advisor.Seller" />
	<!-- 动态切面 -->
	<bean id="dynamicAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
		<property name="pointcut">
			<bean class="com.baobaotao.advisor.GreetingDynamicPointcut" />
		</property>
		<property name="advice">
			<bean class="com.baobaotao.advisor.GreetingBeforeAdvice" />
		</property>
	</bean>

	<bean id="waiter2" class="org.springframework.aop.framework.ProxyFactoryBean"
		p:interceptorNames="dynamicAdvisor" p:target-ref="waiterTarget"
		p:proxyTargetClass="true" />
[java] view plain copy print ?
  1. public static void main(String[] args) { 
  2.     ApplicationContext ctx=new ClassPathXmlApplicationContext("com/baobaotao/advisor/beans.xml"); 
  3.     Object obj=ctx.getBean("waiter2"); 
  4.     System.out.println("*******************"); 
  5.     Waiter waiter=(Waiter)obj; 
  6.     waiter.greetTo("ken");System.out.println("-----------------------"); 
  7.     waiter.greetTo("Tom");System.out.println("-----------------------"); 
  8.     waiter.greetTo("ken");   
  9. }  
	public static void main(String[] args) {
		ApplicationContext ctx=new ClassPathXmlApplicationContext("com/baobaotao/advisor/beans.xml");
		Object obj=ctx.getBean("waiter2");
		System.out.println("*******************");
		Waiter waiter=(Waiter)obj;
		waiter.greetTo("ken");System.out.println("-----------------------");
		waiter.greetTo("Tom");System.out.println("-----------------------");
		waiter.greetTo("ken");	
	}

运行结果如下：

调用getClassFilter()对com.baobaotao.advisor.Waiter做静态检查.
调用matches(method,clazz)对com.baobaotao.advisor.Waiter.greetTo做静态检查.
调用getClassFilter()对com.baobaotao.advisor.Waiter做静态检查.
调用matches(method,clazz)对com.baobaotao.advisor.Waiter.serveTo做静态检查.
调用getClassFilter()对com.baobaotao.advisor.Waiter做静态检查.
调用matches(method,clazz)对com.baobaotao.advisor.Waiter.clone做静态检查.
调用getClassFilter()对com.baobaotao.advisor.Waiter做静态检查.
调用matches(method,clazz)对com.baobaotao.advisor.Waiter.toString做静态检查.
*******************
调用getClassFilter()对com.baobaotao.advisor.Waiter做静态检查.
调用matches(method,clazz)对com.baobaotao.advisor.Waiter.greetTo做静态检查.
调用matches(method,clazz,args)对com.baobaotao.advisor.Waiter.greetTo做动态检查.
waiter greet to ken...
----------------
调用matches(method,clazz,args)对com.baobaotao.advisor.Waiter.greetTo做动态检查.
com.baobaotao.advisor.Waiter.greetTo
How are you！Mr.Tom.
waiter greet to Tom...
----------------
调用matches(method,clazz,args)对com.baobaotao.advisor.Waiter.greetTo做动态检查.
waiter greet to ken...

如果和ControlFowPointcut结合使用就叫流程切面，这里不详述了

2. NameMatchMethodPointcutAdvisor
NameMatchMethodPointcutAdvisor是细化后的DefaultPointcutAdvisor，它限定了自身可以使用的Pointcut类型为NameMatchMethodPointcut，并且外部不可更改。不过，对于使用的Advice来说，除了Introduction，其他任何类型的Advice都可以使用。
NameMatchMethodPointcutAdvisor内部持有一个NameMatchMethodPointcut类型的Pointcut实例。当通过NameMatchMethodPointcutAdvisor公开的setMappedName和setMappedNames方法设置将被拦截的方法名称的时候，实际上是在操作NameMatchMethodPointcutAdvisor所持有的这个NameMatchMethodPointcut实例。

[html] view plain copy print ?
  1. <bean id="advice" class="...">      ...  </bean>   
  2. <bean id="advisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">   
  3.     <property name="advice">   
  4.         <ref bean="advice"/>   
  5.     </property>   
  6.     <property name="mappedNames">   
  7.         <list>   
  8.             <value>method1</value>   
  9.             ...   
  10.         </list>   
  11.     </property>   
  12. </bean>  
<bean id="advice" class="...">      ...  </bean>  
<bean id="advisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">  
    <property name="advice">  
        <ref bean="advice"/>  
    </property>  
    <property name="mappedNames">  
        <list>  
            <value>method1</value>  
            ...  
        </list>  
    </property>  
</bean>

3. RegexpMethodPointcutAdvisor
与NameMatchMethodPointcutAdvisor类似，RegexpMethodPointcutAdvisor也限定了自身可以使用的Pointcut的类型，即只能通过正则表达式为其设置相应的Pointcut。
RegexpMethodPointcutAdvisor自身内部持有一个AbstractRegexpMethodPointcut的实例。AbstractRegexpMethodPointcut有两个实现类，即Perl5RegexpMethodPointcut和JdkRegexpMethodPointcut。默认情况下，RegexpMethodPointcutAdvisor会使用JdkRegexp- MethodPointcut。如果要强制使用Perl5RegexpMethodPointcut，那么可以通过RegexpMethod- PointcutAdvisor的setPerl5(boolean)达成所愿。
RegexpMethodPointcutAdvisor提供了许多构造方法，我们可以在构造时就指定Pointcut的正则表达式匹配模式以及相应的Advice，也可以构造完成之后再指定，在使用上与其他的Advisor实现并无太多差别。

[html] view plain copy print ?
  1. <bean id="advice" class="...">      ...  </bean>   
  2. <bean id="advisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">   
  3.     <property name="pattern">   
  4.         <value>cn\.spring21\..*\.methodNamePattern</value>   
  5.     </property>   
  6.     <property name="advice">   
  7.         <ref bean="advice"/>   
  8.     </property>   
  9.     <property name="perl5">   
  10.         <value>false</value>   
  11.     </property>   
  12. </bean>   
<bean id="advice" class="...">      ...  </bean>  
<bean id="advisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">  
    <property name="pattern">  
        <value>cn\.spring21\..*\.methodNamePattern</value>  
    </property>  
    <property name="advice">  
        <ref bean="advice"/>  
    </property>  
    <property name="perl5">  
        <value>false</value>  
    </property>  
</bean>

4. DefaultBeanFactoryPointcutAdvisor
DefaultBeanFactoryPointcutAdvisor是使用比较少的一个Advisor实现，因为自身绑定到了BeanFactory，所以要使用DefaultBeanFactoryPointcutAdvisor，我们的应用一定要绑定到Spring的IoC容器了。而且通常情况下，DefaultPointcutAdvisor已经完全可以满足需求。
DefaultBeanFactoryPointcutAdvisor的作用是，我们可以通过容器中的Advice注册的beanName来关联对应的Advice。只有当对应的Pointcut匹配成功之后，才去实例化对应的Advice，减少了容器启动初期Advisor和Advice之间的耦合性。

[html] view plain copy print ?
  1. <bean id="advice" class="...">  </bean>    
  2. <bean id="pointcut" class="org.springframework.aop.support.NameMatchMethodPointcut">   
  3.     <property name="mappedName" value="doSth"/>   
  4. </bean>   
  5. <bean id="advisor" class="org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor">   
  6.     <property name="pointcut" ref="pointcut"/>   
  7.     <property name="adviceBeanName" value="advice"/>   
  8. </bean>   
<bean id="advice" class="...">  </bean>   
<bean id="pointcut" class="org.springframework.aop.support.NameMatchMethodPointcut">  
    <property name="mappedName" value="doSth"/>  
</bean>  
<bean id="advisor" class="org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor">  
    <property name="pointcut" ref="pointcut"/>  
    <property name="adviceBeanName" value="advice"/>  
</bean>

注意，对应advice的配置属性名称为"adviceBeanName"，而它的值就对应advice的beanName。除了这一点，与DefaultPointcutAdvisor使用一致。
5.StaticMethodMatcherPointcutAdvisor静态普通方法名匹配切面

[java] view plain copy print ?
  1. import java.lang.reflect.Method; 
  2. import org.springframework.aop.ClassFilter; 
  3. import org.springframework.aop.support.StaticMethodMatcherPointcutAdvisor; 
  4. public class GreetingAdvisor extends StaticMethodMatcherPointcutAdvisor { 
  5.     @Override 
  6.     public boolean matches(Method method, Class clazz) { 
  7.         return "greetTo".equals(method.getName()); 
  8.     }    
  9.     @Override 
  10.     public ClassFilter getClassFilter(){ 
  11.         return new ClassFilter(){ 
  12.             public boolean matches(Class clazz){ 
  13.                 return Waiter.class.isAssignableFrom(clazz); 
  14.             } 
  15.         }; 
  16.     } 
  17. }  
import java.lang.reflect.Method;
import org.springframework.aop.ClassFilter;
import org.springframework.aop.support.StaticMethodMatcherPointcutAdvisor;
public class GreetingAdvisor extends StaticMethodMatcherPointcutAdvisor {
	@Override
	public boolean matches(Method method, Class clazz) {
		return "greetTo".equals(method.getName());
	}	
	@Override
	public ClassFilter getClassFilter(){
		return new ClassFilter(){
			public boolean matches(Class clazz){
				return Waiter.class.isAssignableFrom(clazz);
			}
		};
	}
}
[html] view plain copy print ?
  1. <bean id="waiterTarget" class="com.baobaotao.advisor.Waiter" /> 
  2. <bean id="sellerTarget" class="com.baobaotao.advisor.Seller" /> 
  3.  
  4. <bean id="greetingAdvice" class="com.baobaotao.advisor.GreetingBeforeAdvice" /> 
  5. <bean id="greetingAdvisor" class="com.baobaotao.advisor.GreetingAdvisor" 
  6.     p:advice-ref="greetingAdvice" /> 
  7.      
  8. <bean id="parent" abstract="true" 
  9.     class="org.springframework.aop.framework.ProxyFactoryBean" 
  10.     p:interceptorNames="greetingAdvisor"  
  11.     p:proxyTargetClass="true" /> 
  12.      
  13. <bean id="waiter" parent="parent" p:target-ref="waiterTarget" /> 
  14. <bean id="seller" parent="parent" p:target-ref="sellerTarget" />  
	<bean id="waiterTarget" class="com.baobaotao.advisor.Waiter" />
	<bean id="sellerTarget" class="com.baobaotao.advisor.Seller" />
	
	<bean id="greetingAdvice" class="com.baobaotao.advisor.GreetingBeforeAdvice" />
	<bean id="greetingAdvisor" class="com.baobaotao.advisor.GreetingAdvisor"
		p:advice-ref="greetingAdvice" />
		
	<bean id="parent" abstract="true"
		class="org.springframework.aop.framework.ProxyFactoryBean"
		p:interceptorNames="greetingAdvisor" 
		p:proxyTargetClass="true" />
		
	<bean id="waiter" parent="parent" p:target-ref="waiterTarget" />
	<bean id="seller" parent="parent" p:target-ref="sellerTarget" />

ClassFilter是类过滤器，这里表示只过滤Waiter类

6.AspectJExpressionPointcutAdvisor  可以定义aspectJ表达式

[html] view plain copy print ?
  1. <bean id="audienceAdvisor" class="org.springframework.aop.aspectj.AspectJExpressionPointcutAdvisor">   
  2.     <property name="advice" ref="audienceAdvice" />   
  3.     <property name="expression" value="execution(* Performer+.perform(..))" />   
  4. </bean>    
<bean id="audienceAdvisor" class="org.springframework.aop.aspectj.AspectJExpressionPointcutAdvisor">  
    <property name="advice" ref="audienceAdvice" />  
    <property name="expression" value="execution(* Performer+.perform(..))" />  
</bean>

对应的pointcut是org.springframework.aop.aspectj.AspectJExpressionPointcut

[html] view plain copy print ?
  1. <bean id="performancePointcut" class="org.springframework.aop.aspectj.AspectJExpressionPointcut">   
  2.     <property name="expression" value="execution(* Performer+.perform(..))" />   
  3. </bean>  
<bean id="performancePointcut" class="org.springframework.aop.aspectj.AspectJExpressionPointcut">  
    <property name="expression" value="execution(* Performer+.perform(..))" />  
</bean>



7.AspectJPointcutAdvisor

[java] view plain copy print ?
  1. public AspectJPointcutAdvisor(AbstractAspectJAdvice advice) 
  2. //Create a new AspectJPointcutAdvisor for the given advice  
public AspectJPointcutAdvisor(AbstractAspectJAdvice advice)
//Create a new AspectJPointcutAdvisor for the given advice

AbstractAspectJAdvice的子类:AspectJAfterAdvice, AspectJAfterReturningAdvice, AspectJAfterThrowingAdvice, AspectJAroundAdvice, AspectJMethodBeforeAdvice

这些advisor的实现类，都可以在pointcut中找到对应的类，因为他们本来就是通过扩张对应pointcut的实现类并实现PointcutAdvisor接口而产生的。

 
  
 
  
 关于使用@Aspect和aop空间参考博客@Aspect 和 aop命名空间 
 
 
 
 
 


                

        

        

    

  


    

      

        

            

              
                
                  拎包客
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
SpringAOP(图文详解)

				
			

			

				

					lhj520cb的博客
				

				

					07-16
					
					4万+
					
				

			

		

		

			
				
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。

			
		

	



                

              
                



	

		

			

				
					
Spring源码分析----AOP概念(Advice,Pointcut,Advisor)和AOP的设计与实现

				
			

			

				

					a657281084的博客
				

				

					11-13
					
					4798
					
				

			

		

		

			
				
一、基本知识
1.1.AOP基本概念：
  Aspect-Oriented Programming，面向方面编程的简称，Aspect是一种新的模块化机制，用来描述分散在对象、类或方法中的横切关注点(crosscutting concern)，从关注点中分离出横切关注点是面向方面程序设计的核心所在。分离关注点使得解决特定领域问题的代码从业务逻辑中独立出来，业务逻辑的代码中不再含有针对特定领域

			
		

	



                


  
              

                


	

		

			

				
					
Spring3系列10- Spring AOP——Pointcut，Advisor拦截指定方法

				
			

			

				

					weixin_33827965的博客
				

				

					02-20
					
					431
					
				

			

		

		

			
				
Spring3系列10- Spring AOP——Pointcut，Advisor
 
　　上一篇的Spring AOP Advice例子中，Class（CustomerService）中的全部method都被自动的拦截了。但是大多情况下，你只需要一个方法去拦截一两个method。这样就引入了Pointcut（切入点）的概念，它允许你根据method的名字去拦截指定的method。另外，一个P...

			
		

	





	

		

			

				
					
Spring中PointcutAdvisor和IntroductionAdvisor梳理

					
最新发布

				
			

			

				

					weixin_37862824的博客
				

				

					10-13
					
					1040
					
				

			

		

		

			
				
Advisor是SpringAOP的顶层抽象，用来管理Advice和PointcutSpring中有五种增强：BeforeAdvide（前置增强）、AfterAdvice（后置增强）、RoundAdvice（环绕增强）、ThrowsAdvice（异常增强）、IntroductionAdvice（引介增强）。前面4种大家比较熟悉，引介增强我下面会单独说。主要表达目标类或者目标方法Advisor是继承体系主要有和，PointcutAdvisor与IntroductionAdvisor最本质上的区别就是。

			
		

	



		

			
		



	

		

			

				
					
Spring AOP名词解释Advice,Pointcut,Advisor,Joinpoint,Advised是什么？

				
			

			

				

					yangzsirr的博客
				

				

					10-22
					
					3458
					
				

			

		

		

			
				
Advice

advice解释为通知，需要执行的增强逻辑方法。

advice规范接口如图，分为了before，after等等，为什么没有around呢，因为是通过interceptor实现的。



这里可以看出，AfterAdvice最终会被转换包装成MethodBeforeAdviceInterceptor实现类进行适配桥接，同理BeforeAdvice也会被包装成MethodBeforeAdviceInterceptor最终调用MethodIntercepter#invoke()方法进行适配。



			
		

	





	

		

			

				
					
Spring 5 - Advisors和Pointcuts

				
			

			

				

					weixin_43364172的博客
				

				

					11-26
					
					511
					
				

			

		

		

			
				
Spring 5 - Advisors和PointcutsPointcut有效的Pointcut实现使用DefaultPointcutAdvisor使用StaticMethodMatcherPointcut增加静态Pointcut使用DyanmicMethodMatcherPointcut增加动态Pointcut简单的名称匹配使用正则表达式增加Pointcuts增加注解匹配的Pointcuts
P...

			
		

	





	

		

			

				
					
Spring AOP 16道面试题及答案.docx

				
			

			

				

					06-29
				

			

		

		

			
				
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...

			
		

	





	

		

			

				
					
SpringAOP:Spring AOP示例

				
			

			

				

					05-06
				

			

		

		

			
				
SpringAOP  Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行...

			
		

	





	

		

			

				
					
Spring源码最难问题：当Spring AOP遇上循环依赖.docx

				
			

			

				

					06-15
				

			

		

		

			
				
Spring源码最难问题：当Spring AOP遇上循环依赖   Spring源码中最难的问题之一是循环依赖问题，当Spring AOP遇上循环依赖时，该如何解决？ Spring通过三级缓存机制解决循环依赖的问题。  在Spring中，bean的实例化...

			
		

	





	

		

			

				
					
Spring总结

				
			

			

				

					qq_44837912的博客
				

				

					12-30
					
					239
					
				

			

		

		

			
				
一. 简介


什么是Spring ？
Spring是一个开源的轻量级的IoC和AOP容器框架。简化了企业应用程序的开发，使得开发者只需关心业务需求。


什么是IoC ？
Spring IoC即控制反转，其作用是管理所有的Bean，相当于一个容器。首先将javaBean加载到容器中，如果我需要使用javaBean时直接从容器中获取，使用结束也无需销毁，再放回容器中即可，避免了手动创建和销毁jav...

			
		

	





	

		

			

				
					
Spring入门第2天--面向切面编程入门

				
			

			

				

					lutianfei的专栏
				

				

					06-23
					
					5021
					
				

			

		

		

			
				
AOP的概述
什么是AOP
AOP底层原理
Spring的AOP代理
AOP的术语
AOP的底层实现
CGLIB动态代理
代理知识总结
Spring中的AOP
Spring的传统AOP
Spring中的通知(增强类型)
Spring中的切面类型
Spring的AOP的开发
自动代理
使用AspectJ实现AOP
AspectJ表达式
AspectJ的通知类型
基于注解方式配置切面
基于XML配置切面

			
		

	





	

		

			

				
					
Java Web Spring核心之AOP的解析及实战(AOP的实现、切入点、Aspect Spring的持久化 Hibernate)

				
			

			

				

					showswoller的博客
				

				

					10-13
					
					1012
					
				

			

		

		

			
				
Java Web Spring核心之AOP的解析及实战(AOP的实现、切入点、Aspect Spring的持久化 Hibernate)

			
		

	





	

		

			

				
					
Spring中的Advisor，Advice，Pointcut

				
			

			

				

					qq_42949806的博客
				

				

					01-07
					
					703
					
				

			

		

		

			
				
Spring中的Advisor，Advice，Point概述

 

1、Advisor：充当Advice和Pointcut的适配器，类似使用Aspect的@Aspect注解的类（前一章节所述）。一般有advice和pointcut属性。

祖先接口为org.springframework.aop.Advisor,应用中可直接使用org.springframework.aop.support.De...

			
		

	





	

		

			

				
					
Spring AOP中定义切点（PointCut）和通知（Advice）

				
			

			

				

					GarfieldEr007的专栏
				

				

					09-21
					
					1766
					
				

			

		

		

			
				
本文讨论一下Spring AOP编程中的两个关键问题，定义切点和定义通知，理解这两个问题能应付大部分AOP场景。
如果你还不熟悉AOP，请先看AOP基本原理，本文的例子也沿用了AOP基本原理中的例子。

切点表达式
切点的功能是指出切面的通知应该从哪里织入应用的执行流。切面只能织入公共方法。
在Spring AOP中，使用AspectJ的切点表达式语言定义切点其中excecution()

			
		

	





	

		

			

				
					
AOP中通知(advice)、切点（pointcut）和连接点（join point）的概念

				
			

			

				

					u011230736的专栏
				

				

					09-01
					
					1万+
					
				

			

		

		

			
				
借助Spring框架的帮助，业务模块被合理的纵向分割，彼此之间互相独立。
而将这些纵向柱形的业务模块共同的，重复的部分横向切分放大，就称之为切面
在AOP中，描述切面的术语有通知（advice），切点（pointcut），连接点（join point）。
通知（advice）：
它用于描述切面的目标 即切面必须要完成的工作。通知定义了切面是什么以及何时使用。
SpringAOP可以应用5

			
		

	





	

		

			

				
					
Spring原理简单分析

				
			

			

				

					奔跑的小车车博客专栏
				

				

					01-16
					
					1747
					
				

			

		

		

			
				
本文知识点主要来自Spring技术内幕：深入解析Spring架构与设计原理(第2版) 。
1.spring设计理念
操作系统关心的是对存储、计算、通信、外围设备等物理资源的管理，为用户提供一个统一的服务接口。
而spring其关心的是一些企业应用资源的使用，比如数据的持久化，数据集成、事务处理、消息中间件、分布式计算等高效可靠处理企业数据方法的技术抽象。

把spring划分为三个层次核

			
		

	





	

		

			

				
					
Druid数据库连接池监控的使用

					
热门推荐

				
			

			

				

					学习
				

				

					11-02
					
					2万+
					
				

			

		

		

			
				
Druid数据库连接池
1. Druid是什么？
Druid是Java语言中最好的数据库连接池，由阿里巴巴团队开发。Druid能够提供强大的监控和扩展功能。
github地址为https://github.com/alibaba/druid，有丰富的中文文档和常见问题的解答，非常方便。
2. 如何在springboot项目中使用？
2.1 首先引入依赖
	
		 &amp;amp;amp;amp;lt;dependency&amp;amp;amp;amp;gt...

			
		

	





	

		

			

				
					
spring aop  

				
			

			

				

					09-11
				

			

		

		

			
				
Spring AOP（Aspect-Oriented Programming）是Spring框架中的一个重要特性，它提供了一种在应用程序中实现横切关注点（cross-cutting concerns）的方法。所谓横切关注点，指的是那些在应用程序中散布于各个模块之中...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值