Spring循环注入依赖算法

Spring循环注入依赖算法

	/**
	 * 给Bean注入，首先检测该bean是否被注入过，如果没有，取得该类以及该类的成员
	 * 再检测该类的成员是否有Autowired注解，如果有，取得Autowired中 value的值
	 * 执行setValue()方法;
	 * @param bean
	 */
	private void setBeanValue(BeanDefinition bean) throws Exception { 
		if (bean.isDone()) {
			return;
		}
		bean.done = true;
		Class<?> klass = bean.getKlass();
		Field[] fields = klass.getDeclaredFields();
		for (Field field : fields) {
			if (!field.isAnnotationPresent(Autowired.class)) {
				continue;
			}
			Autowired autowired = field.getAnnotation(Autowired.class);
			String value = autowired.value();
			boolean singleton = autowired.singleton();
			setValue(bean, field, value.length() <= 0 ? null : value, singleton);
		}
	}
	
	/**
	 * 通过setBeanValue()传过来的BeanDefinition，Field，value
	 * 来给成员赋值
	 * @param bd
	 * @param field
	 * @param value
	 */
	private void setValue(BeanDefinition bd, Field field, String value, boolean singleton) throws Exception {
		//设置了value，说明为依赖关系的最后一个
		if (value != null) {
			setFieldWithValue(bd.getKlass(), bd.getObject(), field, value);
			return;
		}
		//当没有设置value，说明该成员仍然是需要注入的类
		//通过成员类型再加上包名就得到了对应的类名，然后去beanFactory和beanIdMap里面找对应的类
		Class<?> type = field.getType();
		BeanDefinition bean = getBeanDefinition(type.getName());
	
		if (bean == null) {
			//如果找不到，去找它的父类是不是某个接口
			BeanDefinition[] beans = searchBeanBySuperType(type);
			if (beans.length == 1) {
				bean = beans[0];
			}
			//存在@Qualifier注解的成员才需要去找它的接口实现类，若没有直接抛出异常
			//若存在的话一个实现类那么就将这个类注入，若存在多个实现类，根据@Qualifier注解中value的值来确定是哪个实现类
			if (beans.length <= 0 || !field.isAnnotationPresent(Qualifier.class)) {
				throw new Exception("类" + bd.getKlass() + "的成员" + field.getName() + "注入失败！");
			} else {
				Qualifier qualifier = field.getAnnotation(Qualifier.class);
				String beanName = qualifier.value();
				bean = getBeanDefinition(beanName);
				if (bean == null) {
					throw new Exception("类" + bd.getKlass() + "的成员" + field.getName() + "注入失败！");
				}
			}
		}
		if (!singleton) {
			bean = new BeanDefinition(type);
		}
		if (!bean.isDone()) {
			setBeanValue(bean);
		}
		setFieldValue(bd.getObject(), bd.getKlass(), field, bean.getObject());
	}
	
	/**
	 * 如果没有在beanFactory和beanidMap中找到该类
	 * 那么就找在beanfactory中是否有它的实现类，如果有
	 * 就把它的所有实现类放入一个数组，然后返回这个数组
	 * 那么就在这里找
	 * @param klass
	 * @return
	 */
	private BeanDefinition[] searchBeanBySuperType(Class<?> klass) {
		List<BeanDefinition> beanList = new ArrayList<>();
		
		for (BeanDefinition bean : beanFactory.values()) {
			Class<?> beanClass = bean.getKlass();
			if (klass.isAssignableFrom(beanClass)) {
				beanList.add(bean);
			}
		}
		BeanDefinition[] beans = new BeanDefinition[beanList.size()];
		beanList.toArray(beans);
		
		return beans;
	}

思路可以遵循leetCode的第一道算法题中的twoSum,先去map中找如果找到了，则返回，否则放入到map中

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> twoSum = new HashMap<>();
        for(int i = 0 ; i < nums.length ; i++){
            int temp = target -  nums[i];
            if(twoSum.containsKey(temp)){
                return new int[] { twoSum.get(temp),i};
            }
            twoSum.put(nums[i],i);
        } 
        throw new IllegalArgumentException("No two sum solution");
    }
}