关于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的注解