Spring IOC容器和元信息来源

BeanFactory和ApplicationContext谁才是Spring Ioc容器？

BeanFactory 接口提供了能够管理任何类型对象的高级配置机制。ApplicationContext 是BeanFactory 的子接口。ApplicationContext添加了以下特性:

1. 更容易与 Spring 的 AOP 特性集成
2. 消息资源处理(用于国际化)
3. 事件发布。
4. 应用层特定的上下文，例如 web 应用程序中使用的 WebApplicationContext。

1. public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
2.   MessageSource, ApplicationEventPublisher, ResourcePatternResolver {

1. public interface ListableBeanFactory extends BeanFactory {

简而言之，BeanFactory 提供了配置框架和基本功能，而ApplicationContext 添加了更多特定于企业的功能。

总结：BeanFactory和ApplicationContext可以说都是Spring Ioc容器，在底层实现时，ApplicationContext不止实现了BeanFactory接口，同时还组合了BeanFactory的另一个实现类DefaultListableBeanFactory。

1. public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
2. public abstract class AbstractXmlApplicationContext extends AbstractRefreshableConfigApplicationContext {
3. public abstract class AbstractRefreshableConfigApplicationContext extends AbstractRefreshableApplicationContext
4.   implements BeanNameAware, InitializingBean {
5. public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
7.  @Nullable
8.  private Boolean allowBeanDefinitionOverriding;
10.  @Nullable
11.  private Boolean allowCircularReferences;
13.  /** Bean factory for this context. */
14.  @Nullable
15.  private DefaultListableBeanFactory beanFactory;
17. @Override
18.  public final ConfigurableListableBeanFactory getBeanFactory() {
19.   synchronized (this.beanFactoryMonitor) {
20.    if (this.beanFactory == null) {
21.     throw new IllegalStateException("BeanFactory not initialized or already closed - " +
22.       "call 'refresh' before accessing beans via the ApplicationContext");
23.    }
24.    return this.beanFactory;
25.   }
26.  }

configurableApplicationContext <-ApplicationContext<-BeanFactory
configurableApplicationContext#getBeanFactory()

Spring容器启动的过程中，会将Bean解析成Spring内部的BeanDefinition结构。 不管是是通过xml配置文件的 <Bean> 标签，还是通过注解配置的 @Bean ，还是 @Compontent 标注的类，还是扫描得到的类，它最终都会被解析成一个BeanDefinition对象，最后Bean工厂就会根据这份Bean的定义信息，对bean进行实例化、初始化等等操作。

Bean定义配置注意基于xml文件、properties文件、Java注解以及java Api;

Ioc容器配置注意基于xml文件、Java注解以及Java Api；

外部化属性配置基于Java注解 @Value。

Spring IoC依赖注入

1. public class UserRepository {
2.     /**
3.      * 自定义bean
4.      */
5.     private Collection<User> users;
7.     /**
8.      * bean工厂
9.      * 内建非bean对象
10.      */
11.     private BeanFactory beanFactory;
13.     private ObjectFactory<User> userObjectFactory;
15.     private ObjectFactory<ApplicationContext> objectFactory;
17.     public ObjectFactory<ApplicationContext> getObjectFactory() {
18.         return objectFactory;
19.     }
21.     public void setObjectFactory(ObjectFactory<ApplicationContext> objectFactory) {
22.         this.objectFactory = objectFactory;
23.     }
25.     public ObjectFactory<User> getUserObjectFactory() {
26.         return userObjectFactory;
27.     }
29.     public void setUserObjectFactory(ObjectFactory<User> userObjectFactory) {
30.         this.userObjectFactory = userObjectFactory;
31.     }
33.     public Collection<User> getUsers() {
34.         return users;
35.     }
37.     public BeanFactory getBeanFactory() {
38.         return beanFactory;
39.     }
41.     public void setBeanFactory(BeanFactory beanFactory) {
42.         this.beanFactory = beanFactory;
43.     }
45.     public void setUsers(Collection<User> users) {
46.         this.users = users;
47.     }
48. }

Xml配置信息

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
5.         https://www.springframework.org/schema/beans/spring-beans.xsd">
7.     <bean id="user" class="org.mango.spring.ioc.overview.domain.User" >
8.         <property name="id" value="1"/>
9.         <property name="name" value="mango"/>
10.     </bean>
12.     <bean id="superUser" class="org.mango.spring.ioc.overview.domain.SuperUser" parent="user" primary="true">
13.         <property name="address" value="西安"></property>
14.     </bean>
16.     <bean id="objectFactory" class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean" >
17.         <property name="targetBeanName" value="user"></property>
18.     </bean>
20. </beans>

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.        xmlns:util="http://www.springframework.org/schema/util"
5.        xsi:schemaLocation="
6.         http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
7.         http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd">
10.     <!--通过导入复用 dependency-->
11.     <import resource="dependency-lookup-context.xml"></import>
13.     <!--autowire自动注入-->
14.     <bean id="userRepository" class="org.mango.spring.ioc.overview.repository.UserRepository"
15.           autowire="byType"> 
16.         <!--硬编码-->
17.      <!--   <property name="users">
18.             <util:list>
19.                 <ref bean="user"/>
20.                 <ref bean="superUser"/>
21.             </util:list>
22.         </property>-->
23.     </bean>
25. </beans>

1.  //配置xml文件 启动spring 应用上下文
2.         BeanFactory beanFactory = new ClassPathXmlApplicationContext("META-INF/dependency-injection-context.xml");
3.         //来源1： 自定义bean
4.         UserRepository userRepository = (UserRepository) beanFactory.getBean("userRepository");
6.         //实时注入bean
7.         userRepository.getUsers().forEach(System.out::println);
8.         //来源2: 依赖注入 （内建依赖）
9.         System.out.println(userRepository.getBeanFactory());
10.         System.out.println(userRepository.getBeanFactory() == beanFactory);
12.         //延时注入
13.         ObjectFactory userFactory = userRepository.getUserObjectFactory();
14.         System.out.println(userFactory.getObject());
16.         ObjectFactory objectFactory = userRepository.getObjectFactory();
17.         System.out.println(objectFactory.getObject());
19.         System.out.println(objectFactory.getObject() == beanFactory);
20.         //来源三： 容器内建 bean
21.         Environment environment = beanFactory.getBean(Environment.class);

                 System.out.println("获取Environment类型的bean" + environment);

 System.out.println(userRepository.getBeanFactory() == beanFactory); 输出为false