Spring AOP使用整理：常用的AutoProxyCreator

一、自动代理创建器

      创建器是BeanPostProcessor的子类。

 

     1、BeanNameAutoProxyCreator： 根据Bean名自动代理

           通过Spring的ProxyFactory对目标bean进行代理，Advice自动包装成PointcutAdvisor。

@Bean
public BeanNameAutoProxyCreator beanNameAutoProxyCreator(){
	BeanNameAutoProxyCreator creator = new BeanNameAutoProxyCreator();
	creator.setBeanNames("*Mapper");  
	creator.setInterceptorNames("customMethodInterceptor");
	return creator;
}

@Bean
public CustomMethodInterceptor customMethodInterceptor(){
	CustomMethodInterceptor interceptor = new CustomMethodInterceptor();
	return interceptor;
}

 

     2、DefaultAdvisorAutoProxyCreator

          DefaultAdvisorAutoProxyCreator自动查找配置文件中定义的所有Advisor，并将它们作用于所有的Bean。

@Bean
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
	DefaultAdvisorAutoProxyCreator creator = new DefaultAdvisorAutoProxyCreator();
	creator.setProxyTargetClass(true);
	return creator;
}

@Bean  
public NameMatchMethodPointcutAdvisor getNameMatchMethodPointcutAdvisor() {
	NameMatchMethodPointcutAdvisor advisor = new NameMatchMethodPointcutAdvisor();
	advisor.setAdvice(new CustomMethodInterceptor());
	advisor.setMappedName("*show*");
	advisor.addMethodName("show");
	return advisor;
}

 

      3、AnnotationAwareAspectJAutoProxyCreator

             具有DefaultAdvisorAutoProxyCreator的功能，即自动查找配置文件中定义的所有Advisor，并将它们作用于所有的Bean。

             同时也支持自动将标注有@Aspect注解的切面类织入到目标bean中，等价于 <aop:aspectj-autoproxy />

//Aspect类
@Aspect
public class MyAspect {
	@Pointcut("execution(* com.seasy.springboottest..*(..))")
    private void commonPointcut() {}

    @Before("commonPointcut()")
    public void beforeMethod(JoinPoint point) {
        String methodName = point.getSignature().getName();
        System.out.println("-----------before-----------" + methodName);
    }
    
    @After("commonPointcut()")
    public void afterMethod(JoinPoint point){
        String methodName = point.getSignature().getName();
        System.out.println("-----------after-----------" + methodName);
    }
    
    @AfterReturning(value="execution(* com.seasy.springboottest..*(..))", returning="result")
    public void afterReturningMethod(JoinPoint point, Object result){
        String methodName = point.getSignature().getName();
        System.out.println("methodName=" + methodName + ", result=" + result);
    }
    
    @AfterThrowing(value="execution(* com.seasy.springboottest..*(..))", throwing="ex")
    public void afterThorwingMethod(JoinPoint point, Exception ex){
        String methodName = point.getSignature().getName();
        System.out.println("methodName=" + methodName + ", exception: " + ex);
    }
    
    @Around(value="execution(* com.seasy.springboottest..*(..))")
    public Object aroundMethod(ProceedingJoinPoint invocation) throws Throwable{
    	System.out.println("around start");
    	Object result = invocation.proceed();
    	System.out.println("around end");
    	return result;
    }
}

//配置类
@Configuration
public class AnnotationAwareAspectJAutoProxyConfig {
	@Bean
	public CountryMapper countryMapper(){
		CountryMapper countryMapper = new CountryMapperImpl();
		return countryMapper;
	}
	
	@Bean
	public MyAspect myAspect(){
		return new MyAspect();
	}
	
	@Bean
	public AnnotationAwareAspectJAutoProxyCreator annotationAwareAspectJAutoProxyCreator(){
		AnnotationAwareAspectJAutoProxyCreator creator = new AnnotationAwareAspectJAutoProxyCreator();
		creator.setProxyTargetClass(true);
		return creator;
	}
}

//测试类
public class AnnotationAwareAspectJAutoProxyConfigTest {
	public static void main(String[] args) {
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AnnotationAwareAspectJAutoProxyConfig.class);
        CountryMapper countryMapper = applicationContext.getBean(CountryMapper.class);
        countryMapper.show();
	}
}

 

四、基于aop命名空间的AOP

     1、切面类MyAspect的源码

public class MyAspect {
	public void BeforeAdvice(JoinPoint point){
		PersonImpl p = (PersonImpl)point.getTarget();
	}
	
	public void AfterAdvice(JoinPoint point){
		PersonImpl p = (PersonImpl)point.getTarget();
	}
	
	public void AfterReturningAdvice(Object retValue){
		System.out.println(retValue);
	}
	
	public void AroundAdvice(ProceedingJoinPoint point)throws Throwable{
		System.out.println("AroundAdvice >> 目标对象 前");
		point.proceed(point.getArgs());
		System.out.println("AroundAdvice >> 目标对象 后");
	}
	
	public void ThrowingAdvice(Throwable throwing)throws Throwable{
		System.out.println(throwing);
	}
}

 

     2、配置

<!-- 切面受管Bean -->
<bean id="myAspect" class="com.cjm.aop.MyAspect"/>

<aop:config proxy-target-class="true">
	<!-- 声明一个切面 -->
	<aop:aspect ref="myAspect" order="0">
		<!-- 声明一个切入点 -->
		<aop:pointcut id="pointcut1" expression="execution(* com.cjm.aop..*(..))"/>
		
		<!-- 声明通知 -->
		<aop:before pointcut-ref="pointcut1" method="BeforeAdvice"/>
		<aop:after pointcut-ref="pointcut1" method="AfterAdvice"/>
		<aop:after-returning pointcut-ref="pointcut1" method="AfterReturningAdvice" returning="retValue"/>
		<aop:around pointcut-ref="pointcut1" method="AroundAdvice"/>
		<aop:after-throwing pointcut-ref="pointcut1" method="ThrowingAdvice" throwing="throwing"/>
	</aop:aspect>
</aop:config>