Spring源码学习(十四)---Aop知识点总结和Advice接口的增强测试(含代码)

这里主要是使用org.springframework:spring-beans:5.2.0.RELEASE进行分析

1. 查看源码相关的快捷键

快捷键	作用
Ctrl + Shift+i	出现类似于预览的小窗口
Ctrl + Enter	（接上步）完全打开源码
Ctrl + 鼠标左键	一步到位打开源码 = Ctrl + Shift+i –>Ctrl + Enter
Alt+7	查看类的有什么方法
ctrl+f12	查看继承方法
ctrl+h	查看接口的实现类
alt+7	查看类的有什么方法
2下shift	全局搜索整个项目

一. Aop知识点总结

1. 连接点（Jointpoint）：表示需要在程序中插入横切关注点的扩展点，连接点可能是类初始化、方法执行、方法调用、字段调用或处理异常等等，Spring只支持方法执行连接点，在AOP中表示为“在哪里干”；
2. 切入点（Pointcut）：选择一组相关连接点的模式，即可以认为连接点的集合，Spring支持perl5正则表达式和AspectJ切入点模式，Spring默认使用AspectJ语法，在AOP中表示为“在哪里干的集合”；
3. 增强（Advice）：很多地方理解为通知，但是理解为增强更为准确，增强表示在连接点上执行的行为，增强提供了在AOP中需要在切入点所选择的连接点处进行扩展现有行为的手段；包括前置增强（before advice）、后置增强(after advice)、环绕增强（around advice），在Spring中通过代理模式实现AOP，并通过拦截器模式以环绕连接点的拦截器链织入增强；在AOP中表示为“干什么”；
4. 方面/切面（Aspect）：横切关注点的模块化，比如上边提到的日志组件。可以认为是增强、引入和切入点的组合；在Spring中可以使用Schema和@AspectJ方式进行组织实现；在AOP中表示为“在哪干和干什么集合”；
5. 引介增强（inter-type declaration）：引介增强是一个比较特殊的增强，它不是在目标方法周围织入增强，而是为目标类创建新的方法或属性，所以引介增强的连接点是类级别的，而非方法级别的，Spring允许引入新的接口（必须对应一个实现）到所有被代理对象（目标对象）, 在AOP中表示为“干什么（引入什么）”；
6. 目标对象（Target Object）：需要被织入横切关注点的对象，即该对象是切入点选择的对象，需要被增强的对象，从而也可称为“被增强对象”；由于Spring AOP 通过代理模式实现，从而这个对象永远是被代理对象，在AOP中表示为“对谁干”；
7. AOP代理（AOP Proxy）：AOP框架使用代理模式创建的对象，从而实现在连接点处插入增强（即应用切面），就是通过代理来对目标对象应用切面。在Spring中，AOP代理可以用JDK动态代理或CGLIB代理实现，而通过拦截器模型应用切面。
8. 织入（Weaving）：织入是一个过程，是将切面应用到目标对象从而创建出AOP代理对象的过程，织入可以在编译期、类装载期、运行期进行。

二. Advice接口的增强测试–使用配置文件

测试一个含异常的delete方法

测试一个不含异常的add方法

被增强的接口

package com.xizi.service;

public interface UserService {
    public  void add();
    public  void delete();
    public  void update();
    public  void select(int id,String name);
}

被增强的接口的实现类

package com.xizi.service;

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

    public void delete() {
        System.out.println("删除了一个用户");
        System.out.println("==抛出异常==：" + 1 / 0);
    }

    public void update() {
        System.out.println("更新了一个用户");
    }

    public void select(int id,String name) {
        System.out.println("查询了一个用户");
        System.out.println("id="+id+"  name="+name);
    }
}

前置增强

package com.xizi.log;

import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;

/**
 * 前置增强
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {

	@Override
	public void before(Method method, Object[] args, Object target) throws Throwable {
		System.out.println("==前置增强开始==");
		System.out.println("==方法名=：" + method.getName());
		if (null != args && args.length > 0) {
			for (int i = 0; i < args.length; i++) {
				System.out.println("==第" + (i + 1) + "参数：" + args[i]);
			}
		}
		System.out.println("==目标类信息==：" + target.toString());
	}
}

后置增强

package com.xizi.log;

import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;

/**
 * 后置增强
 */
public class MyAfterReturningAdvice implements AfterReturningAdvice {

	@Override
	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
		System.out.println("==后置增强开始==");
		System.out.println("==方法名=：" + method.getName());
		if (null != args && args.length > 0) {
			for (int i = 0; i < args.length; i++) {
				System.out.println("==第" + (i + 1) + "参数：" + args[i]);
			}
		}
		System.out.println("==目标类信息：" + target.toString());
	}
}

环绕增强

package com.xizi.log;

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

/**
 * 环绕增强
 */
public class MyMethodInterceptor implements MethodInterceptor {

	/**
	 * 环绕增强 这里的方法参数与之前的前置增强、后置增强明显不同，只有一个MethodInvocation类型的参数

	 */
	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		System.out.println("==环绕增强开始==");
		System.out.println("==方法名：" + invocation.getMethod().getName());
		Object[] args = invocation.getArguments();
		if (null != args && args.length > 0) {
			for (int i = 0; i < args.length; i++) {
				System.out.println("==第" + (i + 1) + "参数：" + args[i]);
			}
		}

		Object proceed = invocation.proceed();

		System.out.println("==环绕增强结束==");
		return proceed;
	}
}

异常增强

package com.xizi.log;

import org.springframework.aop.ThrowsAdvice;
import java.lang.reflect.Method;

public class MyThrowsAdvice implements ThrowsAdvice {

	/**
	 * 异常增强
	 */
	public void afterThrowing(Method method, Object[] args, Object target, Exception ex) {
		System.out.println("==异常增强==");
		System.out.println("==方法名：" + method.getName());
		if (null != args && args.length > 0) {
			for (int i = 0; i < args.length; i++) {
				System.out.println("==第" + (i + 1) + "参数：" + args[i]);
			}
		}
		System.out.println("==目标类信息：" + target.toString());
		System.out.println("==异常信息：" + ex.toString());
	}
}

在配置文件中将增强的方法全部进行切入

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

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

    <!--方式一 使用原生Spring API接口-->
    <!--注册bean-->
    <bean id="userService" class="com.xizi.service.UserServiceImpl"/>
    <!--前置增强-->
    <bean id="myMethodBeforeAdvice" class="com.xizi.log.MyMethodBeforeAdvice"/>
    <!--后置增强-->
    <bean id="myAfterReturningAdvice" class="com.xizi.log.MyAfterReturningAdvice"/>
    <!--环绕增强-->
    <bean id="myMethodIntercepter" class="com.xizi.log.MyMethodInterceptor"/>
    <!--异常增强-->
    <bean id="myThrowsAdvice" class="com.xizi.log.MyThrowsAdvice"/>

    <!--配置aop-->
    <aop:config>
        <!--切入点 expression表达式  (要执行的位置)-->
        <aop:pointcut id="pointcut" expression="execution(* com.xizi.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增加-->
        <aop:advisor advice-ref="myMethodBeforeAdvice" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="myAfterReturningAdvice" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="myMethodIntercepter" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="myThrowsAdvice" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

测试编写

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

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

三. Advice接口的增强测试–使用代理对象

这里就测试一个前置增强，其他的都是一样的

使用ProxyFactory代理对象并设置代理目标和增强

 @Test
    public void test5() {
        // 前置增强
        // 1、实例化bean和增强
        UserService userService = new UserServiceImpl();
        MyMethodBeforeAdvice advice = new MyMethodBeforeAdvice();
        // 2、创建ProxyFactory并设置代理目标和增强
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(userService);
        proxyFactory.addAdvice(advice);
        // 3、生成代理实例
        UserService proxyUser = (UserService) proxyFactory.getProxy();
        proxyUser.select(66,"戏子");
    }