Spring IOC 概述

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>4.3.11.RELEASE</version>
</dependency>

public interface MessageService {
    String getMessage();
}

@Component("messageService")
public class MessageServiceImpl implements MessageService {

    public String getMessage() {
        return "hello world";
    }
}

// Main.java
@ComponentScan // 非常重要，会扫描包下所有注解
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(Main.class);
        MessageService messageService = (MessageService) context.getBean("messageService");
        System.out.println(messageService.getMessage());
        // 输出 Hello, World
    }
}

@Component("messageService")
public class MessageServiceImpl implements MessageService {

    public String getMessage() {
        return "hello world";
    }
}

@Configuration
public class DataConfig{ 
  @Bean("aSource") // 配置文件来源，通常用 properties 文件定义
  public DataSource source(){
    DataSource source = new RedisProperties();
    source.setHost("localhost");
    source.setPassword("123");
    return source;
  }
  @Bean(name = "redisTemplate")
  public RedisTemplate redisTemplate(@Qualifier("aSource") DataSource source) {
        return super.stringRedisTemplate(source);
  }
}

@Component
public class Customer {                                                                                         
    private Person person;
    @Autowired                                                                                                      
    public void setPerson (Person person) {
     this.person=person;
    }
}

@Component
public class Customer {
    @Autowired                               
    private Person person;                   
    private int type;
}

@Component
public class Customer {
    private Person person;
    @Autowired // 甚至可以直接不写
    public Customer (Person person) { 
      this.person=person;
    }
}

@Component
public class BeanB1 implements BeanInterface {
  //
}
@Component
public class BeanB2 implements BeanInterface {
  //
}
@Component
public class BeanA {
  @Autowired
  @Qualifier("beanB2")
  private BeanInterface dependency;
  ...
}

@Component
public class LifeCycleControl implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        //.. doSomeThing
    }
}

@Component
public class TestB extends BeanNameAware {
    @Override
    public void setBeanName(String name) {
        // 会告诉 TestB 他的 BeanName 是什么
    }
}

MessageService messageService = context.getBean(MessageService.class);

<bean id="messageService" class="ma.luan.example.MessageServiceImpl"/>

<bean id="messageService" class="ma.luan.example.MessageServiceImpl"/>

public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("classpath:application.xml");
    MessageService messageService = context.getBean(MessageService.class);
    System.out.println(messageService.getMessage());
    // 输出 hello world
}

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
      throws BeansException {

   super(parent); 
   setConfigLocations(configLocations); // 保存XML路径
   if (refresh) {
      refresh(); // 第一次执行会到这里，初始化 
   }
}

public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
      prepareRefresh();

      // 创建工厂，读取 XML，把 BeanName -> BeanDefinition 在 BeanFactory 的 Registry 里 注册
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // ....

    }
}

@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {

        prepareRefresh();

        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // 主要是设置 BeanFactory 的 ClassLoader
        prepareBeanFactory(beanFactory);

        try {
            // 注册实现了 BeanFactory 的 Bean
            postProcessBeanFactory(beanFactory);
            // 调用上面注册的 Bean 的相关方法 （用于 BeanFactory 读取 Definition 之后，初始化之前）
            invokeBeanFactoryPostProcessors(beanFactory);
            // 这个比较会用到，检测 注册好的 Bean 里面，实现了 BeanPostProcessors 接口的 Bean
            // 等下初始化 Bean 的前后，会调用这些所有 Bean 的 相关方法
            registerBeanPostProcessors(beanFactory);
            // 国际化的，用不到
            initMessageSource();
            // 注册ApplicationEvent接口的Bean，初始化事件广播器
            initApplicationEventMulticaster();
            // 给子类的钩子，会再注册一些内置 Bean
            onRefresh();
            // 注册实现了 ApplicationListener 接口的 Bean
            registerListeners();
    
            // 初始化所有的 singleton beans （lazy-init 的除外）：下面讲
            finishBeanFactoryInitialization(beanFactory);
            
            // ...
        }
        //...
    }

public void preInstantiateSingletons() throws BeansException {
   // this.beanDefinitionNames 保存了所有的 beanNames
   List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

   // 触发所有的非懒加载的 singleton beans 的初始化操作
   for (String beanName : beanNames) {

      // 非抽象、非懒加载的 singletons。如果配置了 ‘abstract = true‘，那是不需要初始化的
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
         
         if (isFactoryBean(beanName)) {
            // FactoryBean 的话，在 beanName 前面加上 ‘&’ 符号。再调用 getBean
            final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
         }
         else {
            // 对于普通的 Bean，只要调用 getBean(beanName) 这个方法就可以进行初始化了
            getBean(beanName);
         }
      }
   }

   }

@Override
public Object getBean(String name) throws BeansException {
   return doGetBean(name, null, null, false);
}

@SuppressWarnings("unchecked")
protected <T> T doGetBean(
            final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {
        // 获取 BeanName
        final String beanName = transformedBeanName(name);

        // 这个是返回值
        Object bean;

        // 检查单例是否已经初始化，单例全部注册在 regisrty 的 singletonObjects，多例不会在这里注册
        Object sharedInstance = getSingleton(beanName);
        // 如果注册表中没有这个单例，会返回 null，后面还会讲到这个方法
        
        // 开始创建 bean
        if (sharedInstance != null) {
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
            // 默认非 BeanFactor 时，等同于 bean = sharedInstance
        } else {
            // 如果上面为 null,则说明单例未初始化，或者是多例

            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            // 这里，实际执行了：this.beanDefinitionMap.get(beanName)
            // 就是把 BeanDefinition 拿出来了
            
            // 这里有一百多行代码，除了插入各种钩子和特殊情况，其实我们只执行了一行代码
            bean = createBean(beanName, mbd, args)
        ｝
        return (T) bean;
    }

<bean id="circleA" class="entity.CircleA" >
    <property name="circleB" ref="circleB"/>
</bean>
<bean id="circleB" class="entity.CircleB" >
    <property name="circleC" ref="circleC"/>
</bean>
<bean id="circleC" class="entity.CircleC" >
    <property name="circleA" ref="circleA"/>
</bean>

addSingletonFactory(beanName, new ObjectFactory<Object>() {
   @Override
   public Object getObject() throws BeansException {
      return getEarlyBeanReference(beanName, mbd, bean);
   }
});
// this.singletonFactories.put(beanName, singletonFactory);

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		Object singletonObject = this.singletonObjects.get(beanName);
       // getBean 默认走这里，从单例注册表拿已经创建好的单例，但是现在A还没创建好
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
           // 单例注册表里面没有，对象正在初始化，符合循环引用的条件
			synchronized (this.singletonObjects) {
				singletonObject = this.earlySingletonObjects.get(beanName);
				if (singletonObject == null && allowEarlyReference) {
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						singletonObject = singletonFactory.getObject();
                      // getObject，就是把A的引用拉过来了，A其实还没建好，不过他的引用已经有了
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
        // 返回A的引用给C
		return (singletonObject != NULL_OBJECT ? singletonObject : null);
	}

// 自定义事件
public class MyEvent extends ApplicationEvent {
    public MyEvent(Object source) {
        super(source);
    }
}
// 自定义 Bean 实现 ApplicationContextAware 接口
@Component
public class HelloBean implements ApplicationContextAware {
    private ApplicationContext applicationContext;
    private String name;
    public void setApplicationContext(ApplicationContext context) {
        this.applicationContext = context;
    }
    // 当调用 setName 时, 触发事件
    public void setName(String name) {
        this.name = name;
        applicationContext.publishEvent(new MyEvent(this));  // 这行代码执行完会立即被监听到
    }
    public String getName() {
        return name;
    }
}
// 自定义监听器, 监听上面的事件
@Component
public class MyApplicationListener implements ApplicationListener {
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof MyEvent) {
            System.out.println(((HelloBean)event.getSource()).getName());
        }
    }
}