spring基础2（AOP）

1、基本概念

​ 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

​ web层级设计中，web层->网关层->服务层->数据层，每一层之间也是一个切面。编程中，对象与对象之间，方法与方法之间，模块与模块之间都是一个个切面。

​ 将方法注入到接口调用的某个地方（切点）。这样接口只需要关心具体的业务，而不需要关注其他非该接口关注的逻辑或处理。
红框处，就是面向切面编程。

2、相关名词

Aspect（切面）： 切面 声明类似于 Java 中的类声明，在 切面中会包含着一些切点 以及相应的通知。
Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 连接点。
Pointcut（切点）：表示一组连接点，这些连接点 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。
Advice（通知）：通知 定义了在 切点 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
Target（目标对象）：织入 通知的目标对象.。
Weaving（织入）：将 切面 和其他对象连接起来, 并创建 Adviced object 的过程

3、代码实现

（1）导入依赖

<dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.9.9.1</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.21</version>
        <scope>runtime</scope>
    </dependency>

（2）pojo

​ Person

public interface Person {
    String buy();
}

​ Boy

@Repository
public class Boy implements Person{
    @Override
    public String buy() {
        System.out.println("男孩购买游戏机");
        return "游戏机";
    }
}

​ Girl

@Repository
public class Girl implements Person {
    @Override
    public String buy() {
        System.out.println("女孩购买衣服");
        return "衣服";
    }
}

（3）切面类

​ 切面类依旧需要使用 @Component注解实现Spring托管，使用@Aspect注解声明为切面类， @Befor、@After、@AfterReturning、@Around注解都是通知类型，括号内是AspectJ的切点表达式，@Pointcut注解可以直接封装一个切点表达式，方便后续使用。

​ 切点表达式规则：

@Aspect
@Component
public class MyAdvice {
    @Pointcut("execution(* com.zhangxin.pojo.Person.buy(..))")  // 定义命名的切点
    public void performance() {

    }
    @Before("execution(* com.zhangxin.pojo.Person.*(..))")
    public void before(){
        System.out.println("before...");
    }
    @After("performance()")
    public void after() {
        System.out.println("After ...");
    }

    @AfterReturning("performance()")
    public void afterReturning() {
        System.out.println("AfterReturning ...");
    }
    @Around("performance()")
    public void around(ProceedingJoinPoint pj) {
        try {
            System.out.println("Around 1");
            pj.proceed();
            System.out.println("Around 2");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
}

（4）配置类

​ 出现了之前没有的注解@EnableAspectJAutoProxy(proxyTargetClass = true)，表示开启AOP，因为spring默认是关闭的，另外需要扫描两个包。

@Configuration
@ComponentScan({"com.zhangxin.pojo","com.zhangxin.advice"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class MyConfig {
}

（5）Test

public class MyTest {
    @Test
    public void test1(){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        Boy boy = context.getBean("boy", Boy.class);
        Girl girl = context.getBean("girl", Girl.class);
        boy.buy();
        girl.buy();
    }
}

测试结果：

（6）利用@Around读取参数

pojo

@Component
public class User {
    public void test(String string){
         System.out.println("传入参数是："+string);
     }
}

切面类、

@Aspect
@Component
public class MyAdvice2 {
    @Pointcut("execution(* com.zhangxin.pojo.User.test(String))&& args(string)")  // 定义命名的切点
    public void performance(String string) {
    }
    @Around("performance(string)")
    public void around(ProceedingJoinPoint pj,String string) {
        try {
            pj.proceed();
            System.out.println("读取的参数是："+string);
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
}

test

    @Test
    public void test2(){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        User user = context.getBean("user", User.class);
        user.test("1212121");
    }

结果