从约定编程到理解Spring AOP

2022-06-15 04:56:15

概述

提到Spring 不得不赞叹其IOC 跟AOP 实现之精巧，设计之伟大。平时工作中我们也会通过AOP 去实现一些功能，如对接口环形日志打印，通用的防止重复提交的功能。我觉得第一次感受到AOP 的强大就是其对数据库事务的冗余代码的解放。


在了解Spring aop 之前我们先了解一下约定编程。


约定编程

下面基于Java Proxy实现一个小demo 体验一下什么是约定编程，其实这也是与AOP 有着异曲同工之妙的。

/**
 * 首先创建一个接口
 */
public interface UserService {

    /**
     * say hello
     * @param name 名字
     */
    void sayHello(String name);
}
/**
 * 接着创建一个类实现接口
 */
public class UserServiceImpl implements UserService{
    @Override
    public void sayHello(String name) {
        System.out.println("name:"+name+" hello");
    }
}

以上是准备工作，接下来实现一个约定的接口

/**
 * 首先创建约定编程接口
 * 定义约定的方法
 */
public interface Interceptor {

    /**
     * 事前方法
     *
     * @return 是否
     */
    boolean before();

    /**
     * 事后方法
     */
    void after();

    /**
     * 取代原有事件方法
     *
     * @param invocation 回调参数，可以通过proceed 方法 调用原有目标方法
     * @return 原有事件返回结果
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     */
    Object around(Invocation invocation)throws InvocationTargetException,IllegalAccessException;

    /**
     * 事后返回方法，事件没有发生异常执行
     */
    void afterReturning();

    /**
     * 事后异常方法，当事件发生异常后执行
     */
    void afterThrowing();
}

/**
 * 接着创建约定编程接口的实现
 * 具体实现自己想要的功能
 */
public class MyInterceptor implements Interceptor{
    @Override
    public boolean before() {
        log.info("before.........");
        return true;
    }

    @Override
    public void after() {
        log.info("after ....");
    }

    @Override
    public Object around(Invocation invocation) throws InvocationTargetException, IllegalAccessException {
        log.info("around before.........");
        Object proceed = invocation.proceed();
        log.info("around after.........");
        return proceed;
    }

    @Override
    public void afterReturning() {
        log.info("afterReturning.........");
    }

    @Override
    public void afterThrowing() {
        log.info("afterThrowing.........");
    }
}

/**
 * Invocation 类封装具体反射调用方法
 */
public class Invocation {

    private Object[] params;
    private Method method;
    private Object target;


    public Invocation(Object target,Method method,Object[] params){
        this.target = target;
        this.method = method;
        this.params = params;
    }

    public Object proceed()throws InvocationTargetException,IllegalAccessException{
        return method.invoke(target,params);
    }

}

接下来是重要的核心，使用Java Proxy 来实现动态代理，完成变身大法；

/**
 * Java Proxy 代理需要实现InvocationHandler 接口用来实现动态代理
 */
public class ProxyBean implements InvocationHandler {
    /**
     * 该target变量 存放的是被代理的类
     */
    private Object target = null;

    /**
     * 该interceptor变量存放目标拦截器
     */
    private Interceptor interceptor = null;
    
    /**
     * 构建代理对象方法
     * 
     * @param target 被代理的对象
     * @param interceptor 想要代理时运行的方法对象
     * @return 整合好的代理对象
     */
    public static Object getProxyBean(Object target,Interceptor interceptor){
        ProxyBean proxyBean = new ProxyBean();
        proxyBean.target = target;
        proxyBean.interceptor = interceptor;
        // 通过Proxy 的方法 生成一个代理对象
        Object instance = Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), proxyBean);
        return instance;
    }

    /**
     * 该方法是代理对象在调用被代理对象方法时一定会调用的方法
     * 在此对被代理方法进行包装的主要逻辑，其实等同于aop 中织入的过程
     * 
     * @param proxy 目标对象
     * @param method 代理方法对象
     * @param args 方法入参
     * @return 返回被代理的方法的结果
     * @throws Throwable 抛出异常
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        boolean exceptionFlag = false;
        Invocation invocation = new Invocation(target,method,args);
        Object obj = null;
        try{
            if (this.interceptor.before()){
                obj = this.interceptor.around(invocation);
            }else {
                obj = method.invoke(target,args);
            }
        }catch (Exception ex){
            exceptionFlag = true;
        }
        this.interceptor.after();
        if (exceptionFlag){
            this.interceptor.afterThrowing();
        }else {
            this.interceptor.afterReturning();
            return obj;
        }
        return null;
    }
}

接下来是测试方法

public class ProxyTest {

    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        UserService proxyBean = (UserService) ProxyBean.getProxyBean(userService, new MyInterceptor());
        // 因为是通过Proxy 实现的代理对象，Java 保证代理对象在调用目标方式时，一定会调用其invoke 方法
        proxyBean.sayHello("小明");
    }
}

以上就是完成约定编程的案例，其实细心的读者应该也可以发现，我们定义的约定编程的接口，类似于aop 中的通知（事前通知，事后通知，环绕通知等），而MyInterceptor 类相当于我们的切面，构建代理对象时ProxyBean.getProxyBean 方法，像是将目标对象通进行了绑定，最终代理对象调用目标方法时相当于连接点通过动态代理技术及反射技术完成了织入，不过这些都由框架实现了对我们来说透明了，要想探究其本质，则需要深入源码，遨游一番。


Spring AOP 底层实现

AOP 术语介绍

  • 连接点（join point）：对应的是具体被拦截的对象，因为Spring只能支持方法，所以被拦截的对象往往就是指特定的方法；
  • 切点（point cut）：有时候，切面不单单应用于单个方法，也可能是多个类的不同方法，这时，可以通过正则式和指示器的规则去定义，从而适配连接点。切点就是提供这样一个功能的概念。
  • 通知（advice）：就是按照约定的流程下的方法，分为前置通知（beforeadvice）、后置通知（after advice）、环绕通知（around advice）、事后返回通知（afterReturning advice）和异常通知（afterThrowing advice），它会根据约定织入流程中，需要弄明白它们在流程中的顺序和运行的条件。
  • 目标对象（target）：即被代理对象
  • 引入（introduction）：是指引入新的类和其方法，增强现有Bean的功能。
  • 织入（weaving）：它是一个通过动态代理技术，为原有服务对象生成代理对象，然后将与切点定义匹配的连接点拦截，并按约定将各类通知织入约定流程的过程。
  • 切面（aspect）：是一个可以定义切点、各类通知和引入的内容，Spring AOP将通过它的信息来增强Bean的功能或者将对应的方法织入流程。

基于AOP 实现控制层日志打印

/**
 * controller 层日志打印切面
 */
@Component
@Aspect
@Slf4j
public class ControllerLogHandler {

    @Resource
    private ObjectMapper objectMapper;

    /**
     * 定义切点 该切点就是项目的controller 方法
     */
    @Pointcut("execution(public * com.esaycodin.learn.controller.*.*(..))")
    public void logPointCut() {

    }


    /**
     * 定义具体逻辑
     * 
     * @param joinPoint 切点对象传入
     * @return 结果
     * @throws Throwable 异常
     */
    @Around("logPointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        //判断是否忽略打印日志
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        IgnoreSysLog ignoreSysLog = methodSignature.getMethod().getAnnotation(IgnoreSysLog.class);
        if (ignoreSysLog != null) {
            return joinPoint.proceed();
        }

        //解析请求内容
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = requestAttributes.getRequest();

        //打印入参
        log.info("controller:{}-method:{}-param:{}", joinPoint.getSignature().getDeclaringTypeName(), joinPoint.getSignature().getName(), objectMapper.writeValueAsString(Arrays.toString(joinPoint.getArgs())));
        log.info("remoteAddr:{}-request url:{}-method:{}", request.getRemoteAddr(), request.getRequestURL().toString(), request.getMethod());

        long startTime = System.currentTimeMillis();
        Object result = joinPoint.proceed();

        //执行时长
        log.info("resp value:{}", objectMapper.writeValueAsString(result));
        log.info("cost:{}ms", (System.currentTimeMillis() - startTime));
        return result;
    }

}

/**
 * 忽略controller层中请求的切面日志打印注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface IgnoreSysLog {
}

以上就是我们对学习了AOP 的一个具体功能实现。接下来，我们基于源码探秘一下Spring AOP 是如何实现的吧。


Spring AOP 源码

本次探秘的始发站就是AnnotationAwareAspectJAutoProxyCreator 类。下图为该类的结构关系图：

从约定编程到理解Spring AOP

我们可以看到其实现了BeanPostProcessor,也就是说在IOC 管理bean 的时候会调用BeanPostProcessor 的接口；具体可以看源码，这里指出几个关键方法。父类AbstractAutoProxyCreator的postProcessAfterInitialization 方法被框架调用，其执行过程中wrapIfNecessary方法判断bean 是否需要被AOP。我们具体关注getAdvicesAndAdvisorsForBean 方法及createProxy 方法。

wrapIfNecessary 源码：

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // 处理过不需要进行aop 逻辑
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    } else if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
        // 不是基础类的bean 且没有标识不需要自动代理的bean 也就是说要过自动代理的流程的bean 走以下逻辑
    } else if (!this.isInfrastructureClass(bean.getClass()) && !this.shouldSkip(bean.getClass(), beanName)) {
        // 获取AOP 相关切面几切面bean
        Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, (TargetSource)null);
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            // 创建proxy
            Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        } else {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }
    } else {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }
}

根据上面的方法，其实可以分析出，this.getAdvicesAndAdvisorsForBean 方法其实是对整个框架进行搜索Advisors 并确定与该bean 有关的advisor。


匹配bean合适的Advices

沿着getAdvicesAndAdvisorsForBean 该方法走我们会来到AnnotationAwareAspectJAutoProxyCreator 的findCandidateAdvisors 方法往下走会看到一个比较关键的方法就是BeanFactoryAspectJAdvisorsBuilder的buildAspectJAdvisors()；该方法实现的功能是

  • 获取所有beanName，并将其从beanFacotry 中提取出来
  • 遍历所有的bean，并找出AspectJ 注解类，进行进一步的处理
  • 对标记为AspectJ注解的类进行提取
  • 将提取结果加入缓存（这一步就是再有其它bean 需要绑定时节省了获取的步骤了）

感兴趣的可以对照源码。

advice获取到了那么接下来就需要找到与当前bean匹配的了，具体的方法是AbstractAdvisorAutoProxyCreator类的findAdvisorsThatCanApply ；当我们找到了匹配的则进入到创建代理的流程。


创建代理

对于代理类的创建及处理，Srping 委托给了ProxyFactory来进行，接下来通过DefaultAopProxyFactory 下的createAopProxy 方法来看Spring 是通过什么来选择代理技术的：

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    if (!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
        return new JdkDynamicAopProxy(config);
    } else {
        Class<?> targetClass = config.getTargetClass();
        if (targetClass == null) {
            throw new AopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
        } else {
            return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
        }
    }
}

从上面可以看出：

  • 如果目标对象实现了接口，默认情况下会采用Java的动态代理实现AOP。
  • 如果目标对象实现了接口，可以强制使用CGLIB实现AOP。
  • 如果目标对象没有实现了接口，必须采用CGLIB库，Spring会自动在JavaJava动态代理和CGLIB之间转换。


如何强制使用CGLIB 做AOP 代理？

  • 在SpringBoot 2.x中，如果需要替换使用Java动态代理可以通过配置项spring.aop.proxy-target-class=false来进行修改


Java动态代理和CGLIB字节码生成的区别？

  • Java动态代理只能对实现了接口的类生成代理，而不能针对类。
  • CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法，因为是继承，所以该类或方法最好不要声明成final。


由此结合开始的约定编程的案例，可以了解到Java Proxy 的调用流程，CGlib 则是通过构建一个链，串联的将方法进行增强。篇幅有限，就不过多介绍CGlib 了。


到此对于Spring AOP 的理解就告一段落了，大家加油。


上一篇：写写Java 内存模型


下一篇：从手写同步工具到了解AQS