Spring 学习之路（八）：Spring 中的AOP（一）：aop初步了解

为什么需要AOP（面向切面编程）

• 先看一段代码

- 定义一个接口

public interface People {

    void eat(String tool); 

    void say(String language);
}

- 定义接口的实现类

public class Chinese implements People{

    private String name;
    //...

    @Override
    public void eat(String tool) {
//      System.out.println(this.name+"是一个中国人");
        System.out.println("我用"+tool+"吃饭");
    }

    @Override
    public void say(String language) {
//      System.out.println(this.name+"是一个中国人");
        System.out.println("我说"+language);
    }
}

- 测试

@Test
    void test() {

        People people = new Chinese("cris");
        people.eat("筷子");
        people.say("中文");

    }

console:

• 咋看之下，这段代码执行没有什么问题，但是如果要求实现类的每个方法都需要加上”cris是一个中国人”(日志),我们势必要一个方法一个方法的添加，这样做不仅重复，也大大的增加后期维护成本（如果需求改了，要把cris是一个中国人改为cris是一个日本妞，自己想想有多恶心）
• 所以，aop 应运而生

aop 解决的问题

• 就像上面的代码一样，面向切面编程主要解决了以下问题

  1. 代码混乱：越来越多的非业务需求(日志和验证等)加入后, 原有的业务方法急剧膨胀. 每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点.

  2. 代码分散: 以日志需求为例, 只是为了满足这个单一需求, 就不得不在多个模块（方法）里多次重复相同的日志代码. 如果日志需求发生变化, 必须修改所有模块.

什么是 aop？

• aop的核心就是 动态代理 （这部分我之前的笔记有很详细的解读，有时间我把笔记整理一下贴出来）

• 动态代理的原理: 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上

• 如图：

• AOP(Aspect-Oriented Programming, 面向切面编程): 是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充.
• AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点.

• 在应用 AOP 编程时, 仍然需要定义公共功能, 但可以明确的定义这个功能在哪里, 以什么方式应用, 并且不必修改受影响的类. 这样一来横切关注点就被模块化到特殊的对象(切面)里.

• AOP 的好处:

  1. 每个事物逻辑位于一个位置, 代码不分散, 便于维护和升级
  2. 业务模块更简洁, 业务模块就做关于业务的核心代码，把关注点放在需要关注的地方，核心代码从冗余的其他代码中抽离出来，实现了核心业务和普通业务分离，大大简化开发流程
  3. 一图流，完美诠释 aop

  

• AOP 比较晦涩的术语

  1. 切面(Aspect): 横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象

  2. 通知(Advice): 切面必须要完成的工作

  3. 目标(Target): 被通知的对象
  4. 代理(Proxy): 向目标对象应用通知之后创建的对象
  5. 连接点（Joinpoint）：程序执行的某个特定位置：如类某个方法调用前、调用后、方法抛出异常后等。连接点由两个信息确定：方法表示的程序执行点；相对点表示的方位。例如 People#eat() 方法执行前的连接点，执行点为 People#eat()； 方位为该方法执行前的位置
  6. 切点（pointcut）：每个类都拥有多个连接点：例如 People 的所有方法实际上都是连接点，即连接点是程序类中客观存在的事务。AOP 通过切点定位到特定的连接点。类比：连接点相当于数据库中的记录，切点相当于查询条件。切点和连接点不是一对一的关系，一个切点匹配多个连接点，切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件

• 最后，在讲解 Spring 的aop 之前，先看看用以前的方法（动态代理）是如何实现面向切面编程的

public class PeopleProxy {

    private People target = null;

    public PeopleProxy(People people) {
        this.target = people;
    }


    // 获取代理对象的方法
    public People getPeopleProxy() {

        People proxy = null;

        // 当前代理对象由哪个类加载器来进行加载
        ClassLoader loader = this.target.getClass().getClassLoader();

        // 代理对象的类型，即实现的接口的类，主要是为了确定被代理对象有哪些方法
        Class[] interfaces = new Class[] { People.class };

        // 当调用代理对象的方法时，应该如何执行
        InvocationHandler handler = new InvocationHandler() {
            /*
             * proxy：被返回的代理对象，一般情况下，不建议在invoke方法里面使用这个对象 method：正在被调用的方法对象 args：调用方法时，传入的参数
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // 强烈不建议在invoke方法里面使用proxy这个代理对象，否则很容易出现 statckOverFlow 异常
                // System.out.println(proxy.toString());

                // 日志
                System.out.println("我是一个中国人");

                // 执行方法
                Object obj = method.invoke(target, args);

                // 日志
                System.out.println(method.getName() + "======" + Arrays.asList(args));

                return obj;
            }
        };

        //创建代理对象并返回
        proxy =  (People) Proxy.newProxyInstance(loader, interfaces, handler);
        return proxy;
    }
}

- 被代理对象 Chinese 类

@Override
    public void eat(String tool) {
//      System.out.println(this.name+"是一个中国人");
        System.out.println("我用"+tool+"吃饭");
    }

    @Override
    public void say(String language) {
//      System.out.println(this.name+"是一个中国人");
        System.out.println("我说"+language);
    }

- junit

@Test
    void testProxy() {

        Chinese chinese = new Chinese("老爹");

        People peopleProxy = new PeopleProxy(chinese).getPeopleProxy();
        peopleProxy.eat("大米");
        peopleProxy.say("中文");
    }

console:

• 源代码点我