Spring基础配置（AOP切面编程）

一、AOP切面编程的简要说明

AOP:面向切面编程，相对于OOP面向对象编程

Spring的AOP的存在目的就是为了解耦。AOP可以让一组类共享相同行为。在OOP中只能

通过继承类和实现接口，来使代码的耦合度增强，且类继承只能为单继承，阻碍更多行为添加到一组类 上，AOP弥补了OOP的不足

Spring 支持AspectJ的注解式切面编程

1、使用@Aspect声明是一个切面

2、使用@After、@Before、@Around定义建言(advice)，可直接将拦截规则（切点）作为参数

3、其中@After、@Before、@Around参数的拦截规则作为切点（PointCut）,为了使切点复用，可使

@PointCut专门定义拦截规则，然后在@After、@Before、@Around的参数中调用。

4、其中符合条件的每一个被拦截处为连接点（JoinPoint）

二、示例说明

package service.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();
}

//编写使用注解的被拦截类
package service.aop;
import org.springframework.stereotype.Service;
@Service
public class DemoAnnotationService {
@Action(name="注解拦截式add()")
public void add(){}
}

//编写使用方法的被拦截类
package service.aop;
import org.springframework.stereotype.Service;
@Service
public class DemoMethodService {
public void add(){}
}

package service.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;
/*
* AOP:面向切面编程，相对于OOP面向对象编程
* Spring的AOP的存在目的就是为了解耦。AOP可以让一组类共享相同行为。在OOP中只能
* 通过继承类和实现接口，来使代码的耦合度增强，且类继承只能为单继承，阻碍更多行为添加到一组类上，AOP弥补了OOP的不足
* Spring 支持AspectJ的注解式切面编程
* 1、使用@Aspect声明是一个切面
* 2、使用@After、@Before、@Around定义建言(advice)，可直接将拦截规则（切点）作为参数
* 3、其中@After、@Before、@Around参数的拦截规则作为切点（PointCut）,为了使切点复用，可使
*    @PointCut专门定义拦截规则，然后在@After、@Before、@Around的参数中调用。
* 4、其中符合条件的每一个被拦截处为连接点（JoinPoint）
*/
//使用@Aspect声明是一个切面
@Aspect
//通过@Component让此切面成为Spring容器管理的Bean
@Component
public class LogAspect {
//@PointCut专门定义拦截规则，然后在@After、@Before、@Around的参数中调用。
@Pointcut("@annotation(service.aop.Action)")
public void annotationPointCut(){};
//使用@After、@Before、@Around定义建言(advice)，可直接将拦截规则（切点）作为参数
@After("annotationPointCut()")
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注解声明一个建言，此建言直接使用拦截规则作为参数
@Before("execution(* service.aop.DemoMethodService.*(..))")
public void before(JoinPoint joinPoint){
MethodSignature signature=(MethodSignature) joinPoint.getSignature();
Method method=signature.getMethod();
System.out.println("方法式拦截,"+method.getName());

}
}

package service.aop;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@Configuration
@ComponentScan("service.aop")
//使用@EnableAspectJAutoProxy注解开启Spring对AspectJ代理的支持
@EnableAspectJAutoProxy
public class AopConfig {

}

package service.aop;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class Main {
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();
}
}