目录:
- 内置Servlet Container
- 使用Spring Boot
- 安装Spring Boot CLI
- 开发一个简单的Spring Boot应用--使用最原始的方式
- 建立一个文件夹
- 新建一个pom.xml文件
- 命令:mvn package
- 添加依赖
- 开始写代码
- 启动项目
- 打包
- 执行
- Dependency Management
- 继承 spring-boot-starter-parent
- 不继承 spring-boot-starter-parent
- Starters
- 自动配置
- Spring Beans 和 依赖注入(略)
- @SpringBootApplication
- 运行Spring Boot Application
- 从IDE中运行
- 运行fat jar(executable jar)
- 使用Maven Plugin
- Hot swapping
- Developer tools
- Property defaults
- 自动重启
- 热加载 LiveReload
- 全局设置
- 远程应用
- 远程调试
- 生产打包
Name |
Servlet Version |
Java Version |
Tomcat 8html |
3.1java |
Java 7+web |
Tomcat 7正则表达式 |
3.0spring |
Java 6+apache |
Jetty 9.3浏览器 |
3.1tomcat |
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+的容器。
你能够像使用标准的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,或者你不喜欢默认的设置。-- 办法见后面。
这是一个命令行工具,能够执行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来启动项目(根路径)。
七、打包。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,退出。
每一个版本的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>
能够建立本身的Starter,但名字格式不能是 spring-boot-starter-*,而是 *-spring-boot-starter。相似Maven插件的规则。
@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,而后使用全路径便可。
@SpringBootApplication 等同于默认的属性的
@Configuration
,
@EnableAutoConfiguration
and @ComponentScan
。
-- 注意,@ComponentScan 不能凭空使用。
10、运行Spring Boot Application
须要导入现有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
四、Hot swapping 热部署??? 好像不是,是热加载。
由于Spring Boot应用都是简单的Java应用,因此JVM Hot-swapping能够直接使用。可是,JVM Hot-swapping对于可以替换的字节码有些限制,因此建议使用JRebel或者Spring Loaded??
spring-boot-devtools 模块一样包含了快速重启应用的支持。
另外,貌似JVM Hot-swapping 只能在debug期间修改方法体??
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。
一些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中没有考虑到这个问题,无解。
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,那你须要进行以下操做:
Select Run -> Run Configurations...
Create a new Java Application "launch configuration"
Browse for the my-app project
Use org.springframework.boot.devtools.RemoteSpringApplication as the main class.
Add https://myapp.cfapps.io to the Program arguments (or whatever your remote URL is).
代理访问远程的设置方法(略)。p47(60/346)
远程方式下,客户端的任何更新都会被push到服务器端,并按设置触发restart。比较快。
并不老是能开启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很不错。
Executable jars能够直接在生产环境下使用。
其余的生产就绪功能,例如监控等,能够考虑
spring-boot-actuator 。后面会有介绍。