正文前先来一波福利推荐:

福利一:

百万年薪架构师视频,该视频可以学到很多东西,是本人花钱买的VIP课程,学习消化了一年,为了支持一下女朋友公众号也方便大家学习,共享给大家。

福利二:

毕业答辩以及工作上各种答辩,平时积累了不少精品PPT,现在共享给大家,大大小小加起来有几千套,总有适合你的一款,很多是网上是下载不到。

获取方式:

微信关注 精品3分钟 ,id为 jingpin3mins,关注后回复   百万年薪架构师 ,精品收藏PPT  获取云盘链接,谢谢大家支持!

-----------------------正文开始---------------------------

一、Bean的生命过程

Bean的生命过程可以借鉴Servlet的生命过程,了解其生命过程对于不管是思想还是以后的使用都很有帮助;

Bean可以通过两种方式进行加载,分别是使用BeanFactory 和 applicationContext, 下边就这两种方式进行Bean的声明周期总结:

applicationContext:

先用一种生命周期流程图来概括;

1:Bean的建立:

容器寻找Bean的定义信息并将其实例化,也就是new一个对象,。

2:属性注入:

使用依赖注入,Spring按照Bean定义信息配置Bean所有属性,相当于调用set方法进行属性set操作

3. 如果这个Bean实现了BeanNameAware接口,会调用它实现的setBeanName(String beanId)方法,此处传递的是Spring配置文件中Bean的ID

4. 如果这个Bean实现了BeanFactoryAware接口,会调用它实现的setBeanFactory(),传递的是Spring工厂本身(可以用这个方法获取到其他Bean)

5. 如果这个Bean实现了ApplicationContextAware接口,会调用setApplicationContext(ApplicationContext)方法,传入Spring上下文,该方式同样可以实现步骤4,但比4更好,以为ApplicationContext是BeanFactory的子接口,有更多的实现方法

6. 如果这个Bean关联了BeanPostProcessor接口,将会调用postProcessBeforeInitialization(Object obj, String s)方法,BeanPostProcessor经常被用作是Bean内容的更改,并且由于这个是在Bean初始化结束时调用After方法,也可用于内存或缓存技术

7.如果设置了initializingBean接口,则会调用实现的afterPropertiesSet()方法;

8. 如果这个Bean在Spring配置文件中配置了init-method属性会自动调用其配置的初始化方法【相当于定制方法】

9. 如果这个Bean关联了BeanPostProcessor接口,将会调用postAfterInitialization(Object obj, String s)方法

注意:以上工作完成以后就可以用这个Bean了,那这个Bean是一个single的,所以一般情况下我们调用同一个ID的Bean会是在内容地址相同的实例

10. 容器关闭,当Bean不再需要时,会经过清理阶段,如果Bean实现了DisposableBean接口,会调用其实现的destroy方法,如果这个Bean的Spring配置中配置了destroy-method属性,会自动调用其配置的销毁方法

BeanFactory:

下边对BeanFactory的生命周期过程进行分析,BeanFactory的生命周期相对于ApplicationContext来说相对简化了一些;

下面用图进行概括:

下面以BeanFactory为例,说明一个Bean的生命周期活动

  • Bean的建立, 由BeanFactory读取Bean定义文件,并生成各个实例
  • Setter注入,执行Bean的属性依赖注入
  • BeanNameAware的setBeanName(), 如果实现该接口,则执行其setBeanName方法
  • BeanFactoryAware的setBeanFactory(),如果实现该接口,则执行其setBeanFactory方法
  • InitializingBean的afterPropertiesSet(),如果实现了该接口,则执行其afterPropertiesSet()方法
  • Bean定义文件中定义init-method
  • DisposableBean的destroy(),在容器关闭时,如果Bean类实现了该接口,则执行它的destroy()方法
  • Bean定义文件中定义destroy-method,在容器关闭时,可以在Bean定义文件中使用“destory-method”定义的方法

如果使用ApplicationContext来维护一个Bean的生命周期,则基本上与上边的流程相同,只不过在执行BeanNameAware的setBeanName()后,若有Bean类实现了org.springframework.context.ApplicationContextAware接口,则执行其setApplicationContext()方法,然后再进行BeanPostProcessors的processBeforeInitialization()
实际上,ApplicationContext除了向BeanFactory那样维护容器外,还提供了更加丰富的框架功能,如Bean的消息,事件处理机制等

 结果展示:

二、BeanFactory 接口和 ApplicationContext 接口有什么区别 ?

    ①ApplicationContext 接口继承BeanFactory接口,Spring核心工厂是BeanFactory ,BeanFactory采取延迟加载,第一次getBean时才会初始化Bean, ApplicationContext是会在加载配置文件时初始化Bean。
    ②ApplicationContext是对BeanFactory扩展,它可以进行国际化处理、事件传递和bean自动装配以及各种不同应用层的Context实现 

开发中基本都在使用ApplicationContext, web项目使用WebApplicationContext ,很少用到BeanFactory

  1. BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
  2. IHelloService helloService = (IHelloService) beanFactory.getBean("helloService");
  3. helloService.sayHello();

三、Bean的加载方式:

1)使用类构造器实例化(默认无参数)

  1.  <bean id="bean1" class="cn.itcast.spring.b_instance.Bean1"></bean>
    2)使用静态工厂方法实例化(简单工厂模式)
 
  1. //下面这段配置的含义:调用Bean2Factory的getBean2方法得到bean2
    <bean id="bean2" class="cn.itcast.spring.b_instance.Bean2Factory" factory-method="getBean2"></bean>
 
    3)使用实例工厂方法实例化(工厂方法模式)
  1. //先创建工厂实例bean3Facory,再通过工厂实例创建目标bean实例
  2. <bean id="bean3Factory" class="cn.itcast.spring.b_instance.Bean3Factory"></bean>
  3. <bean id="bean3" factory-bean="bean3Factory" factory-method="getBean3"></bean>

1. 使用静态工厂方法创建Bean

使用静态工厂方法创建Bean实例时,class属性也必须指定,但此时class属性并不是指定Bean实例的实现类,而是静态工厂类。因为Spring需要知道是用哪个工厂来创建Bean实例。另外,还需要使用factory-method来指定静态工厂方法名,Spring将调用静态工厂方法(可能包含一组参数),来返回一个Bean实例,一旦获得了指定Bean实例,Spring后面的处理步骤与采用普通方法创建Bean实例则完全一样。需要注意的是,当使用静态工厂方法来创建Bean时,这个factory-method必须要是静态的。这段阐述听上去有点晕,话不多说,上代码:

先定义一个接口,静态方法产生的将是该接口的实例:

  1. public interface Animal {
  2. public void sayHello();
  3. }

下面是接口的两个实现类:

  1. public class Cat implements Animal {
  2. private String msg;
  3. //依赖注入时必须的setter方法
  4. public void setMsg(String msg){
  5. this.msg = msg;
  6. }
  7. @Override
  8. public void sayHello(){
  9. System.out.println(msg + ",喵~喵~");
  10. }
  11. }
  12.  
  13. public class Dog implements Animal {
  14. private String msg;
  15. //依赖注入时必须的setter方法
  16. public void setMsg(String msg){
  17. this.msg = msg;
  18. }
  19. @Override
  20. public void sayHello(){
  21. System.out.println(msg + ",旺~旺~");
  22. }
  23. }

下面的AnimalFactory工厂中包含了一个getAnimal的静态方法,该方法将根据传入的参数决定创建哪个对象。这是典型的静态工厂设计模式。

  1. public clas AnimalFactory {
  2. public static Animal getAnimal(String type){
  3. if ("cat".equalsIgnoreCase(type)){
  4. return new Cat();
  5. } else {
  6. return new Dog();
  7. }
  8. }
  9. }

如果需要指定Spring使用AnimalFactory来产生Animal对象,则可在Spring配置文件中作如下配置:

  1. <!-- 配置AnimalFactory的getAnimal方法,使之产生Cat -->
  2. <bean id="cat" class="com.abc.AnimalFactory" factory-method="getAnimal">
  3. <!-- 配置静态工厂方法的参数,getAnimal方法将产生Cat类型的对象 -->
  4. <constructor-arg value="cat" />
  5. <!-- 通过setter注入的普通属性 -->
  6. <property name="msg" value="猫猫" />
  7. </bean>
  8. <!-- 配置AnimalFactory的getAnimal方法,使之产生Dog -->
  9. <bean id="dog" class="com.abc.AnimalFactory" factory-method="getAnimal">
  10. <!-- 配置静态工厂方法的参数,getAnimal方法将产生Dog类型的对象 -->
  11. <constructor-arg value="dog" />
  12. <!-- 通过setter注入的普通属性 -->
  13. <property name="msg" value="狗狗" />
  14. </bean>

从上面的配置可以看出:cat和dog两个Bean配置的class和factory-method完全相同,这是因为两个实例都使用同一个静态工厂类、同一个静态工厂方法产生得到的。只是为这个静态工厂方法指定的参数不同,使用<constructor-arg />元素来为静态工厂方法指定参数。

主程序获取cat和dog两个Bean实例的方法不变,同样只需要调用Spring容器的getBean()即可:

  1. public class Test {
  2. public static void main(String args[]){
  3. ApplicationContext context =
  4. new ClassPathXmlApplicationContext("applicationContext.xml");
  5. Animal a1 = context.getBean("cat", Animal.class);
  6. a1.sayHello();
  7. Animal a2 = context.getBean("dog", Animal.class);
  8. a2.sayHello();
  9. }
  10. }

使用静态工厂方法创建实例时必须提供工厂类和产生实例的静态工厂方法。通过静态工厂方法创建实例时需要对Spring配置文件做如下改变;

  • class属性不在是Bean实例的实现类,而是生成Bean实例的静态工厂类

  • 使用factory-method指定生产Bean实例的静态工厂方法

  • 如果静态工厂方法需要参数,使用<constructor-arg />元素为其配置

当我们指定Spring使用静态工厂方法来创建Bean实例时,Spring将先解析配置文件,并根据配置文件指定的信息,通过反射调用静态工厂类的静态工厂方法,并将该静态工厂方法的返回值作为Bean实例,在这个过程中,Spring不再负责创建Bean实例,Bean实例是由用户提供的静态工厂方法提供的。

2. 使用实例工厂方法创建Bean

实例工厂方法与静态工厂方法只有一点不同:调用静态工厂方法只需要使用工厂类即可,调用实例工厂方法则必须使用工厂实例。所以在Spring配置上也只有一点区别:配置静态工厂方法指定静态工厂类,配置实例工厂方法则指定工厂实例。同样是上面的例子将AnimalFactory修改为:

  1. public clas AnimalFactory {
  2. public Animal getAnimal(String type){ //这里仅仅是去掉了static关键字
  3. if ("cat".equalsIgnoreCase(type)){
  4. return new Cat();
  5. } else {
  6. return new Dog();
  7. }
  8. }
  9. }

Spring文件修改为:

  1. <!-- 先配置工厂类 -->
  2. <bean id="animalFactory" class="com.abc.AnimalFactory" />
  3. <!-- 这里使用factory-bean指定实例工厂类对象 -->
  4. <bean id="cat" factory-bean="animalFactory" factory-method="getAnimal">
  5. <!-- 同样指定factory-method的参数 -->
  6. <constructor-arg value="cat" />
  7. <property name="msg" value="猫猫" />
  8. </bean>
  9.  
  10. <bean id="dog" factory-bean="animalFactory" factory-method="getAnimal">
  11. <constructor-arg value="dog" />
  12. <property name="msg" value="狗狗" />
  13. </bean>

测试类不用修改,输出结果和上面相同。

四、请介绍一下Spring框架中Bean的作用域

singleton

当一个bean的作用域为singleton, 那么Spring IoC容器中只会存在一个共享的bean实例,并且所有对bean的请求,只要id与该bean定义相匹配,则只会返回bean的同一实例。

prototype

Prototype作用域的bean会导致在每次对该bean请求(将其注入到另一个bean中,或者以程序的方式调用容器的getBean() 方法)时都会创建一个新的bean实例。根据经验,对所有有状态的bean应该使用prototype作用域,而对无状态的bean则应该使用 singleton作用域

request

在一次HTTP请求中,一个bean定义对应一个实例;即每次HTTP请求将会有各自的bean实例, 它们依据某个bean定义创建而成。该作用 域仅在基于web的Spring ApplicationContext情形下有效。

session

在一个HTTP Session中,一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。

global session

在一个全局的HTTP Session中,一个bean定义对应一个实例。典型情况下,仅在使用portlet context的时候有效。该作用域仅在基于 web的Spring ApplicationContext情形下有效。

五、Bean注入属性有哪几种方式?

spring支持构造器注入和setter方法注入属性
    构造器注入,通过 <constructor-arg> 元素完成注入
    setter方法注入, 通过<property> 元素完成注入【开发中常用方式】
 
 

六、Spring的核心类有哪些,各有什么作用?

BeanFactory:产生一个新的实例,可以实现单例模式

BeanWrapper:提供统一的get及set方法

ApplicationContext:提供框架的实现,包括BeanFactory的所有功能

七、Spring里面如何配置数据库驱动?

使用”

  1. com.mchange.v2.c3p0.ComboPooledDataSource

”数据源来配置数据库驱动。示例如下:

  1. <!-- 配置数据库数据源 -->
  2. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  3. <property name="driverClass" value="${jdbc.driverClassName}"/>
  4. <property name="jdbcUrl" value="${jdbc.url}"/>
  5. <property name="user" value="${jdbc.username}"/>
  6. <property name="password" value="${jdbc.password}"/>
  7.  
  8. <!-- 初始化连接大小 -->
  9. <property name="initialPoolSize" value="${initialSize}"/>
  10. <!-- 最小连接池数量 -->
  11. <property name="minPoolSize" value="${minActive}" />
  12. <!-- 连接池最大数量 -->
  13. <property name="maxPoolSize" value="${maxActive}"/>
  14. <property name="autoCommitOnClose" value="true"/>
  15. </bean>

八、Spring里面applicationContext.xml文件能不能改成其他文件名?

ContextLoaderListener是一个ServletContextListener, 它在你的web应用启动的时候初始化。缺省情况下, 它会在WEB-INF/applicationContext.xml文件找Spring的配置。

你可以通过定义一个<context-param>元素名字为”contextConfigLocation”来改变Spring配置文件的 位置。示例如下:

  1. <listener>
  2. <listener-class>org.springframework.web.context.ContextLoaderListener
  3. <context-param>
  4. <param-name>contextConfigLocation</param-name>
  5. <param-value>/WEB-INF/xyz.xml</param-value>
  6. </context-param>
  7. </listener-class>
  8. </listener>
 

九、Spring如何处理线程并发问题?

Spring使用ThreadLocal解决线程安全问题【博客有一节专门对于TreadLocal的分析】

我们知道在一般情况下,只有无状态的Bean才可以在多线程环境下共享,在Spring中,绝大部分Bean都可以声明为singleton作用域。就是因为Spring对一些Bean(如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等)中非线程安全状态采用ThreadLocal进行处理,让它们也成为线程安全的状态,因为有状态的Bean就可以在多线程中共享了。

ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。

在同步机制中,通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的,使用同步机制要求程序慎密地分析什么时候对变量进行读写,什么时候需要锁定某个对象,什么时候释放对象锁等繁杂的问题,程序设计和编写难度相对较大。

而ThreadLocal则从另一个角度来解决多线程的并发访问。ThreadLocal会为每一个线程提供一个独立的变量副本,从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本,从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象,在编写多线程代码时,可以把不安全的变量封装进ThreadLocal。

由于ThreadLocal中可以持有任何类型的对象,低版本JDK所提供的get()返回的是Object对象,需要强制类型转换。但JDK5.0通过泛型很好的解决了这个问题,在一定程度地简化ThreadLocal的使用。

概括起来说,对于多线程资源共享的问题,同步机制采用了“以时间换空间”的方式,而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量,让不同的线程排队访问,而后者为每一个线程都提供了一份变量,因此可以同时访问而互不影响。

十、为什么要有事物传播行为?

 意义是大大的,由于不能保证系统绝对不出错,所以当出错的时候,应该讲之前所处理的事情全部回退到事件发生之前,包括对数据库这些修改等等,这是最为简单的场景,当然还有事务之间的交互,比如A事务失败了,会不会影响B事务,A事务捕获B事务的异常,这时候应该怎么办,要不要回滚,还有一些其他情况,这些都需要spring事务传播行为的支持。

十一、介绍一下Spring的事物管理

事务就是对一系列的数据库操作(比如插入多条数据)进行统一的提交或回滚操作,如果插入成功,那么一起成功,如果中间有一条出现异常,那么回滚之前的所有操作。这样可以防止出现脏数据,防止数据库数据出现问题。

开发中为了避免这种情况一般都会进行事务管理。Spring中也有自己的事务管理机制,一般是使用TransactionMananger进行管 理,可以通过Spring的注入来完成此功能。spring提供了几个关于事务处理的类:

TransactionDefinition //事务属性定义

TranscationStatus //代表了当前的事务,可以提交,回滚。

PlatformTransactionManager这个是spring提供的用于管理事务的基础接口,其下有一个实现的抽象类 AbstractPlatformTransactionManager,我们使用的事务管理类例如 DataSourceTransactionManager等都是这个类的子类。

一般事务定义步骤:

  1. TransactionDefinition td =newTransactionDefinition();
  2. TransactionStatus ts = transactionManager.getTransaction(td);
  3. try{
  4. //do sth
  5. transactionManager.commit(ts);
  6. }catch(Exception e){
  7. transactionManager.rollback(ts);
  8. }
 spring提供的事务管理可以分为两类:编程式的和声明式的。
编程式的,比较灵活,但是代码量大,存在重复的代码比较多;

编程式主要使用transactionTemplate。省略了部分的提交,回滚,一系列的事务对象定义,需注入事务管理对象.【这里使用了模板模式】

  1. void add(){
  2. transactionTemplate.execute(newTransactionCallback(){
  3. pulic Object doInTransaction(TransactionStatus ts){
  4. //do sth
  5. }
  6. }
  7. }
 
声明式:声明式的比编程式的更灵活。

使用TransactionProxyFactoryBean:PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED,readOnly

围绕Poxy的动态代理 能够自动的提交和回滚事务

org.springframework.transaction.interceptor.TransactionProxyFactoryBean

  1. PROPAGATION_REQUIRED–支持当前事务,如果当前没有事务,就新建一个事务。这是最常见的选择。
  2.  
  3. PROPAGATION_SUPPORTS–支持当前事务,如果当前没有事务,就以非事务方式执行。
  4.  
  5. PROPAGATION_MANDATORY–支持当前事务,如果当前没有事务,就抛出异常。
  6.  
  7. PROPAGATION_REQUIRES_NEW–新建事务,如果当前存在事务,把当前事务挂起。
  8.  
  9. PROPAGATION_NOT_SUPPORTED–以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。
  10.  
  11. PROPAGATION_NEVER–以非事务方式执行,如果当前存在事务,则抛出异常。
  12.  
  13. PROPAGATION_NESTED–如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则进行与 PROPAGATION_REQUIRED类似的操作。
 

Spring的原理性总结的更多相关文章

  1. Javascript之十大常用原理性样例大总结

    案例一:全选等 运用知识点:ondblclick=()| onclick | 寻找标签属性及判断和函数的应用

  2. RAC 的一些概念性和原理性的知识(转)

    一 集群环境下的一些特殊问题 1.1 并发控制 在集群环境中, 关键数据通常是共享存放的,比如放在共享磁盘上. 而各个节点的对数据有相同的访问权限, 这时就必须有某种机制能够控制节点对数据的访问. O ...

  3. malloc函数的一种简单的原理性实现

    malloc()是C语言中动态存储管理的一组标准库函数之一.其作用是在内存的动态存储区中分配一个长度为size的连续空间.其参数是一个无符号整形数,返回值是一个指向所分配的连续存储域的起始地址的指针 ...

  4. JS扫雷原理性代码

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...

  5. 【pyhon】黑客用字典暴力破解Zip文件密码原理性展示

    基本原理:用程序把字典文件里拟定好的密码一个个提取出来,去测试zip能否打开 字典文件pass.txt内容: 1224 2121 asdf abcd1234 dwsdsd dssds 程序代码: # ...

  6. java线程安全问题原理性分析

    1.什么是线程安全问题? 从某个线程开始访问到访问结束的整个过程,如果有一个访问对象被其他线程修改,那么对于当前线程而言就发生了线程安全问题:如果在整个访问过程中,无一对象被其他线程修改,就是线程安全 ...

  7. (草稿)spring @value 原理源码解读

    一切要从这说起:http://www.cnblogs.com/guazi/p/6698654.html 我们直接开始debug: 这里会遍历所有的需要注入的InjectedElement 这里我们需要 ...

  8. MySQL 原理性

    1.MySQL的复制原理以及流程 (1).复制基本原理流程 1. 主:binlog线程——记录下所有改变了数据库数据的语句,放进master上的binlog中: 2. 从:io线程——在使用start ...

  9. vue和react原理性知识点

    Vue组件如何通信? computed和watch有什么区别? Vue是如何实现双向绑定的? Proxy与Object.defineProperty的优劣对比? 你是如何理解Vue的响应式系统的? 既 ...

随机推荐

  1. (转)Apache从2.2换至2.4httpd.conf的调整笔记(windows环境)

    原文:https://www.cnblogs.com/tjws/articles/3469075.html#top 整理一下Windows环境Apache 2.2 改成 Apache 2.4.1后 h ...

  2. 解决ionic <ion-nav> rootParams获取不到参数

    在使用ion-nav 标签的时候 设置的页面 无法拿到传递的参数 import { Component } from '@angular/core'; import { GettingStartedP ...

  3. Session提要

    Session即会话,批一种持续性的.双向的链接.Sesstion和Cookie本质上没有什么区别,都是针对HTTP协议的局限性而提出的一种保持客户端和服务器间保持会话连接状态的机制.       S ...

  4. 用主题模型可视化分析911新闻(Python版)

    本文由 伯乐在线 - 东狗 翻译,toolate 校稿.未经许可,禁止转载!英文出处:blog.dominodatalab.com.欢迎加入翻译小组. 本文介绍一个将911袭击及后续影响相关新闻文章的 ...

  5. Zookeeper(一) —— 环境搭建

    一.概述 集中式 向 分布式演变,高并发.海量存储 应用场景: * 数据发布.订阅的两种方式:推模式.拉模式 * 命名服务 * 分布式协调/通知(心跳检测) * 负载均衡 自增长id和uuid的缺点, ...

  6. 【转载】 C#工具类:使用iTextSharp操作PDF文档

    iTextSharp是一个用于操作PDF文件的组件DLL程序,在C#程序中可以引用iTextSharp组件,用于开发与PDF文件相关的报表等功能,利用iTextSharp组件提供出来的方法接口,我们可 ...

  7. nginx支持跨域访问

    1,进入nginx的html目录 vim ./crossdomain.xml 具体路径: /usr/local/nginx/html/crossdomain.xml 2,在crossdomain.xm ...

  8. asp .net core Get raw request.

      小弟初来乍到,分享一些工作学习中遇到的问题和解决方式,如有不准确或是有错误的地方,希望不吝赐教,谢过了.  --Dogtwo 背景: 一个代理服务器BK,接收前端A发送的请求,记录log,并转发给 ...

  9. WCF SqlParameter序列化问题解决方案

    博文 http://www.cnblogs.com/pan11jing/archive/2011/08/19/2051827.html 通过自定义类,再在WCF端转换的方式解决问题,之后出现了一个很小 ...

  10. ASP.NET MVC 学习笔记-7.自定义配置信息(后续)

    自定义配置信息的高级应用 通过上篇博文对简单的自定义配置信息的学习,使得更加灵活的控制系统配置信息.实际项目中,这种配置的灵活度往往无法满足项目的灵活度和扩展性. 比如,一个配置信息有三部分组成,而每 ...