Spring-----aop

什么是aop？

AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

AOP带来的好处？
让我们可以 “专心做事”

AOP中关键性概念
连接点(Joinpoint)：程序执行过程中明确的点，如方法的调用，或者异常的抛出.

目标(Target)：被通知(被代理)的对象
注1：完成具体的业务逻辑

通知(Advice)：在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理)
注2：完成切面编程

代理(Proxy)：将通知应用到目标对象后创建的对象(代理=目标+通知),
例子：外科医生+护士
注3：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的

切入点(Pointcut)：多个连接点的集合，定义了通知应该应用到那些连接点。
(也将Pointcut理解成一个条件，此条件决定了容器在什么情况下将通知和目标组合成代理返回给外部程序)

适配器(Advisor)：适配器=通知(Advice)+切入点(Pointcut)

aop的核心点
通知
前置通知
实现org.springframework.aop.MethodBeforeAdvice接口
买书、评论前加系统日志
后置通知
实现org.springframework.aop.AfterReturningAdvice接口
买书返利
环绕通知
org.aopalliance.intercept.MethodInterceptor
类似拦截器，会包括切入点，目标类前后都会执行代码。
异常通知
org.springframework.aop.ThrowsAdvice
出现异常执行系统提示，然后进行处理。价格异常为例
过滤通知（适配器）
org.springframework.aop.support.RegexpMethodPointcutAdvisor

接下来用代码来了解一下前后置通知

接口和实现类：

package com.psy.aop.biz;

public interface IBookBiz {
    // 购书
    public boolean buy(String userName, String bookName, Double price);

    // 发表书评
    public void comment(String userName, String comments);
}

package com.psy.aop.biz.impl;

import com.psy.aop.biz.IBookBiz;
import com.psy.aop.exception.PriceException;

public class BookBizImpl implements IBookBiz {

    public BookBizImpl() {
        super();
    }

    public boolean buy(String userName, String bookName, Double price) {
        // 通过控制台的输出方式模拟购书
        if (null == price || price <= 0) {
            throw new PriceException("book price exception");
        }
        System.out.println(userName + " buy " + bookName + ", spend " + price);
        return true;
    }

    public void comment(String userName, String comments) {
        // 通过控制台的树池方式模拟发表书评
        System.out.println(userName + " say:" + comments);
    }

}

异常：

package com.psy.aop.exception;

public class PriceException extends RuntimeException {

    public PriceException() {
        super();
    }

    public PriceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }

    public PriceException(String message, Throwable cause) {
        super(message, cause);
    }

    public PriceException(String message) {
        super(message);
    }

    public PriceException(Throwable cause) {
        super(cause);
    }
    
}

前置通知：

package com.psy.aop.advice;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.springframework.aop.MethodBeforeAdvice;


/**
 * 买书、评论前加系统日志
 * @author Admin
 *
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {

    @Override
    public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
        String clzName=arg2.getClass().getName();
        String methodName= arg0.getName();
        String params =Arrays.toString(arg1);
        System.out.println("【系统日志：】"+clzName+"."+methodName+"("+params+")");

    }

}

后置通知：

package com.psy.aop.advice;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.springframework.aop.AfterReturningAdvice;

public class MyAfterReturningAdvice implements AfterReturningAdvice {

    @Override
    public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
        String clzName=arg3.getClass().getName();
        String methodName= arg1.getName();
        String params =Arrays.toString(arg2);
        System.out.println("【后置通知（买书返利）：】"+clzName+"."+methodName+"("+params+")");


    }

}

测试类：

package com.psy.aop.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.psy.aop.biz.IBookBiz;

public class Demo1 {

    public static void main(String[] args) {
        ApplicationContext context= new ClassPathXmlApplicationContext("/spring-context.xml");
        //IBookBiz  bean = (IBookBiz) context.getBean("bookBiz");
        
        IBookBiz  bean = (IBookBiz) context.getBean("bookBizProxy");
        
        bean.buy("小乔", "圣墟", 66d);
        bean.comment("小乔", "上头");
        
        
    }
}

打印结果：

从结果上看，后置通知是存在bug的，因为用户在购买的时候反了一次利评论的时候又反了一次利，这显然是不合理的

那么如何解决这个bug呢，在后面的过滤通知会提到

环绕通知：

package com.psy.aop.advice;

import java.util.Arrays;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class MyMethodInterceptor implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation arg0) throws Throwable {
        String clzName=arg0.getClass().getName();
        String methodName= arg0.getMethod().getName();
        String params =Arrays.toString(arg0.getArguments());
        
        System.out.println("【环绕通知：】"+clzName+"."+methodName+"("+params+")");

        //returnValue是代理对象调用目标对象的返回值
        Object returnValue = arg0.proceed();
        System.out.println("【环绕通知：】"+clzName+"."+methodName+"("+params+")"+" 方法调用的返回值"+returnValue);

        return returnValue;
    }

}

在spring-context.xml中加入：

<bean id="myMethodInterceptor" class="com.psy.aop.advice.MyMethodInterceptor"></bean>

以及：

<value>myMethodInterceptor</value>

打印结果：

环绕通知相当于前置通知加后置通知

异常通知：

异常通知的方法必须要符合public void afterThrowing( MyException1 ex ) {}这种格式

package com.psy.aop.advice;

import org.springframework.aop.ThrowsAdvice;

import com.psy.aop.exception.PriceException;

public class MyThrowsAdvice implements ThrowsAdvice {
    public void afterThrowing( PriceException ex ) {
        System.out.println("价格输入有误，购买失败，请重新输入！！！");
        
    }
}

同时在spring-context.xml中配置

过滤通知：

解决上面返利bug

过滤通知只需要改spring-context.xml配置

加入：

<bean id="myAfterReturningAdvicePlus" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice" ref="myAfterReturningAdvice"></property>
        <property name="pattern" value=".*buy"></property>
    </bean>

修改：

<!-- <value>myAfterReturningAdvice</value> -->
          <value>myAfterReturningAdvicePlus</value>

打印结果：

从结果可以看到只反了一次利