Java中Spring @Lazy延遲注入的示例分析

小編給大家分享一下Java中Spring @Lazy延遲注入的示例分析，相信大部分人都還不怎么了解，因此分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后大有收獲，下面讓我們一起去了解一下吧！

一、一個簡單的小例子

代碼如下：

@Service
public class NormalService1 {

	@Autowired
	@Lazy
	private MyService myService;

	public void doSomething() {
		myService.getName();
	}
}

作用是為了進行延遲加載，在NormalService1進行屬性注入的時候，如果MyService還沒有生成bean也不用擔心，會注入一個代理，但是在實際運行的時候，會獲取Spring容器中實際的MyService，在某些情況下，因為spring生命周期的原因，這個注解有大用。

二、源碼解讀

1. 注入

代碼如下(DefaultListableBeanFactory#resolveDependency)：

public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

		descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
		if (Optional.class == descriptor.getDependencyType()) {
			return createOptionalDependency(descriptor, requestingBeanName);
		}
		else if (ObjectFactory.class == descriptor.getDependencyType() ||
				ObjectProvider.class == descriptor.getDependencyType()) {
			return new DependencyObjectProvider(descriptor, requestingBeanName);
		}
		else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
			return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
		}
		else {
			//如果注入屬性添加了@Lazy，懶加載，此時spring會根據具體類型搞個cglib代理類
			Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
					descriptor, requestingBeanName);
			if (result == null) {
				result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
			}
			return result;
		}
	}

很明顯要執行getLazyResolutionProxyIfNecessary方法，如果加了@Lazy注解，最終會執行buildLazyResolutionProxy方法

protected Object buildLazyResolutionProxy(final DependencyDescriptor descriptor, final @Nullable String beanName) {
		Assert.state(getBeanFactory() instanceof DefaultListableBeanFactory,
				"BeanFactory needs to be a DefaultListableBeanFactory");
		final DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) getBeanFactory();
		TargetSource ts = new TargetSource() {
			@Override
			public Class<?> getTargetClass() {
				return descriptor.getDependencyType();
			}
			@Override
			public boolean isStatic() {
				return false;
			}
			@Override
			public Object getTarget() {
				Object target = beanFactory.doResolveDependency(descriptor, beanName, null, null);
				/**
				something valid
				**/
				return target;
			}
			@Override
			public void releaseTarget(Object target) {
			}
		};
		ProxyFactory pf = new ProxyFactory();
		pf.setTargetSource(ts);
		Class<?> dependencyType = descriptor.getDependencyType();
		if (dependencyType.isInterface()) {
			pf.addInterface(dependencyType);
		}
		return pf.getProxy(beanFactory.getBeanClassLoader());
	}

可以看到上面這段代碼，其實就是生成了一個TargetSource，然后再生成了一個代理（CGLIB或者JDK），然后作為MyService對象注入給了NormalService1。那么所謂的執行的過程中才進行獲取真正的MyService對象是什么意思呢？

2. 使用邏輯

本文示例代碼使用的是CGLIB代理，其實是類似的，因為注入的MyService是個CGLIB代理對象，那么在執行方法的時候，就會調用CglibAopProxy#DynamicAdvisedInterceptor#intercept方法

那么此處其實調用的就是上面的

Object target = beanFactory.doResolveDependency(descriptor, beanName, null, null);

這個方法就不用認真看了，主要功能就是從Spring容器中找到MyService。
在之前講@Autowired原理和@Resource注入原理的時候解釋過了，不清楚的可以看專欄里其他文章。
拿出來之后會發現，咱們拿到的target對象還是一個CGLIB代理的對象

那么當執行方法邏輯時

由于target是CGLIB對象，會再次進入到CglibAopProxy#DynamicAdvisedInterceptor#intercept方法。
此時拿到的target對象類型就不同了

是我們代理之前的target對象，此時再次進行invoke的時候，就會進行動態代理的一般邏輯，先查找該方法匹配的所有advice，然后依次調用，最終調用target本身對于方法的執行。

總結

所以可以發現其實@Lazy只不過是給spring的代理對象proxy再進行了一次proxy，只不過沒有在注入的時候，就獲取到對象，而是借用了方法invoke時通過proxy的intercept方法getTarget，然后進行方法調用，延遲了對象的注入。之后每次調用的時候都需要從Spring容器中獲取到原生的proxy對象。

以上是“Java中Spring @Lazy延遲注入的示例分析”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！