spring boot官网_booterx-优快云博客

Spring框架的文档
版本5.1.9.RELEASE
什么是新的、升级注释、支持的版本和其他独立于发布节奏的主题，都在项目的Github Wiki外部维护。
概述
历史，设计理念，反馈，开始。

核心
IoC容器、事件、资源、i18n、验证、数据绑定、类型转换、SpEL、AOP。

测试
模拟对象，TestContext框架，Spring MVC测试，WebTestClient。

数据访问
事务、DAO支持、JDBC、O/R映射、XML编组。

Web Servlet
Spring MVC, WebSocket, SockJS, STOMP消息。

网络无功
Spring WebFlux, WebClient, WebSocket。

集成
远程，JMS, JCA, JMX，电子邮件，任务，调度，缓存。

语言
Kotlin, Groovy，动态语言。

概述

历史，设计理念，反馈，开始。

Spring框架概述
版本5.1.9.RELEASE
表的内容
回到指数

我们所说的“春天”是什么意思
Spring的历史和Spring框架
3.设计理念
反馈和贡献
开始
Spring使创建Java企业应用程序变得很容易。它提供了在企业环境中使用Java语言所需要的一切，支持Groovy和Kotlin作为JVM上的替代语言，并根据应用程序的需求灵活地创建多种体系结构。从Spring Framework 5.1开始，Spring就需要JDK 8+ (Java SE 8+)，并为JDK 11 LTS提供开箱即用的支持。

Spring支持广泛的应用程序场景。在大型企业中，应用程序通常存在很长时间，并且必须运行在JDK和应用服务器上，升级周期超出了开发人员的控制。其他的可以作为一个单独的jar运行，并嵌入服务器，可能是在云环境中。还有一些可能是不需要服务器的独立应用程序(例如批处理或集成工作负载)。

Spring是开源的。它拥有一个大型且活跃的社区，该社区基于各种实际用例提供持续的反馈。这帮助Spring在很长一段时间内成功地进化。

我们所说的“春天”是什么意思
“春天”一词在不同的上下文中有不同的含义。它可以用来引用Spring Framework项目本身，这是它开始的地方。随着时间的推移，其他Spring项目已经构建在Spring框架之上。大多数情况下，当人们说“春天”，他们指的是整个家庭的项目。这个参考文档主要关注基础:Spring框架本身。

Spring框架被划分为多个模块。应用程序可以选择它们需要哪些模块。核心是核心容器的模块，包括配置模型和依赖注入机制。除此之外，Spring框架还为不同的应用程序体系结构提供了基础支持，包括消息传递、事务数据和持久性以及web。它还包括基于servlet的Spring MVC web框架，以及与之并行的Spring WebFlux反应性web框架。

关于模块的说明:Spring的框架jar允许部署到JDK 9的模块路径(“Jigsaw”)。为了在支持jigsaw的应用程序中使用，Spring Framework 5 jar附带了“Automatic-Module-Name”清单条目，其中定义了稳定的语言级模块名(“Spring”)。核心”、“春天。独立于jar工件名称(jar遵循相同的命名模式，使用“-”代替“”)。”,如。“spring核心”和“spring上下文”)。当然，Spring的框架jar在JDK 8和9+的类路径上都能很好地工作。

Spring的历史和Spring框架
Spring是在2003年作为对早期J2EE规范复杂性的响应而出现的。虽然有些人认为Java EE和Spring是竞争对手，但Spring实际上是Java EE的补充。Spring编程模型不包含Java EE平台规范;相反，它集成了从EE保护伞中精心选择的各个规范:

Servlet API (JSR 340)

WebSocket API (JSR 356)

并发实用程序(JSR 236)

JSON绑定API (JSR 367)

Bean验证(JSR 303)

JPA (JSR 338)

JMS (JSR 914)

以及JTA/JCA设置，以便在必要时进行事务协调。

Spring框架还支持依赖项注入(JSR 330)和公共注释(JSR 250)规范，应用程序开发人员可以选择使用这些规范，而不是Spring框架提供的特定于Spring的机制。

Spring Framework 5.0,春天需要Java EE 7水平(例如Servlet 3.1 +, JPA 2.1 +)最小,同时提供开箱即用的集成与更新的API在Java EE 8级(例如Servlet 4.0, JSON绑定API)在运行时当遇到。这使得Spring与Tomcat 8和Tomcat 9、WebSphere 9和JBoss EAP 7完全兼容。

随着时间的推移，Java EE在应用程序开发中的角色已经发生了变化。在Java EE和Spring的早期，创建应用程序是为了部署到应用服务器。今天，在Spring Boot的帮助下，应用程序以一种devops和云友好的方式创建，嵌入了Servlet容器，而且更改起来很简单。从Spring Framework 5开始，WebFlux应用程序甚至不直接使用Servlet API，并且可以运行在不是Servlet容器的服务器上(比如Netty)。

春天继续创新和进化。除了Spring框架之外，还有其他项目，比如Spring Boot、Spring Security、Spring Data、Spring Cloud、Spring Batch等等。重要的是要记住，每个项目都有自己的源代码存储库、问题跟踪器和发布节奏。看到春天。io/ Spring项目的完整列表。

3.设计理念
当您学习一个框架时，重要的是不仅要知道它做什么，还要知道它遵循什么原则。以下是Spring框架的指导原则:

在每个层次上提供选择。Spring允许您尽可能推迟设计决策。例如，您可以通过配置切换持久性提供者，而无需更改代码。对于许多其他基础设施问题以及与第三方api的集成也是如此。

容纳不同的观点。Spring支持灵活性，并且不对应该如何做事情发表意见。它支持具有不同视角的广泛应用程序需求。

保持强大的向后兼容性。Spring的发展已经被小心地管理，以在版本之间强制进行很少的破坏性更改。Spring支持精心选择的JDK版本和第三方库，以方便维护依赖于Spring的应用程序和库。

关心API设计。Spring团队投入了大量的思想和时间来开发直观的api，并支持多个版本和许多年。

为代码质量设定高标准。Spring框架非常强调有意义的、当前的和准确的javadoc。它是极少数可以声明干净代码结构且包之间没有循环依赖关系的项目之一。

反馈和贡献
对于how-to问题、诊断或调试问题，我们建议使用StackOverflow，并且我们有一个问题页面，列出了建议使用的标记。如果您非常确定Spring框架中存在问题，或者想建议一个特性，请使用GitHub Issues。

如果您心中有一个解决方案或建议的修复，您可以在Github上提交一个pull request。但是，请记住，除了最琐碎的问题外，我们希望在问题跟踪器中归档票据，在那里进行讨论，并留下记录供将来参考。

有关详细信息，请参阅提供内容的顶级项目页面中的指导原则。

开始
如果您刚刚开始使用Spring，您可能希望通过创建一个基于Spring boot的应用程序来开始使用Spring框架。Spring Boot提供了一种快速(且固执己见)的方法来创建基于Spring的可生产应用程序。它基于Spring框架，支持约定而不是配置，旨在让您尽可能快地启动和运行。

您可以使用start.spring。io生成一个基本项目或遵循“入门”指南之一，例如开始构建RESTful Web服务。这些指南不仅更容易理解，而且非常专注于任务，其中大多数都是基于Spring Boot的。它们还涵盖了Spring portfolio中的其他项目，您在解决特定问题时可能需要考虑这些项目。

版本5.1.9.RELEASE
最后更新2019-08-02 08:42:27协调世界时

核心

IoC容器、事件、资源、i18n、验证、数据绑定、类型转换、SpEL、AOP。

核心技术
版本5.1.9.RELEASE
表的内容
回到指数

IoC容器
1.1。介绍Spring IoC容器和bean
1.2。集装箱概述
1.3。豆概述
1.4。依赖关系
1.5。豆范围
1.6。自定义Bean的性质
1.7。Bean定义继承
1.8。容器扩展点
1.9。基于注解的容器配置
1.10。类路径扫描和托管组件
1.11。使用JSR 330标准注释
1.12。基于java的容器配置
1.13。环境抽象
1.14。注册一个LoadTimeWeaver
1.15。应用程序上下文的附加功能
1.16。BeanFactory
资源
3.验证、数据绑定和类型转换
Spring表达式语言(SpEL)
使用Spring进行面向方面的编程
Spring AOP api
Null-safety
数据缓冲区和编解码器
附录
参考文档的这一部分涵盖了Spring框架中不可或缺的所有技术。

其中最重要的是Spring框架的控制反转(IoC)容器。对Spring框架的IoC容器进行彻底的处理之后，紧接着是对Spring面向方面编程(AOP)技术的全面覆盖。Spring框架有自己的AOP框架，它在概念上很容易理解，并且成功地解决了Java企业编程中AOP需求的80%的最佳点。

还提供了Spring与AspectJ集成的内容(就特性而言，AspectJ目前是最丰富的，当然也是Java企业空间中最成熟的AOP实现)。

IoC容器
本章讨论Spring的反转控制(IoC)容器。

1.1。介绍Spring IoC容器和bean
本章介绍了控制反转(IoC)原理的Spring框架实现。IoC也称为依赖注入(dependency injection, DI)。这是一个过程，在这个过程中，对象仅通过构造函数参数、工厂方法的参数或对象实例构造或从工厂方法返回后在该对象实例上设置的属性来定义它们的依赖关系(即与它们一起工作的其他对象)。然后容器在创建bean时注入这些依赖项。这个过程本质上与bean本身相反(因此称为控制反转)，bean本身通过直接构造类或一种机制(如服务定位器模式)来控制依赖项的实例化或位置。

org.springframework。豆类和org.springframework。上下文包是Spring Framework的IoC容器的基础。BeanFactory接口提供了能够管理任何类型对象的高级配置机制。ApplicationContext是BeanFactory的子接口。它补充道:

更容易与Spring的AOP特性集成

消息资源处理(用于国际化)

事件发布

应用程序层特定的上下文，如web应用程序中使用的WebApplicationContext。

简而言之，BeanFactory提供了配置框架和基本功能，而ApplicationContext添加了更多企业特定的功能。ApplicationContext是BeanFactory的一个完整超集，在本章描述Spring的IoC容器时仅使用它。有关使用BeanFactory而不是ApplicationContext的更多信息，请参见BeanFactory。

在Spring中，构成应用程序主干并由Spring IoC容器管理的对象称为bean。bean是由Spring IoC容器实例化、组装和管理的对象。否则，bean只是应用程序中的许多对象之一。bean及其之间的依赖关系反映在容器使用的配置元数据中。

1.2。集装箱概述
org.springframework.context。ApplicationContext接口表示Spring IoC容器，负责实例化、配置和组装bean。容器通过读取配置元数据获取关于要实例化、配置和组装哪些对象的指令。配置元数据用XML、Java注释或Java代码表示。它允许您表达组成应用程序的对象以及这些对象之间丰富的相互依赖关系。

Spring提供了ApplicationContext接口的几个实现。在独立应用程序中，通常创建ClassPathXmlApplicationContext或FileSystemXmlApplicationContext的实例。虽然XML一直是定义配置元数据的传统格式，但是您可以通过提供少量XML配置来声明支持这些额外的元数据格式，从而指示容器使用Java注释或代码作为元数据格式。

在大多数应用程序场景中，不需要显式用户代码来实例化Spring IoC容器的一个或多个实例。例如，在web应用程序场景中，在应用程序的web. XML文件中使用8行左右的简单样例web描述符XML就足够了(请参阅web应用程序的方便的ApplicationContext实例化)。如果使用Spring工具套件(一个eclipse支持的开发环境)，只需单击几下鼠标或按键，就可以轻松创建这个样板配置。

下图显示了Spring如何工作的高级视图。您的应用程序类与配置元数据相结合，这样，在创建并初始化ApplicationContext之后，您就拥有了一个完全配置的可执行系统或应用程序。

容器的魔法
图1所示。Spring IoC容器
1.2.1。配置元数据
如上图所示，Spring IoC容器使用一种配置元数据形式。此配置元数据表示作为应用程序开发人员，您如何告诉Spring容器实例化、配置和组装应用程序中的对象。

配置元数据通常以简单直观的XML格式提供，本章的大部分内容都使用这种格式来传达Spring IoC容器的关键概念和特性。

基于xml的元数据不是惟一允许的配置元数据形式。Spring IoC容器本身与实际编写配置元数据的格式完全解耦。现在，许多开发人员为他们的Spring应用程序选择基于java的配置。
有关在Spring容器中使用其他形式的元数据的信息，请参见:

基于注释的配置:Spring 2.5引入了对基于注释的配置元数据的支持。

基于java的配置:从Spring 3.0开始，Spring JavaConfig项目提供的许多特性成为Spring核心框架的一部分。因此，您可以使用Java而不是XML文件来定义应用程序类外部的bean。要使用这些新特性，请参见@Configuration、@Bean、@Import和@DependsOn注释。

Spring配置包含容器必须管理的至少一个bean定义，并且通常包含多个bean定义。基于xml的配置元数据将这些bean配置为顶级元素中的元素。Java配置通常在@Configuration类中使用@ bean注释的方法。

这些bean定义对应于组成应用程序的实际对象。通常，您定义服务层对象、数据访问对象(DAOs)、表示对象(如Struts操作实例)、基础设施对象(如Hibernate SessionFactories)、JMS队列等等。通常，不会在容器中配置细粒度域对象，因为通常由dao和业务逻辑负责创建和加载域对象。不过，您可以使用Spring与AspectJ的集成来配置在IoC容器控制之外创建的对象。请参阅使用AspectJ使用Spring来依赖注入域对象。

下面的例子展示了基于xml的配置元数据的基本结构:

< ?xml version = " 1.0 " encoding = " utf - 8 " ? >
< bean xmlns = " http://www.springframework.org/schema/beans "
xmlns: xsi = " http://www.w3.org/2001/XMLSchema-instance "
xsi: schemaLocation = " http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd " >

< bean id = "…" class = "…" >
< !——协作者和这个bean的配置到这里——>
< /豆>

< bean id = "…" class = "…" >
< !——协作者和这个bean的配置到这里——>
< /豆>

< !——更多的bean定义在这里——>

< /豆>

id属性是标识单个bean定义的字符串。
class属性定义bean的类型并使用完全限定的类名。
id属性的值引用协作对象。本例中没有显示用于引用协作对象的XML。有关更多信息，请参见依赖项。

1.2.2。实例化一个容器
提供给ApplicationContext构造函数的位置路径或路径是资源字符串，允许容器从各种外部资源(如本地文件系统、Java类路径等)加载配置元数据。

ApplicationContext = new ClassPathXmlApplicationContext(“services”)。xml”、“daos.xml”);
在了解了Spring的IoC容器之后，您可能想了解更多关于Spring的资源抽象(如参考资料中所述)的信息，它提供了一种方便的机制，可以从URI语法中定义的位置读取InputStream。特别是，资源路径用于构造应用程序上下文，如应用程序上下文和资源路径中所述。
下面的示例显示了服务层对象(services.xml)配置文件:

< ?xml version = " 1.0 " encoding = " utf - 8 " ? >
< bean xmlns = " http://www.springframework.org/schema/beans "
xmlns: xsi = " http://www.w3.org/2001/XMLSchema-instance "
xsi: schemaLocation = " http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd " >

< !- - -服务- - - >

< bean id = " petStore " class = " org.springframework.samples.jpetstore.services.PetStoreServiceImpl " >
<属性名= " accountDao“ref = " accountDao " / >
<属性名= " itemDao“ref = " itemDao " / >
< !——这个bean的其他合作者和配置到这里——>
< /豆>

< !——服务的更多bean定义在这里——>

< /豆>

下面的例子展示了数据访问对象daos.xml文件:

< ?xml version = " 1.0 " encoding = " utf - 8 " ? >
< bean xmlns = " http://www.springframework.org/schema/beans "
xmlns: xsi = " http://www.w3.org/2001/XMLSchema-instance "
xsi: schemaLocation = " http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd " >

< bean id = " accountDao "
类= " org.springframework.samples.jpetstore.dao.jpa.JpaAccountDao " >
< !——这个bean的其他合作者和配置到这里——>
< /豆>

< bean id = " itemDao " class = " org.springframework.samples.jpetstore.dao.jpa.JpaItemDao " >
< !——这个bean的其他合作者和配置到这里——>
< /豆>

< !——更多数据访问对象的bean定义到这里——>

< /豆>

在前面的示例中，服务层由PetStoreServiceImpl类和JpaAccountDao和JpaItemDao类型的两个数据访问对象(基于JPA对象关系映射标准)组成。property name元素引用JavaBean属性的名称，ref元素引用另一个bean定义的名称。id和ref元素之间的这种链接表示协作对象之间的依赖关系。有关配置对象依赖项的详细信息，请参见依赖项。

组合基于xml的配置元数据

让bean定义跨多个XML文件是很有用的。通常，每个单独的XML配置文件表示体系结构中的逻辑层或模块。

您可以使用应用程序上下文构造函数从所有这些XML片段加载bean定义。这个构造函数接受多个资源位置，如前一节所示。或者，使用一个或多个出现的元素从另一个或多个文件加载bean定义。下面的例子说明了如何做到这一点:

< bean >
<进口资源= " xml " / >
<进口资源= "资源/ messageSource.xml " / >
<进口资源= " /资源/ themeSource.xml " / >

< bean id = " bean1 " class = "…" / >
< bean id = " bean2 " class = "…" / >
< /豆>

在前面的示例中，外部bean定义从三个文件加载:服务。xml, messageSource。xml和themeSource.xml。所有位置路径都相对于执行导入的定义文件，因此services.xml必须与执行导入的文件位于相同的目录或类路径位置，而messageSource.xml和themeSource.xml必须位于导入文件位置下方的resources位置。可以看到，前面的斜杠被忽略了。但是，由于这些路径是相对的，所以最好不要使用斜杠。根据Spring模式，导入的文件的内容，包括顶层元素，必须是有效的XML bean定义。

它是可能的，但不推荐，在父目录中引用文件使用一个相对"…/”路径。这样做会创建对当前应用程序外部文件的依赖。特别地，这个引用不推荐用于类路径url(例如，类路径:…/services.xml)，其中运行时解析过程选择“最近的”类路径根，然后查看其父目录。类路径配置更改可能导致选择不同的、不正确的目录。

您总是可以使用完全限定的资源位置，而不是相对路径:例如，file:C:/config/services.xml或类路径:/config/services.xml。但是，请注意，您正在将应用程序的配置耦合到特定的绝对位置。通常更可取的做法是为这些绝对位置保留一个间接的位置——例如，通过“${…}”占位符，这些占位符在运行时根据JVM系统属性解析。
名称空间本身提供导入指令特性。除了普通bean定义之外，Spring提供的XML名称空间的选择还提供了其他配置特性——例如上下文和util名称空间。

Groovy Bean定义DSL

作为外部化配置元数据的另一个示例，bean定义也可以用Spring的Groovy bean定义DSL表示，Grails框架中有这样的定义。通常，这样的配置位于“。文件，其结构如下例所示:

豆子{
数据源(BasicDataSource) {
driverClassName = " org.hsqldb.jdbcDriver "
url = " jdbc: hsqldb: mem: grailsDB”
用户名= "山"
密码= " "
设置= [mynew:“设置”)
}
sessionFactory (sessionFactory) {
数据源=数据源
}
myService (myService) {
nestedBean ={另一个bean bean ->
数据源=数据源
}
}
}

这种配置风格在很大程度上等同于XML bean定义，甚至支持Spring的XML配置名称空间。它还允许通过importBeans指令导入XML bean定义文件。

1.2.3。使用集装箱
ApplicationContext是高级工厂的接口，该工厂能够维护不同bean及其依赖项的注册表。通过使用方法T getBean(String name, Class requiredType)，可以检索bean的实例。

ApplicationContext允许您读取bean定义并访问它们，如下面的示例所示:

//创建和配置bean
ApplicationContext = new ClassPathXmlApplicationContext(“services”)。xml”、“daos.xml”);

//检索已配置的实例
PetStoreService服务=上下文。getBean (“petStore PetStoreService.class);

//使用已配置的实例
List<String> userList = service.getUsernameList();

对于Groovy配置，引导看起来非常类似。它有一个不同的上下文实现类，它支持groovy(但也理解XML bean定义)。下面的示例显示了Groovy配置:

ApplicationContext = new GenericGroovyApplicationContext(“services”)。groovy”、“daos.groovy”);

最灵活的变体是GenericApplicationContext与reader委托相结合——例如，使用XmlBeanDefinitionReader来处理XML文件，如下例所示:

GenericApplicationContext = new GenericApplicationContext();
新XmlBeanDefinitionReader(上下文).loadBeanDefinitions(“服务。xml”、“daos.xml”);
context.refresh ();

您还可以对Groovy文件使用GroovyBeanDefinitionReader，如下面的示例所示:

GenericApplicationContext = new GenericApplicationContext();
新GroovyBeanDefinitionReader(上下文).loadBeanDefinitions(“服务。groovy”、“daos.groovy”);
context.refresh ();

您可以在相同的ApplicationContext上混合和匹配这样的reader委托，从不同的配置源读取bean定义。

然后可以使用getBean检索bean的实例。ApplicationContext接口还有一些用于检索bean的其他方法，但在理想情况下，应用程序代码不应该使用它们。实际上，您的应用程序代码应该完全不调用getBean()方法，因此完全不依赖于Spring api。例如，Spring与web框架的集成为各种web框架组件(如控制器和jsf管理的bean)提供了依赖注入，允许您通过元数据(如自动装配注释)声明对特定bean的依赖。

1.3。豆概述
Spring IoC容器管理一个或多个bean。这些bean是使用您提供给容器的配置元数据创建的(例如，以XML 定义的形式)。

在容器内部，这些bean定义被表示为BeanDefinition对象，其中包含(其他信息)以下元数据:

包限定的类名:通常，定义bean的实际实现类。

Bean行为配置元素，它声明Bean在容器中的行为(范围、生命周期回调，等等)。

对bean执行其工作所需的其他bean的引用。这些引用也称为协作者或依赖项。

要在新创建的对象中设置的其他配置设置—例如，池的大小限制或在管理连接池的bean中使用的连接数。

此元数据转换为组成每个bean定义的一组属性。下表描述了这些属性:

表1。bean定义
属性解释……
类
实例化bean
名字
命名bean
范围
豆范围
构造函数参数
依赖注入
属性
依赖注入
自动装配模式
自动装配的合作者
延迟初始化模式
延迟初始化的豆子
初始化方法
初始化回调
破坏的方法
破坏回调
除了包含关于如何创建特定bean的信息的bean定义之外，ApplicationContext实现还允许注册(由用户)在容器外部创建的现有对象。通过getBeanFactory()方法访问ApplicationContext的BeanFactory，该方法返回BeanFactory DefaultListableBeanFactory实现。DefaultListableBeanFactory通过registerSingleton(…)和registerBeanDefinition(…)方法支持这种注册。然而，典型的应用程序只使用通过常规bean定义元数据定义的bean。

Bean元数据和手动提供的单例实例需要尽早注册，以便容器在自动装配和其他内省步骤中正确地推断它们。虽然在某种程度上支持覆盖现有的元数据和现有的单例实例，但是在运行时注册新bean(与对工厂的实时访问同时进行)并不是官方支持的，并且可能会导致并发访问异常、bean容器中不一致的状态，或者两者兼有。
1.3.1。命名bean
每个bean都有一个或多个标识符。这些标识符在承载bean的容器中必须是惟一的。bean通常只有一个标识符。但是，如果需要多个别名，则可以将额外的别名视为别名。

在基于xml的配置元数据中，可以使用id属性、name属性或两者都使用来指定bean标识符。id属性允许您只指定一个id。通常，这些名称是字母数字(‘myBean’、'someService’等)，但它们也可以包含特殊字符。如果希望为bean引入其他别名，还可以在name属性中指定它们，以逗号(、)、分号(;)或空格分隔。作为历史记录，在Spring 3.1之前的版本中，id属性被定义为xsd: id类型，这限制了可能的字符。从3.1开始，它被定义为xsd:string类型。注意，bean id惟一性仍然由容器执行，但不再由XML解析器执行。

您不需要为bean提供名称或id。如果不显式提供名称或id，容器将为该bean生成唯一的名称。但是，如果您希望通过名称引用该bean，通过使用ref元素或服务定位器样式查找，您必须提供一个名称。不提供名称的动机与使用内部bean和自动装配协作者有关。

豆命名约定
约定是在为bean命名时使用标准Java约定作为实例字段名。也就是说，bean名称以小写字母开头，并从那里开始采用驼峰大小写。此类名称的示例包括accountManager、accountService、userDao、loginController等等。

一致地命名bean使您的配置更容易阅读和理解。另外，如果您使用Spring AOP，当您将建议应用到一组按名称关联的bean时，它会提供很大的帮助。
通过在类路径中扫描组件，Spring按照前面描述的规则为未命名的组件生成bean名称:本质上，使用简单的类名并将其初始字符转换为小写。但是，在(不寻常的)特殊情况下，如果有多个字符，并且第一个和第二个字符都是大写的，则保留原来的大小写。这些规则与java.bean .自省器.decapitalize (Spring在这里使用)定义的规则相同。

在Bean定义之外别名化Bean

在bean定义本身中，可以使用id属性指定的最多一个名称和name属性中任意数量的其他名称的组合，为bean提供多个名称。这些名称可以是相同bean的等价别名，在某些情况下非常有用，比如通过使用特定于该组件本身的bean名称，让应用程序中的每个组件引用公共依赖项。

但是，指定实际定义bean的所有别名并不总是足够的。有时需要为在其他地方定义的bean引入别名。在大型系统中，配置通常在每个子系统之间进行划分，每个子系统都有自己的一组对象定义。在基于xml的配置元数据中，可以使用元素来完成此任务。下面的例子说明了如何做到这一点:

<别名= " fromName "别名" toName " / >

在这种情况下，在使用别名定义之后，名为fromName的bean(在同一个容器中)也可以称为toName。

例如，子系统A的配置元数据可以通过子系统-数据源的名称引用数据源。子系统B的配置元数据可以通过子系统-数据源的名称引用数据源。在组合使用这两个子系统的主应用程序时，主应用程序通过myApp-dataSource的名称引用数据源。要使所有三个名称都引用同一个对象，可以将以下别名定义添加到配置元数据中:

= <别名= " myApp-dataSource "别名" subsystemA-dataSource " / >
= <别名= " myApp-dataSource "别名" subsystemB-dataSource " / >

现在，每个组件和主应用程序都可以通过惟一的名称引用数据源，并且保证不会与任何其他定义冲突(有效地创建名称空间)，但是它们引用的是同一个bean。

java配置
如果使用Javaconfiguration，可以使用@Bean注释提供别名。有关详细信息，请参见使用@Bean注释。
1.3.2。实例化bean

bean定义本质上是创建一个或多个对象的诀窍。当被询问时，容器会查看命名bean的配方，并使用该bean定义封装的配置元数据来创建(或获取)一个实际对象。

如果使用基于xml的配置元数据，则指定要在元素的class属性中实例化的对象的类型(或类)。这个类属性(在内部是BeanDefinition实例上的一个类属性)通常是强制性的。(有关异常，请参见使用实例工厂方法和Bean定义继承进行实例化。)您可以通过以下两种方式之一使用Class属性:

通常，在容器本身通过反射调用其构造函数直接创建bean的情况下，指定要构造的bean类，这有点类似于使用新操作符的Java代码。

要指定包含创建对象时调用的静态工厂方法的实际类，在容器调用类上的静态工厂方法来创建bean的不太常见的情况下。从静态工厂方法调用返回的对象类型可以是同一个类，也可以完全是另一个类。

内部类的名字
如果要为静态嵌套类配置bean定义，必须使用嵌套类的二进制名称。

例如，如果您在com中有一个类名为SomeThing。这个类有一个静态的嵌套类叫做OtherThing, bean定义上的class属性的值是com。example。SomeThing$OtherThing。

注意，在名称中使用$字符将嵌套的类名与外部类名分隔开。
使用构造函数实例化

当您使用构造函数方法创建bean时，所有的普通类都可以被Spring使用并与Spring兼容。也就是说，正在开发的类不需要实现任何特定的接口或以特定的方式编码。只需指定bean类就足够了。但是，根据您为特定bean使用的IoC类型，您可能需要一个默认(空)构造函数。

Spring IoC容器几乎可以管理您希望它管理的任何类。它不仅限于管理真正的javabean。大多数Spring用户更喜欢实际的javabean，它只有一个默认(无参数)构造函数，以及根据容器中的属性建模的适当的setter和getter。您还可以在容器中包含更多非bean样式的类。例如，如果您需要使用完全不符合JavaBean规范的遗留连接池，Spring也可以管理它。

使用基于xml的配置元数据，您可以指定您的bean类如下:

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

< bean name = " anotherExample " class = " examples.ExampleBeanTwo " / >
有关向构造函数提供参数(如果需要)和在构造对象之后设置对象实例属性的机制的详细信息，请参阅注入依赖项。

使用静态工厂方法实例化

在定义使用静态工厂方法创建的bean时，使用class属性指定包含静态工厂方法的类，使用factory-method属性指定工厂方法本身的名称。您应该能够调用这个方法(带有可选参数，如后面所述)并返回一个活动对象，随后将其视为通过构造函数创建的。这种bean定义的一个用途是在遗留代码中调用静态工厂。

下面的bean定义指定通过调用工厂方法创建bean。定义没有指定返回对象的类型(类)，只指定包含工厂方法的类。在本例中，createInstance()方法必须是一个静态方法。下面的例子展示了如何指定工厂方法:

测试

模拟对象，TestContext框架，Spring MVC测试，WebTestClient。

数据访问

事务、DAO支持、JDBC、O/R映射、XML编组。

Web Servlet

Spring MVC, WebSocket, SockJS, STOMP消息。

网络无功

Spring WebFlux, WebClient, WebSocket。

集成

远程，JMS, JCA, JMX，电子邮件，任务，调度，缓存。

语言

Kotlin, Groovy，动态语言。

弹簧引导参考指南

下一个
弹簧引导参考指南

作者
菲利普·韦伯,戴夫Syer,杰克长,Stephane Nicoll Rob绞车安迪·威尔金森Marcel Overdijk,基督教Dupuis Sebastien德勒兹迈克尔•西蒙斯Vedran Pavić,杰伊·科比,Madhura Bhave
2.1.7.RELEASE

表的内容

一、Spring引导文档

关于该文档
得到帮助
3.第一步
使用弹簧启动
了解Spring引导特性
搬到生产
高级的主题
二世。开始
引入弹簧引导
系统需求
9.1。Servlet容器
安装弹簧引导
10.1。Java开发人员的安装说明
大家。Maven安装
10.1.2。Gradle安装
10.2。安装Spring Boot CLI
10.2.1。手动安装
10.2.2。安装与SDKMAN !
10.2.3。OSX自制程序安装
10.2.4。MacPorts安装
10.2.5。命令行完成
10.2.6。Windows勺安装
10.2.7。快速启动Spring CLI示例
10.3。从较早版本的Spring Boot升级
开发您的第一个Spring引导应用程序
11.1。创建POM
11.2。添加类路径依赖
11.3。编写代码
11.3.1。@RestController和@RequestMapping注释
11.3.2。@EnableAutoConfiguration注释
11.3.3。“主要”方法
11.4。运行这个例子
11.5。创建一个可执行Jar
接下来要读什么
三世。使用Spring的引导
构建系统
13.1。依赖关系管理
13.2。Maven
13.2.1。继承启动父级
13.2.2。在没有父POM的情况下使用Spring Boot
13.2.3。使用Spring Boot Maven插件
13.3。Gradle
13.4。蚂蚁
13.5。刚开始的时候
构建你的代码
14.1。使用“默认”包
14.2。定位主应用程序类
配置类
15.1。导入其他配置类
15.2。导入XML配置
的自动
16.1。逐渐取代自动配置
16.2。禁用特定的自动配置类
Spring bean和依赖项注入
使用@SpringBootApplication注释
运行您的应用程序
19.1。从IDE运行
19.2。作为打包的应用程序运行
19.3。使用Maven插件
19.4。使用Gradle插件
19.5。热插拔
20.开发人员工具
20.1。属性默认值
20.2。自动重启
20.2.1。记录条件评估中的变化
20.2.2。不包括资源
20.2.3。看更多的路径
20.2.4。禁用重启
20.2.5。使用触发器文件
20.2.6。自定义重新启动类加载器
20.2.7。已知的限制
20.3。LiveReload
20.4。全局设置
20.5。远程应用程序
20.5.1。运行远程客户机应用程序
20.5.2。远程更新
打包您的生产应用程序
接下来要读什么
四、春季开机功能
SpringApplication
23.1。启动失败
23.2。自定义横幅
23.3。定制SpringApplication
23.4。流利的构建器API
23.5。应用程序事件和监听器
23.6。网络环境
23.7。访问应用程序参数
23.8。使用ApplicationRunner或CommandLineRunner
23.9。应用程序退出
23.10。管理功能
外部化配置
24.1。配置随机值
24.2。访问命令行属性
24.3。应用程序属性文件
24.4。特殊概要文件的属性
24.5。占位符的属性
24.6。加密属性
24.7。使用YAML而不是属性
24.7.1。加载YAML
24.7.2。在Spring环境中将YAML作为属性公开
24.7.3。Multi-profile YAML文件
24.7.4。YAML的缺点
24.8。类型安全的配置属性
24.8.1。第三方配置
24.8.2。轻松绑定
24.8.3。合并复杂类型
24.8.4。属性转换
转换时间
转换数据大小
24.8.5。@ConfigurationProperties验证
24.8.6。@ConfigurationProperties与@ value
配置文件
25.1。添加活动概要
25.2。以编程方式设置配置文件
25.3。特殊概要文件的配置文件
日志记录
26.1。日志格式
26.2。控制台输出
26.2.1。彩色编码输出
26.3。文件输出
26.4。日志级别
26.5。日志组
26.6。自定义日志配置
26.7。Logback扩展
26.7.1。特殊概要文件配置
26.7.2。环境属性
国际化
JSON
28.1。杰克逊
28.2。Gson
28.3。JSON-B
开发Web应用程序
29.1。“Spring Web MVC框架”
29.1.1。Spring MVC的自动
29.1.2。HttpMessageConverters
29.1.3。自定义JSON序列化器和反序列化器
29.1.4。MessageCodesResolver
29.1.5。静态内容
29.1.6。欢迎页面
29.1.7。自定义图标
29.1.8。路径匹配和内容协商
29.1.9。ConfigurableWebBindingInitializer
29.1.10。模板引擎
29.1.11。错误处理
自定义错误页面
映射错误页面