[Java知识库]Spring AOP

Spring AOP

什么是AOP

AOP：面向切面编程，功能是在不改变源代码的前提下，给核心业务添加功能

Aop的分类

AOP 实现的关键就在于 AOP 框架自动创建的 AOP 代理，AOP 代理则可分为静态代理(AspectJ)和动态代理(Spring AOP)两大类，其中静态代理是指使用 AOP 框架提供的命令进行编译，从而在编译阶段就可生成 AOP 代理类，因此也称为编译时增强；而动态代理则在运行时借助于 JDK 动态代理、CGLIB 等在内存中“临时”生成 AOP 动态代理类，因此也被称为运行时增强。

使用Spring AOP

与 AspectJ 相同的是，Spring AOP 同样需要对目标类进行增强，也就是生成新的 AOP 代理类；与 AspectJ 不同的是，Spring AOP 无需使用任何特殊命令对 Java 源代码进行编译，它采用运行时动态地、在内存中临时生成“代理类”的方式来生成 AOP 代理。

Spring 允许使用 AspectJ Annotation 用于定义方面（Aspect）、切入点（Pointcut）和增强处理（Advice），Spring 框架则可识别并根据这些 Annotation 来生成 AOP 代理。Spring 只是使用了和 AspectJ 5 一样的注解，但并没有使用 AspectJ 的编译器或者织入器（Weaver），底层依然使用的是 Spring AOP，依然是在运行时动态生成 AOP 代理，并不依赖于 AspectJ 的编译器或者织入器。
简单地说，Spring 依然采用运行时生成动态代理的方式来增强目标对象，所以它不需要增加额外的编译，也不需要 AspectJ 的织入器支持；而 AspectJ 在采用编译时增强，所以 AspectJ 需要使用自己的编译器来编译 Java 文件，还需要织入器。

开启@Aspect注解

为了启用 Spring 对 @AspectJ 方面配置的支持，并保证 Spring 容器中的目标 Bean 被一个或多个切面类自动增强，必须在 Spring 配置文件中配置如下片段

<?xml version="1.0" encoding="GBK"?> 
 <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-3.0.xsd 
 http://www.springframework.org/schema/aop 
 http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"> 
 <!-- 启动 @AspectJ 支持 --> 
 <aop:aspectj-autoproxy/> 
 </beans> 

当启动了 @AspectJ 支持后，只要我们在 Spring 容器中配置一个带 @Aspect 注释的 Bean，Spring 将会自动识别该 Bean，并将该 Bean 作为方面 Bean 处理。

使用 @Aspect 标注一个 Java 类，该 Java 类将会作为方面 Bean，如下面代码片段所示：

// 使用 @Aspect 定义一个方面类
 @Aspect 
 public class LogAspect 
 { 
 // 定义该类的其他内容
 ... 
 } 

AOP的底层原理

AOP底层使用的是动态代理

	动态代理有两种情况：
	
		1. 有接口，使用JDK动态代理，创建接口实现类对象，增强类的方法
		2. 没接口，使用CGLIB动态代理，创建子类的代理对象，增强类的方法
	
	eg.JDK动态代理，使用Proxy类里面的方法创建代理对象

	1.创建接口，定义方法
public interface UserDao {
 public int add(int a,int b);
 public String update(String id);
}

	2.创建接口实现类，实现方法
public class UserDaoImpl implements UserDao {
 @Override
 public int add(int a, int b) {
 return a+b;
 }
 @Override
 public String update(String id) {
 return id;
 } }

	3.创建增强类，实现InvocationHandler接口
		class UserDaoProxy implements InvocationHandler {
 //1 把创建的是谁的代理对象，把谁传递过来
 //有参数构造传递
 private Object obj;
 public UserDaoProxy(Object obj) {
 this.obj = obj;
 }
 //增强的逻辑
 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws 
Throwable {
 //方法之前
 System.out.println("方法之前执行...."+method.getName()+" :传递的参
数..."+ Arrays.toString(args));
 //被增强的方法执行
 Object res = method.invoke(obj, args);
 //方法之后
 System.out.println("方法之后执行...."+obj);
 return res;
 } }

4.使用Proxy类创建接口代理对象
public class JDKProxy {
 public static void main(String[] args) {
 //创建接口实现类代理对象
 Class[] interfaces = {UserDao.class};
 UserDaoImpl userDao = new UserDaoImpl();
 UserDao dao = 
(UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, 
new UserDaoProxy(userDao));
int result = dao.add(1, 2);
 System.out.println("result:"+result);
 } }

相关解释：
jdk动态代理是通过反射来实现的，通过反射可以动态的创建对象，调用方法，创建对象的首先要获取类的class对象，再通过class对象的getConstructor（）创建对象

@Test
    public void test07()throws  Exception {
        Class classType=UserDaoImpl.class;
        Constructor constructor=classType.getConstructor(new Class[]{});
        UserDao userDaoImpl=(UserDaoImpl) constructor.newInstance(new Class[]{});

        int sum=userDaoImpl.add(1,9);
        System.out.println(sum);
    }

Proxy是java中的一个类

//创建代理对象
UserDao dao = 
(UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, 
new UserDaoProxy(userDao));

nexProxyInstance有三个参数，类加载器（谁便一个类都行），包含接口的class数组，增强类（实现了invocationHandler接口的对象）
返回的dao对象就是一个代理对象

//创建增强类
public class UserDaoProxy implements InvocationHandler {
    private Object obj;

    public UserDaoProxy(Object obj) {
        this.obj = obj;
        System.out.println("增强类");
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(Arrays.toString(args));
        Object res=method.invoke(obj,args);
        System.out.println("invoke被调用");
        return res;
    }
}

创建代理对象
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)：直接创建一个动态代理对象，该代理对象的实现类实现了interfaces指定的系列接口，执行代理对象的每个方法时都会被替换执行InvocationHandler对象的invoke方法，相当于把增强类的invoke方法嵌入到接口的所有方法中。所以使用代理对象调用方法就会调用增强类的invoke方法，这时可以在invoke方法中’method.invoke(obj,args)'调用被增强的方法。注意这和method.invoke()是没有关系的。proxy是Proxy的实例对象，method是被调用的方法的method对象，args是调用方法时传进来的参数。调用代理对象的方法相当于调用增强类的invoke方法，在增强类的invoke()中调用method的invoke（obj,args）才是调用被增强类的方法，obj是被增强类的实例对象。

Spring AOP的相关术语

1. 连接点：类中可以被增强的方法，这些方法称为连接点。

2. 切入点：被增强的方法，称为切入点

3. 通知（增强）：实际增强的逻辑部分称为通知（增强）

4. 通知的类型：

   @Before 前置通知 被增强类方法执行前执行
   @AfterReturning 返回通知 方法后执行(5个常用通知中最后执行)
   @Around 环绕通知 方法前执行。方法后结束
   @AfterThrowing 异常通知
   @After 最终通知 方法后执行，如果有环绕通知后于环绕通知执行

5. 切面：把通知应用到切入点的过程，注意是一个过程

6. 切面类：把通知应用到切入点的类，我习惯把他称为增强类

7. 切入点表达式：用于确定切面类中的通知应该增强哪个类的哪个方法

切入点表达式execution的语法规则

execution（注解？修饰符？返回值类型 类型声明？方法名（参数）异常？）

1. 注解：可选，如要hock注解，则必须添加。例如execution(@java.lang.Override * *(. .))
2. 修饰符：可选，如public，protected，写在返回值前；
3. 返回值类型：必选，可以使用 * 来代表任意返回值；
4. 类型声明：可选，可以是任意类型；
5. 方法名：必选，可以用*来代表任意方法；
6. 参数：()代表是没有参数，(. .)代表是匹配任意数量，任意类型的参数，当然也可以指定类型的参数进行匹配，如要接受一个String类型的参数，则(java.lang.String)；任意数量的String类型参数：(java.lang.String. .)；第一个是任意类型，第二个是String的参数匹配：(*,java.lang.String)等等；
7. 异常：可选，语法：“throws 任意异常类型”，可以是多个，用逗号分隔，例如：throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException。

注意：问号前面的都是可写可不写，没有问号的都是必写，例如返回值类型，和方法名。以上所有的类都需要是全类名写入，不能简写（就是你不能模糊用 * 代替）。
举几个例子：
execution(* *(. .)) 这是最基本的，意思是切点为所有返回值类
型，对所有包下的类的方法，因为就算你可选的不写，但是这两个必须写

execution(public * *(. .)) 可选的加进去后，可任意加都可识别，但是返回值和方法必须有，这里切点范围就为public类型，任意返回值，任意包下所有类的方法。

execution(void com.csdn.*(. .)) 对返回值为void，在包com.csdn下的所有类方法设置为切点（不包含子包，就是这个包下面没有包了，全是类）

execution(void com.csdn. .*(. .)) 对返回值为void，在包com.csdn下的子孙包和自身下的所有类方法设置为切点(这里两个点，上面那个一个点)

execution(* com.csdn.User.*(. .)) 对返回值类型任意，在com.csdn下具体类User里的方法设置为切点

所以execution里面必须有返回值类型，和方法名俩个筛选的基础，那些其余可以加上，将筛选条件范围减小。

切面类

切面类（用 @Aspect 修饰的类）和其他类一样可以有方法、属性定义，还可能包括切入点、增强处理定义。

当我们使用 @Aspect 来修饰一个 Java 类之后，Spring 将不会把该 Bean 当成组件 Bean 处理，因此负责自动增强的后处理 Bean 将会略过该 Bean，不会对该 Bean 进行任何增强处理。

开发时无须担心使用 @Aspect 定义的方面类被增强处理，当 Spring 容器检测到某个 Bean 类使用了 @Aspect 标注之后，Spring 容器不会对该 Bean 类进行增强。

注解如何实现切面

1.设置切面类，用@org.aspectj.lang.annotation.Aspect在类前申明该类为切面类（这样在bean配置时候，扫描注解可以节省时间）
2.在切面里设置通知方法，这里不像传统aop需要实现某个接口
3.在方法前面设置注解，什么类型的注解，最上面有解释，这里就是通知
4.在通知注解里使用execution设置切点范围
在一个类里面就实现了通知和切点，该类就成了切面类
5.在配置文件里申明bean，那么这个类里面的注解就被激活了，因为被aop:aspectj-autoproxy/扫描了，实现了功能。

基于@AspectJ注解实现AOP操作

//定义接口
public interface UserDao {
    public  int add(int a,int b);
    public String update(String id);
}

//创建接口实现类
@Component
public class UserDaoImpl implements UserDao{
    public UserDaoImpl() {
        System.out.println("无参构造方法调用");
    }

    public int add(int a, int b) {
        System.out.println("add方法调用");
        return a+b;
    }

    public String update(String id) {
        return id;
    }
}

//创建切面类
@Component
@Aspect
public class UserDaoProxy02 {

    @AfterReturning(value = "execution(* com.cailibin.UserDaoImpl.add(..))",returning = "returnValue")
    public void afterReturning(JoinPoint joinPoint,Object returnValue){
//        System.out.println(Arrays.toString(joinPoint.getArgs()));

        System.out.println("AfterReturning获得的值："+returnValue);
        System.out.println("AfterReturning返回通知.....");
    }
   @After("execution(* com.cailibin.UserDaoImpl.add(..))")
    public void after(JoinPoint joinPoint){

        System.out.println("After最终通知.....");
    }
    @Around("execution(* com.cailibin.UserDaoImpl.add(..))")
    public int around(ProceedingJoinPoint proceedingJoinPoint)throws Throwable{
        System.out.println("AroundStart环绕开始.....");
       Object[] arr= proceedingJoinPoint.getArgs();//proceedingJoinPoint可以获取方法参数
       //System.out.println(Arrays.toString(arr));
       int returnValue=(int)proceedingJoinPoint.proceed(arr);//执行方法
        System.out.println("环绕通知获得原方法的返回值："+returnValue);
        System.out.println("Aroundend环绕结束...");
        returnValue=0;//修改原方法的返回值，测试方法和AfterReturning通知获得的值就是该值
        return returnValue;
    }
    @Before("execution(public int com.cailibin.UserDaoImpl.add(..))")
    public void before(JoinPoint joinPoint){

//        System.out.println(Arrays.toString(joinPoint.getArgs()));
        System.out.println("before开始通知.....");
    }
}

//spring的配置文件，component-scan扫描注解，aspectJ-autoproxy启用@AspectJ注解
<?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">
    <context:component-scan base-package="com.cailibin"></context:component-scan>
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

//测试方法
@Test
    public  void test05(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean4.xml");
        UserDao userDao=context.getBean("userDaoImpl",UserDao.class);
        System.out.println("代理类对象："+userDao.getClass());
        int s=userDao.add(1,3);
      System.out.println("测试方法获得的值："+s);
    }

执行结果：

构造方法执行了
无参构造方法调用
代理类对象：class com.sun.proxy.$Proxy25
AroundStart环绕开始…
before开始通知…
add方法调用
环绕通知获得原方法的返回值：4
Aroundend环绕结束…
After最终通知…
AfterReturning获得的值：0
AfterReturning返回通知…
测试方法获得的值：0

Process finished with exit code 0

UserDao userDao=context.getBean(“userDaoImpl”,UserDao.class);由名称和类型或名称可以获取Spring AOP动态生成的AOP代理类对象userDao，但是由名获取到的对象要进行强制类型转换。userDao对象是userDao接口的实现类的实例。Spring AOP 框架对 AOP 代理类的处理原则是：如果目标对象的实现类实现了接口，Spring AOP 将会采用 JDK 动态代理来生成 AOP 代理类；如果目标对象的实现类没有实现接口，Spring AOP 将会采用 CGLIB 来生成 AOP 代理类——不过这个选择过程对开发者完全透明、开发者也无需关心。AOP 代理其实是由 AOP 框架动态生成的一个对象，该对象可作为目标对象使用。AOP 代理包含了目标对象的全部方法，但 AOP 代理中的方法与目标对象的方法存在差异：AOP 方法在特定切入点添加了增强处理，并回调了目标对象的方法。
所以，
有接口用jdk动态代理，代理对象是接口的实现类的实例。
无接口用cglib代理，代理对象是原类的子类的实例。
该代理对象的实现类实现了接口或原类的全部方法，执行代理对象的每个方法都会替换成InvocationHandler的invoke方法。

抽取相同切入点

//创建一个新的类，并添加@Pointcut注解和通知要注入的方法的全类名
 @Pointcut(value ="execution(* com.cailibin.UserDaoImpl.add())")
    public void pointcut(){}

//直接在通知注解中写入pointcut的全类名
@After("com.cailibin.UserDaoImpl.pointcut()")
    public void after(JoinPoint joinPoint){

        System.out.println("After最终通知.....");
    }

增强类的优先级

有多个增强类对同一个方法进行增强，可以设置增强类优先级
在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高
@Component
@Aspect
@Order(1)
public class PersonProxy{}

完全注解开发

//创建配置类
@Configuration
//注解扫描
@ComponentScan(basePackages ={"com.cailibin"})
//自动创建代理对象
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ComfigAop {
}

@Test
    public void test08(){
    //从java类中获取应用上下文
        ApplicationContext context=new AnnotationConfigApplicationContext(ComfigAop.class);
        UserDao userDao=context.getBean("userDaoImpl",UserDao.class);
        System.out.println("代理类对象："+userDao.getClass());
        int s=userDao.add(1,3);
        System.out.println("测试方法获得的值："+s);
    }

基于XML的Spring AOP开发

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

    <!--<context:component-scan base-package=""-->

    <!-- 定义目标对象 -->
    <bean name="productDao" class="com.zejian.spring.springAop.dao.daoimp.ProductDaoImpl" />

    <!-- 定义切面 -->
    <bean name="myAspectXML" class="com.zejian.spring.springAop.AspectJ.MyAspectXML" />
    <!-- 配置AOP 切面 -->
    <aop:config>
        <!-- 定义切点函数 -->
        <aop:pointcut id="pointcut" expression="execution(* com.zejian.spring.springAop.dao.ProductDao.add(..))" />

        <!-- 定义其他切点函数 -->
        <aop:pointcut id="delPointcut" expression="execution(* com.zejian.spring.springAop.dao.ProductDao.delete(..))" />

        <!-- 定义通知 order 定义优先级,值越小优先级越大-->
        <aop:aspect ref="myAspectXML" order="0">
            <!-- 定义通知
            method 指定通知方法名,必须与MyAspectXML中的相同
            pointcut 指定切点函数
            -->
            <aop:before method="before" pointcut-ref="pointcut" />

            <!-- 后置通知  returning="returnVal" 定义返回值 必须与类中声明的名称一样-->
            <aop:after-returning method="afterReturn" pointcut-ref="pointcut"  returning="returnVal" />

            <!-- 环绕通知 -->
            <aop:around method="around" pointcut-ref="pointcut"  />

            <!--异常通知 throwing="throwable" 指定异常通知错误信息变量,必须与类中声明的名称一样-->
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="throwable"/>

            <!--
                 method : 通知的方法(最终通知)
                 pointcut-ref : 通知应用到的切点方法
                -->
            <aop:after method="after" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>
</beans>