アーキテクチャ図

ここに画像の説明を挿入

Beanのライフサイクル

Beanの確立
@ComponentなどのSpringコンテナにクラスをロードします
BeanDefinitionの生成
Beanが
Springコンテナにロードされると、対応するBeanDefinitionが生成され、BeanClass、scope、abstractFlag、lazyInit、autowireMode、dependencyCheck、dependsOn、autowireCandidate、primary、qualifiers、instanceSupplier、nonPublicAccessAllowedなどのBeanの情報が格納されます。、lenientConstructorResolution、factoryBeanName、factoryMethodName…
beanFactoryでBeanFactory（DefaultListableBeanFactory;）を形成します。
- beanDefinitionMap：存储beanDefinition（DefaultListableBeanFactory;）
```
 private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap(256);
```
- singletonObjects：ロードされたBeanを格納します（DefaultSingletonBeanRegistry）
```
 private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
```
- beanDefinitionNames：beanDefinitionの名前リストを保存します（DefaultListableBeanFactory）
```
private volatile List<String> beanDefinitionNames = new ArrayList(256);
```
- factoryBeaObjectCache
- aliasMap
- BeanPostProcessor
Beanオブジェクトを作成する
- インスタンス化
- 推定工法
- AOP
- 依存性注入
- PostConstruct
- 気がついて
- InitializingBean
シングルトンプールに格納されます（Map <BeanName、Object>）

ソースコード分析

org.springframework.context.support.AbstractApplicationContext.refresh（）のソースコード：

@Override
	public void refresh() throws BeansException, IllegalStateException {
    
    
		synchronized (this.startupShutdownMonitor) {
    
    
			// 准备上下文的刷新.
			prepareRefresh();

			// 刷新并获取bean工厂
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			//准备beanFactory
			prepareBeanFactory(beanFactory);

			try {
    
    
				// beanFacory 后置处理器.供子类实现
				postProcessBeanFactory(beanFactory);

				// 调用上下文中注册为bean的工厂后置处理器
				invokeBeanFactoryPostProcessors(beanFactory);

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

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// 初始化特定上下文子类中的其他特殊bean
				onRefresh();

				// 注册监听器
				registerListeners();

				// 例化所有剩余的（非延迟初始化）单例.
				finishBeanFactoryInitialization(beanFactory);

				// 发布相应事件，完成刷新
				finishRefresh();
			}

			catch (BeansException ex) {
    
    
				if (logger.isWarnEnabled()) {
    
    
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// 发生异常，则销毁已经实例化的bean
				destroyBeans();

				// 重置active标识
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
    
    
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}

1.インスタンス化の前

BeanDefinitionを登録する

ImportBeanDefinitionRegister

public class MyBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    
    
    /**
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
    
    

        Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(MyAnnotationScan.class.getName());

        //拿到包
        Object value = annotationAttributes.get("value");
        //掃描
        System.out.println(value);
        List<Class> mappers = new ArrayList<>();
        mappers.add(UserMapper.class);
        mappers.add(OrderMapper.class);

        for (Class mapper : mappers) {
    
    
            //生成一个空的beanDefinition
            BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition();
            AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();
            beanDefinition.setBeanClass(MyFactoryBean.class);
            beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(mapper);
            registry.registerBeanDefinition(mapper.getSimpleName(),beanDefinition);
        }
    }
}

beaファクトリポストプロセッサBeanFactoryPostProcessor

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    
    


        GenericBeanDefinition bd = (GenericBeanDefinition) beanFactory.getBeanDefinition("userService");
        Class<?> beanClass = bd.getBeanClass();
        Object userService = beanFactory.getBean("userService");
      /*  System.out.println(beanClass);
        bd.setBeanClass(UserEntity.class);*/
    }
}

2. Beanの確立：

コンテナはBeanの定義情報を探し、それをインスタンス化します。

3.属性インジェクション：

Springは、依存性注入（IOC）を使用して、Bean定義情報に従ってBeanのすべてのプロパティを構成します。

4.BeanNameAware的setBeanName（）：

Beanクラスがorg.springframework.beans.BeanNameAwareインターフェースを実装している場合、ファクトリはBeanのsetBeanName（）メソッドを呼び出してBeanのIDを渡します。

/**
 * @author XingShuaiJiang
 * 可设置beanName的值
 */
@Component
public class MyBeanNameAware implements BeanNameAware {
    
    
    @Override
    public void setBeanName(String s) {
    
    

    }
}

5. BeanFactoryAware的setBeanFactory（）：

Beanクラスがorg.springframework.beans.factory.BeanFactoryAwareインターフェースを実装している場合、ファクトリはsetBeanFactory（）メソッドを呼び出してファクトリ自体を渡します。

/**
 * @author 
 * 可设置beanFactory
 */
@Component
public class MyBeanFactoryAware implements BeanFactoryAware {
    
    
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    
    
        
    }
}

6. BeanPostProcessorsのProcessBeforeInitialization（）

Beanに関連付けられたorg.springframework.beans.factory.config.BeanPostProcessorsがある場合、そのpostProcessBeforeInitialization（）メソッドが呼び出されます。

/**
 * bean创建成功后的 后置处理器
 * 经常被用作是Bean内容的更改，并且由于这个是在Bean初始化结束时调用那个的方法，也可以被应用于内存或缓存技术；
 */
 @Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    
    
    /**
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     * 在实例化bean之前调用
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    
    
        return null;
    }

    /**
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     * 在实例化bean之后调用
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    
    
        return null;
    }
}

7.initializingBean的afterPropertiesSet（）：

Beanクラスがorg.springframework.beans.factory.InitializingBeanインターフェースを実装している場合は、そのafterProPertiesSet（）メソッドを実行します。

/**
 * 初始化bean
 */
@Component
class MyInitializingBean implements InitializingBean {
    
    
    @Override
    public void afterPropertiesSet() throws Exception {
    
    

    }
}

8. BeanDefinitionの属性がinit-methodを定義している場合：

Bean定義ファイルの「init-method」属性を使用して、メソッド名を設定できます。例：

上記の設定がある場合、実行がこの段階に達すると、initBean（）メソッドが実行されます。

9.BeanPostProcessorsのProcessaAfterInitialization（）

BeanPostProcessorsインスタンスがBeanインスタンスに関連付けられている場合は、BeanPostProcessorsインスタンスのProcessaAfterInitialization（）メソッドを実行します。

/**
 * bean创建成功后的 后置处理器
 * 经常被用作是Bean内容的更改，并且由于这个是在Bean初始化结束时调用那个的方法，也可以被应用于内存或缓存技术；
 */
 @Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    
    
    /**
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     * 在实例化bean之前调用
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    
    
        return null;
    }

    /**
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     * 在实例化bean之后调用
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    
    
        return null;
    }
}

10.DisposableBean的destroy（）

コンテナが閉じられているときに、Beanクラスがorg.springframework.beans.factory.DisposableBeanインターフェースを実装している場合、そのdestroy（）メソッドが実行されます。


/**
 * 销毁bean
 */
@Component
public class MyDisposableBean implements DisposableBean {
    
    
    @Override
    public void destroy() throws Exception {
    
    

    }
}

Springソースコード-Beanのライフサイクル

目次