Spring(三)：注解式AOP的使用

　　Spring 支持 AspectJ的注解式切面编程。AOP可以让一组类共享相同的行为。

注解

1. 使用@Aspect声明一个切面。
2. 使用@After,@Before,@Around定义建言(Advice),可以直接拦截规则(切点)作为参数。
3. 其中**@After,@Before,@Around参数的拦截规则为切点(PointCut)，为了使切点复用，可使用@PointCut专门定义拦截规则，然后在@After,@Before,@Around**的参数中调用。
4. 其中符合条件的每一个被拦截处为连接点(JoinPoint)。

示例

1. 编写拦截规则的注解

   package com.aop;
   
   import java.lang.annotation.Documented;
   import java.lang.annotation.ElementType;
   import java.lang.annotation.Retention;
   import java.lang.annotation.RetentionPolicy;
   import java.lang.annotation.Target;
   
   @Target(ElementType.METHOD)
   @Retention(RetentionPolicy.RUNTIME)
   @Documented
   public @interface Action {
   	String name();
   }

2. 编写使用注解的被拦截的类

   package com.aop;
   
   import org.springframework.stereotype.Service;
   
   @Service
   public class DemoAnnotationService {
   	@Action(name="注解释拦截的add操作")
   	public void add() {
   		System.out.println("DemoAnnotationService ---");
   		
   	}
   }

3. 编写使用方法规则的被拦截的类

   package com.aop;
   
   import org.springframework.stereotype.Service;
   
   @Service
   public class DemoMethodService {
   	
   	public void add() {
   		System.out.println("DemoMethodService ---");
   	}
   
   }

4. 编写切点

   package com.aop;
   
   import java.lang.reflect.Method;
   
   import org.aspectj.lang.JoinPoint;
   import org.aspectj.lang.annotation.After;
   import org.aspectj.lang.annotation.Aspect;
   import org.aspectj.lang.annotation.Before;
   import org.aspectj.lang.annotation.Pointcut;
   import org.aspectj.lang.reflect.MethodSignature;
   import org.springframework.stereotype.Component;
   
   @Aspect	//声明一个切面
   @Component	//成为spring容器中的一个Bean
   public class LogAspect {
   	
   	@Pointcut("@annotation(com.aop.Action)")//声明切点
   	public void annotationPointCut() {};
   	
   	@After("annotationPointCut()")	//声明建言，并使用@Pointcut定义切点
   	public void after(JoinPoint joinPoint) {
   		MethodSignature signature = (MethodSignature) joinPoint.getSignature();
   		Method method = signature.getMethod();
   		Action action = method.getAnnotation(Action.class);
   		System.out.println("注解式拦截，在方法执行之后拦截： " + action.name());//通过反射获取注解上的属性
   	}
   	
   	@Before("execution(* com.aop.DemoMethodService.*(..))")
   	public void before(JoinPoint joinPoint) {
   		MethodSignature signature = (MethodSignature) joinPoint.getSignature();
   		Method method = signature.getMethod();
   		System.out.println("方法规则式拦截,方法执行之前拦截：" + method.getName());
   	}
   
   }

5. 编写配置类

   package com.aop;
   
   import org.springframework.context.annotation.ComponentScan;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.context.annotation.EnableAspectJAutoProxy;
   
   @Configuration
   @ComponentScan("com.aop")
   @EnableAspectJAutoProxy//开启spring对AspectJ的支持
   public class AopConfig {
   	
   }

6. 运行测试

   package com.aop;
   
   import org.springframework.context.annotation.AnnotationConfigApplicationContext;
   
   public class AopMain {
   	
   	public static void main(String[] args) {
   		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AopConfig.class);
   		
   		DemoAnnotationService demoAnnotationService = context.getBean(DemoAnnotationService.class);
   		DemoMethodService demoMethodService = context.getBean(DemoMethodService.class);
   		
   		demoAnnotationService.add();
   		demoMethodService.add();
   		
   		context.close();
   	}
   }

7. 运行结果

   DemoAnnotationService ---
   注解式拦截，在方法执行之后拦截： 注解释拦截的add操作
   方法规则式拦截,方法执行之前拦截：add
   DemoMethodService ---