博客分类：
由于多个项目之中有很多重复的内容，在做新项目的时候需要复制粘贴很多重复的东西。所以需要对项目进行重构进行依赖。
项目是用maven进行构建和管理的，所以先进行父子项目划分，然后抽离公用部分，新建项目的时候直接依赖。项目结构为一个父项目，之下若干子项目，子项目有util，dao，controller，web等项目。web项目为前端页面，单独提供给FE做开发用，这样多个web项目可以共用一套后台逻辑。
项目mvc是用的WF框架，底层是依赖spring-context和spring-webmvc，然后做了一下封装。所以根本上还是和springmvc的使用无异。
但是在实验的过程中发现项目不能正常启动，bean没有被注入。进行测试发现，如果controller和web分离的话bean没有注入，但是合并却可以，因为web项目是依赖的controller项目，最终项目build之后controller项目被打成jar放入web项目的lib中。而对于controller的扫描是用的component-scan方式，因此问题就变成了spring不能scan到jar中bean。
对于引入applicationContext.xml配置文件的两种方式：
classpath*:applicationContext.xml
会加入本项目及所有jar包根目录下的applicationContext.xml文件，跨jar包依赖时使用
classpath:applicationContext.xml
只加入本项目根目录下的applicationContext.xml文件，不依赖其它jar包的配置文件时可以这样写
WF框架初始化spring的bean容器不是由使用者配置启动的，而是使用web-fragment新特性，在项目启动时自动进行一系列的初始化（这一点感觉很shit）。查看源代码发现启动时也是用的classpath*这种方式，按理说是可以搜索到所有jar中的applicationContext.xml。但是在WF框架中applicationContext.xml配置文件不是在项目的根目录中，而是在依赖WF的相关jar中的。研究spring初始化bean的过程发现，在最终扫描.class并进行初始化的过程是用getClassLoader().getResources("")的方式获取Resource对象的，而对于这种方式，是只能获取当前classpath中的文件的。这个classpath是相对于applicationContext.xml来说的，也就是说applicationContext.xml位于哪里，就会加载到该项目的classpath，并不能跨jar进行。
于是将applicationContext.xml文件拷贝一份放到controller项目的classpath中，重新启动项目，果然可以了，所有的bean被初始化。
关于spring的component-scan扫描初始化bean的过程可以参见这篇博客
http://www.it165.net/pro/html/05.html
浏览: 26131 次
来自: 北京
jerrynbcl 写道我也是碰到这问题，在控制层加事务的注解 ...
我也是碰到这问题，在控制层加事务的注解没有生效，如果不加ser ...
为啥我看不懂
感觉还可以
很不错的例子，一步一步来，基本功能已经实现2622人阅读
spring boot（19）
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-parent&/artifactId&
&version&1.5.2.RELEASE&/version&
&dependencies&
&dependency&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-web&/artifactId&
&/dependency&
&/dependencies&
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
@SpringBootApplication
public class Run{
public static void main(String[] args) throws Exception {
SpringApplication.run(Run.class, args);
这个Run是一个单独的项目启动类，这里不应该有业务功能，上一篇的hello world业务代码应该写在一个单独的@Controller里面，和上一篇相比，这里用@SpringBootApplication替换了@EnableAutoConfiguration。
@SpringBootApplication
@EnableAutoConfiguration：只是实现自动配置一个功能，具体参考上一篇
@SpringBootApplication：是一个组合注解，包括@EnableAutoConfiguration及其他多个注解，是一个项目的启动注解
在eclipse的代码中 按 crtl+左键 点击@SpringBootApplication注解可以查看他的源码，如下
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication
前四个注解：是元注解，用来修饰当前注解，就像public类的修饰词，没有实际功能，如果不打算写自定义注解，不需要了解
后三个注解：是真正起作用的注解，包括
@SpringBootConfiguration：当前类是一个配置类，就像xml配置文件，而现在是用java配置文件，效果是一样的
@EnableAutoConfiguration：上篇已经讲了
@ComponentScan：用注解配置实现自动扫描，默认会扫描当前包和所有子包，和xml配置自动扫描效果一样，@Filter是排除了两个系统类
@SpringBootConfiguration和@Bean
import org.springframework.boot.SpringBootC
import org.springframework.context.annotation.B
@SpringBootConfiguration
public class Config {
public String hello(){
return &Hello World&;
@SpringBootConfiguration：说明这是一个配置文件类，它会被@ComponentScan扫描到
@Bean：就是在spring容器中声明了一个bean，赋值为hello world，String方法类型就是bean的类型，hello方法名是bean的id
如果是用xml配置文件来声明bean，如下图
&bean id=&hello& class=&String&&&/bean&
SampleController.java
import org.springframework.beans.factory.annotation.A
import org.springframework.stereotype.*;
import org.springframework.web.bind.annotation.*;
@Controller
public class SampleController {
@Autowired
@RequestMapping(value=&/&)
@ResponseBody
String test(){
把hello world业务功能独立出来，在这里注入了spring容器中的那个String类型的Bean，并且打印到页面
现在的项目结构如下，共三个文件
通过Run.java的main方法启动项目，访问


&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：51305次
排名：千里之外
原创：39篇
文章：20篇
阅读：20787
文章：19篇
阅读：28159
(4)(4)(4)(4)(4)(4)(4)(4)(6)(4)
(window.slotbydup = window.slotbydup || []).push({
id: '4740887',
container: s,
size: '250,250',
display: 'inlay-fix'博客分类：
随着Spring 4新版本的发布，Spring Boot这个新的子项目得到了广泛的关注，因为不管是Spring 4官方发布的新闻稿还是针对首席架构师Adrian Colyer的专访，都对这个子项目所带来的生产率提升赞誉有加。
Spring Boot充分利用了JavaConfig的配置模式以及“约定优于配置”的理念，能够极大的简化基于Spring MVC的Web应用和REST服务开发。
Spring 4倡导微服务的架构，针对这一理念，近来在微博上也有一些有价值的讨论，如这里和这里。微服务架构倡导将功能拆分到离散的服务中，独立地进行部署，Spring Boot能够很方便地将应用打包成独立可运行的JAR包，因此在开发模式上很契合这一理念。目前，Spring Boot依然是0.5.0的里程碑版本，因此相关的文档尚不完善，本文将会以一个简单的样例来介绍基于这个项目的开发过程。
要Spring Boot进行功能开发，需要使用Gradle或者Maven作为构建工具。在本例中，我们会使用Eclipse和Maven插件进行开发。要使用Spring Boot，首先创建一个Maven工程，并修改Maven主要的配置文件pom.xml，如下所示：
&properties&
&java.version&1.7&/java.version&
&start-class&com.test.springboot.Startup&/start-class&
&/properties&
&!-- Inherit defaults from Spring Boot --&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-parent&/artifactId&
&version&1.0.1.RELEASE&/version&
&!-- Add typical dependencies for a web application --&
&dependencies&
&dependency&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-web&/artifactId&
&/dependency&
&/dependencies&
&pluginManagement&
&artifactId&maven-compiler-plugin&/artifactId&
&configuration&
&source&1.7&/source&
&target&1.7&/target&
&/configuration&
&/plugins&
&/pluginManagement&
&repositories&
&repository&
&id&spring-snapshots&/id&
&url&http://repo.spring.io/snapshot&/url&
&snapshots&
&enabled&true&/enabled&
&/snapshots&
&/repository&
&repository&
&id&spring-milestones&/id&
&url&http://repo.spring.io/milestone&/url&
&/repository&
&/repositories&
&pluginRepositories&
&pluginRepository&
&id&spring-snapshots&/id&
&url&http://repo.spring.io/snapshot&/url&
&/pluginRepository&
&pluginRepository&
&id&spring-milestones&/id&
&url&http://repo.spring.io/milestone&/url&
&/pluginRepository&
&/pluginRepositories&
在上面的配置中，需要将工程的parent设置为spring-boot-starter-parent，并添加对spring-boot-starter-web的依赖，这样我们就无需设置各个依赖项及其版本信息了。并且在构建中要声明使用spring-boot-maven-plugin这个插件，它会对Maven打包形成的JAR进行二次修改，最终产生符合我们要求的内容结构。
在我们的应用中将要发布一个REST服务，显示一个基本的用户信息，首先定义一个简单的模型类：
public class User {
public Long getId() {
public void setId(Long id) {
public String getName() {
public void setName(String name) {
this.name =
接下来，我们需要声明一个Spring MVC的Controller，响应对实体的请求：
//@EnableAutoConfiguration
@RestController
@RequestMapping("/user")
public class UserController {
@RequestMapping("/{id}")
public User view(@PathVariable("id") Long id) {
User user = new User();
user.setId(id);
user.setName("zhang");
//public static void main(String[] args) {
SpringApplication.run(UserController.class);
这个类与我们在使用Spring MVC定义Controller时并无任何差别。接下来，我们需要声明一个主类启动这个应用程序：
@Configuration
@ComponentScan
@EnableAutoConfiguration
public class Startup {
public static void main(String[] args) {
SpringApplication app = new SpringApplication(Startup.class);
app.setWebEnvironment(true);
app.setShowBanner(false);
Set&Object& set = new HashSet&Object&();
//set.add("classpath:applicationContext.xml");
app.setSources(set);
app.run(args);
这个类的main方法中使用了SpringApplication帮助类，并以Application这个类作为配置来启动Spring的应用上下文。在这个类中使用了ComponentScan以及EnableAutoConfiguration注解，其中ComponentScan注解会告知Spring扫描指定的包来初始化Spring Bean，这能够确保我们声明的Bean能够被发现。EnableAutoConfiguration将会启动自动配置模式，在我们的配置中会将对Tomcat的依赖级联进来，因此在应用启动时将会自动启动一个嵌入式的Tomcat，因为在样例中使用了Spring MVC，所以也会自动注册所需的DispatcherServlet，这都不需要类似web.xml这样的配置。在Eclipse中要运行这个应用的话，可以直接以Java Application的形式来运行这个main函数，此时会启动应用，我们在浏览器中可以看到如下的运行效果，这就是我们想要的REST服务：
在开发调试完成之后，可以将应用打成JAR包的形式，在Eclipse中可以直接使用Maven插件的package命令，最终会形成一个可运行的JAR包。我们使用java –jar命令就可以运行这个JAR包了。Myeclipse的Maven的package请参考（ ）所呈现出的效果与在调试期是一样的。现在看一下这个JAR包解压后的目录结构：
这个JAR包与传统JAR包的不同之处在于里面有一个名为lib的目录，在这个目录中包含了这个简单应用所依赖的其他JAR包，其中也包含内置的嵌入式Tomcat，正是使用它，才能发布服务和访问Web资源。除了我们编写的源码所编译形成的CLASS以外，在org目录下还有许多Spring所提供的CLASS，正是依赖这些CLASS，才能够加载位于lib目录下JAR中的类。这样的加载机制与在OSGi bundle中声明Bundle-Classpath很类似，不过在OSGi中会由容器来负责加载指定路径下的类。这大致阐述了这样一个JAR包能够发布服务的原因。
如果我们想要使用HTML、JSP等Web资源的话，在Controller中直接返回对应的视图就可以了。
如果我们想要将这个JAR包转换成可以在Servlet容器中部署的WAR的话，就不能依赖于Application的main函数了，而是要以类似于web.xml文件配置的方式来启动Spring应用上下文，此时我们需要声明这样一个类：
public class HelloWebXml extends SpringBootServletInitializer {
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(Application.class);
这个类的作用与在web.xml中配置负责初始化Spring应用上下文的监听器作用类似，只不过在这里不需要编写额外的XML文件了。
如果要将最终的打包形式改为WAR的话，还需要对pom.xml文件进行修改，除了需要将packaging的值修改为war以外，还需要对依赖进行适当的配置（这一部分在Spring Boot的样例和文档中均未提及，提醒大家注意）：
&dependency&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-web&/artifactId&
&exclusions&
&exclusion&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-tomcat&/artifactId&
&/exclusion&
&/exclusions&
&/dependency&
在这里需要移除对嵌入式Tomcat的依赖，这样打出的WAR包中，在lib目录下才不会包含Tomcat相关的JAR包，否则将会出现启动错误。另外，在移除对Tomcat的依赖后，为了保证编译正确，还需要添加对servlet-api的依赖，因此添加如下的配置：
&dependency&
&groupId&org.apache.tomcat&/groupId&
&artifactId&tomcat-servlet-api&/artifactId&
&version&7.0.42&/version&
&scope&provided&/scope&
&/dependency&
在这里将scope属性设置为provided，这样在最终形成的WAR中不会包含这个JAR包，因为Tomcat或Jetty等服务器在运行时将会提供相关的API类。此时，执行mvn package命令就会得到一个WAR文件，我们可以直接将其放到Tomcat下运行（需要7.0.42版本以上）。
以上介绍了基于Spring Boot开发应用的过程，目前它的文档尚不完善，但是在GitHub上有不少的样例，包括与Spring Data集成访问数据库（关系型以及非关系型）、安全、WebSocket等，读者感兴趣可以下载运行。
基于以上的介绍，希望读者能够对Spring Boot这个新项目有所了解。它简化了JAR包管理和相关基础设施环境的配置，能够帮助我们快速开发Web应用或构建REST服务，希望它能够尽快完善成熟，更多地用于实践，提升开发效率。
浏览 66348
浏览: 279552 次
来自: 北京
&artifactId&maven-compile ...
说明下&start-class&com.test. ...
学习了,感谢了
执行mvn clean install spring-boot ...
请问，filter.c是做什么模块？作用是什么？我的解压出来是 ...spring boot application properties配置详解_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
spring boot application properties配置详解
阅读已结束，下载文档到电脑
想免费下载更多文档？
定制HR最喜欢的简历
下载文档到电脑，方便使用
还剩9页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢当前位置浏览文章
前言前面几章我们见识了SpringBoot为我们做的自动配置，确实方便快捷，但是对于新手来说，如果不大懂SpringBoot内部启动原理，以后难免会吃亏。所以这次博主就跟你们一起一步步揭开SpringBoot的神秘面纱，让它不在神秘。正文我们开发任何一个Spring Boot项目，都会用到如下的启动类@SpringBootApplicationpublic class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}}从上面代码可以看出，Annotation定义（@SpringBootApplication）和类定义（SpringApplication.run）最为耀眼，所以要揭开SpringBoot的神秘面纱，我们要从这两位开始就可以了。SpringBootApplication背后的秘密@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented@Inherited@SpringBootConfiguration@EnableAutoConfiguration@ComponentScan(excludeFilters = {
@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })public @interface SpringBootApplication {...}虽然定义使用了多个Annotation进行了原信息标注，但实际上重要的只有三个Annotation：@Configuration（@SpringBootConfiguration点开查看发现里面还是应用了@Configuration）@EnableAutoConfiguration@ComponentScan所以，如果我们使用如下的SpringBoot启动类，整个SpringBoot应用依然可以与之前的启动类功能对等：@Configuration@EnableAutoConfiguration@ComponentScanpublic class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}}每次写这3个比较累，所以写一个@SpringBootApplication方便点。接下来分别介绍这3个Annotation。@Configuration这里的@Configuration对我们来说不陌生，它就是JavaConfig形式的Spring Ioc容器的配置类使用的那个@Configuration，SpringBoot社区推荐使用基于JavaConfig的配置形式，所以，这里的启动类标注了@Configuration之后，本身其实也是一个IoC容器的配置类。举几个简单例子回顾下，XML跟config配置方式的区别：表达形式层面基于XML配置的方式是这样：&?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"
default-lazy-init="true"&
&!--bean定义--&&/beans&而基于JavaConfig的配置方式是这样：@Configurationpublic class MockConfiguration{
//bean定义}任何一个标注了@Configuration的Java类定义都是一个JavaConfig配置类。注册bean定义层面基于XML的配置形式是这样：&bean id="mockService" class="..MockServiceImpl"&
...&/bean&而基于JavaConfig的配置形式是这样的：@Configurationpublic class MockConfiguration{
public MockService mockService(){
return new MockServiceImpl();
}}任何一个标注了@Bean的方法，其返回值将作为一个bean定义注册到Spring的IoC容器，方法名将默认成该bean定义的id。表达依赖注入关系层面为了表达bean与bean之间的依赖关系，在XML形式中一般是这样：&bean id="mockService" class="..MockServiceImpl"&
&propery name ="dependencyService" ref="dependencyService" /&&/bean&&bean id="dependencyService" class="DependencyServiceImpl"&&/bean&而基于JavaConfig的配置形式是这样的：@Configurationpublic class MockConfiguration{
public MockService mockService(){
return new MockServiceImpl(dependencyService());
public DependencyService dependencyService(){
return new DependencyServiceImpl();
}}如果一个bean的定义依赖其他bean,则直接调用对应的JavaConfig类中依赖bean的创建方法就可以了。@ComponentScan@ComponentScan这个注解在Spring中很重要，它对应XML配置中的&context:component-scan&元素，@ComponentScan的功能其实就是自动扫描并加载符合条件的组件（比如@Component和@Repository等）或者bean定义，最终将这些bean定义加载到IoC容器中。我们可以通过basePackages等属性来细粒度的定制@ComponentScan自动扫描的范围，如果不指定，则默认Spring框架实现会从声明@ComponentScan所在类的package进行扫描。注：所以SpringBoot的启动类最好是放在root package下，因为默认不指定basePackages。@EnableAutoConfiguration个人感觉@EnableAutoConfiguration这个Annotation最为重要，所以放在最后来解读，大家能否还记得Spring框架提供的各种名字为@Enable开头的Annotation定义？比如@EnableScheduling、@EnableCaching、@EnableMBeanExport等，@EnableAutoConfiguration的理念和做事方式其实一脉相承，简单概括一下就是，借助@Import的支持，收集和注册特定场景相关的bean定义。@EnableScheduling是通过@Import将Spring调度框架相关的bean定义都加载到IoC容器。@EnableMBeanExport是通过@Import将JMX相关的bean定义加载到IoC容器。而@EnableAutoConfiguration也是借助@Import的帮助，将所有符合自动配置条件的bean定义加载到IoC容器，仅此而已！@EnableAutoConfiguration作为一个复合Annotation,其自身定义关键信息如下：@SuppressWarnings("deprecation")@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented@Inherited@AutoConfigurationPackage@Import(EnableAutoConfigurationImportSelector.class)public @interface EnableAutoConfiguration {
...}其中，最关键的要属@Import(EnableAutoConfigurationImportSelector.class)，借助EnableAutoConfigurationImportSelector，@EnableAutoConfiguration可以帮助SpringBoot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IoC容器。就像一只“八爪鱼”一样借助于Spring框架原有的一个工具类：SpringFactoriesLoader的支持，@EnableAutoConfiguration可以智能的自动配置功效才得以大功告成！自动配置幕后英雄：SpringFactoriesLoader详解SpringFactoriesLoader属于Spring框架私有的一种扩展方案，其主要功能就是从指定的配置文件META-INF/spring.factories加载配置。public abstract class SpringFactoriesLoader {
public static &T& List&T& loadFactories(Class&T& factoryClass, ClassLoader classLoader) {
public static List&String& loadFactoryNames(Class&?& factoryClass, ClassLoader classLoader) {
}}配合@EnableAutoConfiguration使用的话，它更多是提供一种配置查找的功能支持，即根据@EnableAutoConfiguration的完整类名org.springframework.boot.autoconfigure.EnableAutoConfiguration作为查找的Key,获取对应的一组@Configuration类上图就是从SpringBoot的autoconfigure依赖包中的META-INF/spring.factories配置文件中摘录的一段内容，可以很好地说明问题。所以，@EnableAutoConfiguration自动配置的魔法骑士就变成了：从classpath中搜寻所有的META-INF/spring.factories配置文件，并将其中org.springframework.boot.autoconfigure.EnableutoConfiguration对应的配置项通过反射（Java Refletion）实例化为对应的标注了@Configuration的JavaConfig形式的IoC容器配置类，然后汇总为一个并加载到IoC容器。深入探索SpringApplication执行流程SpringApplication的run方法的实现是我们本次旅程的主要线路，该方法的主要流程大体可以归纳如下：1） 如果我们使用的是SpringApplication的静态run方法，那么，这个方法里面首先要创建一个SpringApplication对象实例，然后调用这个创建好的SpringApplication的实例方法。在SpringApplication实例初始化的时候，它会提前做几件事情：根据classpath里面能否存在某个特征类（org.springframework.web.context.ConfigurableWebApplicationContext）来决定能否应该创建一个为Web应用使用的ApplicationContext类型。使用SpringFactoriesLoader在应用的classpath中查找并加载所有可用的ApplicationContextInitializer。使用SpringFactoriesLoader在应用的classpath中查找并加载所有可用的ApplicationListener。推断并设置main方法的定义类。2） SpringApplication实例初始化完成并且完成设置后，就开始执行run方法的逻辑了，方法执行伊始，首先遍历执行所有通过SpringFactoriesLoader可以查找到并加载的SpringApplicationRunListener。调用它们的started()方法，告诉这些SpringApplicationRunListener，“嘿，SpringBoot应用要开始执行咯！”。3） 创建并配置当前Spring Boot应用将要使用的Environment（包括配置要使用的PropertySource以及Profile）。4） 遍历调用所有SpringApplicationRunListener的environmentPrepared()的方法，告诉他们：“当前SpringBoot应用使用的Environment准备好了咯！”。5） 如果SpringApplication的showBanner属性被设置为true，则打印banner。6） 根据用户能否明确设置了applicationContextClass类型以及初始化阶段的推断结果，决定该为当前SpringBoot应用创建什么类型的ApplicationContext并创建完成，然后根据条件决定能否添加ShutdownHook，决定能否使用自定义的BeanNameGenerator，决定能否使用自定义的ResourceLoader，当然，最重要的，将之前准备好的Environment设置给创建好的ApplicationContext使用。7） ApplicationContext创建好之后，SpringApplication会再次借助Spring-FactoriesLoader，查找并加载classpath中所有可用的ApplicationContext-Initializer，然后遍历调用这些ApplicationContextInitializer的initialize（applicationContext）方法来对已经创建好的ApplicationContext进行进一步的处理。8） 遍历调用所有SpringApplicationRunListener的contextPrepared()方法。9） 最核心的一步，将之前通过@EnableAutoConfiguration获取的所有配置以及其他形式的IoC容器配置加载到已经准备完毕的ApplicationContext。10） 遍历调用所有SpringApplicationRunListener的contextLoaded()方法。11） 调用ApplicationContext的refresh()方法，完成IoC容器可用的最后一道工序。12） 查找当前ApplicationContext中能否注册有CommandLineRunner，如果有，则遍历执行它们。13） 正常情况下，遍历执行SpringApplicationRunListener的finished()方法、（如果整个过程出现异常，则依然调用所有SpringApplicationRunListener的finished()方法，只不过这种情况下会将异常信息一并传入处理）去除事件通知点后，整个流程如下：总结到此，SpringBoot的核心组件完成了基本的解析，综合来看，大部分都是Spring框架背后的一些概念和实践方式，SpringBoot只是在这些概念和实践上对特定的场景事先进行了固化和升华，而也恰恰是这些固化让我们开发基于Sping框架的应用愈加方便高效。想要查看更多Spring Boot干货教程,可前往：Spring Boot干货系列总纲参考本章节大部分参考了《SpringBoot揭秘快速构建为服务体系》这本书的第三章，个人看过的几本书就感觉这本书介绍原理的章节最为透彻，本章也算这本书最精华的部分。所以我没忍住就分享出来给大家学习。当然主要是我也没有这本书的电子版，无法分享给大家了，深表遗憾(。?＿?。)?一直觉得自己写的不是技术，而是情怀，一篇篇文章是自己这一路走来的痕迹。靠专业技能的成功是最具可复制性的，希望我的这条路能让你少走弯路，希望我能帮你抹去知识的蒙尘，希望我能帮你理清知识的脉络，希望未来技术之巅上有你也有我,希望大爷你看完打赏点零花钱给我。}