SpringBoot

SpringBoot

九月 18, 2019

This is SpringBoot

1
$ SpringBoot

一、 Spring介绍

1.1、SpringBoot简介

在我们第1次接触和学习Spring框架的时候，是否因为其繁杂的配置而退却了？在你第n次使用Spring框架的时候，是否觉得一堆反复黏贴的配置有一些厌烦？那么您就不妨来试试使用Spring Boot来让你更易上手，更简单快捷地构建Spring应用！
Spring Boot让我们的Spring应用变的更轻量化。比如：你可以仅仅依靠一个Java类来运行一个Spring引用。你也可以打包你的应用为jar并通过使用java -jar来运行你的Spring Web应用。
Spring Boot的主要优点：
为所有Spring开发者更快的入门
开箱即用，提供各种默认配置来简化项目配置
内嵌式容器简化Web项目
没有冗余代码生成和XML配置的要求

1.2、系统要求：

Java 8及以上
Spring Framework 4.1.5及以上
本文采用Java 1.8.0_74、Spring Boot 2.1.7调试通过。

二、快速入门

2.1、创建一个Maven工程

名为”springboot-helloworld” 类型为Jar工程项目

2.2、pom文件引入依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
  <parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.1.7.RELEASE</version>
	<relativePath/> <!-- lookup parent from repository -->
</parent>	
<dependencies>
  <!--SpringBoot web 组件 -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
</dependencies>
spring-boot-starter-parent作用
在pom.xml中引入spring-boot-start-parent,spring官方的解释叫什么stater poms,它可以提供dependency management,也就是说依赖管理，引入以后在申明其它dependency的时候就不需要version了，后面可以看到。
spring-boot-starter-web作用
springweb 核心组件

2.3、编写HelloWorld服务

创建package命名为com.briup.controller（根据实际情况修改）
创建HelloController类，内容如下

@SpringBootApplication
@RestController
public class HelloController {
@RequestMapping(“/hello”)
public String hello() {
return “hello”;
}
public static void main(String[] args) {
//开始运行
SpringApplication.run(HelloController.class, args);
}
}

2.4、@RestController

在上加上RestController 表示修饰该Controller所有的方法返回JSON格式,直接可以编写

Restful接口

2.5、@SpringBootApplication

注解:作用在于让 Spring Boot   根据应用所声明的依赖来对 Spring 框架进行自动配置
    这个注解告诉Spring Boot根据添加的jar依赖猜测你想如何配置Spring。由于spring-boot-starter-web添加了Tomcat和Spring MVC，所以auto-configuration将假定你正在开发一个web应用并相应地对Spring进行设置。

2.6 SpringApplication.run(HelloController.class, args);

标识为启动类

2.7、SpringBoot启动方式1

Springboot默认端口号为8080
1
2
3
4
5
6
7
8
9
10
11
12
@SpringBootApplication
@RestController
public class TestController {
	@RequestMapping("/hello")
   public String hello() {
			   return "success";
   }	
	public static void main(String[] args) {
		//开始运行
		SpringApplication.run(TestController.class, args);
	}
}
启动主程序，打开浏览器访问http://localhost:8080/hello，可以看到页面输出success

2.8、SpringBoot启动方式2

1
2
3
4
5
6
7
8
@ComponentScan(basePackages = "com.briup.controller")---控制器扫包范围
@SpringBootApplication
@ComponentScan(basePackages="com.briup.controller")
public class Application{
	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}
}

三、 Web开发

3.1、静态资源访问

在我们开发Web应用的时候，需要引用大量的js、css、图片等静态资源。
默认配置
Spring Boot默认提供静态资源目录位置需置于classpath下，目录名需符合如下规则：
/static
/public
/resources
/META-INF/resources
举例：我们可以在src/main/resources/目录下创建static，在该位置放置一个图片文件。启动程序后，尝试访问http://localhost:8080/D.jpg。如能显示图片，配置成功。

3.2、全局捕获异常

@ExceptionHandler 表示拦截异常
•    @ControllerAdvice 是 controller 的一个辅助类，最常用的就是作为全局异常处理的切面类
•    @ControllerAdvice 可以指定扫描范围
•    @ControllerAdvice 约定了几种可行的返回值，如果是直接返回 model 类的话，需要使用 @ResponseBody 进行 json 转换
o    返回 String，表示跳到某个 view
o    返回 modelAndView
o    返回 model + @ResponseBody
1
2
3
4
5
6
7
8
9
10
11
@ControllerAdvice
public class GlobalExceptionHandler {
	@ExceptionHandler(RuntimeException.class)
	@ResponseBody 
	public Map<String, Object> exceptionHandler() {
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("errorCode", "500");
		map.put("errorMsg", "系統错误!");
		return map;
	}
}

3.3、渲染Web页面

渲染Web页面
在之前的示例中，我们都是通过@RestController来处理请求，所以返回的内容为json对象。那么如果需要渲染html页面的时候，要如何实现呢？
模板引擎
在动态HTML实现上Spring Boot依然可以完美胜任，并且提供了多种模板引擎的默认配置支持，所以在推荐的模板引擎下，我们可以很快的上手开发动态网站。
Spring Boot提供了默认配置的模板引擎主要有以下几种：
• Thymeleaf
• FreeMarker
• Velocity
• Groovy
• Mustache
当你使用上述模板引擎中的任何一个，它们默认的模板配置路径为：src/main/resources/templates。当然也可以修改这个路径，具体如何修改，可在后续各模板引擎的配置属性中查询并修改。

3.4、使用Freemarker模板引擎渲染web视图

3.4.1、pom文件引入:
<!-- 引入freeMarker的依赖包. -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>
3.4.2、后台代码

在src/main/resources/创建一个templates文件夹,后缀为*.ftl

1
2
3
4
5
@RequestMapping("/index")
public String index(Map<String, Object> map) {
    map.put("name","美丽的天使...");
	return "index";
}
3.4.3、前台代码
1
2
3
4
5
6
7
8
9
10
<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8" />
<title></title>
</head>
<body>
	  ${name}
</body> 
</html>
3.4.4、Freemarker其他用法
1
2
3
4
5
6
7
8
9
10
11
@RequestMapping("/index")
 public String index(ModelMap map) {
	 map.addAttribute("name","潘广闯");
	 map.put("sex",1);
	 List<String> users=new ArrayList<>();
	 users.add("张三");
	 users.add("李四");
	 users.add("王五");
	 map.addAttribute("users", users);
	 return "index";
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8" />
<title></title>
</head>
<body>
	  ${name}
	  <#if sex==1>
	   男
	   <#elseif sex==2>
	   女
	   <#else>
	   其他
	   </#if>
	<#list users as user>
	   ${user}
	 </#list>
	
</body> 
</html>
3.4.5、Freemarker配置

新建application.properties文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
########################################################
###FREEMARKER (FreeMarkerAutoConfiguration)
########################################################
spring.freemarker.allow-request-override=false
spring.freemarker.cache=true
spring.freemarker.check-template-location=true
spring.freemarker.charset=UTF-8
spring.freemarker.content-type=text/html
spring.freemarker.expose-request-attributes=false
spring.freemarker.expose-session-attributes=false
spring.freemarker.expose-spring-macro-helpers=false
#spring.freemarker.prefix=
#spring.freemarker.request-context-attribute=
#spring.freemarker.settings.*=
spring.freemarker.suffix=.ftl
spring.freemarker.template-loader-path=classpath:/templates/
#comma-separated list
#spring.freemarker.view-names= # whitelist of view names that can be resolved

3.5、使用JSP渲染Web视图

3.5.1、pom文件引入以下依赖
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.7.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<dependencies>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
<dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
		</dependency>
			</dependencies>
3.5.2、在application.properties创建以下配置

spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp

3.5.3、后台代码
1
2
3
4
5
6
7
@Controller
public class IndexController {
	@RequestMapping("/index")
	public String index() {
		return "index";
	}
}

四、 数据访问

4.1、springboot整合使用JdbcTemplate

4.1.1 pom文件引入
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.7.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<dependencies>
	<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>
		
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.37</version>
		</dependency>
			</dependencies>
4.1.2 application.properties新增配置
1
2
3
4
spring.datasource.url=jdbc:mysql://localhost:3306/test?autoReconnect=true&useUnicode=true&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name= com.mysql.jdbc.Driver

4.1.3 UserDAO类

1
2
3
4
5
6
7
8
9
10
11
@Repository
public class UserDaoImpl implements UserDao{
	@Autowired
    private JdbcTemplate jdbcTemplate;
	
	public void save() {
		 jdbcTemplate.update("insert into T_USER(ID,NAME) values(?, ?)", 1, "lisi");
		
	}

}

4.1.4 App类

1
2
3
4
5
6
7
@SpringBootApplication
@ComponentScan(basePackages= {"com.briup.controller","com.briup.dao"})
public class Application{
	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}
	}
注意: spring-boot-starter-parent要在1.5以上
将来可能遇到驱动名为com.mysql.cj.jdbc.Driver，现在高版本的mysql都是这种驱动，但由于我们版本低需要用老的形式，以及mysql配置也许你会看到
1
2
3
4
5
<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>

这种默认就是parent指定的高版本，一般和上面的驱动匹配，但我们版本低才需要指定版本

4.2、springboot整合使用mybatis

4.2.1、pom文件引入
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.1.7.RELEASE</version>
	<relativePath/> <!-- lookup parent from repository -->
</parent>
<dependencies>

	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
	<dependency>
		<groupId>org.mybatis.spring.boot</groupId>
		<artifactId>mybatis-spring-boot-starter</artifactId>
		<version>1.3.2</version>
	</dependency>

	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>5.1.37</version>
	</dependency>
</dependencies>
4.2.2、配置文件引入
spring.datasource.url=jdbc:mysql://localhost:3306/test?autoReconnect=true&useUnicode=true&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
4.2.3、Mapper代码，注解方式
1
2
3
4
5
6
public interface UserMapper {
	@Select("SELECT * FROM USERS WHERE NAME = #{name}")
	User findByName(@Param("name") String name);
	@Insert("INSERT INTO USERS(NAME, AGE) VALUES(#{name}, #{age})")
	int insert(@Param("name") String name, @Param("age") Integer age);
}
4.2.4、启动方式
1
2
3
4
5
6
7
8
@SpringBootApplication
@ComponentScan(basePackages="com.briup.controller")
@MapperScan(basePackages="com.briup.mapper")
public class Application {
	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}
}
4.2.5、配置文件引入，xml形式
mybatis.config-location=classpath:mybatis/mybatis-config.xml
mybatis.mapper-locations=classpath:mybatis/mapper/*.xml
mybatis.type-aliases-package=com.briup.entity
4.2.6、Mapper代码，xml形式
1
2
3
4
5
6
7
public interface UserMapper {
	@Select("SELECT * FROM USERS WHERE NAME = #{name}")
	User findByName(@Param("name") String name);
	@Insert("INSERT INTO USERS(NAME, AGE) VALUES(#{name}, #{age})")
	int insert(@Param("name") String name, @Param("age") Integer age);
List<User> getAll();
}
在resource下创建mybatis目录放入mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 如果需要，可以在这里使用原来的方式配置相关信息 -->
</configuration>

在mybatis包下创建mapper文件夹写入UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.briup.mapper.UserMapper" >
    <select id="getAll" resultType="User">
       SELECT 
            id, name, age
       FROM users
    </select>

</mapper>

4.3、springboot整合多数据源

同学们思考下，你们在项目中有使用到多数据源吗？

4.3.1配置文件中新增两个数据源
1
2
3
4
5
6
7
8
9
spring.datasource.test1.driverClassName = com.mysql.jdbc.Driver
spring.datasource.test1.jdbc-url = jdbc:mysql://localhost:3306/test01?useUnicode=true&characterEncoding=utf-8
spring.datasource.test1.username = root
spring.datasource.test1.password = root

spring.datasource.test2.driverClassName = com.mysql.jdbc.Driver
spring.datasource.test2.jdbc-url = jdbc:mysql://localhost:3306/test02?useUnicode=true&characterEncoding=utf-8
spring.datasource.test2.username = root
spring.datasource.test2.password = root
4.3.2配置文件中新增两个数据源
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
@Configuration // 注册到springboot容器中
@MapperScan(basePackages="com.briup.test1",sqlSessionFactoryRef = "test1SqlSessionFactory")
public class Datasource1 {
	@Bean(name = "test1DataSource")
	@Primary
	@ConfigurationProperties(prefix = "spring.datasource.test1")//加载的数据源
	public DataSource testDataSource() {
		return DataSourceBuilder.create().build();
	}

	/**
	 * 
	 * @methodDesc: 功能描述:(test1 sql会话工厂)
	
	 */
	@Bean(name = "test1SqlSessionFactory")
	@Primary
	public SqlSessionFactory testSqlSessionFactory(@Qualifier("test1DataSource") DataSource dataSource)
			throws Exception {
		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
		bean.setDataSource(dataSource);
		//等同于springmvc中读取mapper的xml一样
//		bean.setMapperLocations(
//				new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/test1/*.xml"));
		return bean.getObject();
	}

	/**
	 * 
	 * @methodDesc: 功能描述:(test1 事物管理)
	 */
	@Bean(name = "test1TransactionManager")
	@Primary
	public DataSourceTransactionManager testTransactionManager(@Qualifier("test1DataSource") DataSource dataSource) {
		return new DataSourceTransactionManager(dataSource);
	}

	@Bean(name = "test1SqlSessionTemplate")
	public SqlSessionTemplate testSqlSessionTemplate(
			@Qualifier("test1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
		return new SqlSessionTemplate(sqlSessionFactory);
	}
}
4.3.2创建分包Mapper
1
2
3
4
public interface User1Mapper {
	@Insert("insert into users values(null,#{name},#{age});")
	public int addUser(@Param("name") String name, @Param("age") Integer age);
}
4.3.3启动项目
1
2
3
4
5
6
7
8
@SpringBootApplication
@ComponentScan(basePackages= {"com.briup.controller","com.briup.datasource"})
@MapperScan(basePackages= {"com.briup.test1.mapper","com.briup.test2.mapper"})
public class Application{
	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}
}

五、 事物管理

5.1.1springboot整合事物管理
springboot默认集成事物,只主要在方法上加上@Transactional即可

六、 日志管理

6.1使用log4j记录日志

6.1.2新建log4j配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#log4j.rootLogger=CONSOLE,info,error,DEBUG
log4j.rootLogger=info,error,CONSOLE,DEBUG
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender     
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout     
log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n     
log4j.logger.info=info
log4j.appender.info=org.apache.log4j.DailyRollingFileAppender
log4j.appender.info.layout=org.apache.log4j.PatternLayout     
log4j.appender.info.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.info.datePattern='.'yyyy-MM-dd
log4j.appender.info.Threshold = info   
log4j.appender.info.append=true   
#log4j.appender.info.File=/home/admin/pms-api-services/logs/info/api_services_info
log4j.appender.info.File=/Users/dddd/Documents/testspace/pms-api-services/logs/info/api_services_info
log4j.logger.error=error  
log4j.appender.error=org.apache.log4j.DailyRollingFileAppender
log4j.appender.error.layout=org.apache.log4j.PatternLayout     
log4j.appender.error.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.error.datePattern='.'yyyy-MM-dd
log4j.appender.error.Threshold = error   
log4j.appender.error.append=true   
#log4j.appender.error.File=/home/admin/pms-api-services/logs/error/api_services_error
log4j.appender.error.File=/Users/dddd/Documents/testspace/pms-api-services/logs/error/api_services_error
log4j.logger.DEBUG=DEBUG
log4j.appender.DEBUG=org.apache.log4j.DailyRollingFileAppender
log4j.appender.DEBUG.layout=org.apache.log4j.PatternLayout     
log4j.appender.DEBUG.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.DEBUG.datePattern='.'yyyy-MM-dd
log4j.appender.DEBUG.Threshold = DEBUG   
log4j.appender.DEBUG.append=true   
#log4j.appender.DEBUG.File=/home/admin/pms-api-services/logs/debug/api_services_debug
log4j.appender.DEBUG.File=/Users/dddd/Documents/testspace/pms-api-services/logs/debug/api_services_debug
6.1.3、pom文件引入依赖
1
2
3
4
5
<dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-log4j</artifactId>
           <version>1.3.8.RELEASE</version>
       </dependency>

七、 缓存支持

7.1注解配置与EhCache使用

7.1.1 pom文件引入
1
2
3
4
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
7.1.2新建ehcache.xml 文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
	updateCheck="false">
	<diskStore path="java.io.tmpdir/Tmp_EhCache" />

	<!-- 默认配置 -->
	<defaultCache maxElementsInMemory="5000" eternal="false"
		timeToIdleSeconds="120" timeToLiveSeconds="120"
		memoryStoreEvictionPolicy="LRU" overflowToDisk="false" />

	<cache name="baseCache" maxElementsInMemory="10000"
		maxElementsOnDisk="100000" />

</ehcache>

配置信息介绍

 name:缓存名称。  
 maxElementsInMemory：缓存最大个数。  
 eternal:对象是否永久有效，一但设置了，timeout将不起作用。  
 timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。  
 timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。  
 overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。  
 diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。  
 maxElementsOnDisk：硬盘最大缓存个数。  
diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.  
 diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。  
 memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。  
 clearOnFlush：内存数量最大时是否清除。
7.1.3代码使用Cacheable
1
2
3
4
5
6
@CacheConfig(cacheNames = "baseCache")
public interface UserMapper {
	@Cacheable
	@Select("SELECT * FROM USERS WHERE name = #{name}")
	User findByName(@Param("name") String name);
	}
7.1.4清除缓存
1
2
3
4
5
6
7
8
@Autowired
private CacheManager cacheManager;
@RequestMapping("/remoKey")
public void remoKey() {
	cacheManager.getCache("baseCache").clear();
}
启动的地方还要加个注解用来开启缓存
@EnableCaching//开启注解

7.2使用Redis做集中式缓存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Pom.xml中引入信息
<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
在application.properties中配置redis相关信息
spring.redis.database=0
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.timeout=5000
对于springboot集成redis用到模板类RedisTemplate
该类中有以下形式
redisTemplate.opsForValue();//操作字符串
redisTemplate.opsForHash();//操作hash
redisTemplate.opsForList();//操作list
redisTemplate.opsForSet();//操作set
redisTemplate.opsForZSet();//操作有序set

举例
存储User对象

八、 其他内容

8.1、自定义参数

配置文件值
name=briup.com

配置文件值
    @Value("${name}")
    private String name;
@ResponseBody
    @RequestMapping("/getValue")
    public String getValue() {
        return name;
    }

8.2、多环境配置

spring.profiles.active=pre

application-dev.properties：开发环境
application-test.properties：测试环境
application-prod.properties：生产环境
8.3、修改端口号
server.port=8888 
server.context-path=/briup
8.4、SpringBoot yml 使用
创建application.yml，也可以自定义参数结构满足yml格式，使用方式和8.1一样
server:
  port:  8090
  context-path: /briup

8.5、发布打包

打包jar工程
执行Maven install，选中项目中target文件夹，刷新一下，将会产生jar包
打包web工程
在pom文件中新增
    在pom.xml里设置
packaging>war</packaging>
添加tomcat依赖
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-tomcat</artifactId>
 <scope>provided</scope>
</dependency>
<!--生成项目名称-->
<build>
    <finalName>jsp1</finalName>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

启动类继承SpringBootServletInitializer
重写configure方法
项目运行run as—maven build..

九、 热部署

9.1 什么是热部署

所谓的热部署：比如项目的热部署，就是在应用程序在不停止的情况下，实现新的部署

9.2 项目演示案例

@RestController
@Slf4j
public class IndexController {
    @RequestMapping("/index")
    public String index() {
        String result = "springboot2.0 V1.0";
                Int age=26;
        return result + age;
    }

}

9.3 热部署原理

spring-boot-devtools 是一个为开发者服务的一个模块，其中最重要的功能就是自动应用代码更改到最新的App上面去。原理是在发现代码有更改之后，重新启动应用，但是速度比手动停止后再启动还要更快，更快指的不是节省出来的手工操作的时间。  
其深层原理是使用了两个ClassLoader，一个Classloader加载那些不会改变的类（第三方Jar包），另一个ClassLoader加载会更改的类，称为  restart ClassLoader  ,这样在有代码更改的时候，原来的restart ClassLoader 被丢弃，重新创建一个restart ClassLoader，由于需要加载的类相比较少，所以实现了较快的重启时间（5秒以内）

9.4 Devtools依赖

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

9.5 Devtools原理

1. devtools会监听classpath下的文件变动，并且会立即重启应用（发生在保存时机），注意：因为其采用的虚拟机机制，该项重启是很快的。  
2. devtools可以实现页面热部署（即页面修改后会立即生效，这个可以直接在application.properties文件中配置spring.thymeleaf.cache=false来实现(这里注意不同的模板配置不一样)

十、 性能优化

10.1 将Servlet容器变成Undertow

默认情况下，Spring Boot 使用 Tomcat 来作为内嵌的 Servlet 容器可以将 Web 服务器切换到 Undertow 来提高应用性能。Undertow 是一个采用 Java 开发的灵活的高性能 Web 服务器，提供包括阻塞和基于 NIO 的非堵塞机制。Undertow 是红帽公司的开源产品，是 Wildfly 默认的 Web 服务器。首先，从依赖信息里移除

** Tomcat 配置：**

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
			<exclusions>
                           <!—排除tomcat依赖-
				<exclusion>
					<groupId>org.springframework.boot</groupId>
					<artifactId>spring-boot-starter-tomcat</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
然后添加 Undertow：
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-undertow</artifactId>
</dependency>

服务器名称 第一次运行 第二次运行 第三次运行 平均值
Tomcat 58.5 60 59.4
Undertow 62.5 60 89.5