Spring Boot入门

科技2026-04-21 5

1. Spring Boot概述

1.1. 什么是Spring Boot

一般把Spring Boot称为搭建程序的脚手架或者说是便捷搭建基于Spring的工程脚手架。其最主要作用就是帮助开发人员快速的构建庞大的spring项目，并且尽可能的减少一切xml配置，做到开箱即用，迅速上手，让开发人员关注业务而非配置。

1.2. 为什么要学习Spring Boot

java一直被人诟病的一点就是臃肿、麻烦。当我们还在辛苦的搭建项目时，可能Python程序员已经把功能写好了，究其原因注意是两点：复杂的配置: 项目各种配置其实是开发时的损耗，因为在思考 Spring 特性配置和解决业务问题之间需要进行思维切换，所以写配置挤占了写应用程序逻辑的时间。一个是混乱的依赖管理: 项目的依赖管理也是件吃力不讨好的事情。决定项目里要用哪些库就已经够让人头痛的了，你还要知道这些库的哪个版本和其他库不会有冲突，这难题实在太棘手。并且，依赖管理也是一种损耗，添加依赖不是写应用程序代码。一旦选错了依赖的版本，随之而来的不兼容问题毫无疑问会是生产力杀手。而Spring Boot让这一切成为过去！

Spring Boot 简化了基于Spring的应用开发，只需要“run”就能创建一个独立的、生产级别的Spring应用。Spring Boot为Spring平台及第三方库提供开箱即用的设置（提供默认设置，存放默认配置的包就是启动器 starter），这样我们就可以简单的开始。多数Spring Boot应用只需要很少的Spring配置。我们可以使用Spring Boot创建java应用，并使用java –jar 启动它，就能得到一个生产级别的web工程。

1.3. Spring Boot的特点

创建独立的Spring应用，为所有 Spring 的开发者提供一个非常快速的、广泛接受的入门体验直接嵌入应用服务器，如tomcat、jetty、undertow等；不需要去部署war包提供固定的启动器依赖去简化组件配置；实现开箱即用（启动器starter-其实就是Spring Boot提供的一个jar包），通过自己设置参数（.properties或.yml的配置文件），即可快速使用。自动地配置Spring和其它有需要的第三方依赖提供了一些大型项目中常见的非功能性特性，如内嵌服务器、安全、指标，健康检测、外部化配置等绝对没有代码生成，也无需 XML 配置。

2. Spring Boot入门

目标：能够使用Spring Boot搭建项目分析：需求：可以在浏览器中访问http://localhost:8080/hello输出一串字符实现步骤：创建工程；添加依赖（启动器依赖，spring-boot-starter-web）；创建启动类；创建处理器Controller；测试；

创建一个新的模块

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>  <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.1.5.RELEASE</version> </parent> <groupId>com.cls</groupId> <artifactId>cls-springboot</artifactId> <version>1.0-SNAPSHOT</version> <properties> <java.version>1.8</java.version> </properties> <dependencies>  <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies> </project>

启动引导类(等会直接运行这个main即可启动项目):

package com.cls; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; /** * @author cls * @version 1.0 * @date 2020/10/8/0008 */ /** * spring boot 工程都有一个启动引导类，这是工程的入口， * 并在引导类上加上 @SpringBootApplication 注解（是一个组合注解） */ @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } }

controller层:

package com.cls.controller; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; /** * @author cls * @version 1.0 * @date 2020/10/8/0008 */ @RestController public class HelloController { @GetMapping("hello") public String hello(){ return "hello spring boot"; } }

启动项目：运行main

**Spring Boot工程可以通过添加启动器依赖和创建启动引导类实现快速创建web工程。spring-boot-starter-web默认的应用服务器端口是8080,Spring Boot项目通过main函数即可启动，直接运行main函数即可 **

3.java配置应用

在入门案例中，我们没有任何的配置，就可以实现一个SpringMVC的项目了，快速、高效！但是有同学会有疑问，如果没有任何的xml，那么我们如果要配置一个Bean该怎么办？比如我们要配置一个数据库连接池，以前会入下配置，但是在spring boot中不建议使用xml配置文件的，建议使用java代码配置所有的组件。 jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/ssm?characterEncoding=utf-8 #characterEncoding=UTF-8 插入数据库中的数据可能会乱码 jdbc.name=root jdbc.password=root

接下来用java配置来尝试实现连接池配置：

3.1尝试java配置(第一种方式)

java配置主要靠java类和一些注解，比较常用的注解有： @Configuration ：声明一个类作为配置类，代替xml文件 @Bean ：声明在方法上，将方法的返回值加入Bean容器，代替标签 @Value ：属性注入 @PropertySource ：指定外部属性文件，

1.在 pom.xml 文件中添加Druid连接池依赖如下

<dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.6</version> </dependency> 然后在项目中创建 G:\MyProject\clsspringboot\src\main\resources\jdbc.properties 文件，内容如下: jdbc.driverClassName=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://127.0.0.1:3306/springboot_test jdbc.username=root jdbc.password=root 编写G:\MyProject\clsspringboot\src\main\java\com\cls\config\JdbcConfig.java如下: package com.cls.config; import com.alibaba.druid.pool.DruidDataSource; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.autoconfigure.jdbc.JdbcProperties; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.PropertySource; import javax.sql.DataSource; /** * @author cls * @version 1.0 * @date 2020/10/8/0008 */ /*@Configuration ：声明我们 JdbcConfig 是一个配置类 @PropertySource ：指定属性文件的路径是: classpath:jdbc.properties 通过 @Value 为属性注入值通过@Bean将 dataSource() 方法声明为一个注册Bean的方法，Spring会自动调用该方法，将方法的返回值加入Spring容器中。然后我们就可以在任意位置通过 @Autowired 注入DataSource了*/ @Configuration @PropertySource("classpath:jdbc.properties") public class JdbcConfig { @Value("${jdbc.url}") String url; @Value("${jdbc.driverClassName}") String driverClassName; @Value("${jdbc.username}") String username; @Value("${jdbc.password}") String password; @Bean public DataSource dataSource() { DruidDataSource dataSource = new DruidDataSource(); dataSource.setDriverClassName(driverClassName); dataSource.setUrl(url); dataSource.setUsername(username); dataSource.setPassword(password); return dataSource; } }

测试注入的DataSource：

3.2Spring Boot的属性注入(第二种方式)

在上面的案例中，我们实验了java配置方式。不过属性注入使用的是@Value注解。这种方式虽然可行，但是不够强大，因为它只能注入基本类型值，而且读取一个要编写一次很麻烦。在Spring Boot中，提供了一种新的属性注入方式，支持各种java基本数据类型及复杂类型的注入。

需求：将配置文件中的配置项读取到一个对象中；实现：可以使用Spring Boot提供的注解@ConfigurationProperties，该注解可以将Spring Boot的配置文件（默认必须为application.properties或application.yml）中的配置项读取到一个对象中。 (1)创建配置项类JdbcProperties类，在该类名上面添加@ConfigurationProperties；在类上通过@ConfifigurationProperties注解声明当前类为属性读取类 prefix=“jdbc” 读取属性文件中，前缀为jdbc的值。在类上定义各个属性，名称必须与属性文件中 jdbc. 后面部分一致

package com.cls.config; import org.springframework.boot.context.properties.ConfigurationProperties; /** * ConfigurationProperties 从application配置文件中读取配置项 * prefix 表示配置项的前缀 * 配置项类中的类变量名必须要与前缀之后的配置项名称保持松散绑定（相同） */ @ConfigurationProperties(prefix = "jdbc") public class JdbcProperties { private String url; private String driverClassName; private String username; private String password; public String getUrl() { return url; } public void setUrl(String url) { this.url = url; } public String getDriverClassName() { return driverClassName; } public void setDriverClassName(String driverClassName) { this.driverClassName = driverClassName; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } }

如果要去掉上述的提示，则可以在 pom.xml 文件中添加如下依赖：

<dependency> <groupId> org.springframework.boot </groupId> <artifactId>spring-boot-configuration-processor</artifactId>  <optional>true</optional> </dependency>

(2)将jdbc.properties修改名称为application.properties；

(3)将JdbcProperties对象注入到JdbcConfig；

测试注入的DataSource：

3.3更优雅的注入（第三种方式）

不需要使用JdbcProperties这个配置类，直接JdbcConfig中返回即可

package com.cls.config; import com.alibaba.druid.pool.DruidDataSource; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.PropertySource; import javax.sql.DataSource; /** * @author cls * @version 1.0 * @date 2020/10/8/0008 */ /*@Configuration ：声明我们 JdbcConfig 是一个配置类然后我们就可以在任意位置通过 @Autowired 注入DataSource了*/ @Configuration public class JdbcConfig { @Bean @ConfigurationProperties(prefix = "jdbc") public DataSource dataSource() { return new DruidDataSource(); } } ```![ \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KwAu9kiH-1602169517191)(en-resource://database/1345:1)\]](https://img-blog.csdnimg.cn/20201008230852782.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9zaGlndWFuZzM=,size_16,color_FFFFFF,t_70#pic_center) #### 3.4Yaml配置文件配置文件除了可以使用application.properties类型，还可以使用后缀名为：.yml或者.yaml的类型，也就是：application.yml或者application.yaml yaml与properties配置文件除了展示形式不相同以外，其它功能和作用都是一样的；在项目中原路的读取方式不需要改变。 1）yml配置文件的特征：树状层级结构展示配置项；配置项之间如果有关系的话需要分行空两格；配置项如果有值的话，那么需要在 ' : ' 之后空一格再写配置项值；将application.properties配置文件修改为application.yml的话： ```yml jdbc: driverClassName: com.mysql.jdbc.Driver url: jdbc:mysql://127.0.0.1:3306/heima username: root password: root key: abc: cba def: - g - h - j

2）多个yml配置文件；在spring boot中是被允许的。这些配置文件的名称必须为application-***.yml，并且这些配置文件必须要在application.yml配置文件中激活之后才可以使用。

3）如果properties和yml配置文件同时存在在spring boot项目中；那么这两类配置文件都有效。在两个配置文件中如果存在同名的配置项的话会以properties文件的为主。

测试：

将之前的jdbc.properties修改为application.yml

多个yml文件 application.yml:

jdbc: driverClassName: com.mysql.jdbc.Driver url: jdbc:mysql://127.0.0.1:3306/springboot_test username: root password: root #激活配置文件;需要指定其它的配置文件名称 spring: profiles: active: abc,def

application-abc.yml

itcast: url: http://www.itcast.cn

application-def.yml

itheima: url: http://www.itheima.com package com.cls.controller; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; import javax.sql.DataSource; /** * @author cls * @version 1.0 * @date 2020/10/8/0008 */ @RestController public class HelloController { @Autowired private DataSource dataSource; @Value("${itcast.url}") private String itcastUrl; @Value("${itheima.url}") private String itheimaUrl; @GetMapping("hello") public String hello(){ System.out.println("DataSource = " + dataSource); System.out.println("itcastUrl = " + itcastUrl); System.out.println("itheimaUrl = " + itheimaUrl); return "hello spring boot"; } }

Application.yml文件中中文乱码或报错Caused by: org.yaml.snakeyaml.error.YAMLException: java.nio.charset.MalformedInputException: Input length = 1

如果还有问题再看看 #和注释的中文之间又没有空格，如有空格就把空格去掉再运行试试

4.自动配置原理

在 META-INF\spring.fatories文件中定义了很多自动配置类；可以根据在pom.xml文件中添加的启动器依赖自动配置组件通过如下流程可以去修改application配置文件，改变自动配置的组件默认参数

5.lombok应用

使用lombok的注解实现pojo类的简化分析：使用Spring Boot整合SSM工程；需要使用到数据库数据。

将数据库表数据导入到数据库中（springboot_test）；编写数据库表对应的实体类；一般情况下需要编写get/set/toString等这些方法会耗时并且会让实体类看起来比较臃肿。可以使用lombok插件对实体类进行简化。 lombok是一个插件工具类包；提供了一些注解@Data、@Getter等这些注解去简化实体类中的构造方法、get/set等方法的编写。在IDEA中安装lombok插件； 2.添加lombok对应的依赖到项目pom.xml文件； 3.改造实体类使用lombok注解小结：在Bean上使用： @Data ：自动提供getter和setter、hashCode、equals、toString等方法 @Getter：自动提供getter方法 @Setter：自动提供setter方法 @Slf4j：自动在bean中提供log变量，其实用的是slf4j的日志功能。 <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> </dependency> package com.cls.pojo; import lombok.Data; import java.util.Date; //在编译阶段会根据注解自动生成对应的方法；data包含get/set/hashCode/equals/toString等方法 @Data public class User { private Long id; private String userName; private String password; private String name; private Integer age; private Integer sex; private Date birthday; private String note; private Date created; private Date updated; }

6.Spring Boot整合

6.1 修改SpringMVC端口和静态资源存放目录

修改tomcat端口查询**.Properties，设置配置项（前缀+类变量名）到application配置文件中 #tomcat端口 server: port: 80 访问项目中的静态资源在spring boot项目中静态资源可以放置在如下目录：

6.2 SpringMVC拦截器

拦截器不是一个普通属性，而是一个类，所以就要用到java配置方式了。可以通过实现 WebMvcConfigurer 并添加 @Configuration 注解来实现自定义部分SpringMvc配置。

如果你想要保持Spring Boot 的一些默认MVC特征，同时又想自定义一些MVC配置（包括：拦截器，格式化器,视图控制器、消息转换器等等），你应该让一个类实现 WebMvcConfigurer ，并且添加 @Configuration 注解，但是千万不要加 @EnableWebMvc 注解。如果你想要自定义 HandlerMapping 、 HandlerAdapter 、ExceptionResolver 等组件，你可以创建一个 WebMvcRegistrationsAdapter 实例来提供以上组件。如果你想要完全自定义SpringMVC，不保留SpringBoot提供的一切特征，你可以自己定义类并且添加 @Configuration 注解和 @EnableWebMvc 注解

1.创建com.cls.interceptor.MyInterceptor拦截器：

package com.cls.interceptor; import lombok.extern.slf4j.Slf4j; import org.springframework.web.servlet.HandlerInterceptor; import org.springframework.web.servlet.ModelAndView; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; /** * @author cls * @version 1.0 * @date 2020/10/8/0008 */ @Slf4j public class MyInterceptor implements HandlerInterceptor { public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { //如果前置方法返回false则直接被拦截，不会向下走了 log.debug("这是MyInterceptor的preHandle方法"); return true; } public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { log.debug("这是MyInterceptor的postHandle方法"); } public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { log.debug("这是MyInterceptor的afterCompletion方法"); } }

2.定义配置类com.cls.config.MvcConfig，用于注册拦截器

package com.cls.config; import com.cls.interceptor.MyInterceptor; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.config.annotation.InterceptorRegistry; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; /** * @author cls * @version 1.0 * @date 2020/10/8/0008 */ @Configuration public class MvcConfig implements WebMvcConfigurer { //注册拦截器将拦截器注册到spring ioc容器 @Bean public MyInterceptor myInterceptor(){ return new MyInterceptor(); } /** * 重写该方法；往拦截器链添加自定义拦截器 * @param registry 拦截器链 */ public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(myInterceptor()).addPathPatterns("/*"); } }

测试： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hHMcmlFI-1602169517199)(en-resource://database/1361:1)\

6.3 事务和连接池

事务配置: spring中的jdbc连接和事务是配置中的重要一环，在SpringBoot中该如何处理呢？答案是不需要处理，我们只要找到SpringBoot提供的启动器即可，在 pom.xml 文件中添加如下依赖添加事务相关的启动器依赖，mysql相关依赖； <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> 编写业务类UserService使用事务注解@Transactional package com.cls.service; import com.cls.pojo.User; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; /** * @author cls * @version 1.0 * @date 2020/10/8/0008 */ @Service public class UserService { //根据id查询 public User findById(Long id){ return new User(); } //新增用户 @Transactional public void save(User user){ System.out.println("保存用户"); } } 数据库连接池hikari配置其实，在刚才引入jdbc启动器的时候，SpringBoot已经自动帮我们引入了一个连接池,HikariCP应该是目前速度最快的连接池了

我们只需要在application.yml添加修改配置如下:（把 JdbcConfig 类中的druid的配置删除或注释）

datasource: driver-class-name: com.mysql.jdbc.Driver url: jdbc:mysql://127.0.0.1:3306/springboot_test username: root password: root

6.4 整合Mybatis

SpringBoot官方并没有提供Mybatis的启动器，不过Mybatis官网自己实现了。在项目的 pom.xml 文件中加入如下依赖：  <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.0.1</version> </dependency> 配置 application.yml ，常用配置如下: mybatis: # 实体类别名包路径 type-aliases-package: com.cls.pojo # 映射文件路径 mapper-locations: classpath:mappers/*.xml configuration: log-impl: org.apache.ibatis.logging.stdout.StdOutImpl 配置Mapper扫描需要注意，这里没有配置mapper接口扫描包，因此我们需要给每一个Mapper接口添加 @Mapper 注解，才能被识别。 @Mapper public interface UserMapper { }

或者我们也可以不加注解，而是在启动类上添加扫描包注解(推荐)：

@SpringBootApplication //扫描mybatis所有的业务mapper接口 @MapperScan("com.cls.mapper") public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } }

6.5 整合-通用Mapper

通用Mapper：可以实现自动拼接sql语句；所有的mapper都不需要编写任何方法也就是不用编写sql语句。可以提高开发效率。配置通用Mapper组件到Spring Boot项目中并使用Mapper接口

通用Mapper的作者也为自己的插件编写了启动器，我们直接引入即可。在项目的 pom.xml 文件中加入如下依赖：  <dependency> <groupId>tk.mybatis</groupId> <artifactId>mapper-spring-boot-starter</artifactId> <version>2.1.5</version> </dependency>

注意：一旦引入了通用Mapper的启动器，会覆盖Mybatis官方启动器的功能，因此需要移除对官方Mybatis启动器的依赖。

编写UserMapper 无需任何配置就可以使用了。如果有特殊需要，可以到通用mapper官网查看：https://github.com/abel533/Mapper/wiki/3.confifig 编写com.cls.mapper.UserMapper 如下： package com.cls.mapper; import com.cls.pojo.User; import tk.mybatis.mapper.common.Mapper; /** * @author cls * @version 1.0 * @date 2020/10/8/0008 */ public interface UserMapper extends Mapper<User> { } 把启动类上的@MapperScan注解修改为通用mapper中自带的： package com.cls; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import tk.mybatis.spring.annotation.MapperScan; /** * @author cls * @version 1.0 * @date 2020/10/8/0008 */ /** * spring boot 工程都有一个启动引导类，这是工程的入口， * 并在引导类上加上 @SpringBootApplication 注解（是一个组合注解） */ @SpringBootApplication //扫描mybatis所有的业务mapper接口 //@MapperScan("com.cls.mapper") @MapperScan("com.cls.mapper") //通过mapper中的 tk包下 public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } 在User实体类上加JPA注解 package com.cls.pojo; import lombok.Data; import tk.mybatis.mapper.annotation.KeySql; import javax.persistence.Column; import javax.persistence.Id; import javax.persistence.Table; import java.util.Date; //在编译阶段会根据注解自动生成对应的方法；data包含get/set/hashCode/equals/toString等方法 @Data @Table(name = "tb_user") public class User { @Id //主键回填(就是插入一条数据后，将数据库中的主键值回填到实体类中的主键) @KeySql(useGeneratedKeys = true) private Long id; // @Column(name = "abc") // 将数据库中字段名为abc的值赋值到userName属性 private String userName; private String password; private String name; private Integer age; private Integer sex; private Date birthday; private String note; private Date created; private Date updated; } 对 UserService 的代码进行简单改造 package com.cls.service; import com.cls.mapper.UserMapper; import com.cls.pojo.User; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; /** * @author cls * @version 1.0 * @date 2020/10/8/0008 */ @Service public class UserService { @Autowired private UserMapper userMapper; //根据id查询 public User queryById(Long id){ return userMapper.selectByPrimaryKey(id); } //新增保存用户 @Transactional public void saveUser(User user){ System.out.println("新增用户... "); //选择性新增；如果属性为空则该属性不会出现在insert语句上 userMapper.insertSelective(user); } }

测试：

6.6 整合Junit测试

在springboot项目中如果要使用Junit进行单元测试，则需要添加如下的依赖：  <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> </dependency>

2.用鼠标左击选中需要进行单元测试的类，然后在类名称上，ctrl+shift+t然后选中需要测试的方法即可生成测试类，在测试类上面必须要添加 @SpringBootTest 注解，这些测试可以同时进行测试

package com.cls.service; import com.cls.pojo.User; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.context.junit4.SpringRunner; import javax.swing.*; import java.util.Date; import static org.junit.Assert.*; /** * @author cls * @version 1.0 * @date 2020/10/8/0008 */ //在类名称上，ctrl+shift+t然后选中需要测试的方法即可生成测试类 @RunWith(SpringRunner.class) @SpringBootTest public class UserServiceTest { @Autowired private UserService userService; @Test public void queryById() { User user = userService.queryById(8L); System.out.println("user = " + user); } @Test public void saveUser() { User user = new User(); user.setUserName("test1"); user.setName("test1"); user.setAge(13); user.setPassword("123456"); user.setSex(1); user.setCreated(new Date()); userService.saveUser(user); } }

测试：

6.7 整合Redis

1.在 pom.xml 文件中添加如下依赖

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency>

2.配置 application.yml 文件；

redis: host: localhost port: 6379

3.编写测试代码

package com.cls.redis; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.test.context.junit4.SpringRunner; import java.util.List; import java.util.Set; /** * @author cls * @version 1.0 * @date 2020/10/8/0008 */ @RunWith(SpringRunner.class) @SpringBootTest public class RedisTest { @Autowired private RedisTemplate redisTemplate; @Test public void test(){ //string 字符串 //redisTemplate.opsForValue().set("str", "heima"); redisTemplate.boundValueOps("str").set("heima"); System.out.println("str = " + redisTemplate.opsForValue().get("str")); System.out.println("str = " + redisTemplate.boundValueOps("str").get()); //hash 散列 redisTemplate.boundHashOps("h_key").put("name", "heima"); redisTemplate.boundHashOps("h_key").put("age", 13); //获取所有域 Set set = redisTemplate.boundHashOps("h_key").keys(); System.out.println(" hash散列的所有域：" + set); //获取所有值 List list = redisTemplate.boundHashOps("h_key").values(); System.out.println(" hash散列的所有域的值：" + list); //list 列表 redisTemplate.boundListOps("l_key").leftPush("c"); redisTemplate.boundListOps("l_key").leftPush("b"); redisTemplate.boundListOps("l_key").leftPush("a"); //获取全部元素 list = redisTemplate.boundListOps("l_key").range(0, -1); System.out.println(" list列表中的所有元素：" + list); // set 集合 redisTemplate.boundSetOps("s_key").add("a", "b", "c"); set = redisTemplate.boundSetOps("s_key").members(); System.out.println(" set集合中的所有元素：" + set); // sorted set 有序集合 redisTemplate.boundZSetOps("z_key").add("a", 30); redisTemplate.boundZSetOps("z_key").add("b", 20); redisTemplate.boundZSetOps("z_key").add("c", 10); set = redisTemplate.boundZSetOps("z_key").range(0, -1); System.out.println(" zset有序集合中的所有元素：" + set); } }

测试：

6.8 Spring Boot项目部署

添加项目的pom.xml插件；在pom.xml要显式的加入插件spring-boot-maven-plugin，否则无法产生 jar 清单文件，导致打出来的 jar 无法使用命令运行； <build> <plugins>  <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>

2.使用maven的package命令打包

3.运行打出来的包；使用命令： java –jar 包全名或者写一个 bat 文件，里面包含 java –jar 包全名；这样就可以双击启动应用。然后通过浏览器也可以访问如执行上述打出来的jar的命令为：java -jar cls-springboot-1.0-SNAPSHOT.jar

7.推荐插件

在应用spring boot工程的时候；一般情况下都需要创建启动引导类Application.java和application.yml配置文件，而且内容都是一样的；为了便捷可以安装一个IDEA的插件 JBLSpringBootAppGen 在项目上右击之后可以自动生成启动引导类Application.java和application.yml配置文件。 JBLSpringBootAppGen 使用：在idea中任意一个maven项目或者src目录上右击，选中JBLSpringBootAppGen即可，会自动生成启动类和配置文件

Processed: 0.009, SQL: 12