perl复制代码在默认情况下， Redis 将内存数据库快照保存在名字为 dump.rdb 的二进制文件中。
你可以对 Redis 进行设置， 让它在“ N 秒内数据集至少有 M 个改动”这一条件被满足时，自动保存一次数据集。
比如说， 设置`save 60 1000`会让 Redis 在满足“ 60 秒内有至少有 1000 个键被改动”这一条件时， 自动保存一次数据集。
关闭RDB只需要将所有的save保存策略注释掉即可

还可以手动执行命令生成RDB快照，客户端执行命令save或bgsave可以生成dump.rdb文件，
每次命令执行都会将所有redis内存快照到一个新的rdb文件里，并覆盖原有rdb快照文件。

save是同步命令，bgsave是异步命令，bgsave会从Redis主进程fork（fork()是linux函数）出一个子进程专门用来生成rdb快照文件

Redis默认是使用的bgsave

markdown复制代码AOF 持久化: 将修改的每一条指令记录进文件appendonly.aof中

你可以通过修改配置文件来打开 AOF 功能：`appendonly yes`

每当 Redis 执行一个改变数据集的命令时（比如 SET)， 这个命令就会被追加到 AOF 文件的末尾。
这样的话， 当 Redis 重新启动时， 程序就可以通过重新执行 AOF 文件中的命令来达到重建数据集的目的。

你可以配置 Redis 多久才将数据 fsync 到磁盘一次。
有三个选项：
1. appendfsync always：每次有新命令追加到 AOF 文件时就执行一次 fsync ，非常慢，也非常安全。
2. appendfsync everysec：每秒 fsync 一次，足够快（和使用 RDB 持久化差不多），并且在故障时只会丢失 1 秒钟的数据。
3. appendfsync no：从不 fsync ，将数据交给操作系统来处理。更快，也更不安全的选择。

推荐（并且也是默认）的措施为每秒 fsync 一次， 这种 fsync 策略可以兼顾速度和安全性。

bash复制代码重启 Redis 时，我们很少使用 RDB来恢复数据，因为会丢失大量数据。
我们通常使用 AOF 日志重放，但是重放 AOF 日志性能相对 RDB来说要慢很多，这样在 Redis 实例很大的情况下，启动需要花费很长的时间。 
Redis 为了解决这个问题，带来了一个新的持久化方式——混合持久化。

通过如下配置可以开启混合持久化：`aof-use-rdb-preamble yes`

如果开启了混合持久化，AOF在重写时，不再是单纯将内存数据转换为RESP命令写入AOF文件，
而是将重写这一刻之前的内存做RDB快照处理，并且将RDB快照内容和增量的AOF修改内存数据的命令存在一起，都写入新的AOF文件，
新的文件一开始不叫appendonly.aof，等到重写完新的AOF文件才会进行改名，原子的覆盖原有的AOF文件，完成新旧两个AOF文件的替换。

于是在 Redis 重启的时候，可以先加载 RDB 的内容，然后再重放增量 AOF 日志就可以完全替代之前的 AOF 全量文件重放，
因此重启效率大幅得到提升。

perl复制代码当redis.conf的配置cluster-require-full-coverage为no时，表示当负责一个插槽的主库下线且没有相应的从库进行故障恢复时，
集群仍然可用，如果为yes则集群不可用。

复制代码因为新master的选举需要大于半数的集群master节点同意才能选举成功，如果只有两个master节点，当其中一个挂了，
是达不到选举新master的条件的。

奇数个master节点可以在满足选举该条件的基础上节省一个节点，比如三个master节点和四个master节点的集群相比，
大家如果都挂了一个master节点都能选举新master节点，如果都挂了两个master节点都没法选举新master节点了，
所以奇数的master节点更多的是从节省机器资源角度出发说的。

js复制代码struct zslnode{
    string value;
    double score;
    zslnode*[] forwards;    //多层连接的指针
    zslnode* backward;        //回溯指针
}

struct zsl{
    zslnode* header;            //跳跃表头指针
    int maxLevel;                //当前节点的最高层
    map<String,zslnode*> ht;    //hash 中的键值对
}

typescript复制代码import { ColumnMeta } from "./column-meta";

/**
* 实体类型枚举，目前仅支持普通实体跟枚举实体，
* 枚举实体类似语法糖，不映射到数据库，
* 枚举类型的字段映射到数据库是string类型
*/
export enum EntityType{
  NORMAL = "Normal",
  ENUM = "Enum",
}

/**
* 实体元数据
*/
export interface EntityMeta{
  /** 唯一标识 */
  uuid: string;

  /** 实体名称 */
  name: string;

  /** 表名，如果tableName没有被设置，会把实体名转化成蛇形命名法，并以此当作表名 */
  tableName?: string;

  /** 实体类型 */
  entityType?: EntityType|"";

  /** 字段元数据列表 */
  columns: ColumnMeta[];

  /** 枚举值JSON，枚举类型实体使用，不参与数据库映射 */
  enumValues?: any;
}

typescript复制代码
/**
* 字段类型，枚举，目前版本仅支持这些类型，后续可以扩展
*/
export enum ColumnType{

  /** 数字类型 */
  Number = 'Number',

  /** 布尔类型 */
  Boolean = 'Boolean',

  /** 字符串类型 */  
  String = 'String',

  /** 日期类型 */  
  Date = 'Date',

  /** JSON类型 */
  SimpleJson = 'simple-json',

  /** 数组类型 */
  SimpleArray = 'simple-array',

  /** 枚举类型 */
  Enum = 'Enum'
}

/**
* 字段元数据，基本跟 TypeORM Column 对应
*/
export interface ColumnMeta{

  /** 唯一标识 */
  uuid: string;

  /** 字段名 */
  name: string;

  /** 字段类型 */
  type: ColumnType;

  /** 是否主键 */
  primary?: boolean;

  /** 是否自动生成 */
  generated?: boolean;

  /** 是否可空 */
  nullable?: boolean;

  /** 字段默认值 */
  default?: any;

  /** 是否唯一 */
  unique?: boolean;

  /** 是否是创建日期 */
  createDate?: boolean;

  /** 是否是更新日期 */
  updateDate?: boolean;

  /** 是否是删除日期，软删除功能使用 */
  deleteDate?: boolean;

  /**
   * 是否可以在查询时被选择，如果这是为false，则查询时隐藏。
   * 密码字段会使用它
   */
  select?: boolean;

  /** 长度 */
  length?: string | number;

  /** 当实体是枚举类型时使用 */
  enumEnityUuid?:string;

  /**
   * ============以下属性跟TypeORM对应，但是尚未启用
   */
  width?: number;
  version?: boolean;
  readonly?: boolean;  
  comment?: string;
  precision?: number;
  scale?: number;
}

typescript复制代码/**
 * 关系类型
 */
export enum RelationType {
  ONE_TO_ONE = 'one-to-one',
  ONE_TO_MANY = 'one-to-many',
  MANY_TO_ONE = 'many-to-one',
  MANY_TO_MANY = 'many-to-many',
}

/**
 * 关系元数据
 */
export interface RelationMeta {
  /** 唯一标识 */
  uuid: string;

  /** 关系类型 */  
  relationType: RelationType;

  /** 关系的源实体标识 */  
  sourceId: string;

  /** 关系目标实体标识 */  
  targetId: string;

  /** 源实体上的关系属性 */  
  roleOnSource: string;

  /** 目标实体上的关系属性  */    
  roleOnTarget: string;

  /** 拥有关系的实体ID，对应 TypeORM 的 JoinTable 或 JoinColumn */
  ownerId?: string;
}

typescript复制代码/**
 * 包的元数据
 */
export interface PackageMeta{
  /** ID，主键  */
  id?: number;

  /** 唯一标识 */
  uuid: string;

  /** 包名 */
  name: string;

  /**实体列表 */
  entities?: EntityMeta[];

  /**ER图列表 */
  diagrams?: DiagramMeta[];

  /**关系列表 */
  relations?: RelationMeta[];
}

typescript复制代码import { X6EdgeMeta } from "./x6-edge-meta";
import { X6NodeMeta } from "./x6-node-meta";

/**
 * ER图元数据
 */
export interface DiagramMeta {
  /** 唯一标识 */
  uuid: string;

  /** ER图名称 */
  name: string;

  /** 节点 */
  nodes: X6NodeMeta[];

  /** 关系的连线 */
  edges: X6EdgeMeta[];
}

typescript复制代码export interface X6NodeMeta{
  /** 对应实体标识uuid */
  id: string;
  /** 节点x坐标 */
  x?: number;
  /** 节点y坐标  */
  y?: number;
  /** 节点宽度 */
  width?: number;
  /** 节点高度 */
  height?: number;
}

typescript复制代码import { Point } from "@antv/x6";

export type RolePosition = {
  distance: number,
  offset: number,
  angle: number,
}
export interface X6EdgeMeta{
  /** 对应关系 uuid */
  id: string;

  /** 折点数据 */
  vertices?: Point.PointLike[];

  /** 源关系属性位置标签位置 */
  roleOnSourcePosition?: RolePosition;

  /** 目标关系属性位置标签位置 */
  roleOnTargetPosition?: RolePosition;
}

console复制代码nest new rx-models

cd rx-models

npm install npm install typeorm

typescript复制代码url: /get/jsonstring...
method: get
返回值:{
  data:any,
  pagination?:{
    pageSize: number,
    pageIndex: number,
    totalCount: number
  }
}

json复制代码{
  "entity": "Post"
}

json复制代码{
  "entity": "Post",
  "id": 1
}

json复制代码{
  "entity": "Post",
  "@orderBy": {
    "title": "ASC",
    "updatedAt": "DESC"
  }
}

json复制代码{
  "entity": "Post",
  "@select": ["title"]
}

json复制代码{
  "entity @select(title)": "Post"
}

json复制代码{
  "entity": "Post",
  "@getOne": true
}

json复制代码{
  "entity @getOne": "Post"
}

json复制代码{
  "entity": "Post",
  "title @like": "%水%"
}

json复制代码{
  "entity": "Post",
  "@where": "name %like '%风%' and ..."
}

json复制代码{
  "entity": "Post",
  "@paginate": [25, 0]
}

json复制代码{
  "entity @paginate(25, 0)": "Post"
}

json复制代码{
  "entity": "Post",
  "medias": {}
}

json复制代码{
  "entity": "Post",
  "medias": {
    "owner":{}
  }
}

json复制代码{
  "entity": "Post",
  "medias": {
    "name @like": "%风景%"
  }
}

json复制代码{
  "entity": "Post",
  "medias @count(5)": {}
}

json复制代码{
  "entity": "Post",
  "@addCopyRight": "content"
}

json复制代码{
  "entity @addCopyRight(content)": "Post"
}

makefile复制代码url: /post
method: post
参数: JSON
返回值: 操作成功的对象

json复制代码{
  "Post": {
    "title": "轻轻的，我走了",
    "content": "...",
    // 作者关联 id
    "author": 1,
    // 图片关联 id
    "medias":[3, 5, 6 ...]
  }
}

json复制代码{
  "Post": [
    {
      "id": 1,
      "title": "轻轻的，我走了",
      "content": "内容有所改变...",
      "author": 1,
      "medias":[3, 5, 6 ...]
    },
    {
      "title": "正如，我轻轻的来",
      "content": "...",
      "author": 1,
      "medias": [6, 7, 8 ...]
    }
  ]
}

json复制代码{
  "Post": [
    {
      ...
    },
    {
      ...
    }
  ],
  "Media": [
    {
      ...
    }
  ]
}

json复制代码{
  "Post": {
    "title": "轻轻的，我走了",
    "content": "...",
    "author": 1,
    "medias":[3, 5, 6 ...],
    "seoMeta":{
      "title": "诗篇解读：轻轻的，我走了|诗篇解读网",
      "descript": "...",
      "keywords": "诗篇，解读，诗篇解读"
    }
  }
}

json复制代码{
  "Post": {
    "title": "轻轻的，我走了",
    "content": "...",
    "author": 1,
    "medias":[3, 5, 6 ...],
    "seoMeta":null
  }
}

json复制代码{
  "Post @cascade(medias)": {
    "title": "轻轻的，我走了",
    "content": "...",
    "author": 1,
    "medias":[3, 5, 6 ...],
    "seoMeta":null
  }
}

json复制代码{
  "Post": {
    "title": "轻轻的，我走了",
    "content": "...",
    "author": 1,
    "medias @cascade":[3, 5, 6 ...],
    "seoMeta":null
  }
}

json复制代码{
  "Post @sendEmail(title, content, water@rxdrag.com)": {
    "title": "轻轻的，我走了",
    "content": "...",
    "author": 1,
    "medias @cascade":[3, 5, 6 ...],
  }
}

makefile复制代码url: /update
method: post
参数: JSON
返回值: 操作成功的对象

json复制代码{
  "Post": {
    "status": "published",
    "@ids":[3, 5, 6 ...],
  }
}

makefile复制代码url: /delete
method: post
参数: JSON
返回值: 被删除的对象

json复制代码{
  "Post": [3, 5, ...]
}

json复制代码{
  "Post @cascade(seoMeta)": [3, 5, ...]
}

makefile复制代码url: /upload
method: post
参数: FormData
headers: {"Content-Type": "multipart/form-data;boundary=..."}
返回值: 上传成功后生成RxMedia对象

json复制代码{
   "entity": "RxMedia",
   "file": ...,
   "name": "文件名"
   }

typescript复制代码url: /auth/login
method: post
参数: {
  username: string,
  password: string
}
返回值：jwt token

vbnet复制代码url: /auth/me
method: get
返回值: 当前登录用户，RxUser类型

typescript复制代码export interface RxPackage {
  /* id 数据库主键 */
  id: number;

  /** 唯一标识uuid，当不同的项目之间共享元数据时，这个字段很有用 */
  uuid: string;

  /** 包名 */
  name: string;

  /** 包的所有实体元数据，以JSON形式存于数据库 */
  entities: any;

  /** 包的所有 ER 图，以JSON形式存于数据库 */
  diagrams?: any;

  /** 包的所有关系，以JSON形式存于数据库 */
  relations?: any;
}

typescript复制代码url: install
method: post
参数: {
  /** 数据库类型 */
  type: string;

  /** 数据库所在主机 */
  host: string;

  /** 数据库端口 */
  port: string;

  /** 数据库schema名 */
  database: string;

  /** 数据登录用户 */
  username: string;

  /** 数据库登录密码 */
  password: string;

  /** 超级管理员登录名  */
  admin: string;

  /** 超级管理员密码 */
  adminPassword: string;

  /** 是否创建演示账号 */
  withDemo: boolean;
}

vbnet复制代码url: /is-installed
method: get
返回值: {
  installed: boolean
}

typescript复制代码import { QueryResult } from 'src/magic-meta/query/query-result';
import { RxUser } from 'src/entity-interface/RxUser';

export interface MagicService {
  me: RxUser;

  query(json: any): Promise<QueryResult>;

  post(json: any): Promise<any>;

  delete(json: any): Promise<any>;

  update(json: any): Promise<any>;
}

console复制代码npx create-react-app rx-models-client--template typescript

typescript复制代码export class EntityBoardStore{
  /**
   * 是否有修改，用于未保存提示
   */
  changed = false;

  /**
   * 所有的包
   */
  packages: PackageStore[];

  /**
   * 当前正在打开的 ER 图
   */
  openedDiagram?: DiagramStore;

  /**
   * 当前使用的 X6 Graph对象
   */
  graph?: Graph;

  /**
   * 工具条上的关系被按下，记录具体类型
   */
  pressedLineType?: RelationType;

  /**
   * 处在鼠标拖动划线的状态
   */
  drawingLine: LineAction | undefined;

  /**
   * 被选中的节点
   */
  selectedElement: SelectedNode;

  /**
   * Command 模式，撤销列表
   */
  undoList: Array<Command> = [];

  /**
   * Command 模式，重做列表
   */
  redoList: Array<Command> = [];

  /**
   * 构造函数传入包元数据，会自动解析成一棵 Mobx Observable 树
   */
  constructor(packageMetas:PackageMeta[]) {
    this.packages = packageMetas.map(
      packageMeta=> new PackageStore(packageMeta,this)
    );
    makeAutoObservable(this);
  }
  
  /**
   * 后面大量的set方法，就不需要了展开了
   */
  ...

}

typescript复制代码export class PackageStore{
  id?: number;
  uuid: string;
  name: string;
  entities: EntityStore[] = [];
  diagrams: DiagramStore[] = [];
  relations: RelationStore[] = [];
  status: PackageStatus;
  
  constructor(meta:PackageMeta, public rootStore: EntityBoardStore){
    this.id = meta.id;
    this.uuid = meta?.uuid;
    this.name = meta?.name;
    this.entities = meta?.entities?.map(
      meta=>new EntityStore(meta, this.rootStore, this)
    )||[];
    this.diagrams = meta?.diagrams?.map(
      meta=>new DiagramStore(meta, this.rootStore, this)
    )||[];
    this.relations = meta?.relations?.map(
      meta=>new RelationStore(meta, this)
    )||[];
    this.status = meta.status;
    makeAutoObservable(this)
  }

  /**
   * 省略set方法
   */
  ...

  
  /**
   * 最后提供一个把 Store 逆向转成元数据的方法，用于往后端发送数据
   */
  toMeta(): PackageMeta {
    return {
      id: this.id,
      uuid: this.uuid,
      name: this.name,
      entities: this.entities.map(entity=>entity.toMeta()),
      diagrams: this.diagrams.map(diagram=>diagram.toMeta()),
      relations: this.relations.map(relation=>relation.toMeta()),
      status: this.status,
    }
  }
}

typescript复制代码export type NodeConfig = X6NodeMeta & {data: EntityNodeData};
export type EdgeConfig = X6EdgeMeta & RelationMeta;

export class DiagramStore {
  ...

  /**
   * 获取当前 ER 图所有的节点，利用 mobx 更新机制，
   * 只要数据有更改，调用该方法的视图会自动被更新，
   * 参数只是用了指示当前选中的节点，或者是否需要连线，
   * 这些状态会影响视图，可以在这里直接传递给每个节点
   */
  getNodes(
    selectedId:string|undefined, 
    isPressedRelation:boolean|undefined
  ): NodeConfig[]

  /**
   * 获取当前 ER 图所有的连线，利用 mobx 更新机制，
   * 只要数据有更改，调用该方法的视图会自动被更新
   */
  getAndMakeEdges(): EdgeConfig[]

}

typescript复制代码export const EnityContext = createContext<EntityBoardStore>({} as EntityBoardStore);
export const EntityStoreProvider = EnityContext.Provider;
export const useEntityBoardStore = (): EntityBoardStore => useContext(EnityContext);

typescript复制代码...
const [modelStore, setModelStore] = useState(new EntityBoardStore([]));

...
  return (
    <EntityStoreProvider value = {modelStore}>
      ...
    </EntityStoreProvider>
  )

css复制代码src/componets/entity-board/grahp-canvas

bash复制代码src/componets/entity-board/command

python复制代码# raise
try:
    raise ValueError
except Exception as e:
    raise IndexError
"""
Traceback (most recent call last):
  File "raise.py", line 3, in <module>
    raise ValueError
ValueError

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "raise.py", line 5, in <module>
    raise IndexError
IndexError
"""

python复制代码# raise/from
try:
    raise ValueError
except Exception as e:
    raise IndexError from e
"""
Traceback (most recent call last):
  File "raisefrom.py", line 3, in <module>
    raise ValueError
ValueError

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "raisefrom.py", line 5, in <module>
    raise IndexError from e
IndexError
"""

python复制代码# raise ... from None
# 禁用异常上下文属性
try:
    raise ValueError
except Exception as e:
    raise IndexError from None
"""
Traceback (most recent call last):
  File "raisefromnone.py", line 6, in <module>
    raise IndexError from None
IndexError
"""

java复制代码// 方法一，已过期
String path = "spring/beans.xml";
Resource resource = new ClassPathResource(path);
// BeanDefination注册流程
XmlBeanFactory beanFactory = new XmlBeanFactory(resource );

// 方法二
String path = "spring/beans.xml";
// 创建DefaultListableBeanFactory工厂，这也就是Spring的基本容器
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
// 创建BeanDefinition阅读器
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
// 进行BeanDefinition注册流程
reader.loadBeanDefinitions(path);

// 总结：两种方法最终都是通过XmlBeanDefinitionReader开启解析注册流程

// 方法三：通过高级容器进行创建
// 创建IoC容器，并进行初始化
ApplicationContext context = new ClassPathXmlApplicationContext("spring/spring-ioc.xml");
// 获取Bean的实例
Student bean = (Teacher) context.getBean(Teacher.class);

java复制代码【XmlBeanFactory】#构造方法
	@@XmlBeanDefinitionReader
		# loadBeanDefinitions(EncodedResource resource)
		# doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			// 通过DOM4J加载解析XML文件，最终形成Document对象
			#Document doc = doLoadDocument(inputSource, resource)
			// 通过对Document对象的操作，完成BeanDefinition的加载和注册工作
			# registerBeanDefinitions(doc, resource)
				// 创建BeanDefinitionDocumentReader来解析Document对象，完成BeanDefinition解析
				@@BeanDefinitionDocumentReader
					//解析过程入口，BeanDefinitionDocumentReader只是个接口
					# registerBeanDefinitions(doc, ..)
						// 具体的实现过程在DefaultBeanDefinitionDocumentReader完成
						@@DefaultBeanDefinitionDocumentReader
							// 真正实现BeanDefinition解析和注册工作
							# registerBeanDefinitions(doc, ..)
							// 委托给BeanDefinitionParserDelegate
							// 从Document的根元素开始进行BeanDefinition的解析
							# doRegisterBeanDefinitions(doc.getDocumentElement())
								# parseBeanDefinitions(Eleme(ele)nt root)
									// bean标签、import标签、alias标签，则使用默认解析规则
									# parseDefaultElement(Element ele)
										# processBeanDefinition(ele)
											@@BeanDefinitionParserDelegate
												# parseBeanDefinitionElement(ele)
													// 最终注册方法
													#BeanDefinitionReaderUtils			
														#registerBeanDefinition
									// 解析自定义标签，如：<aop:config>					
									#parseCustomElement()
										// 委托给BeanDefinitionParserDelegate
										@@BeanDefinitionParserDelegate
											# parseCustomElement(..)
                                                # BeanDefinitionParser(..)
                                                    #parse(Element element, ..)
                                                        ...省略
                                                        // 最终注册方法
                                                        #BeanDefinitionReaderUtils
                                                            #registerBeanDefinition	
    
【ClassPathXmlApplicationContext】#构造方法
    # setConfigLocations(configLocations)
    # refresh()
    	@@AbstractApplicationContext
    		# refresh()
    			public void refresh() {
                    synchronized (this.startupShutdownMonitor) {
                        // Prepare this context for refreshing.
                        // STEP 1： 刷新预处理
                        prepareRefresh();

                        // Tell the subclass to refresh the internal bean factory.
                        // STEP 2：
                        // 		a） 创建IoC容器（DefaultListableBeanFactory）
                        //		b） 加载解析XML文件（最终存储到Document对象中）
                        //		c） 读取Document对象，并完成BeanDefinition的加载和注册工作
                        ConfigurableListableBeanFactory beanFactory = 
                            	obtainFreshBeanFactory();

                        // Prepare the bean factory for use in this context.
                        // STEP 3： 对IoC容器进行一些预处理（设置一些公共属性）
                        prepareBeanFactory(beanFactory);

                        try {
                            // Allows post-processing of the bean factory 
                            // in context subclasses.
                            // STEP 4： 
                            postProcessBeanFactory(beanFactory);

                            // Invoke factory processors registered as beans
                            // in the context.
                            // STEP 5： 调用BeanFactoryPostProcessor后置处理器
                            // 对BeanDefinition处理
                            invokeBeanFactoryPostProcessors(beanFactory);

                            // Register bean processors that intercept bean creation.
                            // STEP 6： 注册BeanPostProcessor后置处理器
                            registerBeanPostProcessors(beanFactory);

                            // Initialize message source for this context.
                            // STEP 7： 初始化一些消息源（比如处理国际化的i18n等消息源）
                            initMessageSource();

                            // Initialize event multicaster for this context.
                            // STEP 8： 初始化应用事件广播器
                            initApplicationEventMulticaster();

                            // Initialize other special beans 
                            // in specific context subclasses.
                            // STEP 9： 初始化一些特殊的bean
                            onRefresh();

                            // Check for listener beans and register them.
                            // STEP 10： 注册一些监听器
                            registerListeners();

                            // Instantiate all remaining (non-lazy-init) singletons.
                            // STEP 11： 实例化剩余的单例bean（非懒加载方式）
                            // 注意事项：Bean的IoC、DI和AOP都是发生在此步骤
                            finishBeanFactoryInitialization(beanFactory);

                            // Last step: publish corresponding event.
                            // STEP 12： 完成刷新时，需要发布对应的事件
                            finishRefresh();
                        } catch (BeansException ex) {
                            // Destroy already created singletons
                            // to avoid dangling resources.
                            destroyBeans();

                            // Reset 'active' flag.
                            cancelRefresh(ex);
							...
                        } finally {
                           // Reset common introspection caches in Spring's core, since 
                           // might not ever need metadata for singleton beans anymore
                           resetCommonCaches();
                        }
                    }
                }
		// 通过此方法来解析相关BeanDefinition, 还会完成其余附属功能
		# obtainFreshBeanFactory()
            @@AbstractRefreshableApplicationContext
            	// 如果之前有IoC容器，则销毁
            	# refreshBeanFactory()
            		// 创建IoC容器，也就是DefaultListableBeanFactory
            		# createBeanFactory()
            		// 设置工厂的属性：是否允许BeanDefinition覆盖和是否允许循环依赖
					# customizeBeanFactory(beanFactory);
					// 调用载入BeanDefinition的方法，在当前类中只定义了抽象的
					// loadBeanDefinitions方法，具体的实现调用子类容器
					# loadBeanDefinitions(beanFactory); //钩子方法
						@@ AbstractXmlApplicationContext
							# loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
                            	@@XmlBeanDefinitionReader
                            		// XML Bean读取器调用其父类
                            		// AbstractBeanDefinitionReader读取定位的资源
                            		@@ AbstractBeanDefinitionReader
										# loadBeanDefinitions(configLocations)
                            				...
                            				// 委派调用其子类
                            				// XmlBeanDefinitionReader的方法，实现加载功能
                            				# loadBeanDefinitions(Resource resource)
                            				// 至此，回到上面1或者2的流程处理

java复制代码AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.spring.test.ioc.annotation.po");
Teacher student = context.getBean(Teacher.class);

java复制代码【AnnotationConfigApplicationContext】#构造方法
	# scan(basePackages);
    # refresh();
		@@AbstractApplicationContext
    		# refresh() 
            // 解析源码见1.2说明

java复制代码protected void prepareRefresh() {
    // 1、这个方法设置context的启动日期。
    this.startupDate = System.currentTimeMillis();
    
    // 2、设置context当前的状态，是活动状态还是关闭状态。
    this.closed.set(false);
	this.active.set(true);
    
    // 3、初始化context environment（上下文环境）中的占位符属性来源。
    // 扩展覆盖protected void initPropertySources()方法，加载自定义环境属性值
    // 如：getEnvironment().getSystemProperties().put("name","bobo");
    initPropertySources();

    // 4、验证所有必需的属性。
    // 如：上一步getEnvironment().setRequiredProperties("username");
    // 则在当前方法会进行校验，不存在则抛出异常
    getEnvironment().validateRequiredProperties();

    // 5、创建一些监听器事件的集合
    this.earlyApplicationEvents = new LinkedHashSet<>();
}

java复制代码protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    // 主要是通过该方法完成IoC容器的刷新
    refreshBeanFactory();
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    return beanFactory;
}

protected final void refreshBeanFactory() throws BeansException {
    // 1、如果之前有IoC容器，则销毁
    if (hasBeanFactory()) {
        // 销毁bean
        destroyBeans();
        // 关闭bean工厂
        closeBeanFactory();
    }
    // 2、创建IoC容器，也就是DefaultListableBeanFactory
    DefaultListableBeanFactory beanFactory = createBeanFactory();
    beanFactory.setSerializationId(getId());
    // 3、设置工厂的属性：是否允许BeanDefinition覆盖和是否允许循环依赖
    customizeBeanFactory(beanFactory);
    // 4、调用载入BeanDefinition的方法，在当前类中只定义了抽象的loadBeanDefinitions方法，
    // 具体的实现调用子类容器如：AnnotationConfigWebApplicationContext、			
    // AbstractXmlApplicationContext
    loadBeanDefinitions(beanFactory);
    synchronized (this.beanFactoryMonitor) {
        // 5、将创建好的bean工厂的引用交给的context来管理。
        this.beanFactory = beanFactory;
    }
}

java复制代码// 配置这个工厂的标准环境，比如context的类加载器和后处理器
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 1、设置beanFactory的类加载器
		beanFactory.setBeanClassLoader(getClassLoader());
    	// 2、设置属性解析器
		beanFactory.setBeanExpressionResolver(new                                      					StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); 
		beanFactory.addPropertyEditorRegistrar(new 
                ResourceEditorRegistrar(this,getEnvironment()));

		// 3、添加到后置处理器列表, 新创建的 ApplicationContextAwareProcessor 
    	// 入参为当前 ApplicationContext, 为实现Aware接口的bean设置对应的对象
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    	// 4、忽略自动属性装配/赋值，默认只有BeanFactoryAware被忽略，要忽略其他类型，需要单独设置
    	// 此处目的是为了交给用户自定义实现Aware功能，基于自定义后置处理器处理Bean依赖
    	// 忽略该接口的实现类中和接口setter方法入参类型相同的依赖。
    	// 这样的做法使得ApplicationContextAware和BeanFactoryAware中的ApplicationContext或			// BeanFactory依赖在自动装配时被忽略，而统一由框架设置依赖，如ApplicationContextAware接口			// 的设置会在ApplicationContextAwareProcessor类中完成.
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
		
		// 5、该方法的主要作用就是指定该类型接口，如果外部要注入该类型接口的对象，则会注入我们
    	// 指定的对象，而不会去管其他接口实现类（因为多个实现类不知道注入哪个，在这里明确指定）
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);
		
    	// 6、用于处理实现ApplicationListener接口的bean,bean初始化后添加监听
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
    
    	// 7、增加对AspectJ的支持
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new                      
                      LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new                                 			 
              ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
		// 8、给容器中注册Singleton组件,ConfigurableEnviroment,systemProperties,
    	// systemEnvironment，添加到singletonObjects（ConcurrentHashMap类型）中
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, 	
                                          getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, 
                                          getEnvironment().getSystemEnvironment());
		}
	}

java复制代码// 因为此方法的参数是BeanFactory，所以我们可以重写此方法，然后针对beanFactory进行一些修改。
@Override
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // ServletContextAwareProcessor中拿到应用上下文持有的servletContext引用和servletConfig引用
    // 1.添加ServletContextAwareProcessor处理器
    beanFactory.addBeanPostProcessor(new 	
             ServletContextAwareProcessor(this.servletContext, this.servletConfig));    
    // 在自动注入时忽略指定的依赖接口，通常被应用上下文用来注册以其他方式解析的依赖项
    beanFactory.ignoreDependencyInterface(ServletContextAware.class);
    beanFactory.ignoreDependencyInterface(ServletConfigAware.class);

    // 2.注册web应用的scopes
    WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, 
                                        this.servletContext);
    
    // 3.注册和环境有关的beans
    WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, 						this.servletConfig);
}

java复制代码protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory 	
                                               	beanFactory) {
    // 1.getBeanFactoryPostProcessors(): 拿到当前应用上下文beanFactoryPostProcessors
    // 变量中的值，默认为空的，除非自己手动调用	context.addBeanFactoryPostProcessor
    // (beanFactoryPostProcessor)完成自定义添加
    // 2.invokeBeanFactoryPostProcessors: 实例化并调用所有已注册的BeanFactoryPostProcessor
	PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, 	
 							getBeanFactoryPostProcessors());

	if (beanFactory.getTempClassLoader() == null && 
        				beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		beanFactory.setTempClassLoader(new 
					ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}
}

public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> 	
    								beanFactoryPostProcessors) {
    Set<String> processedBeans = new HashSet<String>();
    // 1. beanFactory为DefaultListableBeanFactory, DefaultListableBeanFactory实现了
    // BeanDefinitionRegistry接口，判定为true
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        // 1.1 保存普通的BeanFactoryPostProcessor
        List<BeanFactoryPostProcessor> regularPostProcessors = new 
            								LinkedList<BeanFactoryPostProcessor>();
        // 1.2 保存BeanDefinitionRegistryPostProcessor
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new 
            					 LinkedList<BeanDefinitionRegistryPostProcessor>();
        // 2. 遍历入参中beanFactoryPostProcessors, 将BeanDefinitionRegistryPostProcessor
        // 和普通BeanFactoryPostProcessor区分开
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                // 2.1. 如果是BeanDefinitionRegistryPostProcessor
                BeanDefinitionRegistryPostProcessor registryProcessor =
                        (BeanDefinitionRegistryPostProcessor) postProcessor;
                // 2.2. 执行BeanDefinitionRegistryPostProcessor接口的		
                // postProcessBeanDefinitionRegistry方法
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                // 2.3. 添加到registryProcessors(用于最后执行postProcessBeanFactory方法)
                registryProcessors.add(registryProcessor);
            } else {
                // 3.1. 普通的BeanFactoryPostProcessor添加到regularPostProcessors
                // (用于最后执行postProcessBeanFactory方法)
                regularPostProcessors.add(postProcessor);
            }
        }
        
        // 保存本次要执行的所有BeanDefinitionRegistryPostProcessor
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new 	
            					ArrayList<BeanDefinitionRegistryPostProcessor>();
        
        // 4. 找出所有实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor实现类
        // 找出所有实现BeanDefinitionRegistryPostProcessor接口的Bean的beanName
        String[] postProcessorNames = beanFactory.getBeanNamesForType
            				(BeanDefinitionRegistryPostProcessor.class, true, false);
        
        // 5. 遍历postProcessorNames
        for (String ppName : postProcessorNames) {
            // 5.1. 判定是否实现了PriorityOrdered接口
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                // 5.2. 获取ppName对应的bean实例, 添加到currentRegistryProcessors中,
                // beanFactory.getBean方法会触发创建ppName对应的bean实例
                currentRegistryProcessors.add(beanFactory.getBean(ppName, 
										BeanDefinitionRegistryPostProcessor.class));
                // 5.3. 将实现类名添加到processedBeans，防止重复
                processedBeans.add(ppName);
            }
        }
        // 6. 进行排序(根据是否实现PriorityOrdered、Ordered接口和order值来排序)
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        // 7. 添加到registryProcessors(用于最后执行postProcessBeanFactory方法)
        registryProcessors.addAll(currentRegistryProcessors);
        // 8. 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        // 9. 清空currentRegistryProcessors
        currentRegistryProcessors.clear();
 
       	// 10. 找出所有实现BeanDefinitionRegistryPostProcessor接口的类, 
        // 重复查找是因为执行完上面的BeanDefinitionRegistryPostProcessor,
        // 可能会新增了其他的BeanDefinitionRegistryPostProcessor
        postProcessorNames = beanFactory.getBeanNamesForType
            				(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            // 校验是否实现了Ordered接口，并且还未执行过
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, 
                                                 					Ordered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, 	
							BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        // 11. 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        currentRegistryProcessors.clear();
 
        // 12. 最后查找所有剩下的BeanDefinitionRegistryPostProcessors
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            // 12.1 找出所有实现BeanDefinitionRegistryPostProcessor接口的类
            postProcessorNames = beanFactory.getBeanNamesForType
               				 (BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                // 12.2 跳过已经执行过的
                if (!processedBeans.contains(ppName)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, 
 										BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                    // 12.3 如果有BeanDefinitionRegistryPostProcessor被执行,
                    // 则有可能会产生新的BeanDefinitionRegistryPostProcessor,
                    // 因此这边将reiterate赋值为true, 代表需要再循环查找一次
                    reiterate = true;
                }
            }
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            // 13. 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, 	
                                                       	registry);
            currentRegistryProcessors.clear();
        }
 
        // 14. 调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法	
        // (BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor)
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        // 15. 调用入参beanFactoryPostProcessors中的普通BeanFactoryPostProcessor的		
        // postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    } else {
        // 直接调用传过来的BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }
 
    // 到这里入参beanFactoryPostProcessors和容器中的所BeanDefinitionRegistryPostProcessor
    // 已经全部处理完毕,下面开始处理容器中的所有BeanFactoryPostProcessor
 
    // 16.找出所有实现BeanFactoryPostProcessor接口的类
    String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    // 17. 保存实现了PriorityOrdered接口的BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new 
        										ArrayList<BeanFactoryPostProcessor>();
    // 保存实现了Ordered接口的BeanFactoryPostProcessor的beanName
    List<String> orderedPostProcessorNames = new ArrayList<String>();
    // 保存普通BeanFactoryPostProcessor的beanName
    List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
    // 18. 遍历postProcessorNames, 将BeanFactoryPostProcessor
    // 按实现PriorityOrdered、实现Ordered接口、普通三种区分开
    for (String ppName : postProcessorNames) {
        if (processedBeans.contains(ppName)) {
            // 18.1 跳过已经执行过的
        } else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            // 18.2 添加实现了PriorityOrdered接口的BeanFactoryPostProcessor
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, 	
												BeanFactoryPostProcessor.class));
        } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            // 18.3 添加实现了Ordered接口的BeanFactoryPostProcessor的beanName
            orderedPostProcessorNames.add(ppName);
        } else {
            // 18.4 添加剩下的普通BeanFactoryPostProcessor的beanName
            nonOrderedPostProcessorNames.add(ppName);
        }
    }
 
    // 19. 对priorityOrderedPostProcessors排序
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    // 20. 调用所有实现PriorityOrdered接口的BeanFactoryPostProcessor
    // 遍历priorityOrderedPostProcessors, 执行postProcessBeanFactory方法
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
 
    // 21. 调用所有实现Ordered接口的BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> orderedPostProcessors = new 	
        									ArrayList<BeanFactoryPostProcessor>();
    for (String postProcessorName : orderedPostProcessorNames) {
        // 21.1 获取postProcessorName对应的bean实例, 添加到orderedPostProcessors, 准备执行
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, 
                                                 BeanFactoryPostProcessor.class));
    }
    // 21.2 对orderedPostProcessors排序
    sortPostProcessors(orderedPostProcessors, beanFactory);
    // 21.3 遍历orderedPostProcessors, 执行postProcessBeanFactory方法
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // 22.调用所有剩下的BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new 
        									ArrayList<BeanFactoryPostProcessor>();
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        // 22.1 获取postProcessorName对应的bean实例, 添加到nonOrderedPostProcessors
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, 
												BeanFactoryPostProcessor.class));
    }
    // 22.2 遍历nonOrderedPostProcessors, 执行postProcessBeanFactory方法
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
 
    // 23. 清除元数据缓存（mergedBeanDefinitions、allBeanNamesByType、	
    // singletonBeanNamesByType），
    // 因为后处理器可能已经修改了原始元数据，例如: 替换值中的占位符
    beanFactory.clearMetadataCache();
}

java复制代码// 注册用来拦截bean创建的BeanPostProcessor bean.这个方法需要在所有的application bean初始化之前调、
// 用。把这个注册的任务委托给了PostProcessorRegistrationDelegate来完成。
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

public static void registerBeanPostProcessors(ConfigurableListableBeanFactory 			
                            beanFactory,AbstractApplicationContext applicationContext) {
	// 1. 查找所有实现BeanPostProcessor的后置处理器名称	
    String[] postProcessorNames = beanFactory.getBeanNamesForType
        										(BeanPostProcessor.class, true, false);
		// 2. 计算处理器总数
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + 
            						postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, 
 									beanProcessorTargetCount));

		// 3. 对所有的BeanPostProcessor按照PriorityOrdered、Ordered和普通的进行分组存储
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, 
                                                           BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// 4. 排序并注册所有实现了PriorityOrdered的后置处理器
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// 5. 排序并注册所有实现了Ordered的后置处理器
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// 6. 注册所有普通的后置处理器
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// 排序并注册所有实现了MergedBeanDefinitionPostProcessor的应用处理器
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		// 重新注册用来自动探测内部ApplicationListener的post-processor，
    	// 这样可以将他们移到处理器链条的末尾
		beanFactory.addBeanPostProcessor(new 		
                              ApplicationListenerDetector(applicationContext));
	}

java复制代码// 初始化MessageSource接口的一个实现类。这个接口提供了消息处理功能。主要用于国际化/i18n。
// 此部分代码不做详细阐述
protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, 	
                                                 MessageSource.class);
        if (this.parent != null && this.messageSource 
            instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource) 
                this.messageSource;
            if (hms.getParentMessageSource() == null) {
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
    }
    else {
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
    }
}

java复制代码// 为context初始化一个事件监听多路广播器（ApplicationEventMulticaster）
protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 检查是否给context配了一个ApplicationEventMulticaster实现类
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        this.applicationEventMulticaster =
            beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, 
                                ApplicationEventMulticaster.class);
    }
    else {
        // 如果没有，就使用默认的实现类 SimpleApplicationEventMulticaster
        this.applicationEventMulticaster = new 	
            			SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, 
                                      this.applicationEventMulticaster);
    }
}

java复制代码// 在AbstractApplicationContext的子类中初始化其他特殊的bean。其实就是初始化ThemeSource接口的实例。
// 这个方法需要在所有单例bean初始化之前调用。
protected void onRefresh() throws BeansException {
    // 是个空壳方法，在AnnotationApplicationContex上下文中没有实现，
    // 可能在spring后面的版本会去扩展。
}
@Override
protected void onRefresh() {
    this.themeSource = UiApplicationContextUtils.initThemeSource(this);
}

java复制代码// 注册应用的监听器。就是注册实现了ApplicationListener接口的监听器bean，这些监听器是注册到
// ApplicationEventMulticaster中的。这不会影响到其它监听器bean。在注册完以后，还会将其前期的事件发布
// 给相匹配的监听器。
protected void registerListeners() {
    // 获取实现了ApplicationListener的监听器
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        // 手动注册的监听器绑定到广播器
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    // 取到监听器的名称
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, 
    // 设置到广播器                                                			false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

   	// 如果存在早期应用事件，发布事件消息
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (earlyEventsToProcess != null) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

java复制代码// 完成bean工厂的初始化工作。这一步非常复杂，也非常重要，涉及到了bean的创建。第二步中只是完成了
// BeanDefinition的定义、解析、处理、注册。但是还没有初始化bean实例。这一步 实例化剩余的单例bean（非懒
// 加载方式）. 注意事项：Bean的IoC、DI和AOP都是发生在此步骤
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory 
                                               						beanFactory) {
		// 1. 初始化此上下文的转换服务
    	...
        // 2. 如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器：
        // 主要用于注解属性值的解析。
        ...
		// 3. 初始化LoadTimeWeaverAware Bean实例对象
		String[] weaverAwareNames = beanFactory.getBeanNamesForType
            								(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// 4. 冻结所有bean定义，注册的bean定义不会被修改
    	// 或进一步后处理，因为马上要创建 Bean 实例对象了
		beanFactory.freezeConfiguration();

		// 实例化单例Bean， 将在第四节【Bean初始化流程分析】进行讲解
		beanFactory.preInstantiateSingletons();
	}

java复制代码// 完成context的刷新。主要是调用LifecycleProcessor的onRefresh()方法，并且发布事件
//（ContextRefreshedEvent）。
protected void finishRefresh() {
    // Clear context-level resource caches (such as ASM metadata from scanning).
    clearResourceCaches();

    // 为此上下文初始化生命周期处理器
    // 初始化所有的 LifecycleProcessor
    // 在 Spring 中还提供了 Lifecycle 接口， Lifecycle 中包含 start/stop 方法，
    // 实现此接口后 Spring 会保证在启动的时候调用其 start 方法开始生命周期，
    // 并在 Spring 关闭的时候调用 stop 方法来结束生命周期，通常用来配置后台程序，在启动后一直运行
    // （如对 MQ 进行轮询等）。ApplicationContext 的初始化最后正是保证了这一功能的实现。
    initLifecycleProcessor();

    // 将刷新完成事件广播到生命周期处理器
    getLifecycleProcessor().onRefresh();

    // 广播上下文刷新完成事件
    publishEvent(new ContextRefreshedEvent(this));

    // 将spring容器注册到LiveBeansView
    // 和MBeanServer和MBean有关的。相当于把当前容器上下文，注册到MBeanServer里面去。
    // MBeanServer持有了容器的引用，就可以拿到容器的所有内容，也就让Spring支持到了MBean的相关功能
    LiveBeansView.registerApplicationContext(this);
}