依赖来源

1 Spring BeanDefinition（xml,注解，BeanDefinitionBuilder, 还有API实现的单例对象）
2 Spring 内建BeanDefinition

3 内建单例对象

依赖注入和依赖查找的区别

Context.refresh() 的时候会调用这个方法：prepareBeanFactory(beanFactory)注入下面这几个对象：

我们可以看到在依赖查找的时候用到了：

public class DependencySourceDemo {//  字段注入注入postProcessProperties 方法执行 早于setter注入 也早于 @PostConstruct@AutowiredBeanFactory beanFactory;@AutowiredResourceLoader resourceLoader;@AutowiredApplicationContext applicationContext;@AutowiredApplicationEventPublisher publisher;@PostConstructpublic void init() {System.out.println(beanFactory == applicationContext);System.out.println(beanFactory == applicationContext.getAutowireCapableBeanFactory());System.out.println(resourceLoader == applicationContext);System.out.println(publisher == applicationContext);}@PostConstructpublic void initLookUp() {getBean(BeanFactory.class);getBean(ApplicationEventPublisher.class);getBean(ApplicationContext.class);getBean(ResourceLoader.class);}public <T> T getBean(Class<T> type) {try {beanFactory.getBean(type);} catch (NoSuchBeanDefinitionException e) {System.err.println("无法在当前容器总找到" + type + "类型的bean");}return null;}public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();context.register(DependencySourceDemo.class);context.refresh();}
}

运行结果：

所以说依赖注入会比依赖查找多这样几个对象。

依赖来源及依赖使用场景

比较这几种来源的使用场景：
单体对象也就是内建的单例对象

1 Spirng BeanDefinition 通过 DefaultListableBeanFactory#registerBeanDefinition进行注册
这个方法后面会有这样一段代码，前者是存储了beanName和beanDefinition 后者是为了保证顺序，因为后者是一个ArrayList

2 单体对象
由SingletonBeanRegistry#registerSingleton
限制是没有生命周期管理的，也无法实现延迟初始化。

为什么ConcurrentHashMap还有加锁呢？
因为我们查找了以后如果没有还需要往里面放，所以也存在线程安全问题。
我们看到这里还有一把锁，是因为这个方法可能会被单独使用，但是其实这里锁的是同一个对象，如果是同一个线程内没有额外加锁。

同样这里也使用了LinkedHashSet保证了有序：

非容器托管的对象

DefaultListableBeanFactory#registerResolvableDependency
限制：
没有生命周期
无法实现延迟初始化
无法通过依赖查找

public class ResolvableDependencySourceDemo {
@Autowired
String value;
public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();context.register(ResolvableDependencySourceDemo.class);context.addBeanFactoryPostProcessor(beanFactory -> {beanFactory.registerResolvableDependency(String.class, "demo");});context.refresh();ResolvableDependencySourceDemo bean = context.getBean(ResolvableDependencySourceDemo.class);System.out.println(bean.value);
}
}

这里为什么要这样写呢？通过回调函数，因为我们依赖注入的时候如果容器启没有refresh beanFactory.registerResolvableDependency(String.class, “demo”);这个时候注册会报错，如果启动了，我们可不可以把这个注册写到refresh之后呢？不可以因为这个时候上面的@Autowired 注入的时候找不到这个bean也会报错，所以通过回调函数的方式来处理，当Factory创建好以后进行注册。

外部化配置作为依赖

没有生命周期
无法实现延迟初始化
无法通过依赖查找

@Configuration
@PropertySource(value = "meta-info/demo.properties", encoding = "GBK")
public class ExtDependencyDemo {@Value("${usr.name}")private String name;@Value("${usr.pass}")private String pass;public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();context.register(ExtDependencyDemo.class);context.refresh();ExtDependencyDemo bean = context.getBean(ExtDependencyDemo.class);System.out.println(bean.pass);System.out.println(bean.name);}
}

参考资料：小马哥核心编程思想