1. Spring Boot概述

目标：了解Spring Boot是什么，有什么作用

小结：

Spring Boot是一个便捷搭建基于spring工程的脚手架；作用是帮助开发人员快速搭建大型的spring 项目。简化工程的配置，依赖管理；实现开发人员把时间都集中在业务开发上。

2. Spring Boot入门

目标：能够使用Spring Boot搭建项目

分析：

需求：可以在浏览器中访问http://localhost:8080/hello输出一串字符

实现步骤：

创建工程；

image.png

看到这里很多同学会有疑惑，前面说传统开发的问题之一就是依赖管理混乱，怎么这里我们还需要管理依赖呢?难道
Spring Boot不帮我们管理吗?
别着急，现在我们的项目与Spring Boot还没有什么关联。Spring Boot提供了一个名为spring-boot-starter-parent 的工程，里面已经对各种常用依赖(并非全部)的版本进行了管理，我们的项目需要以这个项目为父工程，这样我们就不用操心依赖的版本问题了，需要什么依赖，直接引入坐标即可!

添加依赖（启动器依赖，spring-boot-starter-web）；

<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>
    <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>

完整版的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>org.example</groupId>
    <artifactId>Springboot</artifactId>
    <version>1.0-SNAPSHOT</version>

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

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

创建启动类；
Spring Boot项目通过main函数即可启动，我们需要创建一个启动类:
编写 springboot\src\main\java\com\nono\Application.java 如下:

image.png

package com.nono;

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

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

创建处理器Controller；

package com.nono.controller;

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


//相当于@Controller+@ResponseBody两个注解的结合，返回json数据不需要在方法前面加@ResponseBody注解了，但使用@RestController这个注解，就不能返回jsp,html页面，视图解析器无法解析jsp,html页面
@RestController
public class HellowController {

    @GetMapping("hello")
    public String hello(){
        return "hello,spring boot";
    }
}

Spring的复杂性不是来自于它处理的对象，而是来自于自身，不断演进发展的Spring会带来时间维度上复杂性，比如SpringMVC以前版本的@RequestMapping，到了新版本被下面新注释替代，相当于增加的选项：

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
从命名约定我们可以看到每个注释都是为了处理各自的传入请求方法类型，即@GetMapping用于处理请求方法的GET类型，@ PostMapping用于处理请求方法的POST类型等。

如果我们想使用传统的@RequestMapping注释实现URL处理程序，那么它应该是这样的：

@RequestMapping(value = "/get/{id}", method = RequestMethod.GET)

新方法可以简化为：

@GetMapping("/get/{id}")

测试
接下来，运行main函数，查看控制台:

image.png

并且可以看到监听的端口信息:

image.png

1)监听的端口是8080
2)SpringMVC的项目路径是:空

3）/hello 路径已经映射到了 HelloController 中的 hello() 方法
打开页面访问:http://localhost:8080/hello

image.png

小结：

Spring Boot工程可以通过添加启动器依赖和创建启动引导类实现快速创建web工程。

spring-boot-starter-web默认的应用服务器端口是8080

3. Java代码方式配置

image.png

目标：可以使用@Value获取配置文件配置项并结合@Bean注册组件到Spring

分析：

需求：使用Java代码配置数据库连接池，并可以在处理器中注入并使用

步骤：

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

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

创建数据库；

创建数据库连接参数的配置文件jdbc.properties；
然后在项目中创建 springboot\src\main\resources\jdbc.properties 文件，内容如下

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/nono
jdbc.username=root
jdbc.password=123456

创建配置类；
改造处理器类注入数据源并使用
编写 springboot\src\main\java\com\nono\config\JdbcConfig.java 如下

package com.nono.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")
public class JdbcConfig {

    @Value("${jdbc.driverClassName}")
    String driverClassName;
    @Value("${jdbc.url}")
    String url;
    @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;
    }
}

image.png

在 HelloController 中注入DataSource进行测试，改造代码如下:

package com.nono.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;

@RestController
public class HellowController {

    @Autowired
    private DataSource dataSource;

    @GetMapping("hello")
    public String hello(){

        System.out.println("DataSource = "+dataSource);

        return "hello,spring boot";
    }
}

然后打断点，Debug运行并查看:

image.png

属性注入成功了!

小结：

4. Spring Boot属性注入方式

目标：能够使用@ConfigurationProperties实现Spring Boot配置文件配置项读取和应用

分析：

需求：将配置文件中的配置项读取到一个对象中；

实现：可以使用Spring Boot提供的注解@ConfigurationProperties，该注解可以将Spring Boot的配置文件（默认必须为application.properties或application.yml）中的配置项读取到一个对象中。

实现步骤：

创建配置项类JdbcProperties类，在该类名上面添加@ConfigurationProperties；
将jdbc.properties修改名称为application.properties；
将JdbcProperties对象注入到JdbcConfig；
测试

属性文件的名称有变化，默认的文件名必须是:application.properties或application.yml
在上面的案例中，我们实验了java配置方式。不过属性注入使用的是@Value注解。这种方式虽然可行，但是不够强大，因为它只能注入基本类型值。
在Spring Boot中，提供了一种新的属性注入方式，支持各种java基本数据类型及复杂类型的注入。
1)新建 heima-springboot\src\main\java\com\nono\config\JdbcProperties.java ，用于进行属性注入:

package com.nono.config;

import org.springframework.boot.context.properties.ConfigurationProperties;

@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;
    }
}

在类上通过@ConfigurationProperties注解声明当前类为属性读取类 prefix="jdbc" 读取属性文件中，前缀为jdbc的值。
在类上定义各个属性，名称必须与属性文件中 jdbc. 后面部分一致需要注意的是，这里我们并没有指定属性文件的地址，所以我们需要把jdbc.properties名称改为
application.properties，这是Spring Boot默认读取的属性文件名:

image.png

【注意】如果出现如下提示，项目也可以运行;

image.png

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

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

2)将 JdbcConfig 类原来全部注释掉或删除，修改为如下内容:

package com.nono.config;


import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
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;

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfig {



    @Bean
    public DataSource dataSource(JdbcProperties jdbc){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(jdbc.getDriverClassName());
        dataSource.setUrl(jdbc.getUrl());
        dataSource.setUsername(jdbc.getUsername());
        dataSource.setPassword(jdbc.getPassword());
        return dataSource;
    }
}

通过 @EnableConfigurationProperties(JdbcProperties.class) 来声明要使用 JdbcProperties 这个类的对象
然后要使用配置的话;可以通过以下方式注入JdbcProperties:

image.png

3)测试结果;与前面的测试一样的。
大家会觉得这种方式似乎更麻烦了，事实上这种方式有更强大的功能，也是Spring Boot推荐的注入方式。与@Value 对比关系:

image.png

优势:
Relaxed binding:松散绑定
1、不严格要求属性文件中的属性名与成员变量名一致。支持驼峰，中划线，下划线等等转换，甚至支持对象引导。比如:user.friend.name:代表的是user对象中的friend属性中的name属性，显然friend也是对象。@value注解就难以完成这样的注入方式。
2、meta-data support:元数据支持，帮助IDE生成属性提示(写开源框架会用到)。

更优雅的注入：
事实上，如果一段属性只有一个Bean需要使用，我们无需将其注入到一个类(JdbcProperties，将该类上的所有注解去掉)中。而是直接在需要的地方声明即可;再次修改 JdbcConfig 类为如下代码:

package com.nono.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;

@Configuration
public class JdbcConfig {



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

        return new DruidDataSource();
    }
}

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

小结：

5. 多个yml文件配置

目标：可以将多个yml文件在application.yml文件中配置激活

分析：

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

1）yml配置文件的特征：

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

将application.properties配置文件修改为application.yml的话：

jdbc:
  driverClassName: com.mysql.jdbc.Driver
  url: jdbc:mysql://127.0.0.1:3306/nono
  username: root
  password: 123456

key:
  abc: cba
  def:
    - g
    - h
    - j

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

创建 application-abc.yml 文件如下:

nono:
  url: http://www.nono.cn

创建 application-def.yml 文件如下:

gao:
  url: http://www.gao.cn

在多个配置文件时，需要将这些文件在application.yml文件中进行激活：

#激活配置文件;需要指定其它的配置文件名称
spring:
  profiles:
    active: abc,def

修改HellowController获取配置文件中的值

package com.nono.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;

@RestController
public class HellowController {

    @Value("${nono.url}")
    private String nonourl;

    @Value("${gao.url}")
    private String gaourl;

    @Autowired
    private DataSource dataSource;

    @GetMapping("hello")
    public String hello(){

        System.out.println(nonourl);
        System.out.println(gaourl);
        System.out.println("DataSource = "+dataSource);

        return "hello,spring boot";
    }
}

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

小结：

6. 自动配置原理

目标：了解Spring Boot项目的配置加载流程

小结：
（具体看pdf）

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

1560091228494.png

springboot实战：

7. lombok应用

我们编写pojo时，经常需要编写构造函数和getter、setter方法，属性多的时候，就非常浪费时间，使用lombok插件
可以解决这个问题:
在IDEA中安装lombok插件;不安装插件在IDEA中使用lombok的注解虽然编译能通过，但是源码会报错。所以为了让IDEA更好的辨别lombok注解则才安装插件。

image.png

需要在maven工程中的文件引入依赖:

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

然后可以在Bean上使用:
@Data :自动提供getter和setter、hashCode、equals、toString等方法 @Getter:自动提供getter方法
@Setter:自动提供setter方法 @Slf4j:自动在bean中提供log变量，其实用的是slf4j的日志功能。
例如;在javabean上加@Data，那么就可以省去getter和setter等方法的编写，lombok插件会自动生成。

package com.nono.pojo;

import lombok.Data;

import java.util.Date;

@Data
public class User {
    // id
    private Long id;
    // 用户名
    private String userName;

    // 密码
    private String password;
    // 姓名
    private String name;
    // 年龄
    private Integer age;
    // 性别，1男性，2女性 private Integer sex;
    // 出生日期
    private Date birthday;
    // 创建时间
    private Date created;
    // 更新时间
    private Date updated;
    // 备注
    private String note;


}

目标：使用lombok的注解实现pojo类的简化

分析：

使用Spring Boot整合SSM工程；需要使用到数据库数据。

将数据库表数据导入到数据库中（springboot_test）；
编写数据库表对应的实体类；一般情况下需要编写get/set/toString等这些方法会耗时并且会让实体类看起来比较臃肿。可以使用lombok插件对实体类进行简化。

lombok是一个插件工具类包；提供了一些注解@Data、@Getter等这些注解去简化实体类中的构造方法、get/set等方法的编写。
1. 在IDEA中安装lombok插件；
2. 添加lombok对应的依赖到项目pom.xml文件；
3. 改造实体类使用lombok注解

小结：

在Bean上使用：
@Data ：自动提供getter和setter、hashCode、equals、toString等方法
@Getter：自动提供getter方法
@Setter：自动提供setter方法
@Slf4j：自动在bean中提供log变量，其实用的是slf4j的日志功能。

8. Spring Boot整合-SpringMVC端口和静态资源

虽然默认配置已经可以使用SpringMVC了，不过我们有时候需要进行自定义配置。
可以在 application.yml 文件中配置日志级别控制:

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

修改端口:
查看SpringBoot的全局属性可知，端口通过以下方式配置:
修改配置文件，添加如下配置:

server:
  port: 80

访问静态资源:
现在，我们的项目是一个jar工程，那么就没有webapp，我们的静态资源该放哪里呢?
回顾我们在上面看的源码，有一个叫做ResourceProperties的类，里面就定义了静态资源的默认查找路径:

image.png

默认的静态资源路径为:
classpath:/META-INF/resources/ classpath:/resources/ classpath:/static/ classpath:/public
只要静态资源放在这些目录中任何一个，SpringMVC都会帮我们处理。
我们习惯会把静态资源放在 classpath:/static/ 目录下。我们创建目录 static ，并且从资料文件夹中复制 itcast.gif 和 test.js 如下:

image.png

9.Spring Boot整合-SpringMVC拦截器

目标：可以在Spring Boot项目中配置自定义SpringMVC拦截器

拦截器不是一个普通属性，而是一个类，所以就要用到java配置方式了。在SpringBoot官方文档中有这么一段说明:

image.png

分析：

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

总结:通过实现 WebMvcConfigurer 并添加 @Configuration 注解来实现自定义部分SpringMvc配置。

创建 springboot\src\main\java\com\nono\interceptor\MyInterceptor.java 拦截器，内容如下:

package com.nono.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;

@Slf4j
public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                             Object handler) throws Exception {
        log.debug("这是MyInterceptor拦截器的preHandle方法");
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,
                           Object handler, ModelAndView modelAndView) throws Exception {
        log.debug("这是MyInterceptor拦截器的postHandle方法");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse
            response, Object handler, Exception ex) throws Exception {
        log.debug("这是MyInterceptor拦截器的afterCompletion方法");
    }
}

定义配置类 springboot\src\main\java\com\nono\config\MvcConfig.java ，用于注册拦截器，内容如下:

package com.nono.config;

import com.nono.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;

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    /**
     * 将拦截器注册到spring ioc容器 * @return myInterceptor
     */
    @Bean
    public MyInterceptor myInterceptor(){
        return new MyInterceptor();
    }

    /**
     * 重写该方法;往拦截器链添加自定义拦截器 * @param registry 拦截器链
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //通过registry添加myInterceptor拦截器，并设置拦截器路径为 /*
        registry.addInterceptor(myInterceptor()).addPathPatterns("/*");
    }


}

结构如下:

image.png

10. Spring Boot整合-事务和连接池

spring中的jdbc连接和事务是配置中的重要一环，在SpringBoot中该如何处理呢?
答案是不需要处理，我们只要找到SpringBoot提供的启动器即可，在 pom.xml 文件中添加如下依赖:

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

当然，不要忘了数据库驱动，SpringBoot并不知道我们用的什么数据库，这里我们选择MySQL;同样的在 pom.xml 文件中添加如下依赖:

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

至于事务，SpringBoot中通过注解来控制。就是我们熟知的@Transactional 使用的时候设置在对应的类或方法上即可。
创建 springboot\src\main\java\com\nono\service\UserService.java 业务类如下:

package com.nono.service;

import com.nono.pojo.User;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {
    public User queryById(Long id){ //根据id查询
        return new User();
    }
    @Transactional
    public void saveUser(User user){ System.out.println("新增用户...");
    }
}

其实，在刚才引入jdbc启动器的时候，SpringBoot已经自动帮我们引入了一个连接池:

image.png

HikariCP应该是目前速度最快的连接池了，我们看看它与c3p0的对比:

image.png

因此，我们只需要指定连接池参数即可;打开 application.yml 添加修改配置如下:

image.png

【注意】
把 JdbcConfig 类中的druid的配置删除或注释;

image.png

在配置完hikari数据库连接池后的 application.yml 文件如下:

image.png

启动项目，访问 http://localhost/hello ;查看后台输出，一样可以在HelloController中获取到datasource。

image.png

目标：配置Spring Boot自带默认的hikari数据库连接池和使用@Transactional注解进行事务配置

分析：

事务配置
1. 添加事务相关的启动器依赖，mysql相关依赖；
2. 编写业务类UserService使用事务注解@Transactional
数据库连接池hikari配置

只需要在application配置文件中指定数据库相关参数

小结：

事务配置；只需要添加jdbc启动器依赖
数据库连接池使用默认的hikari，在配置文件中配置如下：

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

11. Spring Boot整合-Mybatis

SpringBoot官方并没有提供Mybatis的启动器，不过Mybatis官网自己实现了。在项目的 pom.xml 文件中加入如下依赖:

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

配置 application.yml ，常用配置如下:

# mybatis配置 
mybatis:
  # 实体类别名包路径
  type-aliases-package: com.nono.pojo
  # 映射文件路径
  # mapper-locations: classpath:mappers/*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

配置Mapper扫描
需要注意，这里没有配置mapper接口扫描包，因此我们需要给每一个Mapper接口添加 @Mapper 注解，才能被识别。

@Mapper
public interface UserMapper {
}

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

@SpringBootApplication 
@MapperScan("com.nono.mapper")
public class Application {
    public static void main(String[] args) { 
          // 启动代码
        SpringApplication.run(Application.class, args); 
  }
}

以下代码示例中，我们将采用@MapperScan扫描方式进行。

目标：配置Mybatis在Spring Boot工程中的整合包，设置mybatis的实体类别名，输出执行sql语句配置项

分析：

添加启动器依赖；
配置Mybatis：实体类别名包，日志，映射文件等；
配置MapperScan

小结：

配置mybatis

mybatis:
# 实体类别名包路径
type-aliases-package: com.nono.pojo
# 映射文件路径
# mapper-locations: classpath:mappers/*.xml
configuration:
  log-impl: org.apache.ibatis.logging.stdout.StdOutImpl  ```

设置启动器类中的mapper扫描

12. Spring Boot整合-通用Mapper

通用Mapper的作者也为自己的插件编写了启动器，我们直接引入即可。在项目的 pom.xml 文件中加入如下依赖:

 <!--mybatis
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.1</version>
        </dependency>-->
        <!-- 通用mapper -->
        <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/Mappe
r/wiki/3.config
编写 springboot\src\main\java\com\nono\mapper\UserMapper.java 如下:

package com.itheima.mapper; 
import com.itheima.pojo.User;
import tk.mybatis.mapper.common.Mapper;
public interface UserMapper extends Mapper<User> {

}

把启动类上的@MapperScan注解修改为通用mapper中自带的:

image.png

在User实体类上加JPA注解
修改 springboot\src\main\java\com\nono\pojo\User.java 如下:

package com.nono.pojo;

import lombok.Data;
import tk.mybatis.mapper.annotation.KeySql;

import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;

@Data
@Table(name = "tb_user")
public class User {
    // id
    @Id
    @KeySql(useGeneratedKeys = true)
    private Long id;
    // 用户名
    private String userName;

    // 密码
    private String password;
    // 姓名
    private String name;
    // 年龄
    private Integer age;
    // 性别，1男性，2女性 private Integer sex;
    // 出生日期
    private Date birthday;
    // 创建时间
    private Date created;
    // 更新时间
    private Date updated;
    // 备注
    private String note;


}


package com.nono.service;

import com.nono.mapper.UserMapper;
import com.nono.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User queryById(Long id){
        //根据id查询
        return userMapper.selectByPrimaryKey(id);
    }

    @Transactional
    public void saveUser(User user){
        System.out.println("新增用户...");
        userMapper.insertSelective(user);
    }

}

package com.nono.controller;

import com.nono.pojo.User;
import com.nono.service.UserService;
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.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;

@RestController
public class HellowController {

    @Autowired
    private UserService userService;
    /**
     * 根据id获取用户
     * @param id 用户id * @return 用户
     */
    @GetMapping("/user/{id}")
    public User queryById(@PathVariable Long id){
        return userService.queryById(id);
    }
}

目标：配置通用Mapper组件到Spring Boot项目中并使用Mapper<T>接口

分析：

通用Mapper：可以实现自动拼接sql语句；所有的mapper都不需要编写任何方法也就是不用编写sql语句。可以提高开发效率。

添加启动器依赖；
改造UserMapper继承Mapper<User>；
修改启动引导类Application中的Mapper扫描注解；
修改User实体类添加jpa注解；
改造UserService实现业务功能；

小结：

在启动引导类上面的mapper扫描注解一定要修改为通用mapper的扫描注解

14. Spring Boot整合-Junit

在springboot项目中如果要使用Junit进行单元测试，则需要添加如下的依赖:

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

在测试包下编写测试类
在测试类上面必须要添加 @SpringBootTest 注解。
编写测试类 springboot\src\test\java\com\nono\service\UserServiceTest.java

package com.nono.service;

import com.nono.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 java.util.Date;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {
    @Autowired
    private UserService userService;

    @Test
    public void  queryById(){
        User user = userService.queryById(1L);
        System.out.println("user = " + user);
    }

    @Test
    public void saveUser() {
        User user = new User();
        user.setUsername("test");
        user.setName("test");
        user.setPassword("123456");
        user.setSex(1);
        user.setAge(20);
        user.setCreated(new Date());
        userService.saveUser(user);
    }

}

15. Spring Boot整合-redis

目标：在Spring Boot项目中使用Junit测试RedisTemplate的使用

分析：

添加启动器依赖；spring-boot-starter-data-redis

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

配置application.yml中修改redis的连接参数；（redis需要启动）

spring:
  redis:
    host: localhost
    port: 6379

编写测试类应用RedisTemplate操作redis中的5种数据类型（string/hash/list/set/sorted set）
编写 src\test\java\com\nono\redis\RedisTest.java 测试代码

package com.nono.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;

@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void test(){
        //string 字符串
        //redisTemplate.opsForValue().set("str", "nono");
        redisTemplate.boundValueOps("str").set("nono");
        System.out.println("str = " + redisTemplate.opsForValue().get("str"));

        //hash 散列
        redisTemplate.boundHashOps("h_key").put("name", "Nono");
        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);
    }
}

16. Spring Boot项目部署

目标：将Spring Boot项目使用maven指令打成jar包并运行测试

分析：

需要添加打包组件将项目中的资源、配置、依赖包打到一个jar包中；可以使用maven的package；
部署：java -jar 包名

添加项目的pom.xml插件;在pom.xml要显式的加入插件spring-boot-maven-plugin，否则无法产生 jar 清单文件，导致打出来的 jar 无法使用命令运行;

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

使用maven的命令package打包;

image.png

之后在项目下的 target 目录中将有如下jar包:

image.png

运行打出来的包;使用命令: java –jar 包全名或者写一个 bat 文件，里面包含 java –jar 包全名;这样就可以双击启动应用。
如执行上述打出来的jar的命令为:

java -jar springboot-1.0-SNAPSHOT.jar

image.png

小结：

添加打包组件

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

部署运行
```
java -jar 包名
```

附录—插件安装

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

安装插件

image.png

应用插件

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

image.png

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

image.png

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

image.png