Spring AOP编程思想(注解开发实现)

概念

AOP(Aspect Oriented Programming)面向切面编程，是一种编程思想。可以在不惊动原始设计的基础上为方法进行功能上的增强。

1、代理：Spring下的AoP中，实现的核心本质是利用代理模式来实现的2、连接点：在Spring下的AoP中，可以理解为任意方法的执行3、切入点：匹配连接点的式子，是对具有共性功能的方法的描述（可以是一个方法，也可以是多个方法）4、通知：若干个方法的共性功能在切入点处执行，最终体现为一个方法5、切面：描述通知与切入点之间的关系

写一个简单的程序来感受一下。

使用AoP之前1、入口类

public class ApplicationDemo {

    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.borrowBook();
        bookDao.returnBook();
    }
}

2、SpringConfig类

@Configuration
@ComponentScan("pers.happyfan")
public class SpringConfig {

}

3、BookDao接口

public interface BookDao {
    void borrowBook();
    void returnBook();
}

4、BookDaoImpl实现类

@Service
public class BookDaoImpl implements BookDao {

    @Override
    public void borrowBook() {
        System.out.println("书籍A被借阅");
    }

    @Override
    public void returnBook() {
        System.out.println("书籍A已归还");
    }
}

执行

使用AoP1、在POM文件中导入对应的坐标

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.4</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>
    </dependencies>

2、创建AopProxy类，在这个类中设立切入点、通知与切面

package pers.happyfan;

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.springframework.stereotype.Component;

@Component
@Aspect
public class AopProxy {
    //定义切入点
    @Pointcut("execution(void pers.happyfan.dao.BookDao.borrowBook())")//匹配切入点的式子
    public void proBorrow(){

    }

    @Pointcut("execution(void pers.happyfan.dao.BookDao.returnBook())")
    public void proReturn(){

    }
    //切面，描述切面于通知之间的对应关系
    @Before("proBorrow()")
    //通知
    public void methodBorrow(){
        System.out.println("happyfan来借阅了");
    }

    @After("proReturn()")
    public void methodReturn(){
        System.out.println("happyfan已归还");
    }
}

其中@Before与@After注解是来告诉Spring通知执行的时机，其中的值表示这个通知与哪一个切入点绑定关系。

@Pointcut注解是用于定义切入点的，使用execution()方法来描述切入到哪一个连接点(一个方法)，要携带一个没有参数、没有返回值、没有任何逻辑的方法作为与通知进行绑定。

@Aspect注解是告诉Spring，把这个bean当作AoP来处理

3、在SpringConfig配置类中添加新的注解

@Configuration //将这个类设置为配置类
@ComponentScan("pers.happyfan") //扫描这个路径下的所有的包，找到交给IoC管理的bean
@EnableAspectJAutoProxy //启动了AOP
public class SpringConfig {

}

4、入口类

public class ApplicationDemo {

    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.borrowBook();
        bookDao.returnBook();
    }

}

可以看到，在没有改变入口类、BookDao接口以及BookDao的实现类BookDaoImpl的情况下，就让borrowBook()、returnBook()两个方法进行了增强。使用AoP的好处就是，如果原有的代码不能改动或者改动的代价很大，就可以利用这种方式来给原有的方法新增功能。

总结

实现AoP一共做了两件事情：1、创建了一个类，在这个类中设立切入点、通知以及切面。2、在配置类中添加启动AoP的注解