SpringAOP

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
AOP开发是以动态代理为底层原理的，它的开发步骤也与动态代理类似，只是把方法增强部分交给了Spring去管理。

AOP的底层机制就是动态代理，学习AOP开发之前你需要连接java的动态代理机制可以跳转到 JDK和cglib的动态代理这篇文章进行参考

一、动态代理

动态代理的角色和静态代理的一样 .
动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的
动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理
- 基于接口的动态代理----JDK动态代理
- 基于类的动态代理–cglib
现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist
我们这里使用JDK的原生代码来实现，其余的道理都是一样的！、

1.1 JDK的动态代理核心类

核心 : InvocationHandler 和 Proxy
JDK提供了java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy类，基于接口和反射技术可以实现动态代理。
简单讲一下JDk的动态代理中的这两个核心类

1.2 newProxyInstance

newProxyInstance，方法有三个参数：
loader: 用哪个类加载器去加载代理对象
interfaces:动态代理类需要实现的接口
h:动态代理方法在执行时，会调用h里面的invoke方法去执行

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
throws IllegalArgumentException

1.3 invoke

invoke三个参数：
proxy：就是代理对象，newProxyInstance方法的返回对象
method：调用的方法
args: 方法中的参数

Object invoke(Object proxy, 方法 method, Object[] args)；
//参数
//proxy - 调用该方法的代理实例
//method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
//args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。

1.4 举例

public class ProxyInvocationHandler implements InvocationHandler {  //实现InvocationHandler，重写invoke方法
   private Object target;

   public void setTarget(Object target) {
       this.target = target;
  }

   //生成代理类
   public Object getProxy(){
       return Proxy.newProxyInstance(this.getClass().getClassLoader(),
               target.getClass().getInterfaces(),this);
  }

   // proxy : 代理类
   // method : 代理类的调用处理程序的方法对象.
   public Object invoke(Object proxy, Method method, Object[] args) throwsThrowable {
       log(method.getName());
       Object result = method.invoke(target, args);
       return result;
  }

   public void log(String methodName){
       System.out.println("执行了"+methodName+"方法");
  }

}

测试：

public class Test {
   public static void main(String[] args) {
       //真实对象
       UserServiceImpl userService = new UserServiceImpl();
       //代理对象的调用处理程序
       ProxyInvocationHandler pih = new ProxyInvocationHandler();
       pih.setTarget(userService); //设置要代理的对象
       UserService proxy = (UserService)pih.getProxy(); //动态生成代理类！
       proxy.delete();
  }
}

1.5 动态代理的好处

静态代理有的它都有，静态代理没有的，它也有！

可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
公共的业务由代理来完成 . 实现了业务的分工 ,
公共业务发生扩展时变得更加集中和方便 .
一个动态代理 , 一般代理某一类业务
一个动态代理可以代理多个类，代理的是接口！

二、AOP

2.1 Aop在Spring中的作用

横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
目标（Target）：被通知对象。
代理（Proxy）：向目标对象应用通知之后创建的对象。
切入点（PointCut）：切面通知执行的 “地点”的定义。
连接点（JointPoint）：与切入点匹配的执行点。

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

2.2 基于XML 的AOP 开发

重点使用AOP织入，需要导入依赖包

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>
<!-- AOP -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.13</version>
</dependency>

2.2.1 直接通过 Spring API 实现

创建模板类和接口：

public class Target implements TargetInterface {
    @Override
    public void coreWork() {
        System.out.println("===核心业务方法运行===");
    }
}

public interface TargetInterface {
    public void coreWork();
}

然后去写我们的增强类 , 我们编写两个 , 一个前置增强一个后置增强：

public class Log implements MethodBeforeAdvice {

   //method : 要执行的目标对象的方法
   //objects : 被调用的方法的参数
   //Object : 目标对象
   @Override
   public void before(Method method, Object[] objects, Object o) throws Throwable {
       System.out.println( o.getClass().getName() + "的" + method.getName() + "方法被执行了");
  }
}
public class AfterLog implements AfterReturningAdvice {
   //returnValue 返回值
   //method被调用的方法
   //args 被调用的方法的对象的参数
   //target 被调用的目标对象
   @Override
   public void afterReturning(Object returnValue, Method method, Object[] args,Object target) throws Throwable {
       System.out.println("执行了" + target.getClass().getName()
       +"的"+method.getName()+"方法,"
       +"返回值："+returnValue);
  }
}

最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束 .

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:aop="http://www.springframework.org/schema/aop"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

   <!--注册bean-->
   <bean id="userService" class="com.sys.service.Target"/>
   <bean id="log" class="com.sys.log.Log"/>
   <bean id="afterLog" class="com.sys.log.AfterLog"/>

   <!--aop的配置-->
   <aop:config>
       <!--切入点 expression:表达式匹配要执行的方法-->
       <aop:pointcut id="pointcut" expression="execution(* com.sys.aop.Target.*(..))"/>
       <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
       <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
       <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
   </aop:config>

</beans>

2.2.2 自定义类来实现Aop

就上面例子
创建切面类：

public class DiyPointcut {

   public void before(){
       System.out.println("---------方法执行前---------");
  }
   public void after(){
       System.out.println("---------方法执行后---------");
  }
   
}

去spring中配置：

<!--第二种方式自定义实现-->
<!--注册bean-->
<bean id="diy" class="com.sys.config.DiyPointcut"/>

<!--aop的配置-->
<aop:config>
   <!--第二种方式：使用AOP的标签实现-->
   <aop:aspect ref="diy">
       <aop:pointcut id="diyPonitcut" expression="execution(* com.sys.aop.Target.*(..))"/>
       <aop:before pointcut-ref="diyPonitcut" method="before"/>
       <aop:after pointcut-ref="diyPonitcut" method="after"/>
   </aop:aspect>
</aop:config>

<!--可以每一个通知方法单独设置切入点-->
 <aop:config>
        <aop:aspect ref="aspect">
            <aop:before method="before" pointcut="execution(public void com.sys.aop.Target.*(..))"/>
            <aop:after method="after" pointcut="execution(public void com.sys.aop.Target.*(..))"/>
        </aop:aspect>
    </aop:config>

2.2.3 总结

切点表达式的写法
execution([修饰符] 返回值类型包名.类名.方法名(参数))

访问修饰符可以省略
返回值类型、包名、类名、方法名可以使用星号*代表任意
包名与类名之间一个点. 代表当前包下的类，两个点… 表示当前包及其子包下的类
参数列表可以使用两个点… 表示任意个数，任意类型的参数列表

通知的配置
<aop:通知类型method=“切面类中方法名” pointcut=“切点表达式"></aop:通知类型>

通知类型	标签	解释
前置通知	aop:before	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	aop:after-returning	用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知	aop:around>	用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知	aop:throwing>	用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知	aop:after>	用于配置最终通知。无论增强方式执行是否有异常都会执行

aop织入的配置

<aop:config>
	<aop:aspect ref=“切面类”>
		<aop:before method=“通知方法名称” pointcut=“切点表达式"></aop:before>
	</aop:aspect>
</aop:config>

2.3 基于注解的AOP开发

2.3.1 代码实现

创建目标接口和目标类（内部有切点）

public class Target implements TargetInterface {
    @Override
    public void coreWork() {
        System.out.println("===核心业务方法运行===");
    }
}

public interface TargetInterface {
    public void coreWork();
}

创建切面类(增强方法类)：

public class Aspect {

    public void before(){
        System.out.println("对核心业务方法执行前的增强......");
    }

    public void after(){
        System.out.println("后置增强......");
    }

将目标类和切面类的对象创建权交给spring并使用注解配置织入关系

@Component("aspect")
@Aspect
public class MyAspect {

    @Before("execution(* com.sys.aop.innovation.*.*(..))")
    public void before(){
        System.out.println("对核心业务方法执行前的增强......");
    }

    @After("execution(* com.sys.aop.innovation.*.*(..))")
    public void after(){
        System.out.println("后置增强......");
    }
}

在配置文件中开启组件扫描和AOP 的自动代理

<context:component-scan base-package="com.wang.aop.innovation"/>

<!--aop的自动代理-->
<aop:aspectj-autoproxy/>

通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被<aop:aspectj-autoproxy />隐藏起来了

<aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为<aop:aspectj-autoproxy  poxy-target-class="true"/>时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。

2.3.1 总结

通知类型	注解	解释
前置通知	@Before	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	@after-returning	用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知	@around	用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知	@throwing	用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知	@after	用于配置最终通知。无论增强方式执行是否有异常都会执行

2.4 切入点表达式书写

切入点表达式-execution
execution 主要根据方法的返回值、包名、类名、方法名、方法参数等信息来匹配语法为:
execution(访问修饰符? 返回值包名.类名.方法名(方法参数) throws 异常?)

其中带?的表示可以省略的部分
访问修饰符:可省略(比如:public、protected)
包名.类名: 可省略
throws 异常:可省略(注意是方法上声明抛出的异常，不是实际抛出的异常)
可以使用通配符描述切入点
* :单个独立的任意符号，可以通配任意返回值、包名、类名、方法名、任意类型的一个参数，也可以通配包、类、方法名的一部分
execution(* com.*.service.*.update*(.))

.. :多个连续的任意符号，可以通配任意层级的包，或任意类型、任意个数的参数
execution(* com.sys..DeptService.*(..)

注意:根据业务需要，可以使用且(&&)、或(||)、非(!)来组合比较复杂的切入点表达式

书写建议
所有业务方法名在命名时尽量规范，方便切入点表达式快速匹配。如:查询类方法都是find 开头，更新类方法都是 update开头。
描述切入点方法通常基于接口描述，而不是直接描述实现类，增强拓展性。
在满足业务需要的前提下，尽量缩小切入点的匹配范围。如:包名匹配尽量不使用…，使用*匹配单个包。