超详细的Spring Boot入门笔记（总结）

1. spring boot 入门

spring boot是spring社区较新的一个项目。该项目的目的是帮助开发者更容易的创建基于spring的应用程序和服务，让更多人的人更快的对spring进行入门体验，让java开发也能够实现ruby on rails那样的生产效率。为spring生态系统提供了一种固定的、约定优于配置风格的框架。

spring boot具有如下特性：

1. 为基于spring的开发提供更快的入门体验
2. 开箱即用，没有代码生成，也无需xml配置。同时也可以修改默认值来满足特定的需求。
3. 提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。
4. spring boot并不是对spring功能上的增强，而是提供了一种快速使用spring的方式。

1.1 简单例子

首先创建一个一般的maven项目，有一个pom.xml和基本的src/main/java结构。

1.1.1 pom.xml 文件

<projectxmlns="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.nes.spring.boot</groupid>
<artifactid>springbootdemo1</artifactid>
<version>0.0.1-snapshot</version>

<parent>
 <groupid>org.springframework.boot</groupid>
 <artifactid>spring-boot-starter-parent</artifactid>
 <version>1.3.0.release</version>
</parent>

<dependencies>
 <dependency>
  <groupid>org.springframework.boot</groupid>
  <artifactid>spring-boot-starter-web</artifactid>
 </dependency>
</dependencies>

<build>
 <plugins>
  <!-- compile -->
  <plugin>
   <groupid>org.apache.maven.plugins</groupid>
   <artifactid>maven-compiler-plugin</artifactid>
   <version>2.5.1</version>
   <configuration>
    <source>1.7</source>
    <target>1.7</target>
   </configuration>
  </plugin>
  <!-- spring boot mavenplugin -->
  <plugin>
   <groupid>org.springframework.boot</groupid>
   <artifactid>spring-boot-maven-plugin</artifactid>
   <dependencies>
    <dependency>
     <groupid>org.springframework</groupid>
     <artifactid>springloaded</artifactid>
     <version>1.2.5.release</version>
    </dependency>
   </dependencies>
  </plugin>
 </plugins>
</build>
</project>

1.1.2 对pom的说明

首先是增加了，增加父pom比较简单，而且spring-boot-starter-parent包含了大量配置好的依赖管理，在自己项目添加这些依赖的时候不需要写版本号。

使用父pom虽然简单，但是有些情况我们已经有父pom，不能直接增加时，可以通过如下方式：

<dependencymanagement>
 <dependencies>
  <dependency>
   <!-- import dependency management from spring boot -->
   <groupid>org.springframework.boot</groupid>
   <artifactid>spring-boot-dependencies</artifactid>
   <version>1.2.3.release</version>
   <type>pom</type>
   <scope>import</scope><!—这个地方-->
  </dependency>
 </dependencies>
</dependencymanagement>

1.1.3 关于java.version属性

上面pom.xml虽然没有出现这个属性，这里要特别提醒。

spring默认使用jdk1.6，如果你想使用jdk1.8，你需要在pom.xml的属性里面添加java.version，如下：

<properties>
 <java.version>1.8</java.version>
</properties>

1.1.4 添加spring-boot-starter-web依赖

spring通过添加spring-boot-starter-*这样的依赖就能支持具体的某个功能。

我们这个示例最终是要实现web功能，所以添加的是这个依赖。

1.1.5 添加spring-boot-maven-plugin插件

该插件支持多种功能，常用的有两种，第一种是打包项目为可执行的jar包。

在项目根目录下执行mvn package将会生成一个可执行的jar包，jar包中包含了所有依赖的jar包，只需要这一个jar包就可以运行程序，使用起来很方便。该命令执行后还会保留一个xxx.jar.original的jar包，包含了项目中单独的部分。

生成这个可执行的jar包后，在命令行执行java -jar xxxx.jar即可启动项目。

另外一个命令就是mvn spring-boot:run，可以直接使用tomcat（默认）启动项目。

在我们开发过程中，我们需要经常修改，为了避免重复启动项目，我们可以启用热部署。

1.1.6 spring-loaded热部署

spring-loaded项目提供了强大的热部署功能，添加/删除/修改方法/字段/接口/枚举等代码的时候都可以热部署，速度很快，很方便。

想在spring boot中使用该功能非常简单，就是在spring-boot-maven-plugin插件下面添加依赖：

<!-- 支持热部署 -->
<dependency>
 <groupid>org.springframework</groupid>
 <artifactid>springloaded</artifactid>
 <version>1.2.5.release</version>
</dependency>

添加以后，通过mvn spring-boot:run启动就支持热部署了。

注意：使用热部署的时候，需要ide编译类后才能生效，你可以打开自动编译功能，这样在你保存修改的时候，类就自动重新加载了。

1.2 创建一个应用类

我们创建一个application类：

@restcontroller
@enableautoconfiguration
public class application {

@requestmapping("/") string home() {
 return"hello world!";
 }
@requestmapping("/now") string hehe() {
 return"现在时间：" + (new date()).tolocalestring();
 }
public static void main(string[] args) {
 springapplication.run(application.class, args);
 }
}

1.2.1 注意

spring boot建议将我们main方法所在的这个主要的配置类配置在根包名下。

com
 +- example
  +- myproject
   +- application.java
   +- domain
| +- customer.java
| +- customerrepository.java
   +- service
| +- customerservice.java
   +- web
    +- customercontroller.java

在application.java中有main方法。

因为默认和包有关的注解，默认包名都是当前类所在的包，例如@componentscan, @entityscan, @springbootapplication注解。（都是安当前application.java所在包作为scan扫描）

1.2.2 @restcontroller

因为我们例子是写一个web应用，因此写的这个注解，这个注解相当于同时添加@controller和@responsebody注解。

1.2.3 @enableautoconfiguration

spring boot建议只有一个带有该注解的类。

@enableautoconfiguration作用：spring boot会自动根据你jar包的依赖来自动配置项目。

例如当你项目下面有hsqldb的依赖时，spring boot会创建默认的内存数据库的数据源datasource，如果你自己创建了datasource，spring boot就不会创建默认的datasource。

如果你不想让spring boot自动创建，你可以配置注解的exclude属性，例如：

@configuration
@enableautoconfiguration(exclude={datasourceautoconfiguration.class})
publicclassmyconfiguration {
}

1.2.4 @springbootapplication

由于大量项目都会在主要的配置类上添加

@configuration,@enableautoconfiguration,@componentscan三个注解。

因此spring boot提供了@springbootapplication注解，该注解可以替代上面三个注解（使用spring注解继承实现）。

1.2.5 启动项目springapplication.run

启动spring boot项目最简单的方法就是执行下面的方法：

springapplication.run(application.class, args); 

该方法返回一个applicationcontext对象，使用注解的时候返回的具体类型是annotationconfigapplicationcontext或annotationconfigembeddedwebapplicationcontext，当支持web的时候是第二个。

除了上面这种方法外，还可以用下面的方法：

springapplication application = new springapplication(application.class);
application.run(args);

springapplication包含了一些其他可以配置的方法，如果你想做一些配置，可以用这种方式。

除了上面这种直接的方法外，还可以使用springapplicationbuilder：

new springapplicationbuilder()
  .showbanner(false)
  .sources(application.class)
  .run(args);

当使用springmvc的时候由于需要使用子容器，就需要用到springapplicationbuilder，该类有一个child(xxx…)方法可以添加子容器。

1.3 运行

在ide中直接直接执行main方法，然后访问http://localhost:8080即可。

另外还可以用上面提到的mvn，可以打包为可执行jar包，然后执行java -jar xxx.jar。

或者执行mvn spring-boot:run运行项目。

2. spring boot 属性配置和使用

spring boot 允许通过外部配置让你在不同的环境使用同一应用程序的代码，简单说就是可以通过配置文件来注入属性或者修改默认的配置。

2.1 spring boot 支持多种外部配置方式

这些方式优先级如下：

1. 命令行参数
2. 来自java:comp/env的jndi属性
3. java系统属性（system.getproperties()）
4. 操作系统环境变量
5. randomvaluepropertysource配置的random.*属性值
6. jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
7. jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件
8. jar包外部的application.properties或application.yml(不带spring.profile)配置文件
9. jar包内部的application.properties或application.yml(不带spring.profile)配置文件
10. @configuration注解类上的@propertysource
11. 通过springapplication.setdefaultproperties指定的默认属性

2.1.1 命令行参数

通过java -jar app.jar –name=”spring” –server.port=9090方式来传递参数。

参数用–xxx=xxx的形式传递。

可以使用的参数可以是我们自己定义的，也可以是spring boot中默认的参数。

很多人可能会关心如web端口如何配置这样的问题，这些都是spring boot中提供的参数，部分可用参数如下：

# logging
logging.path=/var/logs
logging.file=myapp.log
logging.config= # location of config file (default classpath:logback.xml for logback)
logging.level.*= # levels for loggers, e.g. "logging.level.org.springframework=debug" (trace, debug, info, warn, error, fatal, off)

# embedded server configuration (serverproperties)
server.port=8080
server.address= # bind to a specific nic
server.session-timeout= # session timeout in seconds
server.context-parameters.*= # servlet context init parameters, e.g. server.context-parameters.a=alpha
server.context-path= # the context path, defaults to '/'
server.servlet-path= # the servlet path, defaults to '/'

注意：命令行参数在app.jar的后面！

可以通过springapplication.setaddcommandlineproperties(false)禁用命令行配置。

2.1.2 java系统属性

注意java系统属性位置java -dname=”isea533” -jar app.jar，可以配置的属性都是一样的，优先级不同。

例如java -dname=”isea533” -jar app.jar –name=”spring!”中name值为spring!

2.1.3 操作系统环境变量

配置过java_home的应该都了解这一个。

这里需要注意的地方，有些os可以不支持使用.这种名字，如server.port，这种情况可以使用server_port来配置。

2.1.4 randomvaluepropertysource

系统中用到随机数的地方，例如：

my.secret=random.valuemy.number={random.int} 
my.bignumber=random.longmy.number.less.than.ten={random.int(10)} 
my.number.in.range=${random.int[1024,65536]} 

random.int*支持value参数和,max参数，当提供max参数的时候，value就是最小值。

2.1.5 应用配置文件（.properties或.yml）

在配置文件中直接写：

name=isea533
server.port=8080

.yml格式的配置文件如：

name: isea533
 server:
 port: 8080

当有前缀的情况下，使用.yml格式的配置文件更简单。关于.yml配置文件用法请看这里

注意：使用.yml时，属性名的值和冒号中间必须有空格，如name: isea533正确，name:isea533就是错的。

2.1.5.1属性配置文件的位置

spring会从classpath下的/config目录或者classpath的根目录查找application.properties或application.yml。

/config优先于classpath根目录

2.1.6 @propertysource

这个注解可以指定具体的属性配置文件，优先级比较低。

2.1.7 springapplication.setdefaultproperties

例如：

springapplication application = new springapplication(application.class);
map<string, object>defaultmap = new hashmap<string, object>();
defaultmap.put("name", "isea-blog");
//还可以是properties对象
application.setdefaultproperties(defaultmap);
application.run(args);
2.2 应用（使用）属性
2.2.1 @value(“${xxx}”)
这种方式是最简单的，通过@value注解可以将属性值注入进来。
2.2.2 @configurationproperties
spring boot 可以方便的将属性注入到一个配置对象中。例如：
my.name=isea533
my.port=8080
my.servers[0]=dev.bar.com
my.servers[1]=foo.bar.com
对应对象：
@configurationproperties(prefix="my")
publicclassconfig {
private string name;
private integer port;
private list<string> servers = newarraylist<string>();
public string gename(){
returnthis.name;
 }
public integer geport(){
returnthis.port;
 }
public list<string>getservers() {
returnthis.servers;
 }
}

spring boot 会自动将prefix=”my”前缀为my的属性注入进来。

spring boot 会自动转换类型，当使用list的时候需要注意在配置中对list进行初始化！

spring boot 还支持嵌套属性注入，例如：

name=isea533
jdbc.username=root
jdbc.password=root
...

对应的配置类：

@configurationproperties
publicclassconfig {
private string name;
privatejdbcjdbc;
 class jdbc {
private string username;
private string password;
//getter...
 }
public integer geport(){
returnthis.port;
 }
publicjdbcgetjdbc() {
returnthis.jdbc;
 }
}

jdbc开头的属性都会注入到jdbc对象中。

2.2.3 在@bean方法上使用@configurationproperties

例如：

@configurationproperties(prefix = "foo")
@bean
publicfoocomponentfoocomponent() {
 ...
}

spring boot 会将foo开头的属性按照名字匹配注入到foocomponent对象中。

2.2.4 属性占位符

例如：

app.name=myapp
app.description=${app.name} is a spring boot application

可以在配置文件中引用前面配置过的属性（优先级前面配置过的这里都能用）。

通过如${app.name:默认名称}方法还可以设置默认值，当找不到引用的属性时，会使用默认的属性。

由于${}方式会被maven处理。如果你pom继承的spring-boot-starter-parent，

spring boot 已经将maven-resources-plugins默认的${}方式改为了@ @方式，例如@name@。

如果你是引入的spring boot，你可以修改使用其他的分隔符

2.2.5 通过属性占位符还能缩短命令参数

例如修改web默认端口需要使用–server.port=9090方式，如果在配置中写上：

server.port=${port:8080}

那么就可以使用更短的–port=9090，当不提供该参数的时候使用默认值8080。

2.2.6 属性名匹配规则

例如有如下配置对象：

@component
@configurationproperties(prefix="person")
publicclassconnectionsettings {
private string firstname;
}

firstname可以使用的属性名如下：

person.firstname，标准的驼峰式命名

person.first-name，虚线（-）分割方式，推荐在.properties和.yml配置文件中使用

person_first_name，大写下划线形式，建议在系统环境变量中使用

2.2.7 属性验证

可以使用jsr-303注解进行验证，例如：

@component
@configurationproperties(prefix="connection")
publicclassconnectionsettings {
@notnull
privateinetaddressremoteaddress;
// ... getters and setters
}

2.3 最后

以上是spring boot 属性配置和使用的内容，有些不全面的地方或者读者有更多疑问，可以查看spring boot完整文档 或 externalized configuration。

3. spring boot 集成mybatis

3.1. spring boot 集成druid

druid有很多个配置选项，使用spring boot 的配置文件可以方便的配置druid。

在application.yml配置文件中写上：

spring:
datasource:
  name: test
  url: jdbc:mysql://192.168.16.137:3306/test
  username: root
  password:
# 使用druid数据源
  type: com.alibaba.druid.pool.druiddatasource
  driver-class-name: com.mysql.jdbc.driver
  filters: stat
  maxactive: 20
  initialsize: 1
  maxwait: 60000
  minidle: 1
  timebetweenevictionrunsmillis: 60000
  minevictableidletimemillis: 300000
  validationquery: select 'x'
  testwhileidle: true
  testonborrow: false
  testonreturn: false
  poolpreparedstatements: true
  maxopenpreparedstatements: 20

 这里通过type: com.alibaba.druid.pool.druiddatasource配置即可！

3.2. spring boot 集成mybatis

spring boot 集成mybatis有两种方式，一种简单的方式就是使用mybatis官方提供的：

mybatis-spring-boot-starter

另外一种方式就是仍然用类似mybatis-spring的配置方式，这种方式需要自己写一些代码，但是可以很方便的控制mybatis的各项配置。

3.2.1. mybatis-spring-boot-starter方式

在pom.xml中添加依赖：

<dependency>
<groupid>org.mybatis.spring.boot</groupid>
<artifactid>mybatis-spring-boot-starter</artifactid>
<version>1.0.0</version>
</dependency>

mybatis-spring-boot-starter依赖树如下：

其中mybatis使用的3.3.0版本，可以通过： 

mybatis: 
mapperlocations: classpath:mapper/*.xml
typealiasespackage: tk.mapper.model

除了上面常见的两项配置，还有：

1. mybatis.config：mybatis-config.xml配置文件的路径
2. mybatis.typehandlerspackage：扫描typehandlers的包
3. mybatis.checkconfiglocation：检查配置文件是否存在
4. mybatis.executortype：设置执行模式（simple, reuse, batch），默认为simple

3.2.2 mybatis-spring方式

这种方式和平常的用法比较接近。需要添加mybatis依赖和mybatis-spring依赖。

然后创建一个mybatisconfig配置类：

/**
 * mybatis基础配置
 *
 * @authorliuzh
 * @since 2015-12-19 10:11
 */
@configuration
@enabletransactionmanagement
publicclassmybatisconfigimplementstransactionmanagementconfigurer {
@autowired
datasourcedatasource;

@bean(name = "sqlsessionfactory")
publicsqlsessionfactorysqlsessionfactorybean() {
sqlsessionfactorybean bean = newsqlsessionfactorybean();
bean.setdatasource(datasource);
bean.settypealiasespackage("tk.mybatis.springboot.model");

//分页插件
pagehelperpagehelper = newpagehelper();
  properties properties = new properties();
properties.setproperty("reasonable", "true");
properties.setproperty("supportmethodsarguments", "true");
properties.setproperty("returnpageinfo", "check");
properties.setproperty("params", "count=countsql");
pagehelper.setproperties(properties);

//添加插件
bean.setplugins(new interceptor[]{pagehelper});

//添加xml目录
resourcepatternresolver resolver = newpathmatchingresourcepatternresolver();
try {
   bean.setmapperlocations(resolver.getresources("classpath:mapper/*.xml"));
returnbean.getobject();
  } catch (exception e) {
e.printstacktrace();
thrownewruntimeexception(e);
  }
 }
@bean
publicsqlsessiontemplatesqlsessiontemplate(sqlsessionfactorysqlsessionfactory) {
returnnewsqlsessiontemplate(sqlsessionfactory);
 }

@bean
@override
publicplatformtransactionmanagerannotationdriventransactionmanager() {
returnnewdatasourcetransactionmanager(datasource);
 }
}

 上面代码创建了一个sqlsessionfactory和一个sqlsessiontemplate，为了支持注解事务，增加了@enabletransactionmanagement注解，并且反回了一个platformtransactionmanagerbean。

另外应该注意到这个配置中没有mapperscannerconfigurer，如果我们想要扫描mybatis的mapper接口，我们就需要配置这个类，这个配置我们需要单独放到一个类中。

/**
 * mybatis扫描接口
 * 
 * @authorliuzh
 * @since 2015-12-19 14:46
 */
@configuration
//注意，由于mapperscannerconfigurer执行的比较早，所以必须有下面的注解
@autoconfigureafter(mybatisconfig.class)
publicclassmybatismapperscannerconfig {
@bean
publicmapperscannerconfigurermapperscannerconfigurer() {
mapperscannerconfigurermapperscannerconfigurer = newmapperscannerconfigurer();
  mapperscannerconfigurer.setsqlsessionfactorybeanname("sqlsessionfactory");
  mapperscannerconfigurer.setbasepackage("tk.mybatis.springboot.mapper");
  //配置通用mappers
propertiesproperties=newproperties();
properties.setproperty("mappers", "tk.mybatis.springboot.util.mymapper");
properties.setproperty("notempty", "false");
properties.setproperty("identity", "mysql");
//这里使用的通用mapper的mapperscannerconfigurer，所有有下面这个方法
mapperscannerconfigurer.setproperties(properties);

returnmapperscannerconfigurer;
 }
}

这个配置一定要注意@autoconfigureafter(mybatisconfig.class)，必须有这个配置，否则会有异常。原因就是这个类执行的比较早，由于sqlsessionfactory还不存在，后续执行出错。做好上面配置以后就可以使用mybatis了。

3.3. 关于分页插件和通用mapper集成

分页插件作为插件的例子在上面代码中有。

通用mapper配置实际就是配置mapperscannerconfigurer的时候使用

tk.mybatis.spring.mapper.mapperscannerconfigurer即可，配置属性使用properties。

3.4. spring boot集成mybatis的基础项目

项目地址：https://github.com/wudongqiang/mybatis-spring-boot

分页插件和通用mapper的相关信息可以通过上面地址找到。

4. spring boot 静态资源处理

spring boot 默认的处理方式就已经足够了，默认情况下spring boot 使用webmvcautoconfiguration中配置的各种属性。
建议使用spring boot 默认处理方式，需要自己配置的地方可以通过配置文件修改。

但是如果你想完全控制spring mvc，你可以在@configuration注解的配置类上增加@enablewebmvc，增加该注解以后webmvcautoconfiguration中配置就不会生效，你需要自己来配置需要的每一项。这种情况下的配置方法建议参考webmvcautoconfiguration类。

本文以下内容针对spring boot 默认的处理方式，部分配置通过在application.yml配置文件中设置。

1.spring boot默认加载文件的路径是

/meta-inf/resources/ 
/resources/ 
/static/ 
/public/
private static final string[] classpath_resource_locations = { 
  "classpath:/meta-inf/resources/", "classpath:/resources/", 
  "classpath:/static/", "classpath:/public/" }; 

所有本地的静态资源都配置在了classpath下面了, 而非在webapp下了

4.1. 配置资源映射

spring boot 默认配置的/映射到/static（或/public ，/resources，/meta-inf/resources），/webjars/会映射到
classpath:/meta-inf/resources/webjars/。

注意：上面的/static等目录都是在classpath:下面。

如果你想增加如/mystatic/**映射到classpath:/mystatic/，你可以让你的配置类继承webmvcconfigureradapter，然后重写如下方法：

@override
publicvoidaddresourcehandlers(resourcehandlerregistry registry) {
registry.addresourcehandler("/mystatic/**")
   .addresourcelocations("classpath:/mystatic/");
}

这种方式会在默认的基础上增加/mystatic/**映射到classpath:/mystatic/，不会影响默认的方式，可以同时使用。

静态资源映射还有一个配置选项，为了简单这里用.properties方式书写：

spring.mvc.static-path-pattern=/** # path pattern used forstatic resources. 

这个配置会影响默认的/，例如修改为/static/后，只能映射如/static/js/sample.js这样的请求（修改前是/js/sample.js）。这个配置只能写一个值，不像大多数可以配置多个用逗号隔开的。

4.2. 使用注意

例如有如下目录结构：

└─resources
│ application.yml
 │
 ├─static
│ ├─css
│ │index.css
 │ │
│ └─js
 │   index.js
 │
 └─templates
index.ftl

在index.ftl中该如何引用上面的静态资源呢？

如下写法：

<linkrel="stylesheet"type="text/css"href="/css/index.css" rel="external nofollow" >
<scripttype="text/javascript"src="/js/index.js"></script>

注意：默认配置的/**映射到/static（或/public ，/resources，/meta-inf/resources）

当请求/css/index.css的时候，spring mvc 会在/static/目录下面找到。

如果配置为/static/css/index.css，那么上面配置的几个目录下面都没有/static目录，因此会找不到资源文件！

所以写静态资源位置的时候，不要带上映射的目录名（如/static/，/public/，/resources/，/meta-inf/resources/）！

4.3. 使用webjars

webjars：

例如使用jquery，添加依赖：

<dependency>
<groupid>org.webjars</groupid>
<artifactid>jquery</artifactid>
<version>1.11.3</version>
</dependency>

然后可以如下使用：

<scripttype="text/javascript"
src="/webjars/jquery/1.11.3/jquery.js"></script>

你可能注意到href中的1.11.3版本号了，如果仅仅这么使用，那么当我们切换版本号的时候还要手动修改href，怪麻烦的，我们可以用如下方式解决。

先在pom.xml中添加依赖：

<dependency>
<groupid>org.webjars</groupid>
<artifactid>webjars-locator</artifactid>
</dependency>

增加一个webjarcontroller：

@controller
publicclasswebjarcontroller {
privatefinalwebjarassetlocatorassetlocator = newwebjarassetlocator();

@responsebody
@requestmapping("/webjarslocator/{webjar}/**")
publicresponseentitylocatewebjarasset(@pathvariable string webjar, httpservletrequest request) {
try {
   string mvcprefix = "/webjarslocator/" + webjar + "/";
   string mvcpath = 
(string) request.getattribute(handlermapping.path_within_handler_mapping_attribute);
   string fullpath = 
assetlocator.getfullpath(webjar, mvcpath.substring(mvcprefix.length()));
returnnewresponseentity(newclasspathresource(fullpath), httpstatus.ok);
  } catch (exception e) {
returnnewresponseentity<>(httpstatus.not_found);
  }
 }
}

然后使用的时候按照如下方式：

<script type="text/javascript"src="/webjarslocator/jquery/jquery.js"></script>

注意：这里不需要在写版本号了，但是注意写url的时候，只是在原来url基础上去掉了版本号，其他的都不能少！

4.4. 静态资源版本管理

spring mvc 提供了静态资源版本映射的功能。

用途：当我们资源内容发生变化时，由于浏览器缓存，用户本地的静态资源还是旧的资源，为了防止这种情况导致的问题，我们可能会手动在请求url的时候加个版本号或者其他方式。

版本号如：

<script type="text/javascript"src="/js/sample.js?v=1.0.1"></script>

spring mvc 提供的功能可以很容易的帮助我们解决类似问题。

spring mvc 有两种解决方式。

注意：下面的配置方式针对freemarker模板方式，其他的配置方式可以参考。

4.4.1. 资源名-md5 方式

<link rel="stylesheet"type="text/css"href="/css/index-2b371326aa93ce4b611853a309b69b29.css" rel="external nofollow" >
 

spring 会自动读取资源md5，然后添加到index.css的名字后面，因此当资源内容发生变化的时候，文件名发生变化，就会更新本地资源。

配置方式：

在application.properties中做如下配置：

spring.resources.chain.strategy.content.enabled=true
spring.resources.chain.strategy.content.paths=/**

这样配置后，所有/**请求的静态资源都会被处理为上面例子的样子。

到这儿还没完，我们在写资源url的时候还要特殊处理。

首先增加如下配置：

@controlleradvice
publicclasscontrollerconfig {
@autowired
resourceurlproviderresourceurlprovider;
@modelattribute("urls")
publicresourceurlproviderurls() {
returnthis.resourceurlprovider;
 }
}

 然后在页面写的时候用下面的写法：

<linkrel="stylesheet"type="text/css"href="${urls.getforlookuppath('/css/index.css')}" rel="external nofollow" >

 

使用urls.getforlookuppath(‘/css/index.css')来得到处理后的资源名。

4.4.2. 版本号方式

在application.properties中做如下配置：

spring.resources.chain.strategy.fixed.enabled=true
spring.resources.chain.strategy.fixed.paths=/js/**,/v1.0.0/**
spring.resources.chain.strategy.fixed.version=v1.0.0

这里配置需要特别注意，将version的值配置在paths中。

在页面写的时候，写法如下：

<script type="text/javascript"src="${urls.getforlookuppath('/js/index.js')}"></script>

注意，这里仍然使用了urls.getforlookuppath，urls配置方式见上一种方式。

在请求的实际页面中，会显示为：

<script type="text/javascript"src="/v1.0.0/js/index.js"></script>

可以看到这里的地址是/v1.0.0/js/index.js。

4.5. 静态资源版本管理处理过程

在freemarker模板首先会调用urls.getforlookuppath方法，返回一个/v1.0.0/js/index.js或/css/index-2b371326aa93ce4b611853a309b69b29.css。

这时页面上的内容就是处理后的资源地址。这之后浏览器发起请求。

这里分开说。

第一种md5方式

请求/css/index-2b371326aa93ce4b611853a309b69b29.css，我们md5配置的paths=/**，所以spring mvc 会尝试url中是否包含-，如果包含会去掉后面这部分，然后去映射的目录（如/static/）查找/css/index.css文件，如果能找到就返回。

第二种版本方式

请求/v1.0.0/js/index.js。

如果我们paths中没有配置/v1.0.0，那么上面这个请求地址就不会按版本方式来处理，因此会找不到上面的资源。

如果配置了/v1.0.0，spring 就会将/v1.0.0去掉再去找/js/index.js，最终会在/static/下面找到。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。