Spring Boot 官方文档学习（一）入门及使用

目录：

1. 内置Servlet Container
2. 使用Spring Boot
3. 安装Spring Boot CLI
4. 开发一个简单的Spring Boot应用--使用最原始的方式
   1. 建立一个文件夹
   2. 新建一个pom.xml文件
   3. 命令：mvn package
   4. 添加依赖
   5. 开始写代码
   6. 启动项目
   7. 打包
   8. 执行
5. Dependency Management
   1. 继承 spring-boot-starter-parent
   2. 不继承 spring-boot-starter-parent
6. Starters
7. 自动配置
8. Spring Beans 和 依赖注入（略）
9. @SpringBootApplication
10. 运行Spring Boot Application
    1. 从IDE中运行
    2. 运行fat jar（executable jar）
    3. 使用Maven Plugin
    4. Hot swapping
11. Developer tools
    1. Property defaults
    2. 自动重启
    3. 热加载 LiveReload
    4. 全局设置
    5. 远程应用
       1. 远程调试
12. 生产打包

---

 

1、内置Servlet Container：

Name	Servlet Version	Java Version
Tomcat 8	3.1	Java 7+
Tomcat 7	3.0	Java 6+
Jetty 9.3	3.1	Java 8+
Jetty 9.2	3.1	Java 7+
Jetty 8	3.0	Java 6+
Undertow 1.3	3.1	Java 7+

 

此外，你仍然能够部署Spring Boot项目到任何兼容Servlet3.0+的容器。

2、使用Spring Boot。

    你能够像使用标准的Java库文件同样使用Spring Boot。简单的将须要的 spring-boot-*.jar 添加到classpath便可。

    Spring Boot不要求任何特殊的工具集成，因此可使用任何IDE，甚至文本编辑器。

 

    只是，仍然建议使用build工具：Maven 或 Gradle。

 

    Spring Boot依赖 使用 org.springframework.boot  groupId 。

    一般，让你的Maven POM文件继承 spring-boot-starter-parent，并声明一个或多个 Starter POMs依赖便可。Spring Boot也提供了一个可选的 Maven Plugin来建立可执行的jars。   以下：

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.example</groupId> <artifactId>myproject</artifactId> <version>0.0.1-SNAPSHOT</version> <!-- Inherit defaults from Spring Boot --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.4.0.RELEASE</version> </parent> <!-- Add typical dependencies for a web application --> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies> <!-- Package as an executable jar --> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>

 

    须要注意的是， spring-boot-starter-parent 是一个很是好的方法，但并不适用于全部状况。有时你须要继承其余的POM，或者你不喜欢默认的设置。-- 办法见后面。

 

3、安装Spring Boot CLI。

    这是一个命令行工具，能够执行Groove脚本。是执行一个Spring Boot的最快途径。

    -- 好吧，Linux下无敌，Win下仍是休息吧。

 

4、开发一个简单的Spring Boot应用--使用最原始的方式。

    务必注意：前提是maven + jdk。

    一、建立一个文件夹。SpringBootSample01

    二、新建一个pom.xml文件。内容以下：

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.example</groupId> <artifactId>myproject</artifactId> <version>0.0.1-SNAPSHOT</version> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.4.0.RELEASE</version> </parent> <!-- Additional lines to be added here... --> </project>

    三、上面没有添加任何依赖，但仍然能够build。命令行：mvn package。注意，是当前路径下 //SpringBootSample01/ 。

        固然，你也可使用IDE，不过使用文本编辑器会让咱们对它更理解。

       

    四、如今须要添加依赖 -- 其实就是把依赖的jar添加到buildpath。

        因为咱们已经继承了 spring-boot-starter-parent ，而 spring-boot-starter-parent 又提供了 dependency-management ，因此咱们能够忽略被选中依赖的版本。

        在添加依赖以前，咱们先看一下如今已有什么：mvn dependency:tree。该命令会打印一个当前项目的依赖树。

     

        结果代表，当前没有任何依赖。 

 

        OK，如今咱们添加一个Starter 模块。

<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies>

　　　

        如今再次查看一下依赖树。

　　

        能够看出，spring-boot-starter-web  包含了不少内容，spring-webmvc、spring-web、jackson、validation、tomcat、starter。

      五、如今就能够开始写代码了。

        因为Maven默认编译路径为 src/main/java 下面的源码，因此，默认设置下，须要建立这些文件夹。        

        而后，编写文件 src/main/java/Example.java：

import org.springframework.boot.*; import org.springframework.boot.autoconfigure.*; import org.springframework.stereotype.*; import org.springframework.web.bind.annotation.*; @RestController @EnableAutoConfiguration public class Example { @RequestMapping("/") String home() { return "Hello World!"; } public static void main(String[] args) throws Exception { SpringApplication.run(Example.class, args); } }

        这里咱们只须要关心 @EnableAutoConfiguration 便可。这个注解是让Spring Boot 猜想 你想怎么配置Spring，但实际上，它是根据你添加到classpath中的依赖来判断的。

        注意，自动配置 能够配合 Starter POMs 一块儿工做，但两者不是捆绑到一块儿的。你仍然能够将Starter POMs中的依赖单独拣出使用，Spring Boot仍是会自动配置。

        六、启动项目。因为咱们使用了 spring-boot-starter-parent POM，因此可使用 mvn spring-boot:run来启动项目（根路径）。

            启动以后就能够访问了，默认地址：  http://localhost:8080/

        七、打包。executable jars 又称 fat jars，是能够直接在生产环境中运行的，包含全部编译生成的class文件以及依赖包。

            注意，Spring Boot的这种打包方式须要使用Spring Boot提供的 spring-boot-maven-plugin 。         

<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>

            注意，spring-boot-starter-parent POM中包含了 <executions> 的配置信息，绑定了 repackage goal （maven）。若是你不使用parent POM，你须要本身来声明这个配置信息。

            如今，能够打包了： mvn package 。

           

            如今，你能够在/target目录下看到 myproject-0.0.1-SNAPSHOT.jar ，大约10 Mb左右。能够经过 jar tvf target/myproject-0.0.1-SNAPSHOT.jar 来查看其中的内容。

            此外，在/target目录下，还能够看到 myproject-0.0.1-SNAPSHOT.jar.original ，这是Maven打包出来的---在Spring Boot repackage 以前。

            八、执行。正常的jar执行：java -jar target/myproject-0.0.1-SNAPSHOT.jar  ，启动信息以下：

           

            执行 ctrl+c，退出。

5、Dependency Management

每一个版本的Spring Boot都提供了一个依赖列表。这个列表包含了你可能经过Spring Boot用到的全部的Spring模块以及第三方库。该列表能够以 BOM（Bills of Material）的形式支持Maven。 --- 怎么理解BOM和Starter？什么区别？？

 

一、继承 spring-boot-starter-parent ：

      spring-boot-starter-parent project 

      默认是 Java 1.6。 Resource filtering。exec plugin、surefire、Git commit ID、shade。

      Resource filtering for application.properties 和 application.yml，以及，profile-specific file，如application-foo.properties 或 application-foo.yml。

      -- 注意Maven filtering使用 @..@ 占位符，你能够在Maven property中覆盖：resource.delimiter。

 

       若是不想使用Spring Boot中的默认版本，能够在<properties>覆盖相应的版本，如，想使用不一样版本的Spring Data，具体以下：

<properties> <spring-data-releasetrain.version>Fowler-SR2</spring-data-releasetrain.version> </properties>

       想使用不一样版本的JDK：

<!-- 使用 java 1.8 --> <java.version>1.8</java.version>

 

二、不继承 spring-boot-starter-parent ：

这种状况下，仍然可使用dependency management，但不能使用plugin management啦。方式以下：

<dependencyManagement> <dependencies> <dependency> <!-- Import dependency management from Spring Boot --> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-dependencies</artifactId> <version>1.4.0.RELEASE</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>

注意，scope是 import 。并且，这种状况下，再也不容许在<properties>覆盖相应的版本。若是要使用其余版本，须要在上面的前面添加一个完整的dependency。以下：

<dependencyManagement> <dependencies> <!-- Override Spring Data release train provided by Spring Boot --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-releasetrain</artifactId> <version>Fowler-SR2</version> <scope>import</scope> <type>pom</type> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-dependencies</artifactId> <version>1.4.0.RELEASE</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>

 

另外，Spring Boot还提供了一个Maven Plugin：spring-boot-maven-plugin，用于将项目打包成fat jar（executable jar）。

继承时只须要 声明一下便可使用：

<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>

 

6、Starters

能够建立本身的Starter，但名字格式不能是 spring-boot-starter-*，而是 *-spring-boot-starter。相似Maven插件的规则。

 

7、自动配置

@Import 和 @ComponentScan 相似；

@EnableAutoConfiguration 和 @SpringBootApplication 相似；---注意，只能使用一次，建议用在primary @Configuration class上。

 

注意，自动配置永远是第二位的，一旦你配置本身的东西，那自动配置的就会被覆盖。

查看自动配置都配置了什么，以及为何，启动应用的时候加上 --debug便可。

禁用特定的自动配置：

import org.springframework.boot.autoconfigure.*; import org.springframework.boot.autoconfigure.jdbc.*; import org.springframework.context.annotation.*; @Configuration @EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class}) public class MyConfiguration { }

若是class不在classpath中，可使用  excludeName，而后使用全路径便可。

 

8、Spring Beans 和 依赖注入。

9、@SpringBootApplication

@SpringBootApplication 等同于默认的属性的 @Configuration,  @EnableAutoConfiguration and @ComponentScan。 

-- 注意，@ComponentScan 不能凭空使用。

  

10、运行Spring Boot Application

一、从IDE中运行

须要导入现有Maven项目。

若是不当心运行了两次，出现端口占用问题，STS（Spring Tools Suite）使用Relaunch便可。

 

二、运行fat jar（executable jar）

java -jar target/xxxx.jar    注意，是在项目路径下执行。

开启 远程调试支持：

java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n -jar target/myproject-0.0.1-SNAPSHOT.jar

 

三、使用Maven Plugin

1. mvn spring-boot:run

四、Hot swapping   热部署？？？ 好像不是，是热加载。

由于Spring Boot应用都是简单的Java应用，因此JVM Hot-swapping能够直接使用。可是，JVM Hot-swapping对于可以替换的字节码有些限制，因此建议使用JRebel或者Spring Loaded？？

spring-boot-devtools 模块一样包含了快速重启应用的支持。

另外，貌似JVM Hot-swapping 只能在debug期间修改方法体？？    

 

11、Developer tools

Spring Boot包含一组附加的开发期工具。

<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <optional>true</optional> </dependency> </dependencies>

注意，生产环境下（java -jar或者经过特定的类加载器启动），这些开发工具自动被禁止。

上面的 <optional>true</optional> 是一个最佳实践，能够有效阻止用于其余模块。

若是想确保生产Build中不包含devtools，可使用excludeDevtools build property。

 

一、Property defaults

一些Spring Boot支持的库使用了cache增进性能。可是cache，在开发过程当中可能会是一个阻碍。例如你没法当即更新一个模板（thymeleaf的）。

cache设置一般在 application.properties 中。可是，比起手动设置这些，spring-boot-devtools模块会自动应用这些开发期的设置。

 

二、自动重启

使用spring-boot-devtools模块的应用，当classpath中的文件有改变时，会自动重启！ -- 就是说，默认会监视classpath入口。

静态资源和视图模板不须要重启！

注意，不一样的IDE有不一样的表现，例如Eclipse中只要改变了文件并保存，那就会致使classpath中的内容改变。而Intellij IDEA则须要 Build #Make Project。

能够经过build plugin启动应用，只要开启了forking支持，由于Devtools须要一个隔离的classloader才能运行正常。Maven下要这样开启：

<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <fork>true</fork> </configuration> </plugin> </plugins> </build>

注意：在使用LiveReload（热加载）时，自动重启仍然能够正常工做。若是你使用了JRebel，自动重启会被禁用以支持动态类加载。此时，devtools其余方面仍然可使用。

注意：DevTools在重启过程当中依赖应用上下文的shutdown hook来关掉它（应用）。因此若是禁用了shutdown hook，它就没法正常工做了：SpringApplication.setRegisterShutdownHook(false)。

 

Spring Boot使用的重启技术，其实是使用了两个类加载器：不变的base类加载器、可变的restart类加载器。前者加载第三方jar之类的。后者加载项目代码。重启的时候，只是丢弃可变的restart类加载器，而后从新建立一个，因此速度比较快。

若是你以为这样仍然不够快，或者遇到了类加载器问题，那你能够考虑JRebel之类的重加载技术。（重写了类？？）

Spring Loaded项目提供了另外一个选择，可是支持的框架不够多，且没有商业支持。

 

一些特定的资源改变时没有必要引发重启。有一些不会引发重启，可是会重加载。若是你想自定义的设置一下，可使用 spring.devtools.restart.exclude 属性。以下：

spring.devtools.restart.exclude=static/**,public/**

若是想在默认的设置以外 再添加新的排除选项，可使用 spring.devtools.restart.additional-exclude 属性。

 

若是想在修改classpath以外的文件时也让应用重启，可使用 spring.devtools.restart.additional-paths 属性。还能够配合上面提到的 spring.devtools.restart.exclude 属性，来控制是重启仍是重加载。

 

若是不想使用自动重启功能，可使用 spring.devtools.restart.enabled 属性。多数状况下，能够在 application.properties 中设置，这样 仍然会建立一个restart类加载器，但再也不监视改变。

若是想彻底禁止自动重启，须要在调用 SpringApplication.run(..) 以前设置一个System属性。以下：

public static void main(String[] args) { System.setProperty("spring.devtools.restart.enabled", "false"); SpringApplication.run(MyApp.class, args); }

 

若是你的IDE会随改随编译，你可能会倾向于只在特定时刻引起重启（不然会很烦人，并且性能降低）。这时，你可使用“trigger file”，就是一个特定的文件，只有修改这个文件时才会触发重启。使用 spring.devtools.restart.trigger-file 属性便可。（还能够设置为全局属性，这样全部的项目均可以使用了！见十八。）

 

自定义restart类加载器。

若是有一个多模块项目，只有部分导入到你的IDE中，你可能须要自定义一下。首先建立一个文件：META-INF/spring-devtools.properties。该文件中，能够有之前缀 restart.exclude. 和 restart.include. 开头的属性。前者会被放入base类加载器，后者则被放入restart类加载器。

该属性的value，是正则表达式。例如：

restart.include.companycommonlibs=/mycorp-common-[\\w-]+\.jar
restart.include.projectcommon=/mycorp-myproj-[\\w-]+\.jar

注意，key只要是前缀 restart.exclude. 和 restart.include. 开头便可， 后缀任意。

 

已知限制：

自动重启，在使用 ObjectInputStream 反序列化时，会出问题。若是你想使用反序列化，应该使用Spring的 ConfigurableObjectInputStream 配合 Thread.currentThread().getContextClassLoader() 使用。

惋惜的是，一些第三方jars中没有考虑到这个问题，无解。

 

三、热加载 LiveReload

spring-boot-devtools 模块内置了一个 LiveReload Server，能够保证在改变资源时 浏览的刷新。LiveReload的浏览器扩展，免费支持Chrome、Firefox、Safari。

若是想禁用： spring.devtools.livereload.enabled=false   。

注意：只能运行 一个LiveReload Server。若是同时开启多个项目，那只有第一个。

 

四、全局设置（前面有提到）

$HOME 文件夹下添加一个文件 .spring-boot-devtools.properties ，该文件中的内容会被做用于全部的Spring Boot项目。例如设置 触发文件：

spring.devtools.reload.trigger-file=.reloadtrigger

 

五、远程应用

Spring Boot 的developer tools也能够在远程使用（应该是使用一部分）。须要开启支持。例如：

spring.devtools.remote.secret=mysecret

问题：值是什么意思？

注意：不要在生产环境下开启！！

 

远程devtools支持是成对出现的。服务器端+客户端。当设置了上面的属性时，服务器端会自动开启。

 

运行远程客户端应用：

运行 org.springframework.boot.devtools.RemoteSpringApplication ，须要使用和远程项目相同的classpath！

传递给应用的non-option参数应该是你要链接到的URL。（ 问题，什么是non-option参数？）

例如，你在使用Eclipse或者STS，有一个项目 my-app ，部署到了Cloud Foundry，那你须要进行以下操做：

1. Select Run -> Run Configurations...
2. Create a new Java Application "launch configuration"
3. Browse for the my-app project
4. Use org.springframework.boot.devtools.RemoteSpringApplication as the main class.
5. Add https://myapp.cfapps.io to the Program arguments (or whatever your remote URL is).

 

代理访问远程的设置方法（略）。p47(60/346)

 

远程方式下，客户端的任何更新都会被push到服务器端，并按设置触发restart。比较快。

 

5.一、远程调试

并不老是能开启Java远程调试功能。（直接翻译的，略拗口。其实就是有时候能开启，有时候不能）

为了改进这些限制，devtools支持Http协议的远程调试通道。远程客户端提供了一个本地服务器（默认8000端口，可修改），用于绑定远程调试器。当一个链接被建立时，debug信息就会经过HTTP发送到远程应用。

修改默认端口： spring.devtools.remote.debug.local-port 。

可是，首先，你须要确认远程应用以远程调试方式启动。一般，配置JAVA_OPTS便可达到目的。例如，在Cloud Foundry上，你能够在 manifest.yml 中添加以下信息：

---
  env:
    JAVA_OPTS: "-Xdebug -Xrunjdwp:server=y,transport=dt_socket,suspend=n"

注意，经过网络进行远程调试，可能很慢，因此你须要增长超时时间。Eclipse中：Java -> Debug -> Debugger timeout (ms)，设成60000很不错。

 

 

12、生产打包

Executable jars能够直接在生产环境下使用。

其余的生产就绪功能，例如监控等，能够考虑 spring-boot-actuator 。后面会有介绍。