1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

package net.liwenbo.myspring;

public class Person {

    private String name;

    private int age;

    private int gender;

    public Person(String name, int age, int gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public void eat() {
        System.out.println(name + " eating...");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// SpringTest.java
package net.liwenbo.myspring;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;

public class SpringTest {

    public static void main(String[] args) {

        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringTest.class);

        Person lwb = context.getBean("person", Person.class);
        lwb.eat();
    }

    @Bean
    public Person person() {
        return new Person("liwenbo", 36, 1);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

package net.liwenbo.myspring;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Invoke postProcessBeforeInitialization, bean Name = " + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Invoke postProcessAfterInitialization, bean Name = " + beanName);
        return bean;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>net.liwenbo</groupId>
    <artifactId>myspring</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.16.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.2.16.RELEASE</version>
        </dependency>
    </dependencies>
</project>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 准备容器刷新
			prepareRefresh();

      // 告诉子类去刷新内部的bean工厂
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // 准备本context的beanFactory
			prepareBeanFactory(beanFactory);

			try {
        // 允许子类中进行beanFacotry的后续处理
				postProcessBeanFactory(beanFactory);

        // 调用本context注册的beanFacotry的后置处理器
				invokeBeanFactoryPostProcessors(beanFactory);

        // 注册Bean的后置处理器（BeanPostProcessor)
				registerBeanPostProcessors(beanFactory);

				// 初始化消息源
				initMessageSource();

        // 初始化应用的事件多播机制
				initApplicationEventMulticaster();

        // 这个是需要子类去实现的，一些在初始化过程中的特定操作
				onRefresh();

        // 检查并注册监听器
				registerListeners();

				// 初始化所有非懒加载的bean，我们的bean就是在这里创建的
        // 可以看到上图里面的调用链，doCreateBean是真正创建Bean的方法
        // 创建和初始化Bean的过程中，就会调用BeanPostProcessor中的方法
				finishBeanFactoryInitialization(beanFactory);

        // 完成刷新，调用LifecycleProcessor的onRefresh方法，发出ContextRefreshedEvent事件
				finishRefresh();
			}
			catch (BeansException ex) {
				// 有异常，处理，清理容器，代码略
                ...
			}
			finally {
        // 清理Spring core里面的一些缓存，因为对于一些单例的bean，我们可能再也不需要他们的metadata了
				resetCommonCaches();
			}
		}
	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// Bean创建的大致过程，忽略非核心代码
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
    
    // 实例化Bean
    BeanWrapper instanceWrapper = null;
    if (instanceWrapper == null) {
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
    
  // 初始化Bean实例
	Object exposedObject = bean;
	try {
    // 属性赋值
		populateBean(beanName, mbd, instanceWrapper);
        
    // 初始化Bean
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
    
    // 其他的一些处理
    ....
        
    return exposedObject;
}    

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

	protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		// ...
		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		
        //...

		return wrappedBean;
	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// Aware相关的接口都是在initializeBean方法中调用，但调用时机不太相同
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
	
    // 这段代码invokeAwareMethods调用Group1中BeanXXXAware
   	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
			invokeAwareMethods(beanName, bean);
			return null;
		}, getAccessControlContext());
	} else {
		invokeAwareMethods(beanName, bean);
	}

    // 这里调用Group2中的几个Aware，调用postProcessBeforeInitialization
    Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

    // 调用初始化方法
    try {
		invokeInitMethods(beanName, wrappedBean, mbd);
	} catch (Throwable ex) {
		// ...
	}
    
    // 调用postProcessAfterInitialization
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}

1
2
3

public interface InitializingBean {
  void afterPropertiesSet() throws Exception;
}

1
2
3
4
5
6
7
8

public class Person {	    
  ...       
  @PostConstruct
  public void addTitle() {        
    this.title = "Mr. ";    
  }        
  ...
}

1
2
3

<bean id="person" class="net.liwenbo.myspring.Person" init-method="addTitle">
  ...
</bean>

1
2
3
4
5
6
7
8

public class Person implements InitializingBean {	    
  ...

  @Override
  public void afterPropertiesSet() throws Exception {
    this.title = "Mr. ";
  }
}

1
2
3
4
5
6
7
8

public interface DisposableBean {
  /**	 
  * Invoked by the containing {@code BeanFactory} on destruction of a bean.	
  * @throws Exception in case of shutdown errors. Exceptions will get logged	 
  * but not rethrown to allow other beans to release their resources as well.	 
  */	
  void destroy() throws Exception;
}

1
2
3
4
5
6
7

public class Person implements DisposableBean {    
  ...    
  @Override    
  public void destroy() throws Exception {
    System.out.println("destroy my bean!");
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public interface FactoryBean<T> {	
  // 创建具体的Bean对象类型
  @Nullable	T getObject() throws Exception;
  
  // 返回这个工厂Bean创建的对象的类型
  @Nullable	Class<?> getObjectType();
  
  // 是否是单例，默认true	
  default boolean isSingleton() {
    return true;
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class PersonFactoryBean implements FactoryBean<Person> {
  @Override
  public Person getObject() throws Exception {
    return new Person();
  }
  
  @Override
  public Class<?> getObjectType() {
    return Person.class;
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@Component
public class PersonA {
  @Autowired
  private PersonB personB;
  
  private String name;
  
  public PersonA() {
    name = "personA";
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@Component
public class PersonB {
  @Autowired
  private PersonC personC;
  
  private String name;
  
  public PersonB() {
    name = "PersonB";
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@Component
public class PersonC {
  @Autowired
  private PersonC personC;
  
  private String name;
  
  public PersonC() {
    name = "PersonC";
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// DefaultSingletonBeanRegistry.java
// Spring解决循环依赖的关键在于这个类
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
  /** Cache of singleton objects: bean name to bean instance. */
  private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
  
  /** Cache of singleton factories: bean name to ObjectFactory. */
  private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
  
  /** Cache of early singleton objects: bean name to bean instance. */
  private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
  
  /** Set of registered singletons, containing the bean names in registration order. */
  private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
  
  /**
  * Add the given singleton factory for building the specified singleton	 
  * if necessary.	 
  * <p>To be called for eager registration of singletons, e.g. to be able to	
  * resolve circular references.
  * @param beanName the name of the bean	
  * @param singletonFactory the factory for the singleton object	 */	
  protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
      if (!this.singletonObjects.containsKey(beanName)) {
        this.singletonFactories.put(beanName, singletonFactory);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
      }
    }
  }
}