Spring源码核心剖析-低调大师

Spring源码核心剖析

2023-03-27 206

作者：京东科技韩国凯

前言

SpringAOP作为Spring最核心的能力之一，其重要性不言而喻。然后需要知道的是AOP并不只是Spring特有的功能，而是一种思想，一种通用的功能。而SpringAOP只是在AOP的基础上将能力集成到SpringIOC中，使其作为bean的一种，从而我们能够很方便的进行使用。

一、SpringAOP的使用方式

1.1 使用场景

当我们在日常业务开发中，例如有些功能模块是通用的（日志、权限等），或者我们需要在某些功能前后去做一些增强，例如在某些方法执行后发送一条mq消息等。

如果我们将这些通用模块代码与业务代码放在一块，那么每个业务代码都要写这些通用模块，维护成本与耦合情况都十分严重。

因此，我们可以将此模块抽象出来，就有了”切面“的概念。

1.2 常用方式

AOP的使用方式相对比较简单，首先我们需要完成业务代码

@Service
public class AopDemo implements AopInterface{

    public Student start(String name) {
        System.out.println("执行业务逻辑代码.....");
        return new Student(name);
    }

}

业务逻辑比较简单，接收一个name参数。

接下来我们需要创建其对应的切面

//将该切面加入spring容器
@Service
//声明该类为一个切面
@Aspect
class AopAspect {

    //声明要进行代理的方法
    @Pointcut("execution(* com.example.demo.aop.AopInterface.start(..))")
    public void startAspect() {
    }

    //在方法执行之前的逻辑
    @Before(value = "startAspect()")
    public void beforeAspect() {
        System.out.println("业务逻辑前代码.....");
    }

    //在方法执行之后的逻辑
    @After(value = "startAspect()")
    public void afterAspect() {
        System.out.println("业务逻辑后代码.....");
    }

    //围绕方法前后的逻辑
    @Around("startAspect()")
    public Object aroundAspect(ProceedingJoinPoint point) throws Throwable {
        Object[] requestParams = point.getArgs();
        String name = requestParams[0].toString();
        System.out.println("传入参数:" + name);
        requestParams[0] = "bob";
        return point.proceed(requestParams);
    }

}

可以看到，首先需要我们指明要代理的对象及方法，然后根据需要选择不同的注解即可实现代理对象。

传入参数:tom
业务逻辑前代码.....
执行业务逻辑代码.....
业务逻辑后代码.....

二、SpringAOP源码解析

2.1 被代理对象的开始initializeBean

根据上面的使用情况，我们知道只需要声明对应的注解即可，不需要其他额外的配置，然后我们获得的bean对象就已经是被代理的了，那么我们可以推断代理对象的过程一定是发生在bean创建的过程的。

我们回顾一下创建bean的流程

实例化bean
装配属性
初始化bean

只有第三步初始化bean的时候才会有机会进行代理。

找到对应的代码位置：

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
      //前置处理器
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }
	 //...
   try {
      //对象的初始化方法
      invokeInitMethods(beanName, wrappedBean, mbd);
   }
   if (mbd == null || !mbd.isSynthetic()) {
      //后置处理器，AOP开始的地方
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }

   return wrappedBean;
}

2.2 后置处理器applyBeanPostProcessorsAfterInitialization

后置处理器会执行那些实现了后置处理器接口的代码：

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
      throws BeansException {

   Object result = existingBean;
   //获取所有的后置处理器
   for (BeanPostProcessor processor : getBeanPostProcessors()) {
      //实现其要执行的方法
      Object current = processor.postProcessAfterInitialization(result, beanName);
      if (current == null) {
         return result;
      }
      result = current;
   }
   return result;
}

而AOP的后置处理器就是其中的一个： AbstractAutoProxyCreator

其对应的方法为（以下代码不为同一个类，而是对应的执行顺序）：

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
   if (bean != null) {
      Object cacheKey = getCacheKey(bean.getClass(), beanName);
      if (this.earlyProxyReferences.remove(cacheKey) != bean) {
         //执行到下面方法
         return wrapIfNecessary(bean, beanName, cacheKey);
      }
   }
   return bean;
}

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		// Create proxy if we have advice.
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
		if (specificInterceptors != DO_NOT_PROXY) {
			this.advisedBeans.put(cacheKey, Boolean.TRUE);
      //创建代理对象
			Object proxy = createProxy(
					bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		}

		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
}

protected Object createProxy(Class beanClass, @Nullable String beanName,
			@Nullable Object[] specificInterceptors, TargetSource targetSource) {

		//获取advisors
		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
		proxyFactory.addAdvisors(advisors);
		proxyFactory.setTargetSource(targetSource);
		customizeProxyFactory(proxyFactory);

		proxyFactory.setFrozen(this.freezeProxy);
		if (advisorsPreFiltered()) {
			proxyFactory.setPreFiltered(true);
		}

		// Use original ClassLoader if bean class not locally loaded in overriding class loader
		ClassLoader classLoader = getProxyClassLoader();
		if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader()) {
			classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
		}
    //通过代理工厂创建代理对象
		return proxyFactory.getProxy(classLoader);
}

public Object getProxy(@Nullable ClassLoader classLoader) {
    //首先获取对应的代理
		return createAopProxy().getProxy(classLoader);
}

//该方法根据要被代理的类选择使用jdk代理还是cglib代理
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		if (!NativeDetector.inNativeImage() &&
				(config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {
			Class targetClass = config.getTargetClass();
      //如果被代理的类是一个接口则使用jdk代理
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass) || ClassUtils.isLambdaClass(targetClass)) 			{
				return new JdkDynamicAopProxy(config);
			}
      //否则使用cglib代理
			return new ObjenesisCglibAopProxy(config);
		}
		else {
      //根据配置选择强制使用jdk代理
			return new JdkDynamicAopProxy(config);
		}
}

我们知道，代理方式有jdk动态代理与cglib动态代理两种方式，而我们一个bean使用那种代理方式则由上述的方法决定。

至此，我们已经确定了使用那种代理方式获取代理对象。

2.3 获取代理对象

从上文中，我们已经确定了选用何种方式构建代理对象。接下来就是通过不同的方式是如何获取代理对象的。

看懂本章需要实现了解jdk动态代理或者cglib动态代理的方式。

2.3.1 JDK代理

首先在获取代理对象时选择 JdkDynamicAopProxy

public Object getProxy(@Nullable ClassLoader classLoader) {
   if (logger.isTraceEnabled()) {
      logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
   }
   //这里通过反射创建代理对象
   return Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this);
}

当被代理对象执行被代理的方法时，会进入到此方法。（jdk动态代理的概念）

JDK通过反射创建对象，效率上来说相对低一些。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

		try {
			// 获取被代理对象的所有切入点
			List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

			// 如果调用链路为空说明没有需要执行的切入点，直接执行对应的方法即可
			if (chain.isEmpty()) {
				// We can skip creating a MethodInvocation: just invoke the target directly
				// Note that the final invoker must be an InvokerInterceptor so we know it does
				// nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
				Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
				retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
			}
			else {
				// 如果有切入点的话则按照切入点顺序开始执行
				MethodInvocation invocation =
						new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
				// Proceed to the joinpoint through the interceptor chain.
				retVal = invocation.proceed();
			}
			
			return retVal;
		}
}

invocation.proceed();这个方法就是通过递归的方式执行所有的调用链路。

public Object proceed() throws Throwable {
   // We start with an index of -1 and increment early.
   if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
      return invokeJoinpoint();
   }

   Object interceptorOrInterceptionAdvice =
         this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
   if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
      InterceptorAndDynamicMethodMatcher dm =
            (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
      Class targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
      if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
         return dm.interceptor.invoke(this);
      }
      else {
         // 继续执行
         return proceed();
      }
   }
   else {
      // 如果调用链路还持续的话，下一个方法仍会调用proceed()
      return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
   }
}

`2.3.2 cglib代理`

public Object getProxy(@Nullable ClassLoader classLoader) {

   try {
      //配置CGLIB Enhancer...
      Enhancer enhancer = createEnhancer();
      if (classLoader != null) {
         enhancer.setClassLoader(classLoader);
         if (classLoader instanceof SmartClassLoader &&
               ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
            enhancer.setUseCache(false);
         }
      }
      enhancer.setSuperclass(proxySuperClass);
      enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
      enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
      enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));

      //1.获取回调函数,对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept()方法
      Callback[] callbacks = getCallbacks(rootClass);
      Class[] types = new Class[callbacks.length];
      for (int x = 0; x < types.length; x++) {
         types[x] = callbacks[x].getClass();
      }
      // fixedInterceptorMap only populated at this point, after getCallbacks call above
      enhancer.setCallbackFilter(new ProxyCallbackFilter(
            this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
      enhancer.setCallbackTypes(types);

      //2.创建代理对象
      return createProxyClassAndInstance(enhancer, callbacks);
   }
   catch (CodeGenerationException | IllegalArgumentException ex) {
      throw new AopConfigException("Could not generate CGLIB subclass of " + this.advised.getTargetClass() +
            ": Common causes of this problem include using a final class or a non-visible class",
            ex);
   }
   catch (Throwable ex) {
      // TargetSource.getTarget() failed
      throw new AopConfigException("Unexpected AOP exception", ex);
   }
}

可以看到我们在创建代理对象前会先获取代理对象的所有回调函数：

首先可以看到我们一共有7个回调方法，其中第一个为AOP相关的方法，其他的为spring相关。

在第一个对调对象中持有的 advised对象中有 advisors属性，就是对应我们的代理类中四个切片，@Before等等。

然后我们看一下 createProxyClassAndInstance()都做了什么。

//CglibAopProxy类的创建代理对象方法
protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
   enhancer.setInterceptDuringConstruction(false);
   enhancer.setCallbacks(callbacks);
   return (this.constructorArgs != null && this.constructorArgTypes != null ?
         enhancer.create(this.constructorArgTypes, this.constructorArgs) :
         enhancer.create());
}

//ObjenesisCglibAopProxy继承了CglibAopProxy类，并覆写了其方法
protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
		Class proxyClass = enhancer.createClass();
		Object proxyInstance = null;

    //1.尝试使用objenesis创建对象
		if (objenesis.isWorthTrying()) {
			try {
				proxyInstance = objenesis.newInstance(proxyClass, enhancer.getUseCache());
			}
			catch (Throwable ex) {
				logger.debug("Unable to instantiate proxy using Objenesis, " +
						"falling back to regular proxy construction", ex);
			}
		}

    //2.根据commit的提交记录发现，objenesis有可能创建对象失败，如果失败的话则选用放射的方式创建对象
		if (proxyInstance == null) {
			// Regular instantiation via default constructor...
			try {
				Constructor ctor = (this.constructorArgs != null ?
						proxyClass.getDeclaredConstructor(this.constructorArgTypes) :
						proxyClass.getDeclaredConstructor());
				ReflectionUtils.makeAccessible(ctor);
				proxyInstance = (this.constructorArgs != null ?
						ctor.newInstance(this.constructorArgs) : ctor.newInstance());
			}
			catch (Throwable ex) {
				throw new AopConfigException("Unable to instantiate proxy using Objenesis, " +
						"and regular proxy instantiation via default constructor fails as well", ex);
			}
		}

    //
		((Factory) proxyInstance).setCallbacks(callbacks);
		return proxyInstance;
	}

`2.3.3 cglib`

此处有个遇到的问题，当我在debug的时候，发现怎么都进不去 createProxyClassAndInstance()，百思不得其解，然后看到IDEA旁边有一个向下的箭头，代表该方法可能其子类被覆写了。然后在其子类处打断点果然发现是其子类的实现。

此处在2.2中也可看到：

可以看到返回的是其子类的对象，而不是CglibAopProxy本身的对象。

微信关注我们

原文链接：https://my.oschina.net/u/4090830/blog/8590985

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

如果用ChatGpt给OpenTiny官网设计页面会怎样？

听说华为云最近新开源了一个组件库项目，叫OpenTiny。作为一个编程爱好者和对组件库有使用需求的程序猿来讲，必须要看看这个OpenTiny到底有什么不一样，让我立马打开了OpenTiny官网一看究竟。首先大概了解到OpenTiny是一套华为云出品的企业级组件库解决方案，适配 PC 端/移动端等多端，涵盖 Vue2 / Vue3 / Angular 多技术栈，拥有主题配置系统 / 中后台模板 / CLI 命令行等效率提升工具，可帮助我们开发者高效开发 Web 应用。首先能看到这个组件还是非常丰富的，如果不断迭代优化，应该后面也会陆续更新更多，听说这个项目也是经过九年持续打磨，服务于华为内外部上千个项目，千锤百炼，如果真的是这样，想必用起来也是一个稳定可靠的组件库。进入OpenTiny官网后发现这个页面主要是采用了四种色系，有天空蓝、极客黑、清爽白、松石绿，据说这个也是结合了华为云设计规范、El行业设计、软件云设计还有其他视觉主题。整体看上去给人一种很清爽的感觉。同时进入OpenTiny官网后，发现里面一共有三个项目包含TinyVue、TinyNg和覆盖前端开发全流程的脚手架工...

2023-03-25

377

文章目录一、数据类型转换场景二、数据类型转换及示例 1、cast(value AS type) 2、to_date(text) 3、to_date(text,format) 4、to_char(datetime, format) 5、to_char(string) 6、CASE 表达式三、小结一、数据类型转换场景数据类型转换在实际应用中非常常见。GaussDB作为一款企业级分布式关系型数据库，在实际业务场景使用中，也会避免不了数据类型的转换。以下是一些数据类型转换的应用场景： 数据清洗与转换：在数据分析和处理中，经常需要对数据进行清洗和转换，例如将文本数据转换为数字格式，将日期格式转换为文本格式等。 数据格式化：在输出数据时，需要将数据格式化为合适的格式，例如将数字格式化为货币格式、百分比格式等。 数据计算：在进行数据计算时，需要对数据类型进行转换，例如将整数类型的数据转换为浮点数类型的数据，以便进行精确的计算或处理。 数据存储：在将数据存储到数据库中时，需要将不同类型的数据转换为数据库支持的数据类型，以便正确地存储和查询数据。 数据传输：在数据传输过程中，需要...

2023-03-27

674

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。