1.1通过代码实例跟我学Spring框架从入门到精通——Spring框架系统的API及应用实例
1、org.springframework.beans 包
（1）其中的相关的类和接口
（2）Spring 的核心是org.springframework.beans 包
该包中所提供的各个类和接口主要是为使用JavaBeans 技术、并且能够实现按名检索对象及管理对象间的关系而设计的。
这个包通常不是由用户直接使用，而是由服务器将其用作其他多数功能的底层中介。
关于beans 包，有三个重要的概念。
1）BeanWrapper接口
首先，它提供了设置/读取Javabeans 属性功能的BeanWrapper接口。
2）BeanFactory接口
第二个重要概念是Bean 工厂。BeanFactory接口是一个泛化工厂，具有实例化对象和管理不同对象间关系的能力。BeanFactory 可以管理几种不同类型的bean，并且支持串行化及其他生命周期方法。
BeanFactory 接口，它是工厂设计模式的实现，允许通过名称创建和检索对象。BeanFactory 也可以管理对象之间的关系。
3）bean 的定义（命名规则）
BeanFactory 是按照bean 定义（BeanDefinition）来实例化对象的。BeanDefinition，顾名思义，是我们对bean 的定义。
通过BeanDefinition，我们不仅可以定义bean 的类结构、实例化的方式，还可以定义bean 在运行时的配合者（相关联的其它对象）。
2、Spring Framework中的核心组件的实现类----BeanWrapper接口
BeanWrapper 接口的功能多少就如它的名字所暗示的：对bean 进行包装，然后对包装后的bean 加以操作，例如设置属性值、检索属性值等等。
（1）在Java中如何动态设置一个对象属性
我们知道，如果动态设置一个对象属性，可以借助Java的Reflection机制完成：Class oneClassObj = Class.forName("https://www.doczj.com/doc/f13097210.html,erInfo");
Method oneMethodObj =
oneClassObj.getMethod("setUserName",new Class[]{String.class});
Object oneObject = (Object) oneClassObj.newInstance();
oneMethodObj.invoke(oneObject,new Object[]{"用户的名称"});
上面我们通过动态加载了https://www.doczj.com/doc/f13097210.html,erInfo类，并通过Reflection调用了UserInfo.setUserName方法设置其userName属性为"用户的名称"。如果这些常量都是通过配置文件读入，则就实现了一个最简单的BeanWrapper。这个BeanWrapper的功能很简单，提供一个设置JavaBean属性的通用方法。
（2）利用BeanWrapper接口来实现动态设置一个对象属性
Spring BeanWrapper基于与前面同样的原理，只是提供了一个更加完善的实现。下面给出一个代码示例以了解在应用系统中如何通过Spring BeanWrapper类来操作一个JavaBean。
Object oneObject = Class.forName("https://www.doczj.com/doc/f13097210.html,erInfo").newInstance();
BeanWrapper oneBeanWrapper = new BeanWrapperImpl(oneObject);
oneBeanWrapper.setPropertyValue("userName", "用户的名称");
System.out.println("UserName="+oneBeanWrapper.getPropertyValue("userName") );
尽管通过这样的方式设定JavaBean的属性实在繁琐，但它却提供了一个通用的属性设定机制，而这样的机制，也正是Spring依赖注入机制所依赖的基础。
上面的代码中，仅仅是指定了需要设置的属性名"userName"，BeanWrapper将根据JavaBean规范，动态调用对象的"setUserName"方法进行属性设定。
（3）主要的作用
通过BeanWrapper接口，我们可以无需在编码时就指定JavaBean的实现类和属性值，通过在配置文件加以设定，就可以在运行期动态创建对象并设定其属性（依赖关系）。3、Spring Framework中的核心组件的实现类----org.springframework.beans.factory.BeanFactory接口
（1）主要的作用
Bean Factory，顾名思义，是根据配置文件负责创建Bean的实例，并负责Bean的生命周期的管理---，包括Bean的生成与销毁、Bean的创建方式的识别（是否为singleton）、Bean的各个属性的设定、依赖关系的建立等。如下面的配置：
XmlBeanFactory从xml文件中读取bean定义，同时ListableBeansFactory从属性文件中读取定义。
（2）BeanFactory 支持两个对象模型
1)单态：模型提供了具有特定名称的对象的共享实例，可以在查询时对其进行检索。
Singleton 是默认的也是最常用的对象模型。对于无状态服务对象很理想。
2)原型：模型确保每次检索都会创建单独的对象。在每个用户都需要自己的对象时，
原型模型最适合。
注意：
在Spring中消除了由用户自己来实现Singleton模式的应用，Spring Bean的缺省行为就是Singleton，不必再为了Singleton编码。
其中IoC容器控制Bean的生命周期，各个Bean通过它们之间的依赖关系由IoC容器预先对它们进行初始化。当各个Bean都准备就序时，它们就进入准备工作状态。最后捕再需要它们时，由IoC容器撤销这些Bean。
（4）配置文件中的主要项目
1)Bean属性值及依赖关系（对其他Bean的引用）
2)Bean创建模式（是否Singleton模式，即是否只针对指定类维持全局唯一的实例）
3)Bean初始化和销毁方法
4)Bean的依赖关系
Bean的定义配置标签中的主要属性的说明
（5）一个较为完整的Bean配置示例
singleton="true" ⑶ init-method="init" ⑷ destroy-method="cleanUpMethod" ⑸ depends-on="UserInfoManagMethod"> ⑹
（6）解释说明
⑴ id：Java Bean在BeanFactory中的唯一标识，代码中通过BeanFactory获取
JavaBean实例时需以此作为索引名称。
⑵ class：JavaBean 类名
⑶ singleton：指定此JavaBean是否采用单例（Singleton）模式，如果设为"true"，
则在BeanFactory作用范围内，只维护此JavaBean的一个实例，代码通过BeanFactory 获得此JavaBean实例的引用。反之，如果设为"false"，则通过BeanFactory获取此Java Bean实例时，BeanFactory每次都将创建一个新的实例返回。
⑷ init-method：初始化方法，此方法将在BeanFactory创建JavaBean实例之后，
在向应用层返回引用之前执行。一般用于一些资源的初始化工作。
⑸ destroy-method：销毁方法。此方法将在BeanFactory销毁的时候执行，一般
用于资源释放。
⑹ depends-on：Bean依赖关系。一般情况下无需设定。Spring会根据情况组织各
个依赖关系的构建工作（这里示例中的depends-on属性非必须）。
只有某些特殊情况下，如JavaBean中的某些静态变量需要进行初始化（这是一种BadSmell，应该在设计上应该避免）。通过depends-on指定其依赖关系可保证在此Bean 加载之前，首先对depends-on所指定的资源进行加载（本例将首先创建ActionManager 组件对象）。
⑺
对应的属性类型加以匹配。
上面的"desc"属性提供了一个null值的设定示例。注意
⑻ ：指定了属性对BeanFactory中其他Bean的引用关系。上面示例中的
oneUserInfo的userPrevile属性引用了id为userPrevile的Bean。BeanFactory将在运行期创建userPrevile Bean的实例，并将其引用传入oneUserInfo Bean的
userPrevile属性中。
（7）如何通过BeanFactory获取Bean实例
这个接口有多个实现。最常使用的简单的BeanFactory实现是org.springframework.beans.factory. xml.XmlBeanFactory。
InputStream oneInputStream = new FileInputStream("myBeanConfigure.xml");
XmlBeanFactory oneXmlBeanFactory = new XmlBeanFactory(oneInputStream);
UserInfoManageBean userInfoManageBean =
(UserInfoManageBean) oneXmlBeanFactory.getBean("userInfoManageBean");
注意：
由于ApplicationContext是BeanFactory的子接口，所以大多数的用户更喜欢使用ApplicationContext的XML形式。
很多情况下，在代码中不需要实例化BeanFactory，因为Spring框架代码会做这件事。例如，Web层提供支持代码，在J2EE Web应用启动过程中自动载入一个Spring ApplicationContext。
（8）BeanFactory中的几个不同的getBean方法
1）Object getBean(String)
按名返回一个已注册bean 的实例。取决于该bean 在BeanFactory 中的配置，将返回一个共享的唯一的bean 实例或者是一个重新创建的bean 实例。当无法找到bean的定义（此时将引发一个NoSuchBeanDefinitionException 异常）或者在进行实例化和初始化bean 时引发了一个异常，都将引起一个BeansException 异常被抛出。
2）Object getBean(String,Class)
按名返回一个已注册bean 的实例。这个bean 实例的Class 类型必须和给出的Class 类型参数相匹配，否则相应的异常将会被抛出（BeanNotOfRequiredTypeException 异常）将会被抛出。此外，这个方法的其他的行为和getBean(String)方法相同。
（8）BeanFactory与BeanWrapper的不同点
BeanWrapper实现了针对单个Bean的属性设定操作。而BeanFactory则是针对多个Bean 的管理容器，根据给定的配置文件，BeanFactory从中读取类名、属性名/值，然后通过Reflection机制进行Bean加载和属性设定。
在实际应用开发中，一般都使用BeanFactory类获得指定的组件。
4、Spring Framework中的核心组件的实现类---- org.springframework.context.ApplicationContext
（1）org.springframework.context包
context包在我们的应用程序中扮演了一个对象注册表的角色。其功能类似J2EE应用程序服务器提供的enterprise naming context（JNDI）特性，然而有几个重要的不同之处。
1)首先，对象的绑定在Spring的application context中不需要额外的远程接口或对象。
2)其次，application contexts可以在我们的应用程序中的各个层面使用，从基于Swing
的客户端到Web应用程序，除此以外，也能使用在EJB环境中。
（2）ApplicationContext接口的定义
Context我们通常解释为上下文环境，我们可以将它理解为“容器”的概念，可能会更容易理解一些，此时则可以将ApplicationContext理解为“应用的容器”！Spring把Bean 放在这个容器中，在需要的时候，用getBean方法取出。
利用“Context”，最终达到在Spring中为我们的应用系统在导入Bean的定义方面，能够提供多种不同的选择形式。
context包的基础是org.springframework.context.ApplicationContext接口，提供了国际化、事件处理及beans在context中的自查能力。它也可创建具有层次结构context 环境，将bean的作用域和可访问区域限制在应用程序的一个特定部分中。
（3）ApplicationContext与BeanFactory的不同点
1）ApplicationContext提供了一个更为框架化的实现
BeanFactory提供了针对JavaBean的管理功能，而ApplicationContext提供了一个更为框架化的实现（从上面的示例中可以看出，BeanFactory的使用方式更加类似一个API，
而非Framework风格）。
一般在我们的应用程序中几乎不必和BeanFactory打交道，而大多数情况下，我们只会使用ApplicationContext----因为，它添加了一些企业级的J2EE特性，如国际化(i18n)，自定义转换器及事件的广播等功能。
2）ApplicationContext除了支持BeanFactory的所有的功能以外，还支持以声明的方式来进行Bean的定义（如使用ContextLoader）。
3）ApplicationContext不仅适用于J2SE，也适用于J2EE的应用
ApplicationContext覆盖了BeanFactory的所有功能，并提供了更多的特性。此外，ApplicationContext为与现有应用框架相整合，提供了更为开放式的实现（如对于Web应用，我们可以在web.xml中对ApplicationContext进行配置）。
（4）ApplicationContext所提供的对BeanFactory类的主要扩展功能
由于ApplicationContext继承自多个不同的接口：ApplicationEventPublisher、HierarchicalBeanFactory、ListableBeanFactory、MessageSource、ResourceLoader，而其中的ListableBeanFactory接口又继承自BeanFactory。
因此，所以除了BeanFactory的功能之外，ApplicationContext还提供了以下的功能：1）国际化支持---继承自MessageSource接口的功能
我们可以在Beans.xml文件中，对程序中的语言信息（如提示信息）进行定义，将程
序中的提示信息抽取到配置文件中加以定义，为我们进行应用的各语言版本转换提供了极大的灵活性。
2）资源访问----继承自ResourceLoader接口的功能
支持对文件和URL的访问。
3）事件传播
事件传播特性为系统中状态改变时的检测提供了良好支持。
4）多实例加载
可以在同一个应用中加载多个Context实例。
（5）Spring在导入Bean定义方面为我们提供了多种选择
1）ClassPathXmlApplicationContext
web应用程序中从classpath(也就是WEB-INF/classes或是W E B - I N F / l i b 下的j a r 文件) 中入c o n t e x t 文件。使用new ClassPathXmlApplicationContext(path)来初始化，其中path是文件的路径。path参数还可以用path的String数组。这是一种在单元测试中好用的context。
2）FileSystemXmlApplicationContext
从文件系统中导入context文件，测试方便。使用new FileSystemXmlApplicationContext (path)初始化，path是文件的相对或是绝对路径。path参数也可以是一个String数组。
3）XmlWebApplicationContext
通过ContextLoaderListener从内部导入context文件，但也可以在外部使用。例如，如果我们运行的服务器没有按web.xml中指定的顺序加载Listener,我们可以必须在另一个Listener中使用它。
（6）ApplicationContext管理Bean的执行阶段
1)创建Bean；
2)属性注入（依赖关系的注入）；
3)BeanNameAware接口实现类的setBeanName（）方法；
4)BeanFactoryAware接口实现类的setBeanFactory（）方法；
5)ApplicationContextAware接口实现类的setApplicationContext（）方法；
6)BeanPostProcessor接口实现类中的postProcessBeforeInitialization（）方法；
7)InitializingBean接口实现类的afterPropertiesSet（）方法；
8)Bean定义文件中init-method属性所指定的方法；
9)BeanPostProcessor接口实现类中的postProcessAfterInitialization（）方法；
5、ApplicationContext所提供的国际化支持
（1）常规的国际化支持的实现
国际化支持在实际开发中可能是最常用的特性。对于一个需要支持不同语言环境的应用而言，我们所采取的最常用的策略一般是通过一个独立的资源文件（如一个properties 文件）完成所有语言信息（如界面上的提示信息）的配置。
（2）ApplicationContext所提供的国际化支持
Spring对这种传统的方式进行了封装，并提供了更加强大的功能，如信息的自动装配以及热部署功能（配置文件修改后自动读取，而无需重新启动应用程序）。
在下面的示例配置文件中，我们简单地通过MessageResource的一个实现类org.springframework.context.support.ResourceBundleMessageSource来获得国际化的信息。
目前Spring中提供了两个MessageSource接口的实现，即ResourceBundleMessageSource和ReloadableResourceBundleMessageSource，后者提供了无需重启即可重新加载配置信息的特性。
（3）一个典型的示例
1）*.xml 配置文件的内容
class="org.springframework.context.support.ResourceBundleMessageSource">
这里声明了一个名为messageSource的Bean（注意：对于Message定义，Bean ID必须为messageSource，这是目前Spring的编码规约），对应类为
ResourceBundleMessageSource。
而其中的basename属性用來设定资源信息文件的前置文件名称，在本例中为messages。Spring会自动在CLASSPATH根路径中按照如下顺序搜寻资源信息文件并进行加载（以Locale为zh_CN为例，其实Spring在实际上调用了JDK的ResourceBundle读取配置文件）: messages_zh_CN.properties
messages_zh.properties
messages.properties
messages_zh_CN.class
messages_zh.class
messages.class
2）资源配置信息文件中的内容
messages_zh_CN.properties：
userInfo=当前登录用户: [{0}] 登录时间:[{1}]
messages_en_US.properties：
userInfo =Current Login user: [{0}] Login time:[{1}]
3）测试代码---直接构造Application Context
ApplicationContext oneApplicationContext =
new FileSystemXmlApplicationContext("myBeanConfigure.xml");
Object[] argArray =new Object[]{ "输出的信息",
Calendar.getInstance().getTime()};
//以系统默认Locale加载信息(对于中文WinXP而言，默认为zh_CN)
String someOneMessage =
oneApplicationContext.getMessage("userInfo ", argArray);
System.out.println("输出的信息为："+ someOneMessage);
代码中，我们将一个Object数组argArray作为参数传递给ApplicationContext.getMessage方法，这个参数中包含了出现在最终文字信息中的可变内容，ApplicationContext将根据参数中的Locale信息对其进行处理（如针对不同Locale 设定日期输出格式），并用其替换配置文件中的{n}标识（n代表参数数组中的索引，从1开始）。
6、ApplicationContext所提供的资源访问
（1）ApplicationContext.getResource方法提供了对资源文件访问支持，如：Resource oneResource = context.getResource("classpath:config.properties");
File oneFile = oneResource.getFile();
（2）注意其中的"classpath:"是Spring中自己定义的url虚拟协定
在本例中将返回一个 org.springframework.core.io.ClassPathResource对象，而配置文件是位于CLASSPATH根目录中。
getResource方法的参数为一个资源访问地址（也就是可以指定标准的url，如是"file:"或"http:"等）。如：
file:C:/config.properties
/config.properties
classpath:config.properties
Resource resource =
context.getResource("file:c:/workspace/springtest/conf/admin.properties");
这将返回一个org.springframework.core.io.FileSystemResource对象，或者我们也可以如下指定来返回一个ServletContextResource对象：
Resource resource = context.getResource("WEB-INF/conf/admin.properties");（3）注意getResource返回的Resource并不一定实际存在
可以通过Resource.exists()方法对其进行判断。并通过get InputStream()方法来获得所打开的IO 流（返回一个InputStream对象）。
7、ApplicationContext所提供的事件传播
（1）ApplicationContextAware等事件监听器接口
Spring中提供一些Aware相关的接口，像是BeanFactoryAware、ApplicationContextAware、ResourceLoaderAware、ServletContextAware等等。
实现這些 Aware接口的Bean在被初始之后，可以取得一些相对应的資源，例如实现BeanFactoryAware的Bean在初始后，Spring容器將会注入BeanFactory的对象实例，而实现ApplicationContextAware的Bean，在Bean被初始后，将会被注入ApplicationContext的实例等等。
（2）触发事件
Bean取得BeanFactory、ApplicationContextAware的实例目的是什么，一般的目的就是要取得一些資源文件的存取、相关信息關訊息資源或是那些被注入的實例所提供的機制，例如ApplicationContextAware提供了publishEvent()方法，可以实现基于Observer设计模式的事件傳播機制。
（3）ApplicationContext基于Observer模式来实现事件传播
ApplicationContext基于Observer模式（java.util包中有对应实现），提供了针对Bean的事件传播功能。通过Application. publishEvent方法，我们可以将事件通知系统内所有的ApplicationListener。
（4）ApplicationContextAware接口
该接口中包含一个void setApplicationContext(ApplicationContext applicationContext) throws BeansException方法
（5）典型应用
事件传播的一个典型应用是，当Bean中的操作发生异常（如数据库连接失败），则通过事件传播机制通知异常监听器进行处理。
在目前版本的Spring中，事件传播部分的设计还有待改进。同时，如果能进一步支持异步事件处理机制，无疑会更具吸引力。
（6）事件广播机制
org.springframework.context.event.ApplicationEventMulticaster接口提供了事件的广播机制，但目前还相对简陋。
在运行期，ApplicationContext会自动在当前的所有Bean中寻找ApplicationListener接口的实现，并将其作为事件接收对象。当Application.publishEvent方法调用时，所有的ApplicationListener接口实现都会被激发，每个ApplicationListener可根据事件的类型判断是否是自己需要处理的事件，如上面的ActionListener只处理ActionEvent事件。
8、Spring Framework中的核心组件的实现类---- org.springframework.web.context. WebApplicationContext
（1）WebApplicationContext的应用场合
在Web应用中（注意：我们这里所说的Web应用程序是指普通的Web应用程序，如果
是采用Spring MVC框架或者Struts框架，则不需要采用WebApplicationContext），我们会用到WebApplicationContext。
（2）WebApplicationContext的继承关系
WebApplicationContext继承自ApplicationContext；在Web环境里，会使用ContextLoader构造ApplicationContext后，压进Servlet Context。
（3）Spring提供了可配置的ApplicationContext加载机制
我们通过在应用系统的web.xml中部署ContextLoaderListener 或者ContextLoaderServlet中的某一个后，Web容器将会自动加载Spring的IoC的*.xml配置文件（默认情况下为/WEB-INF/applicationContext.xml）并完成该*.xml配置文件中的各个组件对象的初始化工作。
以后，我们只需要在代码中通过WebApplicationContextUtils.getWebApplicationContext方法在Web应用中获取ApplicationContext引用，从而也就可以获得我们所需要的目标组件。
9、在Web应用中实现可配置的ApplicationContext加载机制
（1）问题的技术背景
上面的示例中，ApplicationContext均通过编码加载。对于Web应用，Spring提供了可配置的ApplicationContext加载机制org.springframework.web.context.ContextLoader类。
（2）ContextLoader加载器目前有两种选择
1)org.springframework.web.context.ContextLoaderListener
2)org.springframework.web.context.ContextLoaderServlet
这两者在功能上完全等同，只是一个是基于Servlet2.3版本中新引入的Listener接口实现，而另一个基于Servlet接口实现。开发中可根据目标Web容器的实际情况进行选择。
Listerner要比Servlet更好一些，因为Listerner监听应用的启动和结束，而Servlet 得启动要稍微延迟一些。
注意：
对ApplicationContext的获得，也可以采用编程其实现类如FileSystemXmlApplicationContext来创建。
ApplicationContext applicationContext=new FileSystemXmlApplicationContext("c: /SpringWeb/WEB-INF/springappConfigure.xml");
SpringWebAppBusiness timeDateBusiness = (SpringWebAppBusiness) applicationContext.getBean("timeDateBusiness");
（3）实现的方法
1）在web.xml中增加下面对ContextLoader的配置项目
或：
通过以上配置，Web容器会自动加载/WEB-INF/applicationContext.xml（默认的情况下为applicationContext.xml，当然也可以修改为其它的文件名称---但要通过
2）在web.xml中通过
注意：也可以为多个配置文件
＜context-param＞
＜param-name＞contextConfigLocation＜/param-name＞
＜param-value＞/WEB-INF/myApplicationContextConfigureOne.xml,
/WEB-INF/myApplicationContextConfigureTwo.xml ＜/param-value＞
＜/context-param＞
3）在Web应用中获取ApplicationContext和ServletContext的引用
●获取ApplicationContext引用
配置完成之后，即可通过 WebApplicationContextUtils.getWebApplicationContext 方法在Web应用中获取ApplicationContext引用。
注意：
Webapplicationcontextutils.getWebApplicationContext(servletcontext); 和Webapplicationcontextutils.getRequiredWebApplicationContext(servletcontext);
的区别
●前者如果如果没有获得，将直接返回null，而后者将报出异常。
获得当前Web应用的ServletContext——利用WebApplicationContext 接口中的getServletContext()方法，可以获得当前Web应用的ServletContext。
（4）ContextLoaderListener和ContextLoaderServlet的内部实现说明
以ContextLoaderListener为例，可以看到（参考Spring中的源码）
public void contextInitialized(ServletContextEvent event){
this.contextLoader = createContextLoader();
this.contextLoader.initWebApplicationContext(event.getServletContext()) ;
}
protected ContextLoader createContextLoader() {
return new ContextLoader();
}
其中的ContextLoader是一个工具类，用来初始化WebApplicationContext，其主要方法就是initWebApplicationContext，继续追踪initWebApplicationContext这个方法后发现，原来ContextLoader是把WebApplicationContext（XmlWebApplicationContext是默认实现类）放在了ServletContext中。
ServletContext也是一个“容器”，也是一个类似Map的结构，而WebApplicationContext在ServletContext中的KEY就是WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE，我们如果要使用WebApplicationContext则需要从ServletContext取出。
Spring提供了一个WebApplicationContextUtils类，可以方便的取出WebApplicationContext，只要把ServletContext传入就可以了。
10、使用属性文件来进行Spring组件的设置
（1）使用Java属性文件来定义Bean
由于XML文档能够很好地表达层次关系，因此非常适用于组件的配置和定义，也因此几乎所有的各种系统配置都采用XML文档作为组件的缺省的定义方式，但通常也会提供非XML定义的方式，如Java属性文件*.properties。Spring同样也可以使用Java属性文件来定义Bean。
helloBean.class=com.px1987.HelloBean
helloBean.helloWorld=Hello World!
（2）读取属性文件中的内容的示例代码
可以使用如下的类中的方法来读取属性文件中的内容
实现的代码示例如下：
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import
org.springframework.beans.factory.support.DefaultListableBeanFactory;
import
org.springframework.beans.factory.support.PropertiesBeanDefinitionReader;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.core.io.ClassPathResource;
public class SpringJavaBeanTestDemo{
public static void main(String[] args){
BeanDefinitionRegistry oneRegister =
new DefaultListableBeanFactory();
PropertiesBeanDefinitionReader reader =
new PropertiesBeanDefinitionReader(oneRegister);
reader.loadBeanDefinitions(new ClassPathResource("bean.properties"));
BeanFactory oneBeanFactory = (BeanFactory) oneRegister;
HelloBean oneHelloBean =
(HelloBean) oneBeanFactory.getBean("oneHelloBean");
System.out.println(oneHelloBean.getHelloWord());
}
}
11、以编程的方式来获得组件的信息
（1）直接采用编程方法
除了采用XML或Java属性配置文件来设定Spring的各个组件的定义，我们也可以直接采用编程的方式来获得Spring的各个组件的定义。
（2）实现的方法
通过 org.springframework.beans.MutablePropertyValues来设置组件的各个属性，并将属性与Bean的类别设定给
org.springframework.beans.factory.support.BeanDefinitionRegistry注冊该组件。
（3）主要的优点
不使用任何的配置文件来定义的好处是，客戶端与定义文档是相互隔离的，它們无法
直接接触定义文档的內容。
（4）实现的代码示例
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.MutablePropertyValues;
public class SpringJavaBeanTestDemo {
public static void main(String[] args) { // 设置属性
MutablePropertyValues properties = new MutablePropertyValues();
properties.addPropertyValue("helloWord", "Hello World!");
// 设置Bean的定义
RootBeanDefinition oneRootBeanDefinition =
new RootBeanDefinition(HelloBean.class, properties);
// 注册Bean定义与Bean別名
BeanDefinitionRegistry oneBeanDefinitionRegistry =
new DefaultListableBeanFactory();
reg.registerBeanDefinition("helloBean", oneRootBeanDefinition);
BeanFactory oneBeanFactory = (BeanFactory) oneBeanDefinitionRegistry; HelloBean oneHelloBean =
(HelloBean) oneBeanFactory.getBean("helloBean");
System.out.println(oneHelloBean.getHelloWord());
}
}