10.AOP

10.AOP

什么是AOP？

• AOP（Aspect Oriented Programming）为面向切面编程

• 通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

• AOP是OOP的延续，是软件开发中的一个热点，也是Spring]框架中的一个重要内容，是函数式编程的一种衍生范型。

• 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP的主要功能：

• 日志记录，性能统计，安全控制，事务处理，异常处理等等。
• 将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指定业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

10.1 AOP在Spring中的作用

提供声明式事务管理，允许用户自定义切面

AOP相关概念：

• 横切关注点：对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点
• Aspect(切面): 通常是一个类，里面可以定义切入点和通知
• JointPoint(连接点): 程序执行过程中明确的点，一般是方法的调用。被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器。（实际上就是被增强的方法）
• Advice(通知): AOP在特定的切入点上执行的增强处理，有before(前置),after(后置),afterReturning(最终),afterThrowing(异常),around(环绕) 其实afterReturning和afterThrowing二者只会有其中一个执行
  • Before: 在目标方法被调用之前做增强处理,@Before只需要指定切入点表达式即可
  • AfterReturning: 在目标方法正常完成后做增强,@AfterReturning除了指定切入点表达式后，还可以指定一个返回值形参名returning,代表目标方法的返回值
  • AfterThrowing：主要用来处理程序中未处理的异常,@AfterThrowing除了指定切入点表达式后，还可以指定一个throwing的返回值形参名,可以通过该形参名来访问目标方法中所抛出的异常对象
  • After: 在目标方法完成之后做增强，无论目标方法时候成功完成。@After可以指定一个切入点表达式
  • Around:环绕通知： 在目标方法完成前后做增强处理,环绕通知是最重要的通知类型,像事务,日志等都是环绕通知,注意编程中核心是一个ProceedingJoinPoint
• Pointcut(切入点): 就是带有通知的连接点，在程序中主要体现为书写切入点表达式（expression）
• weave(织入): 将切面应用到目标对象并导致代理对象创建的过程
• introduction(引入)： 在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段
• AOP代理(AOP Proxy)： AOP框架创建的对象，代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理，也可以是CGLIB代理，前者基于接口，后者基于子类
• 目标对象（Target Object）: 包含连接点的对象。也被称作被通知或被代理对象。

10.2 Spring的AOP实现方式一：使用spring的API接口实现

先上代码，每一部分代码都会有讲解

​ 第一步：导入相关依赖

• 这个依赖中文翻译过来叫切面（里面可以定义切入点和通知）织入（将切面应用到目标对象并导致代理对象创建的过程）

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.5</version>
</dependency>

​ 第二步：编写UserService接口以及UserServiceImpl实现类

public interface UserService {

    public void add();
    public void delete();
    public void update();
    public void select();

}

public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("修改了一个用户");
    }

    @Override
    public void select() {
        System.out.println("查询了一个用户");
    }
}

​ 第三步：编写Log（用于前置通知的类） 这个类最后会在方法执行前 执行

• 我们编写的这个Log类实现了前置通知的方法类
• 参数method指定我们需要执行的方法
• 参数args 指定我们方法的参数
• 参数target表示我们需要代理的对象

package com.xuan.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Log implements MethodBeforeAdvice {
    /**
     *
     * @param method the method being invoked
     * @param args the arguments to the method
     * @param target the target of the method invocation. May be {@code null}.
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"执行了"+method.getName()+"方法");
    }
}

​ 第四步：编写AfterLog类实现AfterReturningAdvice完成通知 这个类中方法会在方法执行完执行

• 我们编写的这个AfterLog类实现了完成通知的方法类
• 参数returnValue就是方法执行后的返回值类型，由于我们UserServiceImpl类中方法并没有返回值所以执行完这个通知应该是返回null
• Throwable：这个参数就是执行错误抛出的异常

package com.xuan.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {
    /**
     *
     * @param returnValue
     * @param method
     * @param args
     * @param target
     * @throws Throwable
     */
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行"+method.getName()+"方法返回"+returnValue);
    }
}

​ 第五步：编写配置文件

• 第一点由于你要使用到aop切面，所以你需要导入相关的约束
• 第二点：需要将我们写的类都注入到springIOC容器中
• 然后配置原生的Spring api接口
• aop:config标签：表示配置的是aop
• aop:pointcut标签：表示要配置的是aop的切入点（切入点就是带有通知的连接点） id指定唯一标识 expression指定切入点表达式
• 切入点表达式 execution写法： 返回值类型 类名.方法名（参数） * com.xuan.service.UserServiceImpl.*(…)
• aop:advisor标签：执行通知增强的 需要指定切入点id属性以及我们自己编写的前置和完成通知的引用

<?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:context="http://www.springframework.org/schema/context"
       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/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

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


    <!--方式一：使用原生的spring api接口-->
    <!--配置aop-->
    <aop:config>
        <!--切入点表达式 execution 返回值类型 类名.方法名（参数） -->
        <aop:pointcut id="pointcut" expression="execution(* com.xuan.service.UserServiceImpl.*(..))"/>

        <!--增加环绕通知-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

第五步：编写测试类

• 这里需要注意的就是动态代理代理的是接口，所以我们不能用其实现类去调用方法，并不能起到增强的作用还会报错

import com.xuan.service.UserService;
import com.xuan.service.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestAOP {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理的是接口
        UserService userService = context.getBean("userService", UserService.class);

        userService.add();
    }
}

​ 第六步：看看测试结果

com.xuan.service.UserServiceImpl执行了add方法    ------>Log类中before方法输出的结果
增加了一个用户
执行add方法返回null		----------->AfterLog类中afterReturning方法输出的结果

10.3 Spring的AOP实现方式二：自定义实现

这个自定义的关键就是aspect切面对应的aop:aspect 标签的使用

​ 第一步：编写自己定义的类

package com.xuan.custom;

public class CustomPointCut {
    public void before(){
        System.out.println("前置通知");
    }

    public void after(){
        System.out.println("后置通知");
    }
}

​ 第二步：编写配置文件

• aop：aspect标签定义的是一个类
• aop：pointcut标签定义的是切入点表达式
• aop：before标签指定前置通知method属性指定方法
• aop：after标签指定后置通知method属性指定方法

 <bean id="costomPointCut" class="com.xuan.custom.CustomPointCut"/>
<!--方式二：自定义类-->
<!--切面；横切关注点，被模块化的特殊对象，是一个类-->
<aop:config>

    <aop:aspect ref="costomPointCut">
        <aop:pointcut id="pointcut" expression="execution(* com.xuan.service.UserServiceImpl.*(..))"/>
        <aop:before method="before" pointcut-ref="pointcut"/>
        <aop:after method="after" pointcut-ref="pointcut"/>
    </aop:aspect>
    
</aop:config>

最后就测试，然后就测试成功！

10.4 SpringAOP实现方式三：使用注解实现

使用注解开发是相对简单的，下面分析下一个关键点

• <!--开启aop注解支持--> 
  <aop:aspectj-autoproxy/>
  

• @Aspect注解：表明这是一个切面类相当于aop：aspect标签

• @Before注解：说明这是前置通知 里面需要指定execution表达式

• @After注解：说明这是后置通知 里面需要指定execution表达式