Spring-03 Aop简介，实现原理，基于ProxyFactoryBean实现Aop，基于AspectJ开发的实现

Spring-03

1. SpringAop简介

AOP的全称是Aspect-Oriented Programming，即面向切面编程（也称面向方面编程）。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式。

aop 解决的问题就是将共同重复的代码就行抽离（日志，事务，鉴权）

什么是切面？切面就是一个类，类里面包含类某一类具体业务（日志，事务，鉴权），用这个类去拦截/增强你需要监控的方法或者业务

1.1类与切面的关系

在这里插入图片描述
AOP的使用，使开发人员在编写业务逻辑时可以专心于核心业务，而不用过多的关注于其他业务逻辑的实现，这不但提高了开发效率，而且增强了代码的可维护性。

2.AOP术语

在这里插入图片描述
Proxy（代理）：将通知应用到目标对象之后，被动态创建的对象。

Weaving（织入）：将切面代码插入到目标对象上，从而生成代理对象的过程。

Advice（通知/增强处理）：AOP框架在特定的切入点执行的增强处理，即在定义好的切入点处所要执行的程序代码。可以将其理解为切面类中的方法。

Target Object（目标对象）：指所有被通知的对象，也被称为被增强对象。如果AOP框架采用的是动态的AOP实现，那么该对象就是一个被代理对象。

Aspect（切面）：封装的用于横向插入系统功能（如事务、日志等）的类

Joinpoint（连接点）：在程序执行过程中的某个阶段点

Pointcut（切入点）：切面与程序流程的交叉点，即那些需要处理的连接点

2. Aop的实现原理

实现两种

基于自身的ProxyFactoryBean 实现aop功能

借助于aspectj第三方aop框架实现

aspectj 也是一个优秀的aop框架内

JDK动态代理

JDK动态代理是通过java.lang.reflect.Proxy 类来实现的，我们可以调用Proxy类的newProxyInstance()方法来创建代理对象。对于使用业务接口的类，Spring默认会使用JDK动态代理来实现AOP。

CGLIB代理

JDK的动态代理用起来非常简单，但它是有局限性的，使用动态代理的对象必须实现一个或多个接口。

为了实现类的代理可以使用CGLIB代理

CGLIB（Code Generation Library）是一个高性能开源的代码生成包，它采用非常底层的字节码技术，对指定的目标类生成一个子类，并对子类进行增强。

3.基于ProxyFactoryBean实现Aop

ProxyFactoryBean是FactoryBean接口的实现类，FactoryBean负责实例化一个Bean，而ProxyFactoryBean负责为其他Bean创建代理实例。在Spring中，使用ProxyFactoryBean是创建AOP代理的基本方式。

可以配置的属性
在这里插入图片描述

ProxyTargetClass (是否强制使用CGLIB来实现代理)

(true : 强制使用CGLIB来实现代理)

(false : 不强制使用CGLIB来实现代理，首选JDK来实现代理)（默认值）

isOptimize (是否对生成代理策略进行优化)

(true : 进行优化，如果有接口就代理接口(使用JDK动态代理)，没有接口代理类（CGLIB代理）)

(false : 不进行优化) （默认值）

实现：

3.1引入依赖

	<properties>
        <!--在当前pom 或者父类pom 中声明属性  -->
        <spirng.version>5.0.16.RELEASE</spirng.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spirng.version}</version>
        </dependency>
        <!-- 导入spring aop -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spirng.version}</version>
        </dependency>
    </dependencies>

3.2创建切面MyAspect

package com.yth.myaspect;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import java.util.Date;
/**
 * @author yth
 * @date 2020/10/21 - 15:11
 */
public class MyAspect implements MethodInterceptor {
    
    
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
    
    
        System.out.println("代理对象开始执行--"+methodInvocation.getMethod().getName()+new Date());

        Object result = methodInvocation.proceed();
        System.out.println("代理对象结束执行--"+methodInvocation.getMethod().getName());
        return result;
    }
}

3.3在xml中织入切面和目标对象

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean class="com.yth.dao.impl.StudentDaoImpl" id="studentDao"></bean>
    <bean class="com.yth.myaspect.MyAspect" id="aspect"></bean>
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="factoryBean">
        <!--
        当实现接口时，指定对应得接口  可以选择不写，
        如果代理只有类，不能写否者报错
        <property name="proxyInterfaces" value="com.wgz.spring.dao.StudentDaoIm"></property>-->
            <!--
                true   cglib 代理
                false  jdk 动态代理
            -->
        <property name="proxyTargetClass" value="false"></property>
            <!--
                指定目标对象
            -->
        <property name="target" ref="studentDao"></property>
             <!--
                指定切面
             -->
        <property name="interceptorNames" value="aspect"></property>
        
    </bean>
</beans>

3.4测试

public static void main(String[] args) {
    
    
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("aspectj\\Aspectj.xml");
    StudentDao studentDao=  applicationContext.getBean(StudentDao.class);
    studentDao.fingStudentById(100);
}

3.5总结

为什么会有jdk和CGLIB两种选择？

1.jdk 只能代理类实现的接口的类，而没有实现接口类必须使用CGLIB
2.从性能来说：
CGLIB：创建慢，执行块（CGLIB 要生成对应的代理的代码，在创建代理对象）
JDK：创建快，执行慢（反射本身执行就比正常代码的慢）

4. 基于AspectJ开发的实现

AspectJ是一个基于Java语言的AOP框架，它提供了强大的AOP功能。Spring 2.0以后，Spring AOP引入了对AspectJ的支持，并允许直接使用AspectJ进行编程，而Spring自身的AOP API也尽量与AspectJ保持一致。新版本的Spring框架，也建议使用AspectJ来开发AOP。

使用AspectJ实现AOP有两种方式：

基于XML的声明式AspectJ

基于注解的声明式AspectJ

4.1 spring通知的类型

Spring按照通知在目标类方法的连接点位置，可以分为5种类型，具体如下：

org.springframework.aop.MethodBeforeAdvice（前置通知）
在目标方法执行前实施增强，可以应用于权限管理等功能。

org.springframework.aop.AfterReturningAdvice（后置通知）
在目标方法执行后实施增强，可以应用于关闭流、上传文件、删除
临时文件等功能。

org.aopalliance.intercept.MethodInterceptor（环绕通知）
在目标方法执行前后实施增强，可以应用于日志、事务管理等功能。

org.springframework.aop.ThrowsAdvice（异常抛出通知）
在方法抛出异常后实施增强，可以应用于处理异常记录日志等功能。

org.springframework.aop.IntroductionInterceptor（引介通知）
在目标类中添加一些新的方法和属性，可以应用于修改老版本程序。

4.2基于XML的声明式AspectJ

1.引入依赖

<!--引入 aspectj依赖-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.6.12</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.12</version>
        </dependency>

2.创建切面

package com.yth.aspectj;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
/**
 * 切面类
 * @author yth
 * @date 2020/10/21 - 17:26
 */
public class MyAspectj {
    
    
    /**
     * 前置通知，在目标对象调用之前调用
     */
    public void myBefore(JoinPoint joinPoint){
    
    
        // joinPoint  连接点 在这里我们得到的是 切入点    他们都是方法
        //joinPoint.getSignature().getName() 获取目标对象执行的方法名
        System.out.println("myBefore--------"+joinPoint.getSignature().getName());
    }
    /**
     * 后置通知，在目标对象之后调用
     * 目标对象, 能在执行完毕之后执行,并获得结果
     */
    public void myAfterReturning(JoinPoint joinPoint,Object result){
    
    
        //joinPoint.getTarget()  获取目标对象
        //System.out.println(joinPoint.getTarget());
        System.out.println("myAfterReturning--------"+joinPoint.getSignature().getName());
        System.out.println("方法执行的结果------"+result);
    }
    /**
     * 环绕通知
     */
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    
    
        System.out.println("myAround--------"+proceedingJoinPoint.getSignature().getName());
        // 让 目标对象执行 相应的方法 如果不执行代表  被拦截
        // 返回值 目标对象执行 的结果
        Object result = proceedingJoinPoint.proceed();
        System.out.println(result);
        // 必须将 目标对象执行结果 返回给代理
        return result;
    }
    /**
     * 异常通知
     */
    public void  myAfterThrowing(JoinPoint joinPoint,Throwable e){
    
    
        System.out.println("myAfterThrowing-被调用的方法名："+joinPoint.getSignature().getName());
        //得到异常信息
        System.out.println("myAfterThrowing-异常信息："+e.getMessage());
    }
    /**
     * 最终通知, 相当于finally无论是否异常都会执行的代码
     */
    public void myAfter(JoinPoint joinPoint){
    
    
        System.out.println("myAfter--------"+joinPoint.getSignature().getName());
    }
}

2.创建xml文件

<?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 https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--声明切面-->
    <bean class="com.yth.aspectj.MyAspectj" id="myAspectj"></bean>
    <!--目标对象-->
    <bean class="com.yth.dao.impl.StudentDaoImpl" id="studentDao"></bean>
    <!--    基于aspectj xml 实现 所有织入实现功能都必须写在 aop:config   -->
    <aop:config>
        <!--    配置 切点  全局切点 可以被多个切面所应用    切点 就是要拦截的方法
                expression="execution()  切点表达式 就是找到那些需要被拦截的方法   -->
        <aop:pointcut id="myPoint" expression="execution(* com.yth.dao.*.*.*(..))"/>
        <!-- 配置切面   切面就是一个类 里面的方法主要用于拦截/增强 目标对象
             ref="myAspect" 引用切面实例 进行织入 过程 -->
        <aop:aspect id="aopAspectj" ref="myAspectj">
            <!--    前置通知 和 切点绑定  -->
            <aop:before method="myBefore" pointcut-ref="myPoint"></aop:before>
            <!--    后置通知 和 切点绑定     returning="result"  指定后置通知用那个参数 接收目标对象返回的结果 -->
            <aop:after-returning method="myAfterReturning" pointcut-ref="myPoint" returning="result"></aop:after-returning>
            <!--    环绕通知 和 切点绑定  -->
            <aop:around method="myAround" pointcut-ref="myPoint"></aop:around>
            <!--    异常通知 和 切点绑定   throwing="e" 指定异常通知用那个参数 接收异常信息  -->
            <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPoint" throwing="e"></aop:after-throwing>
            <!--    最终通知 和 切点绑定  -->
            <aop:after method="myAfter" pointcut-ref="myPoint"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>

3.测试

public static void main(String[] args) {
    
    
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("aspectj\\Aspectj.xml");
    StudentDao studentDao = (StudentDao) applicationContext.getBean("studentDao");
    studentDao.fingStudentById(100);
}

4.3基于注解的AspectJ

AspectJ框架为AOP的实现提供了一套注解，用以取代Spring配置文件中为实现AOP功能所配置的臃肿代码。AspectJ的注解及其描述如下所示：

在这里插入图片描述
1.创建切面

package com.yth.aspectj_annotation;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @author yth
 * @date 2020/10/21 - 20:20
 */
@Component
@Aspect
public class AspectJAnnotation {
    
    
    @Pointcut("execution(* com.yth.dao.*.*.*(..))")
    public void pointCut(){
    
    }
    /**
     * 前置通知，在目标对象调用之前调用
     */
    @Before("pointCut()")
    public void myBefore(JoinPoint joinPoint){
    
    
        // joinPoint  连接点 在这里我们得到的是 切入点    他们都是方法
        //joinPoint.getSignature().getName() 获取目标对象执行的方法名
        System.out.println("myBefore--------"+joinPoint.getSignature().getName());
    }
    /**
     * 后置通知，在目标对象之后调用
     * 目标对象, 能在执行完毕之后执行,并获得结果
     */
    @AfterReturning(value = "pointCut()",returning = "result")
    public void myAfterReturning(JoinPoint joinPoint,Object result){
    
    
        //joinPoint.getTarget()  获取目标对象
        //System.out.println(joinPoint.getTarget());
        System.out.println("myAfterReturning--------"+joinPoint.getSignature().getName());
        System.out.println("方法执行的结果------"+result);
    }
    /**
     * 环绕通知
     */
    @Around("pointCut()")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    
    
        System.out.println("myAround--------"+proceedingJoinPoint.getSignature().getName());
        // 让 目标对象执行 相应的方法 如果不执行代表  被拦截
        // 返回值 目标对象执行 的结果
        Object result = proceedingJoinPoint.proceed();
        System.out.println(result);
        // 必须将 目标对象执行结果 返回给代理

        return result;
    }
    /**
     * 异常通知
     */
    @AfterThrowing(value = "pointCut()",throwing = "e")
    public void  myAfterThrowing(JoinPoint joinPoint,Throwable e){
    
    
        System.out.println("myAfterThrowing-被调用的方法名："+joinPoint.getSignature().getName());

        // 得到异常信息
        System.out.println("myAfterThrowing-异常信息："+e.getMessage());
    }
    /**
     * 最终通知, 相当于finally无论是否异常都会执行的代码
     */
    @After("pointCut()")
    public void myAfter(JoinPoint joinPoint){
    
    
        System.out.println("myAfter--------"+joinPoint.getSignature().getName());
    }
}

2.创建xml文件

<?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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    <context:component-scan base-package="com.yth"></context:component-scan>
</beans>

3.测试

public static void main(String[] args) {
    
    
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("aspectj_annotation\\Aspectj_Annotation.xml");
    StudentDao studentDao = applicationContext.getBean(StudentDao.class);
    studentDao.fingStudentById(100);
}