lpfasd123

SpringBoot 学习分享文档

SpringBoot简介

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域（rapid application development）成为领导者。

详情请参阅spirngboot官网：http://projects.spring.io/spring-boot/

SpringBoot特点

遵循“习惯优于配置”的原则，使用Spring Boot只需要很少的配置，大部分的时候我们直接使用默认的配置即可；

- 项目快速搭建，可以无需配置的自动整合第三方的框架；

- 可以完全不使用XML配置文件，只需要自动配置和Java Config；

- 内嵌Servlet容器，降低了对环境的要求，可以使用命令直接执行项目，应用可用jar包执行：java -jar；

- 提供了starter POM, 能够非常方便的进行包管理, 很大程度上减少了jar hell或者dependency hell；

- 运行中应用状态的监控；

- 与云计算的天然继承；

SpringBoot优点

SpringBoot是伴随着Spring4.0诞生的，一经推出，引起了巨大的反响。

    - 从字面理解，Boot是引导的意思，因此SpringBoot帮助开发者快速搭建Spring框架； - SpringBoot帮助开发者快速启动一个Web容器；

     - SpringBoot继承了原有Spring框架的优秀基因；

    - SpringBoot简化了使用Spring的过程；

    - Spring Boot为我们带来了脚本语言开发的效率，但是Spring Boot并没有让我们意外的新技术，都是Java EE开发者常见的额技术。

SpringBoot解决的问题

Spring Boot使编码变简单

- Spring Boot使配置变简单

- Spring Boot使部署变简单

- Spring Boot使监控变简单

SpringBoot的核心功能

（一）独立运行的Spring项目 Spring Boot可以以jar包的形式进行独立的运行，使用：java -jar xx.jar 就可以成功的运行项目，或者在应用项目的主程序中运行main函数即可；使得项目的部署，调试都变得简单。

（二）内嵌的Servlet容器内嵌容器，使得我们可以执行运行项目的主程序main函数，使项目的快速运行；主程序代码：SpringbootDemoApplication.java

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class SpringbootDemoApplication {

public static void main(String[] args) { SpringApplication.run(SpringbootDemoApplication.class, args);

}

}

（三）提供starter简化Manen配置 Spring Boot提供了一系列的starter pom用来简化我们的Maven依赖,下边是创建一个简单web demo的依赖pom代码org.springframework.bootspring-boot-starter-parent1.5.2.RELEASE

Maven配置

Spring Boot官网还提供了很多的starter pom，请参考：

http://docs.spring.io/spring-boot/docs/1.5.2.RELEASE/reference/htmlsingle/#boot-documentation 或者访问https://github.com/spring-projects/spring-boot/tree/master/spring-boot-starters

通过粗略阅读，我们知道springboot几乎为市面上主流常见的框架接入做了starter pom整合，我们在使用的时候只要引入相关的starter，然后就可以直接使用（或者很少的配置）就可以使用该框架的功能为我们服务。

（四）自动配置SpringSpring Boot会根据我们项目中类路径的jar包/类，为jar包的类进行自动配置Bean，这样一来就大大的简化了我们的配置。当然，这只是Spring考虑到的大多数的使用场景，在一些特殊情况，我们还需要自定义自动配置；

（五）无代码生成和XML配置Spring Boot神奇的地方不是借助于代码生成来实现的，而是通过条件注解的方式来实现的，这也是Spring 4.x的新特性。

Spring Boot的快速搭建案例

我们可以通过访问http://start.spring.io/来快速构建一个springboot应用，选好我们需要的模块后，回车或者点击Generate Project就会生成一个压缩包，把压缩包解压后导入我们的ide就可以运行一个demo项目。我们也可以通过idea的SPRING INITIALIZR来快速生成一个SpringBoot项目。

SpringBoot启动流程初探

阅读我们的demo代码，我们发现在main方法里我们执行了一串这样的代码

SpringApplication.run(DemoApplication.class, args);

查看run方法，发现这个run方法的方法说明为：

/** * Static helper that can be used to run a {@link SpringApplication} from the

* specified source using default settings.

* @param source the source to load

* @param args the application arguments (usually passed from a Java main method)

* @return the running {@link ApplicationContext}

*/

public static ConfigurableApplicationContext run(Object source, String... args) {

return run(new Object[] { source }, args);

}

从这段说明和代码我们可以看到，该静态方法是用来启动我们的应用，特殊的配置使用默认设置，接收两个参数分别是我们的main方法所在的类，和main方法的方法参数，然后调用了当前类下的重载run方法。重载run方法如下：

public static ConfigurableApplicationContext run(Object[] sources, String[] args) {

return new SpringApplication(sources).run(args);

}

从这段方法我们看到，该方法实例化了一个SpringApplication,传入的参数依然为应用所在入口类，并且调用了SpringApplication下的run（String...args)方法。首先我们查看实例话的方法，也就是SpringApplication的构造函数：

public SpringApplication(Object... sources) {

initialize(sources);

}

查看initialize方法：

@SuppressWarnings({ "unchecked", "rawtypes" })

private void initialize(Object[] sources) {

    if (sources != null && sources.length > 0) {

        this.sources.addAll(Arrays.asList(sources));

    }

    this.webEnvironment = deduceWebEnvironment();

    setInitializers((Collection) getSpringFactoriesInstances(                                                                             ApplicationContextInitializer.class) );

    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

this.mainApplicationClass = deduceMainApplicationClass();

}

从面的代码可以看到初始化过程做了以下几件事情

this.webEnvironment = deduceWebEnvironment();

这一个方法决定创建的是一个WEB应用还是一个SPRING的标准Standalone应用。进方法可以看到其是怎么判断的：

private boolean deduceWebEnvironment() {

    for (String className : WEB_ENVIRONMENT_CLASSES) {

        if (!ClassUtils.isPresent(className, null)){

            return false;

        }

    }

    return true;

}

可以看到是根据org.springframework.util.ClassUtils的静态方法去判断classpath里面是否有WEB_ENVIRONMENT_CLASSES包含的类，如果有都包含则返回true则表示启动一个WEB应用，否则返回false启动一个标准Spring的应用。然后通过代码：

private static final String[] WEB_ENVIRONMENT_CLASSES = { "javax.servlet.Servlet", "org.springframework.web.context.ConfigurableWebApplicationContext" };

可以看到是否启动一个WEB应用就是取决于classpath下是否有javax.servlet.Servlet和 org.springframework.web.context.ConfigurableWebApplicationContext。然后进入下一个阶段：

setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

这个方法是初始化classpath下的所有的可用的

ApplicationContextInitializersetListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

这个方法是初使化classpath下的所有的可用的ApplicationListener。最后的执行deduceMainApplicationClass方法，找出main方法的全类名并返回其实例并设置到SpringApplication的this.mainApplicationClass完成初始化。

private Class deduceMainApplicationClass() {

    try {

        StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();

        for (StackTraceElement stackTraceElement : stackTrace) {

            if ("main".equals(stackTraceElement.getMethodName())) {

                return Class.forName(stackTraceElement.getClassName());

            }

        }

    }catch (ClassNotFoundException ex) {

        // Swallow and continue

    }

return null;

}

然后调用SpringApplication实例的run方法来启动应用，代码如下：

/** * Run the Spring application, creating and refreshing a new

* {@link ApplicationContext}.

* @param args the application arguments (usually passed from a Java main method)

* @return a running {@link ApplicationContext}

*/

public ConfigurableApplicationContext run(String... args) {

    StopWatch stopWatch = new StopWatch();

    stopWatch.start();

    ConfigurableApplicationContext context = null;

    FailureAnalyzers analyzers = null;

    configureHeadlessProperty();

    SpringApplicationRunListeners listeners = getRunListeners(args);

    listeners.starting();

    try {

        ApplicationArguments applicationArguments = new                                                                 DefaultApplicationArguments(args);

        ConfigurableEnvironment environment =                             prepareEnvironment(listeners,applicationArguments);

        Banner printedBanner = printBanner(environment);

        context = createApplicationContext();

        analyzers = new FailureAnalyzers(context);

        prepareContext(context, environment, listeners,                                                         applicationArguments,printedBanner);

        refreshContext(context);afterRefresh(context, applicationArguments);

        listeners.finished(context, null);

        stopWatch.stop();

        if (this.logStartupInfo) {

            new StartupInfoLogger(this.mainApplicationClass)

                                    .logStarted(getApplicationLog(), stopWatch);

        }

        return context;

    }catch (Throwable ex) {

        handleRunFailure(context, listeners, analyzers, ex);

        throw new IllegalStateException(ex);

    }

}

我们可以看到，这段代码作为整个应用启动的具体实现，还是比较复杂的，目前已知这里会加载SpringApplicationRunListener对整个容器的初始化过程进行监听：

SpringApplicationRunListeners listeners = getRunListeners(args);

listeners.starting();

然后我们查看下面几行代码：

ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);

Banner printedBanner = printBanner(environment);

context = createApplicationContext();

prepareContext(context, environment, listeners, applicationArguments, printedBanner);

refreshContext(context);

afterRefresh(context, applicationArguments);

首先是获取启动时传入参数args并初始化为ApplicationArguments对象 SpringApplication.run(Application.class, args);取这里传入值。然后配置SpringBoot应用的环境：

ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);

然后下面代码就是比较核心的：

context = createApplicationContext();

prepareContext(context, environment, listeners, applicationArguments, printedBanner);

refreshContext(context);

afterRefresh(context, applicationArguments);

首先是createApplicationContext()方法：

protected ConfigurableApplicationContext createApplicationContext() {

    Class contextClass = this.applicationContextClass;

    if (contextClass == null) {

try {

contextClass = Class.forName(this.webEnvironment ?                     DEFAULT_WEB_CONTEXT_CLASS : DEFAULT_CONTEXT_CLASS);

}catch (ClassNotFoundException ex) {

throw new IllegalStateException( "Unable create a default ApplicationContext, " + "please specify an ApplicationContextClass", ex);

}

}

return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass);

}

可以看出根据这前初始化过程初始化的this.webEnvironment来决定初始化一个什么容器。如果classpath下是否有javax.servlet.Servlet和 org.springframework.web.context. ConfigurableWebApplicationContext类，则使用DEFAULT_WEB_CONTEXT_CLASS初始化容器，如果不存在则用DEFAULT_CONTEXT_CLASS初始化容器。完成容器的创建工作。然后执行以下的几个步骤完成整个容器的创建与启动以及bean的注入功能。

prepareContext(context, environment, listeners, applicationArguments, printedBanner);

以下这一句代码是实现spring-boot-starter-*的自动化配置的关键。

refreshContext(context);

afterRefresh(context, applicationArguments);

其中refreshContext会更新ApplicationContext基础组件，包括prepareBeanFactory工厂，postProcessBeanFactory工厂，监听器注册，消息流初始化等等操作。详情可以查看AbstractApplicationContext类下的refresh()方法。afterRefresh方法实质上使用的是callRunners(context, args);方法，代码如下：

private void callRunners(ApplicationContext context, ApplicationArguments args) {

List