SSM框架之SpringBoot——微服务快速开发

复杂的配置
- 项目各种配置其实是开发时的损耗，因为在思考 Spring 特性配置和解决业务问题之间需要进行思维切换，所以写配置挤占了写应用程序逻辑的时间。
混乱的依赖管理
- 项目的依赖管理也是件吃力不讨好的事情。决定项目里要用哪些库就已经够让人头痛的了，你还要知道这些库的哪个版本和其他库不会有冲突，这难题实在太棘手。并且，依赖管理也是一种损耗，添加依赖不是写应用程序代码。一旦选错了依赖的版本，随之而来的不兼容问题毫无疑问会是生产力杀手。

而SpringBoot 简化了基于Spring的应用开发，只需要“run”就能创建一个独立的、生产级别的Spring应用。

SpringBoot 为Spring平台及第三方库提供开箱即用的设置（提供默认设置，存放默认配置的包就是启动器starter），这样我们就可以简单的开始。多数Spring Boot应用只需要很少的Spring配置。

我们可以使用SpringBoot 创建java应用，并使用java –jar 启动它，就能得到一个生产级别的web工程。

1.3SpringBoot的特点

SpringBoot 主要特点是：

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

二、SpringBoot入门

假设我们现在有一个需求，在浏览器中访问http://localhost:8080/hello时，会输出一串字符。

利用SpringBoot搭建Spring应用的步骤如下：

创建工程；
添加依赖（启动器依赖，spring-boot-starter-web）；
创建启动类（Spring工程的入口）；
创建处理器Controller（处理url请求）；
测试

Spring Boot工程可以通过添加启动器依赖和创建启动引导类实现快速创建web工程，启动器依赖spring-boot-starter-web默认的应用服务器端口是8080 。

2.1创建工程

首先第一步是创建工程，我们还是创建一个Maven工程，不使用模板，

2.2添加依赖

第二步是添加依赖，这里就不需要我们自己管理依赖关系了，只需要添加Spring Boot提供的一个父工程，里面已经对各种常用依赖（并非全部）的版本进行了管理，我们的项目需要以这个项目为父工程，这样我们就不用操心依赖的版本问题了，需要什么依赖，直接引入坐标即可，

<!--指定父工程-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.5.RELEASE</version>
</parent>

为了让Spring Boot帮我们完成各种自动配置，我们必须引入Spring Boot提供的自动配置依赖，我们称为启动器。因为我们是web项目，这里我们引入web启动器，在 pom.xml 文件中加入如下依赖：

<dependencies>
    <!--添加依赖jar包时不需要指定版本，一切的版本都由父工程指定-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

需要注意的是，我们并没有在这里指定版本信息。因为Spring Boot的父工程已经对版本进行了管理了。
这个时候，我们会发现项目中多出了大量的依赖。那些依赖都是Spring Boot根据spring-boot-starter-web 这个依赖自动引入的，而且所有的版本都已经管理好，不会出现冲突。

如果我们想要修改Spring Boot项目的jdk版本，只需要简单的添加以下属性即可，如果没有需求，则不添加。同样的在 pom.xml 文件中添加如下：

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

2.3启动类

第三步是创建启动类，标志当前类为应用的入口类，

package com.laotang;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * spring boot 工程都有一个启动引导类，这是工程的入口类
 * 并在引导类上添加 @SpringBootApplication 注解
 */
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);//指定应用的入口类为当前类
    }
}

2.4编写Controller

第四步则是创建controller类，处理url的请求，

package com.laotang.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("hello")//GET方法的映射地址
    public String hello(){
        return "Hello, Spring Boot!";
    }
}

2.5测试

第五步我们直接运行启动类的main方法，控制台会输出：

然后我们直接点开浏览器，访问http://localhost:8080/hello，

（我丢，这也太方便了吧，之前的方法可比这复杂多了！！！卧槽）

三、Java代码方式配置

在快速入门中，我们没有任何的配置，就可以快速实现一个SpringMVC的项目了，

但是有人可能会有疑问，如果没有任何的xml，那么我们如果要配置一个Bean该怎么办？比如我们要配置一个数据库连接池，以前会这么配置：

<!-- 配置连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
      init-method="init" destroy-method="close">
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
</bean>

在学习如何配置之前，首先我们来看看Spring配置方式的历史

3.1Spring配置历史

事实上，在Spring3.0开始，Spring官方就已经开始推荐使用java配置来代替传统的xml配置了，我们不妨来回顾一下Spring的历史：

Spring1.0时代
- 在此时因为jdk1.5刚刚出来，注解开发并未盛行，因此一切Spring配置都是xml格式
Spring2.0时代
- Spring引入了注解开发，但是因为并不完善，因此并未完全替代xml，此时的程序员往往是把xml与注解进行结合，我们之前都是采用这种方式。
Spring3.0及以后
- 3.0以后Spring的注解已经非常完善了，因此Spring推荐大家使用完全的java配置来代替以前的xml，不过似乎在国内并未推广盛行。然后当Spring Boot来临，人们才慢慢认识到java配置的优雅。

所以接下来我们一起学习下java配置。

3.2Java配置数据源

Java配置主要靠java类和一些注解，比较常用的注解有：

@Configuration：声明一个类作为配置类，代替xml文件
@Bean：声明在方法上，将方法的返回值加入Bean容器，代替<bean> 标签
@Value：属性注入
@PropertySource：指定外部属性文件，

我们接下来用java配置来尝试实现连接池配置，

第一步我们创建一个数据库用作测试，这里我们就用之前一直使用的mydb1数据库即可

第二步在pom.xml中添加Druid数据源依赖，

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.6</version>
</dependency>

第三步我们在资源目录下新建一个数据库的配置文件jdbc.properties，配置数据库的连接信息，

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mydb1
jdbc.username=root
jdbc.password=3837

第四步开始编写配置类，加载数据库的配置文件并对数据源进行配置，将配置好的数据源通过@Bean 标签放置到Spring容器中，

package com.laotang.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;

@Configuration//标志当前类为一个配置类
@PropertySource("classpath:jdbc.properties")//指定jdbc.properties的路径
public class JdbcConfig {
    //使用注解的方式读取配置文件中的数据库连接参数
    @Value("${jdbc.driverClassName}")
    String driver;
    @Value("${jdbc.url}")
    String url;
    @Value("${jdbc.username}")
    String username;
    @Value("${jdbc.password}")
    String password;

    @Bean//将方法的返回值放置到Spring容器中
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);//设置驱动类
        dataSource.setUrl(url);//设置数据库的url
        dataSource.setUsername(username);//设置用户名
        dataSource.setPassword(password);//设置密码
        return dataSource;//返回数据源，注入到Spring容器中
    }
}

第五步我们编写处理器类，在处理器类中注入刚刚配置的数据源，然后打印获取到的数据源信息，

@RestController
public class HelloController {
    @Autowired
    private DataSource dataSource;

    @GetMapping("hello")//GET方法的映射地址
    public String hello() {
        System.out.println("dataSource = " + dataSource);
        return "Hello, Spring Boot!";
    }
}

第六步进行测试，还是启动spring boot 工程的引导类的main函数，访问对应的url，可以看到控制台输出了数据源的信息，

我们还可以打断点查看数据源里面的一些配置信息，可以看到是配置成功了。

3.3SpringBoot属性注入方式

3.3.1注解@ConfigurationProperties方法

假设我们现在有这么一个需求，将配置文件中的配置项读取到一个对象中，

在上面的案例中，我实现了java配置方式。不过属性注入使用的是 @Value 注解。这种方式虽然可行，但是不够强大，因为它只能注入基本类型值。

我们可以使用SpringBoot提供的注解 @ConfigurationProperties，该注解可以将SpringBoot的配置文件（默认的文件名必须是：application.properties或application.yml）中的配置项读取到对象中。

实现步骤为：

创建配置项类JdbcProperties类，在该类名上面添加 @ConfigurationProperties 注解
将jdbc.properties配置文件改名为appliation.properties
将JdbcProperties对象注入到JdbcConfig配置类
测试

第一步我们创建配置项类JdbcProperties，在里面定义配置变量，用于接受配置文件中的配置项，

/**
 * ConfigurationProperties 从配置文件中读取配置项
 * prefix 表示配置项的前缀
 * 配置项类中的变量名必须要与配置项的名字相同
 */
@ConfigurationProperties(prefix = "jdbc")
class JdbcProperties {
    private String driver;
    private String url;
    private String username;
    private String password;

    //省去了set和get方法
}

如果在加入 @ConfigurationProperties 注解后提示找不到如何处理注解，可以忽略，项目可以正常运行，

如果想要去除提示，则需要在pom.xml中添加如下依赖，

<dependency>
    <groupId> org.springframework.boot </groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <!--不传递依赖-->
    <optional>true</optional>
</dependency>

第二步我们对jdbc.properties配置项进行改名，

第三步我们将JdbcProperties对象注入到JdbcConfig配置类，这里我们使用@EnableConfigurationProperties 注解来指定配置项类，

@Configuration//标志当前类为一个配置类
@EnableConfigurationProperties(JdbcProperties.class)//指定配置项类
public class JdbcConfig {
    @Bean//将方法的返回值放置到Spring容器中
    public DataSource dataSource(JdbcProperties jdbcProperties){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(jdbcProperties.getDriver());//设置驱动类
        dataSource.setUrl(jdbcProperties.getUrl());//设置数据库的url
        dataSource.setUsername(jdbcProperties.getUsername());//设置用户名
        dataSource.setPassword(jdbcProperties.getPassword());//设置密码
        return dataSource;//返回数据源，注入到Spring容器中
    }
}

第四步我们检查一下在controller类中进行测试，还是用之前的测试方法，

@ConfigurationProperties 和 @value 的不同之处如下表所示：

注解	@ConfigurationProperties	@value
功能	批量注入配置文件的属性	一个个指定
松散绑定(松散语法)	支持	不支持
SPEL	不支持	支持(计算,如上age的值所示）
JSR303数据校验	支持 (邮箱验证）	不支持
复杂类型封装	支持	不支持

3.3.2注入改进

事实上，如果一段属性只有一个Bean需要使用，我们无需将其注入到一个类（JdbcProperties，将该类上的所有注解去掉）中。

而是直接在需要的地方声明即可；再次修改JdbcConfig 类为如下代码：

@Configuration
public class JdbcConfig {
    @Bean
// 声明要注入的属性前缀，Spring Boot会自动把相关属性通过set方法注入到DataSource中
    @ConfigurationProperties(prefix = "jdbc")
    public DataSource dataSource() {
        return new DruidDataSource();
    }
}

我们直接把@ConfigurationProperties(prefix = "jdbc") 声明在需要使用的@Bean 的方法上，然后SpringBoot就会自动调用这个Bean（此处是DataSource）的set方法，然后完成注入。使用的前提是：该类必须有对应属性的set方法！

3.3.3yml配置文件

配置文件除了可以使用application.properties类型，还可以使用后缀名为：.yml或者.yaml的类型，也就是：application.yml或者application.yaml，

YAML所表示的为YAML Ain't a Markup Language，YAML是一种简洁的非标记语言，YAML以数据为中心，使用空白、缩进，分行组织数据，从而使得表示更加简洁易读。

YAML与properties配置文件除了展示形式不相同以外，其它功能和作用都是一样的；在项目中原路的读取方式不需要改变。

yml配置文件的特征：

树状层级结构展示配置项；
配置项之间如果有关系的话需要分行空两格；
配置项如果有值的话，那么需要在 `:`之后空一格再写配置项值；

基本格式：

keya:
  keya1: val1
  keya2: val2

如果是配置数组、list、set等结构的内容，那么在yml文件中格式为：

key:
  - value1
  - value2

注意：如果properties和yml配置文件同时存在SpringBoot项目中，会把两个文件的配置合并，如果有重复属性，以properties中的为准。

比如我们要将上述项目中的application.properties改为application.yml，

jdbc:
  driverClassName: com.mysql.jdbc.Driver
  url: dbc:mysql://localhost:3306/mydb1
  username: root
  password: 3837

修改之后发现仍然可以正常使用。

3.3.4多个yml配置文件

当一个项目中有多个yml配置文件的时候，可以以application-*.yml命名，

然后在application.yml中配置项目使用激活这些配置文件即可，

我们随便新建两个yml配置文件，注意命名格式为application-*.yml，这里我新建了application-a.yml和application-b.yml，在里面随便写一点配置，然后我们在application.yml主配置文件中引入这两个配置，

#激活配置文件，指定其他的配置文件名称(仅需写application-之后的*部分即可)
spring:
  profiles:
    active: a,b

然后我们在controller中获取配置进行输出测试，

@RestController
public class HelloController {
    @Value("${laotang.name}")
    private String name1;
    @Value("${xiaodong.name}")
    private String name2;

    @GetMapping("hello")//GET方法的映射地址
    public String hello() {
        System.out.println(name1);
        System.out.println(name2);
        return "Hello, Spring Boot!";
    }
}

启动服务器，访问url，

四、自动配置原理

使用Spring Boot之后，一个整合了SpringMVC的WEB工程开发，变的无比简单，那些繁杂的配置都消失不见了，这是如何做到的？

只需要配置好启动类，就可以一键运行WEB工程，所以我们仔细看看启动类：

我们发现特别的地方有两个：

注解：@SpringBootApplication
run方法：SpringApplication.run()

我们分别来进行学习。

4.1@SpringBootApplication

我们点进该注解，可以发现该注解是一个组合注解，这里的重点注解包括以下三个：

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan

4.1.1SpringBootConfiguration

我们继续点击查看源码，发现在这个注解上面，又有一个@Configuration 注解。这个注解的作用就是声明当前类是一个配置类，然后Spring会自动扫描到添加了@Configuration 的类，并且读取其中的配置信息。

而@SpringBootConfiguration 是来声明当前类是SpringBoot应用的配置类，项目中只能有一个。所以一般我们无需自己添加。

4.1.2@EnableAutoConfiguration

@EnableAutoConfiguration 注解的作用是告诉Spring Boot基于你所添加的依赖，去“猜测”你想要如何配置Spring。

比如我们引入了spring-boot-starter-web ，而这个启动器中帮我们添加了tomcat 、SpringMVC的依赖。此时自动配置就知道你是要开发一个web应用，所以就帮你完成了web及SpringMVC的默认配置了。

4.1.3@ComponentScan

该注解是配置组件扫描的指令，提供了类似与<context:component-scan> 标签的作用，通过basePackageClasses或者basePackages属性来指定要扫描的包。

如果没有指定这些属性，那么将从声明这个注解的类所在的包开始，扫描包及子包，

而我们的@SpringBootApplication注解声明的类就是main函数所在的启动类，因此扫描的包是该类所在包及其子包。因此，一般启动类会放在一个比较前的包目录中。

4.2SpringApplication.run()方法

我们点击这个run方法，可以看到这个类在构造函数有这样一个初始化语句，

它会通过loadFactoryNames尝试加载一些FactoryName，然后利用创造工厂示例对象的方法将这些加载到的类名进行实例化，而这些FactoryName是利用类加载器加载"META-INF/spring.factories"文件，

classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories")

点进去可以看到预置了大量的自动配置类，springboot会根据你需要的项目类型来加载这些自动配置类，比如我们添加了spring-boot-starter-web 的web依赖，那么它就会帮我们创建视图控制器等等。

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

五、SpringBoot实践

接下来，我们来看看如何用SpringBoot来整合SSM

5.1Lombok

首先需要在数据库中引入一张用户表user和对应的实体类User，

一般情况下需要给这个实体类编写get/set/toString等方法，这样会让实体类看起来比较臃肿，特别是属性多的时候，就非常浪费时间，使用Lombok插件可以解决这个问题。

Lombok是一个插件工具包，提供了一些注解@Data、@Getter等，去简化实体类中的构造方法、get/set等方法的编写。

使用Lombok插件主要有以下几个步骤：

在IDEA中安装lombok插件，其实不安装插件在IDEA中使用lombok的注解虽然编译能通过，但是源码会报错。所以为了让IDEA更好的辨别lombok注解则才安装插件。
添加lombok对应的依赖到项目pom.xml文件
改造实体类，使用lombok注解代替get/set方法

首先我们在IDEA中安装lombok插件，打开settings->Plugins，搜索lombok进行安装，

安装以后需要重启我们的IDEA，我们重启之后打开项目的pom.xml文件添加lombok的依赖，

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

第三步我们创建user表对应的实体类User，使用lombok生成get/set等方法，

/**
 * 在编译阶段会根据注解自动生成对应的方法
 * @Data 注解包含get/set/hashCode/equals/toString等方法
 * @Getter 注解包含getter方法
 * @Setter 注解包含setter方法
 * @Slf4j 注解在bean中提供log变量，其实用的是slf4j的日志功能
 */
@Data
class User {
    private Long id;
    private String username;
    private String password;
    private String birthday;
}

这样实体类的代码看着就整洁很多了。

5.2整合SpringMVC

解决了pojo层的实体类，接下来是SpringMVC，虽然默认配置已经可以使用SpringMVC了，不过我们有时候需要进行自定义配置，我们可以在application.yml 文件中配置日志级别控制：

logging:
  level:
    com.itheima: debug
    org.springframework: info

5.2.1修改端口

我们打开项目的依赖库，找到spring-boot-autoconfigure中的ServerProperties配置类，

我们双击点开，可以看到这个配置类中的前缀为server，里面有一个port类变量，所以我们可以通过前缀+类变量的形式在application.yml中修改这个配置项，

我们找到application.yml文件，对端口进行修改，

# 修改tomcat端口，80是浏览器的默认端口可以用localhost://直接访问
server:
  port: 80

5.2.2访问静态资源

之前我们在web工程中，习惯将静态资源放置在webapp的路径下，

但是现在我们创建的是jar工程，没有webapp的路径，我们查看spring-boot-autoconfigure中的ResourceProperties配置类，

点进去可以看到资源配置类中定义了一个默认的资源文件路径的变量CLASSPATH_RESOURCE_LOCATIONS，

private static final String[] CLASSPATH_RESOURCE_LOCATIONS = new String[] {"classpath:/META-INF/resources/", "classpath:/resources/", "classpath:/static/", "classpath:/public/"};

这个里面有四个值，

classpath:/META-INF/resources/
classpath:/resources/
classpath:/static/（常用）
classpath:/public/

注意：这里的resources目录是普通路径，不能是标记为资源根目录的路径

所以我们要把静态资源文件放在这个上面的四个路径之一内，我们在项目中新建一个static目录，然后里面放置我们需要访问的静态资源，比如test.js，

接着我们直接启动app入口main方法，springboot会帮我们自动扫描static目录中的资源，输入对应的url，可以看到资源被成功访问了。

因为我们把端口修改为了80，所以这里我们可以直接用localhost来访问资源。

5.2.3添加拦截器

拦截器也是我们在SpringMVC中经常用到的，而拦截器不是一个普通的属性，是一个类，所以不能使用修改application.yml配置文件来进行配置了。

所以我们需要用到java的配置方式对拦截器进行配置，在SpringBoot官方文档中有这么一段说明：

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

在SpringBoot中配置拦截器的主要步骤如下：

编写拦截器（实现HandlerInterceptor接口）
编写配置类实现 WebMvcConfiguer，在该类中添加各种组件
测试

那么第一步是首先编写一个拦截器，实现HandlerInterceptor接口，

@Slf4j//自动生成一个log变量，提供日志功能
class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.debug("This is MyInterceptor.preHandle() method.");
        return true;//拦截过后继续放行访问请求
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.debug("This is MyInterceptor.postHandle() method.");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.debug("This is MyInterceptor.afterCompletion() method.");
    }
}

这里我们使用到了日志，所以我们在application.yml中修改日志记录级别，

#设置日志记录级别，com.laotang包下的类日志记录级别为debug，org.springframework包下的类日志记录级别为info
logging:
  level:
    com.laotang: debug
    org.springframework: info

都做好了以后我们进行第二步，编写配置类实现 WebMvcConfiguer，我们把自定义的拦截器放置到Spring容器中，然后把拦截器添加到SpringMVC的拦截器链中，并指定拦截路径，

@Configuration//标志当前类为一个配置类
public class MvcConfig implements WebMvcConfigurer {
    //注册拦截器
    @Bean
    public MyInterceptor myInterceptor(){
        return new MyInterceptor();
    }

    //添加拦截器到spring mvc拦截器链
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myInterceptor()).addPathPatterns("/*");//将自定义拦截器添加到拦截器链中，拦截路径为所有请求路径
    }
}

第三步我们就进行测试，启动main方法，可以看到拦截器成功生效了。

5.3整合jdbc和事务

接下来我们开始整合持久层，包括jdbc的连接和事务的控制。

事务配置
- 添加事务相关的启动器依赖spring-boot-starter-jdbc以及mysql相关依赖
- 编写业务类UserService，使用事务注解@Transactional
数据库连接池hikari配置（SpringBoot默认的数据库连接池，比druid更高效）
- 只需要在application配置文件中指定数据库相关参数即可使用

首先我们第一步是在pom.xml中添加jdbc启动器依赖，

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

当然还有指定数据库的驱动，这里我们选择mysql的依赖，

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.32</version>
</dependency>

第二步我们编写一个业务类UserService，使用事务注解进行事务控制，

@Service
public class UserService {
    //根据id查询用户
    public User findById(Long id){
        return new User();
    }

    //添加用户
    @Transactional//添加事务控制
    public void addUser(User user){
        System.out.println("新增用户");
    }
}

第三步我们对数据库连接池hikari进行配置，直接在application.yml配置文件中配置，

#配置数据源hikari的连接信息
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: dbc:mysql://localhost:3306/mydb1
    username: root
    password: 3837

这里我们就不需要前面定义的jdbc配置类了，直接全部删除，controller中还是一样可以获取到数据源对象，打断点可以看到获取到的数据源已经是 Hikari 的数据源连接池了。

5.4整合MyBatis

5.4.1MyBatis

SpringBoot官方并没有提供Mybatis的启动器，不过Mybatis官网自己实现了。

在SpringBoot中整合MyBatis的步骤如下：

添加启动器依赖mybatis-spring-boot-starter
配置MyBatis，包括实体类别名包，日志和映射文件等
配置MapperScan

第一步在项目的pom.xml 文件中加入MyBatis的启动器依赖：

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.0.1</version>
</dependency>

第二步我们对MyBatis进行配置，修改application.yml文件，

# mybatis配置
mybatis:
  # 实体类别名包路径
  type-aliases-package: com.laotang.pojo
  # 指定映射文件路径
  # mapper-locations: classpath:mappers/*.xml
  configuration:
    # 控制台输出执行sql
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

第三步我们创建对应的mapper接口UserMapper，在接口上添加注解@Mapper，告诉SpringBoot这是一个接口，

@Mapper
interface UserMapper {
}

或者我们也可以在SpringBoot启动类上配置@MapperScan注解，指定扫描mapper接口的包，

@SpringBootApplication
@MapperScan(basePackages = "com.laotang.mapper")//扫描mapper接口
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);//指定应用的入口类为当前类
    }
}

一般来说后一种方法比较常用，不用在所有的mapper中都加上@Mapper注解，

5.4.2通用mapper

在原来的MyBatis实现中，我们需要在mapper接口中定义好方法，然后在对应的mapper.xml文件中手动添加对应方法需要执行的sql语句，这种方式比较繁杂。

通用mapper则可以自动拼接sql语句，即在所有的mapper接口中不需要编写任何方法以及对应的sql语句就可以实现对数据库的操作。这会大大的提高开发的效率。

在SpringBoot中加入通用mapper的步骤如下：

添加启动器依赖mapper-spring-boot-starter
修改UserMapper接口，继承Mapper<User>
修改启动引导类Application中的Mapper扫描注解
修改User实体类，添加jpa注解
修改UserService代码，实现具体的业务功能

第一步我们先添加通用mapper的启动器依赖，

<!-- 通用mapper -->
<dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper-spring-boot-starter</artifactId>
    <version>2.1.5</version>
</dependency>

第二步我们对UserMapper接口进行修改，使其继承通用mapper中的Mapper<T>接口，

import com.laotang.pojo.User;
import tk.mybatis.mapper.common.Mapper;
interface UserMapper extends Mapper<User> {
}

第三步修改启动引导类Application中的Mapper扫描注解，不用官方的@MapperScan注解，使用的是tk.mybatis.spring.annotation.MapperScan，

@SpringBootApplication
@MapperScan(basePackages = "com.laotang.mapper")//指定mapper接口的包路径，进行扫描
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);//指定应用的入口类为当前类
    }
}

第四步我们修改User实体类，添加jpa（javax.persistence Annotation，java持久化注解）

@Data
@Table(name = "user")//指定查询user表时，得到的数据映射到当前实体类中
public class User {
    @Id//表明主键
    @KeySql(useGeneratedKeys = true)//主键回填（当我们插入用户数据后，会将数据库中自增得到的id数据回填到用户对象中）
    private Long id;

    @Column(name = "username")//数据库中字段为username赋值给当前变量，如果名称一致或者符合驼峰规则那么可以省略该注解
    private String username;

    private String password;

    private String birthday;
}

第五步开始修改UserService代码，将UserMapper自动注入，调用通用mapper为我们提供的一些方法，

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    //根据id查询用户
    public User findById(Long id){
        //这个方法是通用mapper为我们提供的
        return userMapper.selectByPrimaryKey(id);//根据主键查询用户，主键我们指定为了id
    }

    //添加用户
    @Transactional//添加事务操作
    public void addUser(User user){
        userMapper.insertSelective(user);//选择性新增，如果属性为空则不会出现在insert语句上
        System.out.println("新增用户");
    }
}

5.5SpringBoot整合测试

接下来我们修改一下controller层的代码，注入UserService对象利用其方法进行测试，

@RestController
public class HelloController {
    @Autowired
    private UserService userService;

    @GetMapping("/user/{id}")
    public User findById(@PathVariable Long id){//从url请求中读取id参数
        return userService.findById(id);
    }
}

然后我们启动main方法，访问对应的url，并给定要查询的id，

5.6SpringBoot整合Junit

我们还可以使用Junit进行单元测试，测试Service中的方法，其主要步骤如下：

添加启动器依赖spring-boot-starter-test
编写测试类进行测试

首先我们还是添加测试的启动器依赖，

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

第二步我们编写测试类进行测试，我们对UserService类的类名按住ctrl+shift+t键，可以自动生成测试类，

然后就会自动在test包下生成好对应的测试类，然后我们编写一下测试方法，

注意：在SpringBoot项目中如果编写测试类则必须要在类上面添加@SpringBootTest 注解，

@RunWith(SpringRunner.class)//使用Spring容器，可以使用自动注入
@SpringBootTest//指定当前类为SpringBoot项目的测试类
public class UserServiceTest {
    @Autowired
    private UserService userService;

    @Test
    public void findById() {
        User user = userService.findById(2L);//我们的id是Long类型，所以要在后面加"L"
        System.out.println("user=" + user);
    }

    @Test
    public void addUser() {
        User user = new User();
        user.setUsername("springbootTest");
        user.setPassword("111");
        //user.setBirthday("123456");//这里我们注释掉该属性的赋值，测试insertSelective方法是否会报错
        userService.addUser(user);
    }
}

然后我们运行第一个测试方法，测试根据id查询用户信息，可以看到id为2的用户已经输出了。

接着我们测试第二个方法，插入用户信息，刷新数据库也可以看到插入的数据也成功了。

5.7SpringBoot整合Redis

接下来我们在SpringBoot中整合Redis，其主要步骤如下：

添加启动器依赖spring-boot-starter-data-redis
修改application.yml配置文件中redis的连接参数（需要先启动redis）
编写测试类，用RedisTemplate操作redis中的5种数据类型（string/hash/list/set/sorted set）

第一步我们还是在pom.xml中添加redis的启动器依赖，

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

第二步我们修改application.yml配置文件中redis的连接参数，

spring:
  #配置redis连接参数
  redis:
    host: localhost
    port: 6379

然后我们手动启动一下redis的服务器，

第三步我们开始编写测试类，

@RunWith(SpringRunner.class)//使用Spring容器，可以使用自动注入
@SpringBootTest//标识当前类为SpringBoot的测试类
public class RedisTest {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void test() {
        //string字符串，两种方式设置值
        redisTemplate.opsForValue().set("mystr1", "stringtest1");
        redisTemplate.boundValueOps("mystr2").set("stringtest2");
        System.out.println("str1 = " + redisTemplate.opsForValue().get("str1"));
        System.out.println("str2 = " + redisTemplate.boundValueOps("str2").get());

        //hash散列
        redisTemplate.boundHashOps("myhash").put("name", "hashtest");
        redisTemplate.boundHashOps("myhash").put("age", 23);
        Set keys = redisTemplate.boundHashOps("myhash").keys();//获取所有key
        System.out.println("Keys = " + keys);
        List values = redisTemplate.boundHashOps("myhash").values();//获取所有值
        System.out.println("Values = " + values);

        //list列表
        redisTemplate.boundListOps("mylist").leftPush("c");
        redisTemplate.boundListOps("mylist").leftPush("b");
        redisTemplate.boundListOps("mylist").leftPush("a");
        List list = redisTemplate.boundListOps("mylist").range(0, -1);//获取下标从0开始，-1结束（即获取所有元素）
        System.out.println("mylist = " + list);

        //set集合
        redisTemplate.boundSetOps("myset").add("a", "b", "c");
        Set set = redisTemplate.boundSetOps("myset").members();
        System.out.println("myset = " + set);

        //sortedset有序集合
        redisTemplate.boundZSetOps("mysortedset").add("a", 30);
        redisTemplate.boundZSetOps("mysortedset").add("b", 40);
        redisTemplate.boundZSetOps("mysortedset").add("c", 20);
        Set sortedset = redisTemplate.boundZSetOps("mysortedset").range(0, -1);//按照升序获取下标从0开始，-1结束（即按照升序获取所有元素）
        System.out.println("mysortedset = " + sortedset);
    }
}

我们启动测试类查看运行结果，

六、SpringBoot项目部署

接下来我们将整合好的SpringBoot项目使用maven指令打成jar包并运行测试，

主要步骤如下：

添加打包组件，将项目中的资源、配置、依赖jar包打到一个jar包中，并利用maven的package命令进行打包
部署我们的jar包：java -jar 包名（或者直接双击jar包）

首先第一步我们添加打包需要的组件（注意不是依赖，要放在依赖标签之外），

<build>
    <plugins>
        <!-- 打jar包时如果不配置该插件，打出来的jar包没有清单文件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

然后我们就在右侧的Maven Projects 栏中运行打包命令，我们把测试阶段可以跳过，

执行完毕之后可以看到提示打好的jar包所在的目录，

然后我们进入到该目录，启动cmd使用java -jar 包名的命令运行jar包，

启动完成以后，我们打开浏览器输入url，验证我们controller中写的方法是否还有效，

七、快速开发插件

在应用spring boot工程的时候，一般情况下都需要创建启动引导类Application.java和application.yml配置文件，而且内容都是一样的，

为了便捷我们可以安装一个IDEA的插件 JBLSpringBootAppGen 在项目上右击之后可以自动生成启动引导类Application.java和application.yml配置文件。

7.1安装插件

打开IDEA的设置界面（按 ctrl+alt+S ）之后在插件选项中搜索SpringBoot，安装 JBLSpringBootAppGen，

安装完成之后一般会要求我们重启IDEA，重启一下就行。

7.2使用插件

在IDEA中任意一个maven项目或src目录上右击，选择 JBLSpringBootAppGen 即可，

在如下的界面中输入启动引导类的名称并根据需要勾选是否要生成application.yml配置文件，

点击 OK 之后，在项目中将发现如下内容，

小唐要努力

关注

5
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
SSM框架之SpringBoot——微服务快速开发

一、SpringBoot概述1.1SpringBoot简介及作用Spring Boot是Spring项目中的一个子工程，与我们所熟知的Spring-framework 同属于spring的产品。Spring Boot其实是搭建程序的脚手架或者说是便捷搭建基于Spring的工程脚手架。其最主要作用就是帮助开发人员快速的构建庞大的spring项目，并且尽可能的减少一切xml配置，做到开箱即用，迅速上手，让开发人员关注业务而非配置。1.2SpringBoot的意义java一直被...
复制链接

扫一扫

专栏目录