关于spring: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 已偿还");
    }
}

执行

应用 AoP
1、在 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 的注解