spring学习笔记

java

本教程是基于在 2015 年 3 月发布的 Spring 框架 4.1.6 版本编写的。

Spring 概述概述

Spring 是最受欢迎的企业级 Java 应用程序开发框架。数以百万的来自世界各地的开发人员使用 Spring 框架来创建好性能、易于测试、可重用的代码。

Spring 框架是一个开源的 Java 平台，它最初是由 Rod Johnson 编写的，并且 2003 年 6 月首次在 Apache 2.0 许可下发布。

当谈论到大小和透明度时， Spring 是轻量级的。 Spring 框架的基础版本是在 2 MB 左右的。

Spring 框架的核心特性可以用于开发任何 Java 应用程序，但是在 Java EE 平台上构建 web 应用程序是需要扩展的。 Spring 框架的目标是使 J2EE 开发变得更容易使用，通过启用基于 POJO 编程模型来促进良好的编程实践。

依赖注入（DI Dependecy Injection）

Spring 最认同的技术是控制反转的依赖注入（DI）模式。控制反转（IoC Inversion of Control）是一个通用的概念，它可以用许多不同的方式去表达，依赖注入仅仅是控制反转的一个具体的例子。

当编写一个复杂的 Java 应用程序时，应用程序类应该尽可能的独立于其他的 Java 类来增加这些类可重用可能性，当进行单元测试时，可以使它们独立于其他类进行测试。依赖注入（或者有时被称为配线）有助于将这些类粘合在一起，并且在同一时间让它们保持独立。

到底什么是依赖注入？让我们将这两个词分开来看一看。这里将依赖关系部分转化为两个类之间的关联。例如，类 A 依赖于类 B。现在，让我们看一看第二部分，注入。所有这一切都意味着类 B 将通过 IoC 被注入到类 A 中。

依赖注入可以以向构造函数传递参数的方式发生，或者通过使用 setter 方法 post-construction。由于依赖注入是 Spring 框架的核心部分，所以我将在一个单独的章节中利用很好的例子去解释这一概念。

面向方面的程序设计（AOP）： AOP是OOP的延续，是（Aspect Oriented Programming）的缩写，意思是面向切面编程。

Spring 框架的一个关键组件是面向方面的程序设计（AOP）框架。一个程序中跨越多个点的功能被称为横切关注点，这些横切关注点在概念上独立于应用程序的业务逻辑。有各种各样常见的很好的关于方面的例子，比如日志记录、声明性事务、安全性，和缓存等等。

在 OOP 中模块化的关键单元是类，而在 AOP 中模块化的关键单元是方面。AOP 帮助你将横切关注点从它们所影响的对象中分离出来，然而依赖注入帮助你将你的应用程序对象从彼此中分离出来。

Spring 框架的 AOP 模块提供了面向方面的程序设计实现，允许你定义拦截器方法和切入点，可以实现将应该被分开的代码干净的分开功能。我将在一个独立的章节中讨论更多关于 Spring AOP 的概念。

https://www.w3cschool.cn/wkspring/pesy1icl.html

java

Spring 基于 Java 的配置https://www.w3cschool.cn/wkspring/tlbk1icp.html

java

Spring 基于注解的配置  ----基于XML基于注解的配置

从 Spring 2.5 开始就可以使用注解来配置依赖注入。而不是采用 XML 来描述一个 bean 连线，你可以使用相关类，方法或字段声明的注解，将 bean 配置移动到组件类本身。

在 XML 注入之前进行注解注入，因此后者的配置将通过两种方式的属性连线被前者重写。

注解连线在默认情况下在 Spring 容器中不打开。因此，在可以使用基于注解的连线之前，我们将需要在我们的 Spring 配置文件中启用它。所以如果你想在 Spring 应用程序中使用的任何注解，可以考虑到下面的配置文件。

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. 
   
3. <beans xmlns="http://www.springframework.org/schema/beans"
   
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   
5.     xmlns:context="http://www.springframework.org/schema/context"
   
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans
   
7.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   
8.     http://www.springframework.org/schema/context
   
9.     http://www.springframework.org/schema/context/spring-context-3.0.xsd">
   
10. 
    
11.    <context:annotation-config/>
    
12.    <!-- bean definitions go here -->
    
13. 
    
14. </beans>

复制代码

一旦 被配置后，你就可以开始注解你的代码，表明 Spring 应该自动连接值到属性，方法和构造函数。让我们来看看几个重要的注解，并且了解它们是如何工作的：

序号	注解 & 描述
1	@Required @Required 注解应用于 bean 属性的 setter 方法。
2	@Autowired @Autowired 注解可以应用到 bean 属性的 setter 方法，非 setter 方法，构造函数和属性。
3	@Qualifier 通过指定确切的将被连线的 bean，@Autowired 和 @Qualifier 注解可以用来删除混乱。
4	JSR-250 Annotations Spring 支持 JSR-250 的基础的注解，其中包括了 @Resource，@PostConstruct 和 @PreDestroy 注解。

Spring @Required 注释

@Required 注释应用于 bean 属性的 setter 方法，它表明受影响的 bean 属性在配置时必须放在 XML 配置文件中，否则容器就会抛出一个 BeanInitializationException 异常。下面显示的是一个使用 @Required 注释的示例。

Spring @Autowired 注释

@Autowired 注释对在哪里和如何完成自动连接提供了更多的细微的控制。

@Autowired 注释可以在 setter 方法中被用于自动连接 bean，就像 @Autowired 注释，容器，一个属性或者任意命名的可能带有多个参数的方法。

Setter 方法中的 @Autowired

你可以在 XML 文件中的 setter 方法中使用 @Autowired 注释来除去 元素。当 Spring遇到一个在 setter 方法中使用的 @Autowired 注释，它会在方法中视图执行 byType 自动连接。

@Autowired 的（required=false）选项

默认情况下，@Autowired 注释意味着依赖是必须的，它类似于 @Required 注释，然而，你可以使用 @Autowired 的 （required=false） 选项关闭默认行为。

Spring @Qualifier 注释

可能会有这样一种情况，当你创建多个具有相同类型的 bean 时，并且想要用一个属性只为它们其中的一个进行装配，在这种情况下，你可以使用 @Qualifier 注释和 @Autowired 注释通过指定哪一个真正的 bean 将会被装配来消除混乱。下面显示的是使用 @Qualifier 注释的一个示例。

Spring JSR-250 注释
由 c383542045 创建，最后一次修改 2016-08-12

Spring JSR-250 注释

Spring还使用基于 JSR-250 注释，它包括 @PostConstruct， @PreDestroy 和 @Resource 注释。因为你已经有了其他的选择，尽管这些注释并不是真正所需要的，但是关于它们仍然让我给出一个简短的介绍。

@PostConstruct 和 @PreDestroy 注释：

为了定义一个 bean 的安装和卸载，我们使用 init-method 和/或 destroy-method 参数简单的声明一下 。init-method 属性指定了一个方法，该方法在 bean 的实例化阶段会立即被调用。同样地，destroy-method 指定了一个方法，该方法只在一个 bean 从容器中删除之前被调用。

你可以使用 @PostConstruct 注释作为初始化回调函数的一个替代，@PreDestroy 注释作为销毁回调函数的一个替代

@Resource 注释：

你可以在字段中或者 setter 方法中使用 @Resource 注释，它和在 Java EE 5 中的运作是一样的。@Resource 注释使用一个 ‘name’ 属性，该属性以一个 bean 名称的形式被注入。

如果没有明确地指定一个 ‘name’，默认名称源于字段名或者 setter 方法。在字段的情况下，它使用的是字段名；在一个 setter 方法情况下，它使用的是 bean 属性名称。

java

Spring Beans 自动装配

你已经学会如何使用<bean>元素来声明 bean 和通过使用 XML 配置文件中的<constructor-arg>和<property>元素来注入 。

Spring 容器可以在不使用 和 元素的情况下自动装配相互协作的 bean 之间的关系，这有助于减少编写一个大的基于 Spring 的应用程序的 XML 配置的数量。

自动装配模式

下列自动装配模式，它们可用于指示 Spring 容器为来使用自动装配进行依赖注入。你可以使用<bean>元素的 autowire 属性为一个 bean 定义指定自动装配模式。

模式	描述
no	这是默认的设置，它意味着没有自动装配，你应该使用显式的bean引用来连线。你不用为了连线做特殊的事。在依赖注入章节你已经看到这个了。
byName	由属性名自动装配。Spring 容器看到在 XML 配置文件中 bean 的自动装配的属性设置为 byName。然后尝试匹配，并且将它的属性与在配置文件中被定义为相同名称的 beans 的属性进行连接。
byType	由属性数据类型自动装配。Spring 容器看到在 XML 配置文件中 bean 的自动装配的属性设置为 byType。然后如果它的类型匹配配置文件中的一个确切的 bean 名称，它将尝试匹配和连接属性的类型。如果存在不止一个这样的 bean，则一个致命的异常将会被抛出。
constructor	类似于 byType，但该类型适用于构造函数参数类型。如果在容器中没有一个构造函数参数类型的 bean，则一个致命错误将会发生。
autodetect	Spring首先尝试通过 constructor 使用自动装配来连接，如果它不执行，Spring 尝试通过 byType 来自动装配。

可以使用 byType 或者 constructor 自动装配模式来连接数组和其他类型的集合。

自动装配的局限性

当自动装配始终在同一个项目中使用时，它的效果最好。如果通常不使用自动装配，它可能会使开发人员混淆的使用它来连接只有一个或两个 bean 定义。不过，自动装配可以显著减少需要指定的属性或构造器参数，但你应该在使用它们之前考虑到自动装配的局限性和缺点。

限制	描述
重写的可能性	你可以使用总是重写自动装配的 <constructor-arg>和 <property> 设置来指定依赖关系。
原始数据类型	你不能自动装配所谓的简单类型包括基本类型，字符串和类。
混乱的本质	自动装配不如显式装配精确，所以如果可能的话尽可能使用显式装配。

Spring 自动装配 ‘byName’

这种模式由属性名称指定自动装配。Spring 容器看作 beans，在 XML 配置文件中 beans 的 auto-wire 属性设置为 byName。然后，它尝试将它的属性与配置文件中定义为相同名称的 beans 进行匹配和连接。如果找到匹配项，它将注入这些 beans，否则，它将抛出异常。

例如，在配置文件中，如果一个 bean 定义设置为自动装配 byName，并且它包含 spellChecker 属性（即，它有一个 setSpellChecker(...) 方法），那么 Spring 就会查找定义名为 spellChecker 的 bean，并且用它来设置这个属性。你仍然可以使用 <property> 标签连接其余的属性。下面的例子将说明这个概念。

Spring 自动装配 ‘byType’

这种模式由属性类型指定自动装配。Spring 容器看作 beans，在 XML 配置文件中 beans 的 autowire 属性设置为 byType。然后，如果它的 type 恰好与配置文件中 beans 名称中的一个相匹配，它将尝试匹配和连接它的属性。如果找到匹配项，它将注入这些 beans，否则，它将抛出异常。

例如，在配置文件中，如果一个 bean 定义设置为自动装配 byType，并且它包含 SpellChecker 类型的 spellChecker 属性，那么 Spring 就会查找定义名为 SpellChecker 的 bean，并且用它来设置这个属性。你仍然可以使用 <property> 标签连接其余属性。下面的例子将说明这个概念，你会发现和上面的例子没有什么区别，除了 XML 配置文件已经被改变。

Spring 由构造函数自动装配

这种模式与 byType 非常相似，但它应用于构造器参数。Spring 容器看作 beans，在 XML 配置文件中 beans 的 autowire 属性设置为 constructor。然后，它尝试把它的构造函数的参数与配置文件中 beans 名称中的一个进行匹配和连线。如果找到匹配项，它会注入这些 bean，否则，它会抛出异常。

例如，在配置文件中，如果一个 bean 定义设置为通过构造函数自动装配，而且它有一个带有 SpellChecker 类型的参数之一的构造函数，那么 Spring 就会查找定义名为 SpellChecker 的 bean，并用它来设置构造函数的参数。你仍然可以使用 <constructor-arg> 标签连接其余属性。下面的例子将说明这个概念。

https://www.w3cschool.cn/wkspring/jtlb1mmf.html

java

Spring 依赖注入依赖注入

每个基于应用程序的 java 都有几个对象，这些对象一起工作来呈现出终端用户所看到的工作的应用程序。当编写一个复杂的 Java 应用程序时，应用程序类应该尽可能独立于其他 Java 类来增加这些类重用的可能性，并且在做单元测试时，测试独立于其他类的独立性。依赖注入（或有时称为布线）有助于把这些类粘合在一起，同时保持他们独立。
假设你有一个包含文本编辑器组件的应用程序，并且你想要提供拼写检查。标准代码看起来是这样的：
public class TextEditor {
   private SpellChecker spellChecker;  
   public TextEditor() {
      spellChecker = new SpellChecker();
   }
}

在这里，TextEditor 不应该担心 SpellChecker 的实现。SpellChecker 将会独立实现，并且在 TextEditor 实例化的时候将提供给 TextEditor，整个过程是由 Spring 框架的控制。

在这里，我们已经从 TextEditor 中删除了全面控制，并且把它保存到其他地方（即 XML 配置文件），且依赖关系（即 SpellChecker 类）通过类构造函数被注入到 TextEditor 类中。因此，控制流通过依赖注入（DI）已经“反转”，因为你已经有效地委托依赖关系到一些外部系统。

依赖注入的第二种方法是通过 TextEditor 类的 Setter 方法，我们将创建 SpellChecker 实例，该实例将被用于调用 setter 方法来初始化 TextEditor 的属性。

因此，DI 主要有两种变体和下面的两个子章将结合实例涵盖它们：

序号	依赖注入类型 & 描述
1	Constructor-based dependency injection 当容器调用带有多个参数的构造函数类时，实现基于构造函数的 DI，每个代表在其他类中的一个依赖关系。
2	Setter-based dependency injection 基于 setter 方法的 DI 是通过在调用无参数的构造函数或无参数的静态工厂方法实例化 bean 之后容器调用 beans 的 setter 方法来实现的。

你可以混合这两种方法，基于构造函数和基于 setter 方法的 DI，然而使用有强制性依存关系的构造函数和有可选依赖关系的 sette r是一个好的做法。

代码是 DI 原理的清洗机，当对象与它们的依赖关系被提供时，解耦效果更明显。对象不查找它的依赖关系，也不知道依赖关系的位置或类，而这一切都由 Spring 框架控制的。

Spring 基于构造函数的依赖注入
当容器调用带有一组参数的类构造函数时，基于构造函数的 DI 就完成了，其中每个参数代表一个对其他类的依赖。


<?xml version="1.0" encoding="UTF-8"?>


<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">


   <!-- Definition for textEditor bean -->
   <bean id="textEditor" class="com.tutorialspoint.TextEditor">
      <constructor-arg ref="spellChecker"/>
   </bean>


   <!-- Definition for spellChecker bean -->
   <bean id="spellChecker" class="com.tutorialspoint.SpellChecker">
   </bean>


</beans>



构造函数参数解析:

如果存在不止一个参数时，当把参数传递给构造函数时，可能会存在歧义。要解决这个问题，那么构造函数的参数在 bean 定义中的顺序就是把这些参数提供给适当的构造函数的顺序就可以了。

<beans>

   <bean id="foo" class="x.y.Foo">

      <constructor-arg ref="bar"/>

      <constructor-arg ref="baz"/>

   </bean>

   <bean id="bar" class="x.y.Bar"/>

   <bean id="baz" class="x.y.Baz"/>

</beans>

如果你使用 type 属性显式的指定了构造函数参数的类型，容器也可以使用与简单类型匹配的类型

<beans>

   <bean id="exampleBean" class="examples.ExampleBean">

      <constructor-arg type="int" value="2001"/>

      <constructor-arg type="java.lang.String" value="Zara"/>

   </bean>

</beans>

最后并且也是最好的传递构造函数参数的方式，使用 index 属性来显式的指定构造函数参数的索引。下面是基于索引为 0 的例子，如下所示：

<beans>

   <bean id="exampleBean" class="examples.ExampleBean">

      <constructor-arg index="0" value="2001"/>

      <constructor-arg index="1" value="Zara"/>

   </bean>

</beans>

最后，如果你想要向一个对象传递一个引用，你需要使用 标签的 ref 属性，如果你想要直接传递值，那么你应该使用如上所示的 value 属性。

Spring 注入内部 Beans
Spring 基于设值函数的依赖注入当容器调用一个无参的构造函数或一个无参的静态 factory 方法来初始化你的 bean 后，通过容器在你的 bean 上调用设值函数，基于设值函数的 DI 就完成了。
<?xml version="1.0" encoding="UTF-8"?>


<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">


   <!-- Definition for textEditor bean -->
   <bean id="textEditor" class="com.tutorialspoint.TextEditor">
      <property name="spellChecker" ref="spellChecker"/>
   </bean>


   <!-- Definition for spellChecker bean -->
   <bean id="spellChecker" class="com.tutorialspoint.SpellChecker">
   </bean>


</beans>



使用 p-namespace 实现 XML 配置：

如果你有许多的设值函数方法，那么在 XML 配置文件中使用 p-namespace 是非常方便的。让我们查看一下区别：

以带有 标签的标准 XML 配置文件为例：

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. 
   
3. <beans xmlns="http://www.springframework.org/schema/beans"
   
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   
5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
   
6.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   
7. 
   
8.    <bean id="john-classic" class="com.example.Person">
   
9.       <property name="name" value="John Doe"/>
   
10.       <property name="spouse" ref="jane"/>
    
11.    </bean>
    
12. 
    
13.    <bean name="jane" class="com.example.Person">
    
14.       <property name="name" value="John Doe"/>
    
15.    </bean>
    
16. 
    
17. </beans>

复制代码

上述 XML 配置文件可以使用 p-namespace 以一种更简洁的方式重写，如下所示：

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. 
   
3. <beans xmlns="http://www.springframework.org/schema/beans"
   
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   
5.     xmlns:p="http://www.springframework.org/schema/p"
   
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans
   
7.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   
8. 
   
9.    <bean id="john-classic" class="com.example.Person"
   
10.       p:name="John Doe"
    
11.       p:spouse-ref="jane"/>
    
12.    </bean>
    
13. 
    
14.    <bean name="jane" class="com.example.Person"
    
15.       p:name="John Doe"/>
    
16.    </bean>
    
17. 
    
18. </beans>

复制代码

Spring 注入内部 Beans
注入内部 Beans

正如你所知道的 Java 内部类是在其他类的范围内被定义的，同理，inner beans 是在其他 bean 的范围内定义的 bean。因此在 或 元素内 元素被称为内部bean，如下所示。

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. 
   
3. <beans xmlns="http://www.springframework.org/schema/beans"
   
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   
5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
   
6.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   
7. 
   
8.    <bean id="outerBean" class="...">
   
9.       <property name="target">
   
10.          <bean id="innerBean" class="..."/>
    
11.       </property>
    
12.    </bean>
    
13. 
    
14. </beans>

复制代码

下面是使用内部 bean 为基于 setter 注入进行配置的配置文件 Beans.xml 文件：

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. 
   
3. <beans xmlns="http://www.springframework.org/schema/beans"
   
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   
5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
   
6.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   
7. 
   
8.    <!-- Definition for textEditor bean using inner bean -->
   
9.    <bean id="textEditor" class="com.tutorialspoint.TextEditor">
   
10.       <property name="spellChecker">
    
11.          <bean id="spellChecker" class="com.tutorialspoint.SpellChecker"/>
    
12.        </property>
    
13.    </bean>
    
14. 
    
15. </beans>

复制代码

Spring 注入集合

你已经看到了如何使用 value 属性来配置基本数据类型和在你的 bean 配置文件中使用<property>标签的 ref 属性来配置对象引用。这两种情况下处理奇异值传递给一个 bean。

现在如果你想传递多个值，如 Java Collection 类型 List、Set、Map 和 Properties，应该怎么做呢。为了处理这种情况，Spring 提供了四种类型的集合的配置元素，如下所示：

元素	描述
<list>	它有助于连线，如注入一列值，允许重复。
<set>	它有助于连线一组值，但不能重复。
<map>	它可以用来注入名称-值对的集合，其中名称和值可以是任何类型。
<props>	它可以用来注入名称-值对的集合，其中名称和值都是字符串类型。

你可以使用<list>或<set>来连接任何 java.util.Collection 的实现或数组。

你会遇到两种情况（a）传递集合中直接的值（b）传递一个 bean 的引用作为集合的元素。

这里是 JavaCollection.java 文件的内容：

1. package com.tutorialspoint;
   
2. import java.util.*;
   
3. public class JavaCollection {
   
4.    List addressList;
   
5.    Set  addressSet;
   
6.    Map  addressMap;
   
7.    Properties addressProp;
   
8.    // a setter method to set List
   
9.    public void setAddressList(List addressList) {
   
10.       this.addressList = addressList;
    
11.    }
    
12.    // prints and returns all the elements of the list.
    
13.    public List getAddressList() {
    
14.       System.out.println("List Elements :"  + addressList);
    
15.       return addressList;
    
16.    }
    
17.    // a setter method to set Set
    
18.    public void setAddressSet(Set addressSet) {
    
19.       this.addressSet = addressSet;
    
20.    }
    
21.    // prints and returns all the elements of the Set.
    
22.    public Set getAddressSet() {
    
23.       System.out.println("Set Elements :"  + addressSet);
    
24.       return addressSet;
    
25.    }
    
26.    // a setter method to set Map
    
27.    public void setAddressMap(Map addressMap) {
    
28.       this.addressMap = addressMap;
    
29.    }  
    
30.    // prints and returns all the elements of the Map.
    
31.    public Map getAddressMap() {
    
32.       System.out.println("Map Elements :"  + addressMap);
    
33.       return addressMap;
    
34.    }
    
35.    // a setter method to set Property
    
36.    public void setAddressProp(Properties addressProp) {
    
37.       this.addressProp = addressProp;
    
38.    }
    
39.    // prints and returns all the elements of the Property.
    
40.    public Properties getAddressProp() {
    
41.       System.out.println("Property Elements :"  + addressProp);
    
42.       return addressProp;
    
43.    }
    
44. }

复制代码

下面是配置所有类型的集合的配置文件 Beans.xml 文件：

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. 
   
3. <beans xmlns="http://www.springframework.org/schema/beans"
   
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   
5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
   
6.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   
7. 
   
8.    <!-- Definition for javaCollection -->
   
9.    <bean id="javaCollection" class="com.tutorialspoint.JavaCollection">
   
10. 
    
11.       <!-- results in a setAddressList(java.util.List) call -->
    
12.       <property name="addressList">
    
13.          <list>
    
14.             <value>INDIA</value>
    
15.             <value>Pakistan</value>
    
16.             <value>USA</value>
    
17.             <value>USA</value>
    
18.          </list>
    
19.       </property>
    
20. 
    
21.       <!-- results in a setAddressSet(java.util.Set) call -->
    
22.       <property name="addressSet">
    
23.          <set>
    
24.             <value>INDIA</value>
    
25.             <value>Pakistan</value>
    
26.             <value>USA</value>
    
27.             <value>USA</value>
    
28.         </set>
    
29.       </property>
    
30. 
    
31.       <!-- results in a setAddressMap(java.util.Map) call -->
    
32.       <property name="addressMap">
    
33.          <map>
    
34.             <entry key="1" value="INDIA"/>
    
35.             <entry key="2" value="Pakistan"/>
    
36.             <entry key="3" value="USA"/>
    
37.             <entry key="4" value="USA"/>
    
38.          </map>
    
39.       </property>
    
40. 
    
41.       <!-- results in a setAddressProp(java.util.Properties) call -->
    
42.       <property name="addressProp">
    
43.          <props>
    
44.             <prop key="one">INDIA</prop>
    
45.             <prop key="two">Pakistan</prop>
    
46.             <prop key="three">USA</prop>
    
47.             <prop key="four">USA</prop>
    
48.          </props>
    
49.       </property>
    
50. 
    
51.    </bean>
    
52. 
    
53. </beans>

复制代码

注入 Bean 引用

下面的 Bean 定义将帮助你理解如何注入 bean 的引用作为集合的元素。甚至你可以将引用和值混合在一起，如下所示：

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. 
   
3. <beans xmlns="http://www.springframework.org/schema/beans"
   
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   
5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
   
6.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   
7. 
   
8.    <!-- Bean Definition to handle references and values -->
   
9.    <bean id="..." class="...">
   
10. 
    
11.       <!-- Passing bean reference  for java.util.List -->
    
12.       <property name="addressList">
    
13.          <list>
    
14.             <ref bean="address1"/>
    
15.             <ref bean="address2"/>
    
16.             <value>Pakistan</value>
    
17.          </list>
    
18.       </property>
    
19. 
    
20.       <!-- Passing bean reference  for java.util.Set -->
    
21.       <property name="addressSet">
    
22.          <set>
    
23.             <ref bean="address1"/>
    
24.             <ref bean="address2"/>
    
25.             <value>Pakistan</value>
    
26.          </set>
    
27.       </property>
    
28. 
    
29.       <!-- Passing bean reference  for java.util.Map -->
    
30.       <property name="addressMap">
    
31.          <map>
    
32.             <entry key="one" value="INDIA"/>
    
33.             <entry key ="two" value-ref="address1"/>
    
34.             <entry key ="three" value-ref="address2"/>
    
35.          </map>
    
36.       </property>
    
37. 
    
38.    </bean>
    
39. 
    
40. </beans>

复制代码

为了使用上面的 bean 定义，你需要定义 setter 方法，它们应该也能够是用这种方式来处理引用。

注入 null 和空字符串的值

如果你需要传递一个空字符串作为值，那么你可以传递它，如下所示：

<bean id="..." class="exampleBean">

   <property name="email" value=""/>

</bean>

前面的例子相当于 Java 代码：exampleBean.setEmail("")。

如果你需要传递一个 NULL 值，那么你可以传递它，如下所示：

<bean id="..." class="exampleBean">

   <property name="email"><null/></property>

</bean>

前面的例子相当于 Java 代码：exampleBean.setEmail(null)。

java

Spring Bean 定义继承Bean 定义继承https://www.w3cschool.cn/wkspring/tydj1ick.html

bean 定义可以包含很多的配置信息，包括构造函数的参数，属性值，容器的具体信息例如初始化方法，静态工厂方法名，等等。

子 bean 的定义继承父定义的配置数据。子定义可以根据需要重写一些值，或者添加其他值。

Spring Bean 定义的继承与 Java 类的继承无关，但是继承的概念是一样的。你可以定义一个父 bean 的定义作为模板和其他子 bean 就可以从父 bean 中继承所需的配置。

当你使用基于 XML 的配置元数据时，通过使用父属性，指定父 bean 作为该属性的值来表明子 bean 的定义。

例子

我们在适当的位置使用 Eclipse IDE，然后按照下面的步骤来创建一个 Spring 应用程序：

步骤	描述
1	创建一个名称为 SpringExample 的项目，并且在创建项目的 src 文件夹中创建一个包 com.tutorialspoint。
2	使用 Add External JARs 选项，添加所需的 Spring 库，解释见 Spring Hello World Example 章节。
3	在 com.tutorialspoint 包中创建 Java 类 HelloWorld、HelloIndia 和 MainApp。
4	在 src 文件夹中创建 Beans 配置文件 Beans.xml。
5	最后一步是创建的所有 Java 文件和 Bean 配置文件的内容，并运行应用程序，解释如下所示。

下面是配置文件 Beans.xml，在该配置文件中我们定义有两个属性 message1 和 message2 的 “helloWorld” bean。然后，使用 parent 属性把 “helloIndia” bean 定义为 “helloWorld” bean 的孩子。这个子 bean 继承 message2 的属性，重写 message1 的属性，并且引入一个属性 message3。

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id="helloWorld" class="com.tutorialspoint.HelloWorld">

      <property name="message1" value="Hello World!"/>

      <property name="message2" value="Hello Second World!"/>

   </bean>

   <bean id="helloIndia" class="com.tutorialspoint.HelloIndia" parent="helloWorld">

      <property name="message1" value="Hello India!"/>

      <property name="message3" value="Namaste India!"/>

   </bean>

</beans>

这里是 HelloWorld.java 文件的内容：

package com.tutorialspoint;

public class HelloWorld {

   private String message1;

   private String message2;

   public void setMessage1(String message){

      this.message1  = message;

   }

   public void setMessage2(String message){

      this.message2  = message;

   }

   public void getMessage1(){

      System.out.println("World Message1 : " + message1);

   }

   public void getMessage2(){

      System.out.println("World Message2 : " + message2);

   }

}

这里是 HelloIndia.java 文件的内容：

package com.tutorialspoint;

public class HelloIndia {

   private String message1;

   private String message2;

   private String message3;

   public void setMessage1(String message){

      this.message1  = message;

   }

   public void setMessage2(String message){

      this.message2  = message;

   }

   public void setMessage3(String message){

      this.message3  = message;

   }

   public void getMessage1(){

      System.out.println("India Message1 : " + message1);

   }

   public void getMessage2(){

      System.out.println("India Message2 : " + message2);

   }

   public void getMessage3(){

      System.out.println("India Message3 : " + message3);

   }

}

下面是 MainApp.java 文件的内容：

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {

   public static void main(String[] args) {

      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

      HelloWorld objA = (HelloWorld) context.getBean("helloWorld");

      objA.getMessage1();

      objA.getMessage2();

      HelloIndia objB = (HelloIndia) context.getBean("helloIndia");

      objB.getMessage1();

      objB.getMessage2();

      objB.getMessage3();

   }

}

一旦你创建源代码和 bean 配置文件完成后，我们就可以运行该应用程序。如果你的应用程序一切都正常，将输出以下信息：

World Message1 : Hello World!

World Message2 : Hello Second World!

India Message1 : Hello India!

India Message2 : Hello Second World!

India Message3 : Namaste India!

在这里你可以观察到，我们创建 “helloIndia” bean 的同时并没有传递 message2，但是由于 Bean 定义的继承，所以它传递了 message2。

Bean 定义模板

你可以创建一个 Bean 定义模板，不需要花太多功夫它就可以被其他子 bean 定义使用。在定义一个 Bean 定义模板时，你不应该指定类的属性，而应该指定带 true 值的抽象属性，如下所示：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id="beanTeamplate" abstract="true">

      <property name="message1" value="Hello World!"/>

      <property name="message2" value="Hello Second World!"/>

      <property name="message3" value="Namaste India!"/>

   </bean>

   <bean id="helloIndia" class="com.tutorialspoint.HelloIndia" parent="beanTeamplate">

      <property name="message1" value="Hello India!"/>

      <property name="message3" value="Namaste India!"/>

   </bean>

</beans>

父 bean 自身不能被实例化，因为它是不完整的，而且它也被明确地标记为抽象的。当一个定义是抽象的，它仅仅作为一个纯粹的模板 bean 定义来使用的，充当子定义的父定义使用。

java

Spring Bean 后置处理器Spring——Bean 后置处理器

BeanPostProcessor 接口定义回调方法，你可以实现该方法来提供自己的实例化逻辑，依赖解析逻辑等。你也可以在 Spring 容器通过插入一个或多个 BeanPostProcessor 的实现来完成实例化，配置和初始化一个bean之后实现一些自定义逻辑回调方法。

你可以配置多个 BeanPostProcesso r接口，通过设置 BeanPostProcessor 实现的 Ordered 接口提供的 order 属性来控制这些 BeanPostProcessor 接口的执行顺序。

BeanPostProcessor 可以对 bean（或对象）实例进行操作，这意味着 Spring IoC 容器实例化一个 bean 实例，然后 BeanPostProcessor 接口进行它们的工作。

ApplicationContext 会自动检测由 BeanPostProcessor 接口的实现定义的 bean，注册这些 bean 为后置处理器，然后通过在容器中创建 bean，在适当的时候调用它。

例子：

下面的例子显示如何在 ApplicationContext 的上下文中编写，注册和使用 BeanPostProcessor。

我们在适当的位置使用 Eclipse IDE，然后按照下面的步骤来创建一个 Spring 应用程序：

步骤	描述
1	创建一个名称为 SpringExample 的项目，并且在创建项目的 src 文件夹中创建一个包 com.tutorialspoint。
2	使用 Add External JARs 选项，添加所需的 Spring 库，解释见 Spring Hello World Example 章节。
3	在 com.tutorialspoint 包中创建 Java 类 HelloWorld、InitHelloWorld 和 MainApp。
4	在 src 文件夹中创建 Beans 配置文件 Beans.xml。
5	最后一步是创建的所有 Java 文件和 Bean 配置文件的内容，并运行应用程序，解释如下所示。

这里是 HelloWorld.java 文件的内容：

1. package com.tutorialspoint;
   
2. public class HelloWorld {
   
3.    private String message;
   
4.    public void setMessage(String message){
   
5.       this.message  = message;
   
6.    }
   
7.    public void getMessage(){
   
8.       System.out.println("Your Message : " + message);
   
9.    }
   
10.    public void init(){
    
11.       System.out.println("Bean is going through init.");
    
12.    }
    
13.    public void destroy(){
    
14.       System.out.println("Bean will destroy now.");
    
15.    }
    
16. }

复制代码

这是实现 BeanPostProcessor 的非常简单的例子，它在任何 bean 的初始化的之前和之后输入该 bean 的名称。你可以在初始化 bean 的之前和之后实现更复杂的逻辑，因为你有两个访问内置 bean 对象的后置处理程序的方法。

这里是 InitHelloWorld.java 文件的内容：

1. package com.tutorialspoint;
   
2. import org.springframework.beans.factory.config.BeanPostProcessor;
   
3. import org.springframework.beans.BeansException;
   
4. public class InitHelloWorld implements BeanPostProcessor {
   
5.    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
   
6.       System.out.println("BeforeInitialization : " + beanName);
   
7.       return bean;  // you can return any other object as well
   
8.    }
   
9.    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
   
10.       System.out.println("AfterInitialization : " + beanName);
    
11.       return bean;  // you can return any other object as well
    
12.    }
    
13. }

复制代码

下面是 MainApp.java 文件的内容。在这里，你需要注册一个在 AbstractApplicationContext 类中声明的关闭 hook 的 registerShutdownHook() 方法。它将确保正常关闭，并且调用相关的 destroy 方法。

1. package com.tutorialspoint;
   
2. import org.springframework.context.support.AbstractApplicationContext;
   
3. import org.springframework.context.support.ClassPathXmlApplicationContext;
   
4. public class MainApp {
   
5.    public static void main(String[] args) {
   
6.       AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
   
7.       HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
   
8.       obj.getMessage();
   
9.       context.registerShutdownHook();
   
10.    }
    
11. }

复制代码

下面是 init 和 destroy 方法需要的配置文件 Beans.xml 文件：

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. 
   
3. <beans xmlns="http://www.springframework.org/schema/beans"
   
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   
5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
   
6.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   
7. 
   
8.    <bean id="helloWorld" class="com.tutorialspoint.HelloWorld"
   
9.        init-method="init" destroy-method="destroy">
   
10.        <property name="message" value="Hello World!"/>
    
11.    </bean>
    
12. 
    
13.    <bean class="com.tutorialspoint.InitHelloWorld" />
    
14. 
    
15. </beans>

复制代码

一旦你创建源代码和 bean 配置文件完成后，我们就可以运行该应用程序。如果你的应用程序一切都正常，将输出以下信息：

1. BeforeInitialization : helloWorld
   
2. Bean is going through init.
   
3. AfterInitialization : helloWorld
   
4. Your Message : Hello World!
   
5. Bean will destroy now.

复制代码

https://www.w3cschool.cn/wkspring/xs181ici.html

java

Spring Bean 定义Bean 定义

被称作 bean 的对象是构成应用程序的支柱也是由 Spring IoC 容器管理的。bean 是一个被实例化，组装，并通过 Spring IoC 容器所管理的对象。这些 bean 是由用容器提供的配置元数据创建的，例如，已经在先前章节看到的，在 XML 的表单中的 定义。

bean 定义包含称为配置元数据的信息，下述容器也需要知道配置元数据：

• 如何创建一个 bean
• bean 的生命周期的详细信息
• bean 的依赖关系
  

上述所有的配置元数据转换成一组构成每个 bean 定义的下列属性。

属性	描述
class	这个属性是强制性的，并且指定用来创建 bean 的 bean 类。
name	这个属性指定唯一的 bean 标识符。在基于 XML 的配置元数据中，你可以使用 ID 和/或 name 属性来指定 bean 标识符。
scope	这个属性指定由特定的 bean 定义创建的对象的作用域，它将会在 bean 作用域的章节中进行讨论。
constructor-arg	它是用来注入依赖关系的，并会在接下来的章节中进行讨论。
properties	它是用来注入依赖关系的，并会在接下来的章节中进行讨论。
autowiring mode	它是用来注入依赖关系的，并会在接下来的章节中进行讨论。
lazy-initialization mode	延迟初始化的 bean 告诉 IoC 容器在它第一次被请求时，而不是在启动时去创建一个 bean 实例。
initialization 方法	在 bean 的所有必需的属性被容器设置之后，调用回调方法。它将会在 bean 的生命周期章节中进行讨论。
destruction 方法	当包含该 bean 的容器被销毁时，使用回调方法。它将会在 bean 的生命周期章节中进行讨论。

Spring 配置元数据

Spring IoC 容器完全由实际编写的配置元数据的格式解耦。有下面三个重要的方法把配置元数据提供给 Spring 容器：

• 基于 XML 的配置文件。
• 基于注解的配置
• 基于 Java 的配置
  

你已经看到了如何把基于 XML 的配置元数据提供给容器，但是让我们看看另一个基于 XML 配置文件的例子，这个配置文件中有不同的 bean 定义，包括延迟初始化，初始化方法和销毁方法的：

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. 
   
3. <beans xmlns="http://www.springframework.org/schema/beans"
   
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   
5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
   
6.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   
7. 
   
8.    <!-- A simple bean definition -->
   
9.    <bean id="..." class="...">
   
10.        <!-- collaborators and configuration for this bean go here -->
    
11.    </bean>
    
12. 
    
13.    <!-- A bean definition with lazy init set on -->
    
14.    <bean id="..." class="..." lazy-init="true">
    
15.        <!-- collaborators and configuration for this bean go here -->
    
16.    </bean>
    
17. 
    
18.    <!-- A bean definition with initialization method -->
    
19.    <bean id="..." class="..." init-method="...">
    
20.        <!-- collaborators and configuration for this bean go here -->
    
21.    </bean>
    
22. 
    
23.    <!-- A bean definition with destruction method -->
    
24.    <bean id="..." class="..." destroy-method="...">
    
25.        <!-- collaborators and configuration for this bean go here -->
    
26.    </bean>
    
27. 
    
28.    <!-- more bean definitions go here -->
    
29. 
    
30. </beans>

复制代码

Spring Bean 作用域Bean 的作用域

当在 Spring 中定义一个 时，你必须声明该 bean 的作用域的选项。例如，为了强制 Spring 在每次需要时都产生一个新的 bean 实例，你应该声明 bean 的作用域的属性为 prototype。同理，如果你想让 Spring 在每次需要时都返回同一个bean实例，你应该声明 bean 的作用域的属性为 singleton。

Spring 框架支持以下五个作用域，如果你使用 web-aware ApplicationContext 时，其中三个是可用的。

作用域	描述
singleton	该作用域将 bean 的定义的限制在每一个 Spring IoC 容器中的一个单一实例(默认)。
prototype	该作用域将单一 bean 的定义限制在任意数量的对象实例。
request	该作用域将 bean 的定义限制为 HTTP 请求。只在 web-aware Spring ApplicationContext 的上下文中有效。
session	该作用域将 bean 的定义限制为 HTTP 会话。 只在web-aware Spring ApplicationContext的上下文中有效。
global-session	该作用域将 bean 的定义限制为全局 HTTP 会话。只在 web-aware Spring ApplicationContext 的上下文中有效。

本章将讨论前两个范围，当我们将讨论有关 web-aware Spring ApplicationContext 时，其余三个将被讨论。

singleton 作用域：

如果作用域设置为 singleton，那么 Spring IoC 容器刚好创建一个由该 bean 定义的对象的实例。该单一实例将存储在这种单例 bean 的高速缓存中，以及针对该 bean 的所有后续的请求和引用都返回缓存对象。

默认作用域是始终是 singleton，但是当仅仅需要 bean 的一个实例时，你可以在 bean 的配置文件中设置作用域的属性为 singleton，如下所示：

1. <!-- A bean definition with singleton scope -->
   
2. <bean id="..." class="..." scope="singleton">
   
3.     <!-- collaborators and configuration for this bean go here -->
   
4. </bean>

复制代码

prototype 作用域

如果作用域设置为 prototype，那么每次特定的 bean 发出请求时 Spring IoC 容器就创建对象的新的 Bean 实例。一般说来，满状态的 bean 使用 prototype 作用域和没有状态的 bean 使用 singleton 作用域。

为了定义 prototype 作用域，你可以在 bean 的配置文件中设置作用域的属性为 prototype，如下所示：

1. <!-- A bean definition with singleton scope -->
   
2. <bean id="..." class="..." scope="prototype">
   
3.    <!-- collaborators and configuration for this bean go here -->
   
4. </bean>

复制代码

https://www.w3cschool.cn/wkspring/nukv1ice.html

Spring Bean 生命周期
Bean 的生命周期

理解 Spring bean 的生命周期很容易。当一个 bean 被实例化时，它可能需要执行一些初始化使它转换成可用状态。同样，当 bean 不再需要，并且从容器中移除时，可能需要做一些清除工作。

尽管还有一些在 Bean 实例化和销毁之间发生的活动，但是本章将只讨论两个重要的生命周期回调方法，它们在 bean 的初始化和销毁的时候是必需的。

为了定义安装和拆卸一个 bean，我们只要声明带有 init-method 和/或 destroy-method 参数的 。init-method 属性指定一个方法，在实例化 bean 时，立即调用该方法。同样，destroy-method 指定一个方法，只有从容器中移除 bean 之后，才能调用该方法。

初始化回调

org.springframework.beans.factory.InitializingBean 接口指定一个单一的方法：

1. void afterPropertiesSet() throws Exception;

复制代码

因此，你可以简单地实现上述接口和初始化工作可以在 afterPropertiesSet() 方法中执行，如下所示：

1. public class ExampleBean implements InitializingBean {
   
2.    public void afterPropertiesSet() {
   
3.       // do some initialization work
   
4.    }
   
5. }

复制代码

在基于 XML 的配置元数据的情况下，你可以使用 init-method 属性来指定带有 void 无参数方法的名称。例如：

1. <bean id="exampleBean"
   
2.          class="examples.ExampleBean" init-method="init"/>

复制代码

下面是类的定义：

1. public class ExampleBean {
   
2.    public void init() {
   
3.       // do some initialization work
   
4.    }
   
5. }

复制代码

销毁回调

org.springframework.beans.factory.DisposableBean 接口指定一个单一的方法：

void destroy() throws Exception;

因此，你可以简单地实现上述接口并且结束工作可以在 destroy() 方法中执行，如下所示：

public class ExampleBean implements DisposableBean {

   public void destroy() {

      // do some destruction work

   }

}

在基于 XML 的配置元数据的情况下，你可以使用 destroy-method 属性来指定带有 void 无参数方法的名称。例如：

<bean id="exampleBean"

         class="examples.ExampleBean" destroy-method="destroy"/>

下面是类的定义：

public class ExampleBean {

   public void destroy() {

      // do some destruction work

   }

}

如果你在非 web 应用程序环境中使用 Spring 的 IoC 容器；例如在丰富的客户端桌面环境中；那么在 JVM 中你要注册关闭 hook。这样做可以确保正常关闭，为了让所有的资源都被释放，可以在单个 beans 上调用 destroy 方法。

建议你不要使用 InitializingBean 或者 DisposableBean 的回调方法，因为 XML 配置在命名方法上提供了极大的灵活性。

java

Spring BeanFactory 容器Sping 的 BeanFactory 容器

这是一个最简单的容器，它主要的功能是为依赖注入 （DI） 提供支持，这个容器接口在 org.springframework.beans.factory.BeanFactor 中被定义。 BeanFactory 和相关的接口，比如，BeanFactoryAware、 DisposableBean、InitializingBean，仍旧保留在 Spring 中，主要目的是向后兼容已经存在的和那些 Spring 整合在一起的第三方框架。

在 Spring 中，有大量对 BeanFactory 接口的实现。其中，最常被使用的是 XmlBeanFactory 类。这个容器从一个 XML 文件中读取配置元数据，由这些元数据来生成一个被配置化的系统或者应用。

在资源宝贵的移动设备或者基于 applet 的应用当中， BeanFactory 会被优先选择。否则，一般使用的是 ApplicationContext，除非你有更好的理由选择 BeanFactory。

Spring ApplicationContext 容器

Application Context 是 spring 中较高级的容器。和 BeanFactory 类似，它可以加载配置文件中定义的 bean，将所有的 bean 集中在一起，当有请求的时候分配 bean。 另外，它增加了企业所需要的功能，比如，从属性文件从解析文本信息和将事件传递给所指定的监听器。这个容器在 org.springframework.context.ApplicationContext interface 接口中定义。

ApplicationContext 包含 BeanFactory 所有的功能，一般情况下，相对于 BeanFactory，ApplicationContext 会被推荐使用。BeanFactory 仍然可以在轻量级应用中使用，比如移动设备或者基于 applet 的应用程序。

最常被使用的 ApplicationContext 接口实现：

• FileSystemXmlApplicationContext：该容器从 XML 文件中加载已被定义的 bean。在这里，你需要提供给构造器 XML 文件的完整路径
• ClassPathXmlApplicationContext：该容器从 XML 文件中加载已被定义的 bean。在这里，你不需要提供 XML 文件的完整路径，只需正确配置 CLASSPATH 环境变量即可，因为，容器会从 CLASSPATH 中搜索 bean 配置文件。
• WebXmlApplicationContext：该容器会在一个 web 应用程序的范围内加载在 XML 文件中已被定义的 bean。
  

我们已经在 Spring Hello World Example章节中看到过 ClassPathXmlApplicationContext 容器，并且，在基于 spring 的 web 应用程序这个独立的章节中，我们讨论了很多关于 XmlWebApplicationContext。所以，接下来，让我们看一个关于 FileSystemXmlApplicationContext 的例子。

注意 MainApp.java 内容的不同：

1. package com.tutorialspoint;
   
2. import org.springframework.context.ApplicationContext;
   
3. import org.springframework.context.support.FileSystemXmlApplicationContext;
   
4. public class MainApp {
   
5.    public static void main(String[] args) {
   
6.       ApplicationContext context = new FileSystemXmlApplicationContext
   
7.             ("C:/Users/ZARA/workspace/HelloSpring/src/Beans.xml");
   
8.       HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
   
9.       obj.getMessage();
   
10.    }
    
11. }

复制代码

在主程序当中，我们需要注意以下两点：

• 第一步生成工厂对象。加载完指定路径下 bean 配置文件后，利用框架提供的 FileSystemXmlApplicationContext API 去生成工厂 bean。FileSystemXmlApplicationContext 负责生成和初始化所有的对象，比如，所有在 XML bean 配置文件中的 bean。
• 第二步利用第一步生成的上下文中的 getBean() 方法得到所需要的 bean。 这个方法通过配置文件中的 bean ID 来返回一个真正的对象。一旦得到这个对象，就可以利用这个对象来调用任何方法。
  

java

Spring IoC 容器IoC 容器

Spring 容器是 Spring 框架的核心。容器将创建对象，把它们连接在一起，配置它们，并管理他们的整个生命周期从创建到销毁。Spring 容器使用依赖注入（DI）来管理组成一个应用程序的组件。这些对象被称为 Spring Beans，我们将在下一章中进行讨论。

通过阅读配置元数据提供的指令，容器知道对哪些对象进行实例化，配置和组装。配置元数据可以通过 XML，Java 注释或 Java 代码来表示。下图是 Spring 如何工作的高级视图。 Spring IoC 容器利用 Java 的 POJO 类和配置元数据来生成完全配置和可执行的系统或应用程序。

Spring 提供了以下两种不同类型的容器。

序号	容器 & 描述
1	Spring BeanFactory 容器 它是最简单的容器，给 DI 提供了基本的支持，它用 org.springframework.beans.factory.BeanFactory 接口来定义。BeanFactory 或者相关的接口，如 BeanFactoryAware，InitializingBean，DisposableBean，在 Spring 中仍然存在具有大量的与 Spring 整合的第三方框架的反向兼容性的目的。
2	Spring ApplicationContext 容器 该容器添加了更多的企业特定的功能，例如从一个属性文件中解析文本信息的能力，发布应用程序事件给感兴趣的事件监听器的能力。该容器是由 org.springframework.context.ApplicationContext 接口定义。

ApplicationContext 容器包括 BeanFactory 容器的所有功能，所以通常建议超过 BeanFactory。BeanFactory 仍然可以用于轻量级的应用程序，如移动设备或基于 applet 的应用程序，其中它的数据量和速度是显著。

https://www.w3cschool.cn/wkspring/f8pc1hae.html