精华内容
下载资源
问答
  • java中死循环什么意思 循环一次不再循环是死循环 还是不断循环才是死循环 能否简单的举个死循环单身例子
  • Java嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。whiledo.while、for循环语句都可以进行嵌套,并且它们之间也可以互相嵌套,如最常见的在for循环中嵌套for循环, Java嵌套循环格式如下:  ...

     

      Java嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。whiledo.while、for循环语句都可以进行嵌套,并且它们之间也可以互相嵌套,如最常见的在for循环中嵌套for循环, Java嵌套循环格式如下:

      for(初始化表达式;循环条件;操作表达式){

      for(初始化表达式;循环条件;操作表达式){

      执行语句

      }

      }

      下面我们通过案例Example.java 来介绍。

      public class Example{

      public static void main(String[] args){

      int i,j; //定义两个循环变量

      for(i=1;i i++){ //外层循环

      for (j=1;j j++){ //内层循环

      System.out.print( * //打印*

      }

      System.out.print( \n //换行

      }

      }

      }

      上面程序运行结果如下:

      *

      **

      ***

      ****

      *****

      ******

      *******

      ********

      *********

      Java循环嵌套是什么意思,叩丁狼Java循环嵌套实例

      上面案例中定义了两层for循环,分别为外层循环和内层循环,外层循环用于控制打印的行数,内层循环用于打印 * ,每一行的 * 个数逐行增加,最后输出一个直角三角形。由于嵌套循环程序比较复杂,下面分步骤进行详细地讲解,具体如下:

      第一步,在第3行代码定义了两个循环变量i和j,其中i为外层循环变量,j为内层循环变量。

      第二步,在第4行代码将i初始化为1,条件i =9为true,首次进入外层循环的循环体。

      第三步,在第5行代码将j初始化为1,由于此时i的值为1,条件j =i为true,首次进入内层循环的循环体,打印一个 * 。

      第四步,执行第5行代码中内层循环的操作表达式计j++,将j的值自增为2。

      第五步,执行第5行代码中的判断条件j =i,判断结果为fase,内层循环结束。执行后面的代码,打印换行符。

      第六步,执行第4行代码中外层循环的操作表达式计i++,将i的值自增为2。

      第七步,执行第4行代码中的判断条件i =9,判断结果为true,进入外层循环的循环体,继续执行内层循环。

      第八步,由于i的值为2,内层循环会执行两次,即在第2行打印两个 * 。在内层循环结束时会打印换行符。

      第九步,依此类推,在第3行会打印3个 * ,逐行递增,直到i的值为10时,外层循

      环的判断条件i =9结果为 false,外层循环结束,整个程序也就结束了。

      以上小编通过一个实例为您介绍了 java循环嵌套 以及在具体实例中java循环嵌套的具体运行过程,希望对您有所帮助。如果您在学习java中还遇到其他问题,建议您下载我们的java视频教程同步学习,或者点击咨询按钮获得我们的帮助。

     

    展开全文
  • Java语言中for循环中间带有一个冒号,是什么意思?这种方式的用处是什么
  • java语言里for循环中间有一个冒号是什么意思,有两个分号是什么意思
  • ![图片说明](https://img-ask.csdn.net/upload/201706/23/1498195648_960097.png)
  • site: for (AirSite site : sites) { if (site.getIsCityStatistics() == 1 || site.getIsCityStatistics() == 2) { cityList.add(count++, envRegion2);...site:什么意思啊?break site又是什么意思
  • 这句话是什么意思什么时候跳出循环? 一、先对i的值进行判断 如果i的值0就退出 二、计算:i=i-1 再重复操作! i--表示先使用i,再让i=i-1。 假设初始i=3。第一次while()里的是3,while(3)=>此时i=2(i--...

    while(i--);这句话是什么意思,什么时候跳出循环?

    一、先对i的值进行判断 如果i的值0就退出
    二、计算:i=i-1
    
    再重复操作!

    i--表示先使用i,再让i=i-1。
    假设初始i=3。第一次while()里的是3,while(3)=>此时i=2(i--的缘故);C里非0都是true接着while(2)=>此时i=1;while(1)=>此时i=0,在下一次while判定时,while(0),停止循环。循环了3次。即可推论出,while(i--)将循环i次


    初次之外还有--i:先让i=i-1,再把i用作运算,如果是while(--i),那么将循环i-1次

    展开全文
  • 基于门控循环神经网络词性标注的蒙汉机器翻译研究.pdf
  • 多线程中的忙循环什么?

    千次阅读 2018-02-26 09:56:02
    循环就是程序员用循环让一个线程等待,不像传统方法wait(), sleep() 或 yield() 它们都放弃了CPU控制,而忙循环不会放弃CPU,它就是在运行一个空循环。这么做的目的是为了保留CPU缓存,在多核系统中,一个等待线程...
            忙循环就是程序员用循环让一个线程等待,不像传统方法wait(), sleep() 或 yield() 它们都放弃了CPU控制,而忙循环不会放弃CPU,它就是在运行一个空循环。这么做的目的是为了保留CPU缓存,在多核系统中,一个等待线程醒来的时候可能会在另一个内核运行,这样会重建缓存。为了避免重建缓存和减少等待重建的时间就可以使用它了。
    展开全文
  • 什么是循环依赖? 顾名思义,循环依赖就是A依赖B,B又依赖A,两者之间的依赖关系形成了一个圆环,通常是由于不正确的编码所导致。Spring只能解决属性循环依赖问题,不能解决构造函数循环依赖问题,因为这个问题无解...

    什么是循环依赖?

    顾名思义,循环依赖就是A依赖B,B又依赖A,两者之间的依赖关系形成了一个圆环,通常是由于不正确的编码所导致。Spring只能解决属性循环依赖问题,不能解决构造函数循环依赖问题,因为这个问题无解。

    接下来我们首先写一个Demo来演示Spring是如何处理属性循环依赖问题的。

    Talk is cheap. Show me the code

    第一步:定义一个类ComponentA,其有一个私有属性componentB。

    package com.tech.ioc;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    /**
     * @author 君战
     * **/
    @Component
    public class ComponentA {
    
    	@Autowired
    	private ComponentB componentB;
    
    	public void say(){
    		componentB.say();
    	}
    
    }
    
    

    第二步:定义一个类ComponentB,其依赖ComponentA。并定义一个say方法便于打印数据。

    package com.tech.ioc;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    /**
     * @author 君战
     * **/
    @Component
    public class ComponentB {
    
    	@Autowired
    	private ComponentA componentA;
    
    	public void say(){
    		System.out.println("componentA field " + componentA);
    		System.out.println(this.getClass().getName() + " -----> say()");
    	}
    
    }
    
    

    第三步:重点,编写一个类-SimpleContainer,模仿Spring底层处理循环依赖。如果理解这个代码,再去看Spring处理循环依赖的逻辑就会很简单。

    package com.tech.ioc;
    
    import java.beans.Introspector;
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * 演示Spring中循环依赖是如何处理的,只是个简版,真实的Spring依赖处理远比这个复杂。
     * 但大体思路都相同。另外这个Demo很多情况都未考虑,例如线程安全问题,仅供参考。
     * @author 君战
     *
     * **/
    public class SimpleContainer {
    
    	/***
    	 * 用于存放完全初始化好的Bean,Bean处于就绪状态
    	 * 这个Map定义和Spring中一级缓存命名一致
    	 * */
    	private Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
    
    	/***
    	 * 用于存放刚创建出来的Bean,其属性还没有处理,因此存放在该缓存中的Bean还不可用。
    	 * 这个Map定义和Spring中三级缓存命名一致
    	 * */
    	private final Map<String, Object> singletonFactories = new HashMap<>(16);
    
    
    	public static void main(String[] args) {
    		SimpleContainer container = new SimpleContainer();
    		ComponentA componentA = container.getBean(ComponentA.class);
    		componentA.say();
    	}
    
    	public <T> T getBean(Class<T> beanClass) {
    		String beanName = this.getBeanName(beanClass);
    		// 首先根据beanName从缓存中获取Bean实例
    		Object bean = this.getSingleton(beanName);
    		if (bean == null) {
    			// 如果未获取到Bean实例,则创建Bean实例
    			return createBean(beanClass, beanName);
    		}
    		return (T) bean;
    	}
    	/***
    	 * 从一级缓存和二级缓存中根据beanName来获取Bean实例,可能为空
    	 * */
    	private Object getSingleton(String beanName) {
    		// 首先尝试从一级缓存中获取
    		Object instance = singletonObjects.get(beanName);
    		if (instance == null) { // Spring 之所以能解决循环依赖问题,也是靠着这个三级缓存--singletonFactories
    			instance = singletonFactories.get(beanName);
    		}
    		return instance;
    	}
    
    	/***
    	 * 创建指定Class的实例,返回完全状态的Bean(属性可用)
    	 *
    	 * */
    	private <T> T createBean(Class<T> beanClass, String beanName) {
    		try {
    			Constructor<T> constructor = beanClass.getDeclaredConstructor();
    			T instance = constructor.newInstance();
    			// 先将刚创建好的实例存放到三级缓存中,如果没有这一步,Spring 也无法解决三级缓存
    			singletonFactories.put(beanName, instance);
    			Field[] fields = beanClass.getDeclaredFields();
    			for (Field field : fields) {
    				Class<?> fieldType = field.getType();
    				field.setAccessible(true); 
    				// 精髓是这里又调用了getBean方法,例如正在处理ComponentA.componentB属性,
    				// 执行到这里时就会去实例化ComponentB。因为在getBean方法首先去查缓存,
    				// 而一级缓存和三级缓存中没有ComponentB实例数据,所以又会调用到当前方法,
    				// 而在处理ComponentB.componentA属性时,又去调用getBean方法去缓存中查找,
    				// 因为在前面我们将ComponentA实例放入到了三级缓存,因此可以找到。
    				// 所以ComponentB的实例化结束,方法出栈,返回到实例化ComponentA的方法栈中,
    				// 这时ComponentB已经初始化完成,因此ComponentA.componentB属性赋值成功!
    				field.set(instance, this.getBean(fieldType));
    			}
    			// 最后再将初始化好的Bean设置到一级缓存中。
    			singletonObjects.put(beanName, instance);
    			return instance;
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		throw new IllegalArgumentException();
    	}
    
    	/**
    	 * 将类名小写作为beanName,Spring底层实现和这个差不多,也是使用javaBeans的
    	 * {@linkplain Introspector#decapitalize(String)}
    	 **/
    	private String getBeanName(Class<?> clazz) {
    		String clazzName = clazz.getName();
    		int index = clazzName.lastIndexOf(".");
    		clazzName = clazzName.substring(index);
    		return Introspector.decapitalize(className);
    	}
    }
    

    如果各位同学已经阅读并理解上面的代码,那么接下来我们就进行真实的Spring处理循环依赖问题源码分析,相信再阅读起来就会很容易。

    底层源码分析

    分析从AbstractBeanFactory的doGetBean方法着手。可以看到在该方法首先调用transformedBeanName(其实就是处理BeanName问题),和我们自己写的getBeanName方法作用是一样的,但Spring考虑的远比这个复杂,因为有FactoryBean、别名问题。

    // AbstractBeanFactory#doGetBean
    protected <T> T doGetBean(
    			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    			throws BeansException {
    
    		String beanName = transformedBeanName(name);
    		Object bean;
    
    		// !!!重点是这里,首先从缓存中beanName来获取对应的Bean。
    		Object sharedInstance = getSingleton(beanName);
    		if (sharedInstance != null && args == null) {
    			// 执行到这里说明缓存中存在指定beanName的Bean实例,getObjectForBeanInstance是用来处理获取到的Bean是FactoryBean问题
    			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    		else {
    			try {
    				// 删除与本次分析无关代码....
    				// 如果是单例Bean,则通过调用createBean方法进行创建
    				if (mbd.isSingleton()) {
    					sharedInstance = getSingleton(beanName, () -> {
    						try {
    							return createBean(beanName, mbd, args);
    						} catch (BeansException ex) {
    							destroySingleton(beanName);
    							throw ex;
    						}
    					});
    				
    				}	
    			catch (BeansException ex) {
    				cleanupAfterBeanCreationFailure(beanName);
    				throw ex;
    			}
    		}
    		return (T) bean;
    	}
    

    getSingleton方法存在重载方法,这里调用的是重载的getSingleton方法,注意这里传递的boolean参数值为true,因为该值决定了是否允许曝光早期Bean。

    // DefaultSingletonBeanRegistry#getSingleton
    public Object getSingleton(String beanName) {
    	return getSingleton(beanName, true);
    }
    
    // DefaultSingletonBeanRegistry#getSingleton
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    		// 首先从一级缓存中获取
    		Object singletonObject = this.singletonObjects.get(beanName);
    		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
    			// 如果一级缓存中未获取到,再从二级缓存中获取
    			singletonObject = this.earlySingletonObjects.get(beanName);
    			// 如果未从二级缓存中获取到并且allowEarlyReference值为true(前面传的为true)
    			if (singletonObject == null && allowEarlyReference) {
    				synchronized (this.singletonObjects) {
    				   //Double Check 
    					singletonObject = this.singletonObjects.get(beanName);
    					if (singletonObject == null) {
    						singletonObject = this.earlySingletonObjects.get(beanName);
    						if (singletonObject == null) {
    							// 最后尝试去三级缓存中获取
    							ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
    							if (singletonFactory != null) {
    								singletonObject = singletonFactory.getObject();
    								// 保存到二级缓存
    								this.earlySingletonObjects.put(beanName, singletonObject);
    								// 从三级缓存中移除
    								this.singletonFactories.remove(beanName);
    							}
    						}
    					}
    				}
    			}
    		}
    		return singletonObject;
    	}
    

    ok,看完Spring是如何从缓存中获取Bean实例后,那再看看creatBean方法是如何创建Bean的

    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    		throws BeanCreationException {
    	// 删除与本次分析无关的代码...
    	try {// createBean方法底层是通过调用doCreateBean来完成Bean创建的。
    		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    		if (logger.isTraceEnabled()) {
    			logger.trace("Finished creating instance of bean '" + beanName + "'");
    		}
    		return beanInstance;
    	} catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
    		throw ex;
    	} catch (Throwable ex) {
    		throw new BeanCreationException(
    				mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
    	}
    }
    
    // AbstractAutowireCapableBeanFactory#doCreateBean
    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    			throws BeanCreationException {
    
    		BeanWrapper instanceWrapper = null;
    		if (mbd.isSingleton()) {
    			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    		}
    		if (instanceWrapper == null) {
    			// 创建Bean实例
    			instanceWrapper = createBeanInstance(beanName, mbd, args);
    		}
    		Object bean = instanceWrapper.getWrappedInstance();
    		// 如果允许当前Bean早期曝光。只要Bean是单例的并且allowCircularReferences 属性为true(默认为true)
    		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    				isSingletonCurrentlyInCreation(beanName));
    		if (earlySingletonExposure) {
    			// 这里调用了addSingletonFactory方法将刚创建好的Bean保存到了三级缓存中。
    			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    		}
    
    		// 删除与本次分析无关的代码.....
    		Object exposedObject = bean;
    		try {// Bean属性填充
    			populateBean(beanName, mbd, instanceWrapper);
    			// 初始化Bean,熟知的Aware接口、InitializingBean接口.....都是在这里调用
    			exposedObject = initializeBean(beanName, exposedObject, mbd);
    		} catch (Throwable ex) {
    			
    		}
    		// 删除与本次分析无关的代码.....
    		return exposedObject;
    	}
    

    先分析addSingletonFactory方法,因为在该方法中将Bean保存到了三级缓存中。

    protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    	Assert.notNull(singletonFactory, "Singleton factory must not be null");
    	synchronized (this.singletonObjects) {
    		// 如果一级缓存中不存在指定beanName的key
    		if (!this.singletonObjects.containsKey(beanName)) {
    			// 将刚创建好的Bean实例保存到三级缓存中
    			this.singletonFactories.put(beanName, singletonFactory);
    			// 从二级缓存中移除。
    			this.earlySingletonObjects.remove(beanName);
    			this.registeredSingletons.add(beanName);
    		}
    	}
    }
    

    处理Bean的依赖注入是由populateBean方法完成的,但整个执行链路太长了,这里就不展开讲了,只说下IoC容器在处理依赖时是如何一步一步调用到getBean方法的,这样就和我们自己写的处理字段注入的逻辑对上了。

    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    	// 删除与本次分析无关代码...
    	PropertyDescriptor[] filteredPds = null;
    	if (hasInstAwareBpps) {
    		if (pvs == null) {
    			pvs = mbd.getPropertyValues();
    		}
    		// 遍历所有已注册的BeanPostProcessor接口实现类,如果实现类是InstantiationAwareBeanPostProcessor接口类型的,调用其postProcessProperties方法。
    		for (BeanPostProcessor bp : getBeanPostProcessors()) {
    			if (bp instanceof InstantiationAwareBeanPostProcessor) {
    				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
    				PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
    				// 删除与本次分析无关代码...
    				pvs = pvsToUse;
    			}
    		}
    		// 删除与本次分析无关代码...
    	}
    	
    }
    

    在Spring 中,@Autowired注解是由AutowiredAnnotationBeanPostProcessor类处理,而@Resource注解是由CommonAnnotationBeanPostProcessor类处理,这两个类都实现了InstantiationAwareBeanPostProcessor接口,都是在覆写的postProcessProperties方法中完成了依赖注入。这里我们就分析@Autowired注解的处理。

    // AutowiredAnnotationBeanPostProcessor#postProcessProperties
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    		// 根据beanName以及bean的class去查找Bean的依赖元数据-InjectionMetadata 
    		InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
    		try {// 调用inject方法
    			metadata.inject(bean, beanName, pvs);
    		} catch (BeanCreationException ex) {
    			throw ex;
    		} catch (Throwable ex) {
    			throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
    		}
    		return pvs;
    	}
    

    在InjectionMetadata的inject方法中,获取当前Bean所有需要处理的依赖元素(InjectedElement),这是一个集合,遍历该集合,调用每一个依赖注入元素的inject方法。

    // InjectionMetadata#inject
    public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    	// 获取当前Bean所有的依赖注入元素(可能是方法,也可能是字段)
    	Collection<InjectedElement> checkedElements = this.checkedElements;
    	Collection<InjectedElement> elementsToIterate =
    			(checkedElements != null ? checkedElements : this.injectedElements);
    	if (!elementsToIterate.isEmpty()) {
    		// 如果当前Bean的依赖注入项不为空,遍历该依赖注入元素
    		for (InjectedElement element : elementsToIterate) {
    			// 调用每一个依赖注入元素的inject方法。
    			element.inject(target, beanName, pvs);
    		}
    	}
    }
    

    在AutowiredAnnotationBeanPostProcessor类中定义了两个内部类-AutowiredFieldElement、AutowiredMethodElement继承自InjectedElement,它们分别对应字段注入和方法注入。

    以大家常用的字段注入为例,在AutowiredFieldElement的inject方法中,首先判断当前字段是否已经被处理过,如果已经被处理过直接走缓存,否则调用BeanFactory的resolveDependency方法来处理依赖。
    // AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject
    protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    		Field field = (Field) this.member;
    		Object value;
    		if (this.cached) {// 如果当前字段已经被处理过,直接从缓存中获取
    			value = resolvedCachedArgument(beanName, this.cachedFieldValue);
    		} else {
    			// 构建依赖描述符
    			DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
    			desc.setContainingClass(bean.getClass());
    			Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
    			Assert.state(beanFactory != null, "No BeanFactory available");
    			TypeConverter typeConverter = beanFactory.getTypeConverter();
    			try {// 调用BeanFactory的resolveDependency来解析依赖
    				value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
    			} catch (BeansException ex) {
    				throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
    			}
    			// 删除与本次分析无关代码....
    		}
    		if (value != null) {
    			// 通过反射来对属性进行赋值
    			ReflectionUtils.makeAccessible(field);
    			field.set(bean, value);
    		}
    	}
    }
    

    在DefaultListableBeanFactory实现的resolveDependency方法,最终还是调用doResolveDependency方法来完成依赖解析的功能。在Spring源码中,如果存在do什么什么方法,那么该方法才是真正干活的方法。

    // DefaultListableBeanFactory#resolveDependency
    public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
    			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
    		// .....
    		// 如果在字段(方法)上添加了@Lazy注解,那么在这里将不会真正的去解析依赖
    		Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
    				descriptor, requestingBeanName);
    		if (result == null) {
    			// 如果未添加@Lazy注解,那么则调用doResolveDependency方法来解析依赖
    			result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
    		}
    		return result;
    }
    
    // DefaultListableBeanFactory#doResolveDependency
    public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
    			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
    
    	//.....
    	try {
    		// 根据名称以及类型查找合适的依赖
    		Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
    		if (matchingBeans.isEmpty()) {// 如果未找到相关依赖
    			if (isRequired(descriptor)) { // 如果该依赖是必须的(例如@Autowired的required属性),直接抛出异常
    				raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
    			}
    			return null;
    		}
    
    		String autowiredBeanName;
    		Object instanceCandidate;
    		// 如果查找到的依赖多于一个,例如某个接口存在多个实现类,并且多个实现类都注册到IoC容器中。
    		if (matchingBeans.size() > 1) {// 决定使用哪一个实现类,@Primary等方式都是在这里完成
    			autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
    			if (autowiredBeanName == null) {
    				if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
    					return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
    				} else { 
    					return null;
    				}
    			}
    			instanceCandidate = matchingBeans.get(autowiredBeanName);
    		} else {
    			// We have exactly one match.
    			Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
    			autowiredBeanName = entry.getKey();
    			instanceCandidate = entry.getValue();
    		}
    
    		if (autowiredBeanNames != null) {
    			autowiredBeanNames.add(autowiredBeanName);
    		}
    		// 如果查找到的依赖是某个类的Class(通常如此),而不是实例,
    		//调用描述符的方法来根据类型resolveCandidate方法来获取该类型的实例。
    		if (instanceCandidate instanceof Class) {
    			instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
    		}
    		//...
    }
    

    在依赖描述符的resolveCandidate方法中,是通过调用BeanFactory 的getBean方法来完成所依赖Bean实例的获取。

    // DependencyDescriptor#resolveCandidate
    public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
    			throws BeansException {
    
    	return beanFactory.getBean(beanName);
    }
    

    而在getBean方法实现中,依然是通过调用doGetBean方法来完成。这也和我们自己写的依赖处理基本一致,只不过我们自己写的比较简单,而Spring要考虑和处理的场景复杂,因此代码比较繁杂,但大体思路都是一样的。

    // AbstractBeanFactory#getBean
    public Object getBean(String name) throws BeansException {
    	return doGetBean(name, null, null, false);
    }
    

    重点是前面我们写的处理循环依赖的Demo,如果理解那个代码,再看Spring的循环依赖处理,就会发现很简单。

    总结

    循环依赖就是指两个Bean之间存在相互引用关系,例如A依赖B,B又依赖A,但Spring只能解决属性循环依赖,不能解决构造函数循环依赖,这种场景也无法解决。

    Spring解决循环依赖的关键就是在处理Bean的属性依赖时,先将Bean存到三级缓存中,当存在循环依赖时,从三级缓存中获取到相关Bean,然后从三级缓存中移除,存入到二级缓存中,最后初始化完毕后存入到一级缓存中。

    展开全文
  • C语言的for循环嵌套是什么运行规则? 最开始进入的是第一层for循环,在进入第二层for循环,一直到最后一层for循环执行完,再返回上一层for循环一次,进入下一层循环,一直到所有循环结束。(从内到外) ​​​​ ...
  • 很多时候我们很自然的认为,for循环的时候使用foreach和原来的for循环用下标的方式遍历是相同的。而且因为foreach循环写法简单,很容易理解,而且少去了很多麻烦...数据量小的时候当然没有什么关系,但是一旦数据量...
  • 什么是循环依赖以及解决方式

    万次阅读 多人点赞 2019-03-30 17:18:50
    1.什么是循环依赖? 它发生在bean A依赖于另一个bean B时,bean B依赖于bean A: 豆A→豆B→豆A 当然,我们可以有更多的暗示: 豆A→豆B→豆C→豆D→豆E→豆A 2.春天会发生什么 当Spring上下文加载所有bean时...
  • ![图片说明](https://img-ask.csdn.net/upload/201504/15/1429058106_346547.png)
  • 比如下面这个循环: Set={} function Set.new(l) local set={} for _ , v in inpair(l) do set[v]=true end end (这里‘_’啥意思啊)
  • 请问vb6.0平台编程语言开发怎么实现使用循环语句对控件的列举,循环变量的写法是什么?怎么用循环变量表示控件?
  • 循环移位:循环左移和循环右移

    万次阅读 多人点赞 2018-04-30 15:35:46
    换句话说,循环移位就是将移出的低位放到该数的高位(循环右移)或把移出的高位放到该数的低位(循环左移),左移,和右移动都是对整数进行的操作,在Win32控制台应用程序中,整形占4Byte节32bit。 &nbsp; &...
  • for循环什么要加key

    千次阅读 2019-07-17 18:13:43
    vue for循环什么要加key,因为不加:key="标识符"时候,可能得到的结果不是自己想要的结果,并且有时候会报错哦 vue中列表循环需加:key=“唯一标识” 唯一标识可以是item里面id index等,因为vue组件高度复用增加...
  • 面试官: Handler中有Loop死循环,为什么没有阻塞主线程,原理是什么 心理分析:该问题很难被考到,但是如果一旦问到,100%会回答不上来。开发者很难注意到一个主线程的四循环居然没有阻塞住主线程 **求职者:**应该...
  • 从时频特性出发——什么是循环卷积?

    千次阅读 多人点赞 2020-04-02 12:41:21
    目录背景知识——离散傅里叶级数(DFS)和离散傅里叶变换(DFT)线性卷积和循环卷积从时域看从频域看联想——OFDM中加CP的解释结论 背景知识——离散傅里叶级数(DFS)和离散傅里叶变换(DFT) 首先回顾一套定理性质...
  • 消息循环和消息映射在C++ 6.0中的区别是什么?是否可以理解,消息循环只有一个消息处理函数,而消息映射就是很多函数?好像消息循环更简单啊?
  • 意思是转了一圈又一圈,一次又一次地循回。**循环 ,是C语言编程里非常重要的结构。使用循环,可以帮我们快速解决类似的、需要重复实现、处理的问题。以下分享学习C语言三种常见循环:while循环、do…while循环、for...
  • 是死循环意思。只要括号里为非零,也就是真值,它就一直循环这条句子。 这个句子一般用在三个方面: 1.正常程序里,用来等待中断的产生; 2.在总程序的后面加上这条,可以减少单片机程序跑飞,出现程序可能的...
  • 先说答案,根据代码中的上下文,这里的temp是一个字典dict对象,而且它是通过for循环每次获取可迭代对象(Iterable)中的一个值.在该代码中就是每次获取student_infos(字典列表)中的每一个字典对象(student_infos...
  • 【JS-task4】 return的用法是什么?若用在for循环中,还会执行下一次循环吗? 分享人:陈星宇 目录 1.背景介绍 2.知识剖析 3.常见问题 4.解决...
  • python range() 函数可创建一个整数列表,一般用在 for 循环中。函数语法range(start, stop[, step])参数说明:start: 计数从 start 开始。默认是从 0 开始。例如range(5)等价于range(0, 5);stop: 计数到 stop ...
  • Java 循环语句之for多重循环,在二重for循环中,外层循环每执行一次,内层循环要执行一圈。这一句话是什么意思
  • ![图片说明](https://img-ask.csdn.net/upload/201711/19/1511093780_361536.png) ![图片说明](https://img-ask.csdn.net/upload/201711/19/1511093788_9064.png) ![图片说明]...!...
  • 循环链表 在单链表基础上,尾结点的指针指向链表的头结点 三 双向链表 每个结点不止有一个后继指针next指向后面的结点,还有一个前驱指针prev指向前面的结点。 删除和访问操作 当删除结点中“值等于...
  • Python中for循环和while循环

    千次阅读 2018-06-27 19:55:10
    for循环和while循环是python中仅有的两种循环,今天就来讲一下这两种循环的用法 for循环 (1)Python中for循环在形式上与其他语言有较大的不同,以下是C#中for循环和Python中的for循环 C#的for循环: for(int i = 0...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 375,837
精华内容 150,334
关键字:

循环是什么词性