【SpringBoot 02】SpringBoot整合常用框架Junit5、MyBatis、hikari、JPA、redis、Lombok的使用

àì夳堔傛蜴生んèń 2022-12-21 04:45 50阅读 0赞

### 文章目录 ###

*   *  SpringBoot集成Junit5
     *  SpringBoot集成MyBatis
     *  SpringBoot集成hikari
     *   *  hikari数据库连接池
         *  hikari的配置属性
     *  SpringBoot集成JPA
     *   *  JPA的注解
         *  集成JPA生成数据库表步骤
     *  Lombok的使用
     *   *  Idea安装Lombok插件，开启注解
         *   *  开启Lombok的注解支持
         *  Lombok的注解
         *  Lombok的使用需要加入依赖
     *  SpringBoot集成redis
     *   *  RedisTemplate介绍
         *   *  redisTemplate.boundValueOps()方法介绍
         *  Redis配置属性参数

## SpringBoot集成Junit5 ##

> SpringBoot默认集成**Junit5**，可以直接使用。通过在单元测试类上添加注解 `@SpringBootTest` 然后在方法方法上添加注解 `Test` 来实现单元测试。

测试类

@SpringBootTest
    class Demo01JunitApplicationTests { 
    
        @Autowired
        IPersonService personService;
        
        @Test
        public void testPerson() { 
            //new PersonServiceImpl().savePerson();
            personService.savePerson();
        }
    }

service接口和对应的实现类

public interface IPersonService{ 
        boolean savePerson();
    }

@Service
    public class PersonServiceImpl implements IPersonService { 
    
        @Override
        public boolean savePerson() { 
            System.out.println("PersonServiceImpl savePerson 成功！");
            return true;
        }
    }

## SpringBoot集成MyBatis ##

1.  先准备数据库SpringBoot和创建Person表用于测试

create database springboot;
    create table `person` (
      `id` int(11) not null auto_increment,
      `name` varchar(30) default null,
      `age` int(11) default null,
      primary key (`id`)
    ) engine=innodb auto_increment=4 default charset=utf8;
    
    insert into `person` values ('1', 'strive_day', '21');
    insert into `person` values ('2', 'study', '4');
    insert into `person` values ('3', '小皮孩', '12');

1.  通过SpirngBoot的初始化生成器勾选MyBatis和MySQL依赖。  
    勾选之后，创建的项目会自动添加MyBatis和MySQL需要的依赖（你需要用到什么，就勾选什么，是不是比Spring方便多了）  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center]  
    这样在`pom.xml`中自动集成了mybatis依赖

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

1.  创建Person类  
    `Person`

public class Person { 
        private int id;
        private String name;
        private int age;
        //省略get/set方法
    }

1.  配置数据库连接，配置MyBatis  
    `application.yml`

spring:
      datasource: # hikari
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver # mysql 8
        username: root
        password: 861221293
        url: jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8  # serverTimezone=GMT%2B8表示东8区，不然报错time zone
    
    # 配置Mybatis：实体类别名包、映射文件、日志等
    mybatis:
      type-aliases-package: com.xgf.demo02_mybatis.domain # 类型别名（以后可以用类名以小写字母开头来代替）
      mapper-locations: classpath:com.xgf.demo02_mybatis.dao/*.xml  # xml文件(mapper映射)，类路径
      #使用注解在启动类上面配置注解 @MapperScan("com.xgf.demo02_mybatis.dao") //用于存放dao接口
      # 配置MyBatis的日志（添加这个配置就可以了奈斯）
      configuration:
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #mybatis日志

1.  在Application启动类上添加@MapperScan注解扫描dao

@SpringBootApplication
    @MapperScan("com.xgf.demo02_mybatis.dao")   //扫描dao接口
    public class Demo02MybatisApplication { 
    
        public static void main(String[] args) { 
            SpringApplication.run(Demo02MybatisApplication.class, args);
        }
    }

1.  SpirngBoot集成MyBatis测试  
    6.1 编写Mapper接口(dao)  
    `PersonDao`

public interface PersonDao { 
        //查找所有的person
        List<Person> findAllPersons();
    }

6.2 配置Mapper映射文件  
`PersonDao.xmll`

<?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.xgf.demo02_mybatis.dao.PersonDao">
    
        <select id="findAllPersons" resultType="person">
            select * from person
        </select>
    </mapper>

6.3 编写测试类测试

@SpringBootTest
    class Demo02MybatisApplicationTests { 
    
        @Autowired
        PersonDao personDao;    //如果出现运行无错误，编译爆红，按Alt+Enter修复选择disabled inspection不做语法检查
    
        @Test
        void test01() { 
            System.out.println(personDao.findAllPersons());
        }
    }

6.4 运行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 1]

> 【注意】  
> 如果出现错误`java.sql.SQLException: The server time zone value`，这是因为jdbc驱动的时区要设置，可以设置为东八区（北京时间）  
> jdbcURL  
> `jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8`

## SpringBoot集成hikari ##

### hikari数据库连接池 ###

> Hikari是一款非常强大，高效，并且号称【史上最快连接池】。并且在springboot2.0之后，采用的**默认数据库连接池就是Hikari**。不需要引入依赖，已经在SpringBoot中包含了。  
> **已经自动集成了，我们只需要配置就行**。

HikariCP的GitHub地址：**[https://github.com/brettwooldridge/HikariCP][https_github.com_brettwooldridge_HikariCP]**

因为SpringBoot默认使用**hikari**数据库连接池，所以我们只需要修改**hikari**的配置属性就行。  
`application.yml`

# 数据库配置
    spring:
      datasource: # hikari
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver # mysql 8
        username: root
        password: 861221293
        url: jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8  # serverTimezone=GMT%2B8表示东8区，不然报错time zone
    
      # 修改Hikari 连接池配置
      # 最小空闲连接数量
      hikari:
        minimum-idle: 5
        # 空闲连接存活最大时间，默认600000（10分钟）
        idle-timeout: 180000
        # 连接池最大连接数，默认是10
        maximum-pool-size: 10
        # 此属性控制从池返回的连接的默认自动提交行为,默认值：true
        auto-commit: true
        # 连接池名称
        pool-name: MyHikariCP
        # 此属性控制池中连接的最长生命周期，值0表示无限生命周期，默认1800000即30分钟
        max-lifetime: 1800000
        # 数据库连接超时时间,默认30秒，即30000
        connection-timeout: 30000
        connection-test-query: SELECT 1

### hikari的配置属性 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">Hikari 配置名称</th> 
   <th align="left">描述</th> 
   <th align="left">默认值</th> 
   <th align="left">默认配置validate之后的值</th> 
   <th align="left">validate重置</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">autoCommit</td> 
   <td align="left">自动提交从池中返回的连接</td> 
   <td align="left">true</td> 
   <td align="left">true</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">connectionTimeout</td> 
   <td align="left">等待来自池的连接的最大毫秒数</td> 
   <td align="left">SECONDS.toMillis(30) = 30000</td> 
   <td align="left">30000</td> 
   <td align="left">如果小于250毫秒，则被重置回30秒</td> 
  </tr> 
  <tr> 
   <td align="left">idleTimeout</td> 
   <td align="left">连接允许在池中闲置的最长时间</td> 
   <td align="left">MINUTES.toMillis(10) = 600000</td> 
   <td align="left">600000</td> 
   <td align="left">如果idleTimeout+1秒&gt;maxLifetime 且 maxLifetime&gt;0，则会被重置为0（代表永远不会退出）；如果idleTimeout!=0且小于10秒，则会被重置为10秒</td> 
  </tr> 
  <tr> 
   <td align="left">maxLifetime</td> 
   <td align="left">池中连接最长生命周期</td> 
   <td align="left">MINUTES.toMillis(30) = 1800000</td> 
   <td align="left">1800000</td> 
   <td align="left">如果不等于0且小于30秒则会被重置回30分钟</td> 
  </tr> 
  <tr> 
   <td align="left">connectionTestQuery</td> 
   <td align="left">如果您的驱动程序支持JDBC4，我们强烈建议您不要设置此属性</td> 
   <td align="left">null</td> 
   <td align="left">null</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">minimumIdle</td> 
   <td align="left">池中维护的最小空闲连接数</td> 
   <td align="left">-1</td> 
   <td align="left">10</td> 
   <td align="left">minIdle&lt;0或者minIdle&gt;maxPoolSize,则被重置为maxPoolSize</td> 
  </tr> 
  <tr> 
   <td align="left">maximumPoolSize</td> 
   <td align="left">池中最大连接数，包括闲置和使用中的连接</td> 
   <td align="left">-1</td> 
   <td align="left">10</td> 
   <td align="left">如果maxPoolSize小于1，则会被重置。当minIdle&lt;=0被重置为DEFAULT_POOL_SIZE则为10;如果minIdle&gt;0则重置为minIdle的值</td> 
  </tr> 
  <tr> 
   <td align="left">metricRegistry</td> 
   <td align="left">该属性允许您指定一个 Codahale / Dropwizard <code>MetricRegistry</code> 的实例，供池使用以记录各种指标</td> 
   <td align="left">null</td> 
   <td align="left">null</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">healthCheckRegistry</td> 
   <td align="left">该属性允许您指定池使用的Codahale / Dropwizard HealthCheckRegistry的实例来报告当前健康信息</td> 
   <td align="left">null</td> 
   <td align="left">null</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">poolName</td> 
   <td align="left">连接池的用户定义名称，主要出现在日志记录和JMX管理控制台中以识别池和池配置</td> 
   <td align="left">null</td> 
   <td align="left">HikariPool-1</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">initializationFailTimeout</td> 
   <td align="left">如果池无法成功初始化连接，则此属性控制池是否将 <code>fail fast</code></td> 
   <td align="left">1</td> 
   <td align="left">1</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">isolateInternalQueries</td> 
   <td align="left">是否在其自己的事务中隔离内部池查询，例如连接活动测试</td> 
   <td align="left">false</td> 
   <td align="left">false</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">allowPoolSuspension</td> 
   <td align="left">控制池是否可以通过JMX暂停和恢复</td> 
   <td align="left">false</td> 
   <td align="left">false</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">readOnly</td> 
   <td align="left">从池中获取的连接是否默认处于只读模式</td> 
   <td align="left">false</td> 
   <td align="left">false</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">registerMbeans</td> 
   <td align="left">是否注册JMX管理Bean（<code>MBeans</code>）</td> 
   <td align="left">false</td> 
   <td align="left">false</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">catalog</td> 
   <td align="left">为支持 <code>catalog</code> 概念的数据库设置默认 <code>catalog</code></td> 
   <td align="left">driver default</td> 
   <td align="left">null</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">connectionInitSql</td> 
   <td align="left">该属性设置一个SQL语句，在将每个新连接创建后，将其添加到池中之前执行该语句。</td> 
   <td align="left">null</td> 
   <td align="left">null</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">driverClassName</td> 
   <td align="left">HikariCP将尝试通过仅基于jdbcUrl的DriverManager解析驱动程序，但对于一些较旧的驱动程序，还必须指定driverClassName</td> 
   <td align="left">null</td> 
   <td align="left">null</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">transactionIsolation</td> 
   <td align="left">控制从池返回的连接的默认事务隔离级别</td> 
   <td align="left">null</td> 
   <td align="left">null</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">validationTimeout</td> 
   <td align="left">连接将被测试活动的最大时间量</td> 
   <td align="left">SECONDS.toMillis(5) = 5000</td> 
   <td align="left">5000</td> 
   <td align="left">如果小于250毫秒，则会被重置回5秒</td> 
  </tr> 
  <tr> 
   <td align="left">leakDetectionThreshold</td> 
   <td align="left">记录消息之前连接可能离开池的时间量，表示可能的连接泄漏</td> 
   <td align="left">0</td> 
   <td align="left">0</td> 
   <td align="left">如果大于0且不是单元测试，则进一步判断：(leakDetectionThreshold &lt; SECONDS.toMillis(2) or (leakDetectionThreshold &gt; maxLifetime &amp;&amp; maxLifetime &gt; 0)，会被重置为0 . 即如果要生效则必须&gt;0，而且不能小于2秒，而且当maxLifetime &gt; 0时不能大于maxLifetime</td> 
  </tr> 
  <tr> 
   <td align="left">dataSource</td> 
   <td align="left">这个属性允许你直接设置数据源的实例被池包装，而不是让HikariCP通过反射来构造它</td> 
   <td align="left">null</td> 
   <td align="left">null</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">schema</td> 
   <td align="left">该属性为支持模式概念的数据库设置默认模式</td> 
   <td align="left">driver default</td> 
   <td align="left">null</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">threadFactory</td> 
   <td align="left">此属性允许您设置将用于创建池使用的所有线程的java.util.concurrent.ThreadFactory的实例。</td> 
   <td align="left">null</td> 
   <td align="left">null</td> 
   <td align="left">-</td> 
  </tr> 
  <tr> 
   <td align="left">scheduledExecutor</td> 
   <td align="left">此属性允许您设置将用于各种内部计划任务的java.util.concurrent.ScheduledExecutorService实例</td> 
   <td align="left">null</td> 
   <td align="left">null</td> 
   <td align="left">-</td> 
  </tr> 
 </tbody> 
</table>

此图来自CSDN【把酒问天】博客：[https://blog.csdn.net/long690276759/article/details/82259550][https_blog.csdn.net_long690276759_article_details_82259550]

## SpringBoot集成JPA ##

> **JPA（Java Persistence API）java 持久化应用接口，简单说就是一种规范**。是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。  
> 目前有很多java持久层的框架，比如Hibernate、TopLink、OpeanJPA等等，这么多框架导致java程序员不得不学习多种持久层框架。  
> **使用JPA规范的持久层框架，只要按照JPA的规范开发持久层代码，而不用关心究竟是哪种框架实现的**，而且JPA还对实现其规范的持久层框架做了封装，使得这些框架在使用时更加方便。

### JPA的注解 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">JPA注解</th> 
   <th align="left">作用描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">@Entity</td> 
   <td align="left">声明类为实体或表。</td> 
  </tr> 
  <tr> 
   <td align="left">@Table</td> 
   <td align="left">声明表名。</td> 
  </tr> 
  <tr> 
   <td align="left">@Basic</td> 
   <td align="left">指定非约束明确的各个字段。</td> 
  </tr> 
  <tr> 
   <td align="left">@Embedded</td> 
   <td align="left">指定类或它的值是一个可嵌入的类的实例的实体的属性。</td> 
  </tr> 
  <tr> 
   <td align="left">@Id</td> 
   <td align="left">指定的类的属性，用于识别（一个表中的主键）。</td> 
  </tr> 
  <tr> 
   <td align="left">@GeneratedValue</td> 
   <td align="left">指定如何标识属性可以被初始化，例如自动、手动、或从序列表中获得的值。</td> 
  </tr> 
  <tr> 
   <td align="left">@Transient</td> 
   <td align="left">指定的属性，它是不持久的，即：该值永远不会存储在数据库中。</td> 
  </tr> 
  <tr> 
   <td align="left">@Column</td> 
   <td align="left">指定持久属性栏属性。</td> 
  </tr> 
  <tr> 
   <td align="left">@SequenceGenerator</td> 
   <td align="left">指定在@GeneratedValue注解中指定的属性的值。它创建了一个序列。</td> 
  </tr> 
  <tr> 
   <td align="left">@TableGenerator</td> 
   <td align="left">指定在@GeneratedValue批注指定属性的值发生器。它创造了的值生成的表。</td> 
  </tr> 
  <tr> 
   <td align="left">@AccessType</td> 
   <td align="left">这种类型的注释用于设置访问类型。如果设置@AccessType（FIELD），则可以直接访问变量并且不需要getter和setter，但必须为public。如果设置@AccessType（PROPERTY），通过getter和setter方法访问Entity的变量。</td> 
  </tr> 
  <tr> 
   <td align="left">@JoinColumn</td> 
   <td align="left">指定一个实体组织或实体的集合。这是用在多对一和一对多关联。</td> 
  </tr> 
  <tr> 
   <td align="left">@UniqueConstraint</td> 
   <td align="left">指定的字段和用于主要或辅助表的唯一约束。</td> 
  </tr> 
  <tr> 
   <td align="left">@ColumnResult</td> 
   <td align="left">参考使用select子句的SQL查询中的列名。</td> 
  </tr> 
  <tr> 
   <td align="left">@ManyToMany</td> 
   <td align="left">定义了连接表之间的多对多一对多的关系。</td> 
  </tr> 
  <tr> 
   <td align="left">@ManyToOne</td> 
   <td align="left">定义了连接表之间的多对一的关系。</td> 
  </tr> 
  <tr> 
   <td align="left">@OneToMany</td> 
   <td align="left">定义了连接表之间存在一个一对多的关系。</td> 
  </tr> 
  <tr> 
   <td align="left">@OneToOne</td> 
   <td align="left">定义了连接表之间有一个一对一的关系。</td> 
  </tr> 
  <tr> 
   <td align="left">@NamedQueries</td> 
   <td align="left">指定命名查询的列表。</td> 
  </tr> 
  <tr> 
   <td align="left">@NamedQuery</td> 
   <td align="left">指定使用静态名称的查询。</td> 
  </tr> 
 </tbody> 
</table>

来自CSDN【深存少年梦】：[https://blog.csdn.net/wujiaqi0921/article/details/78789087][https_blog.csdn.net_wujiaqi0921_article_details_78789087]

> （1）添加Spring Data JPA的起步依赖  
> （2）添加数据库驱动依赖  
> （3） 在application.properties中配置数据库和jpa的相关属性

### 集成JPA生成数据库表步骤 ###

1.  SpirngBoot自动集成了JPA，通过SpringBoot的初始化工具创建勾选就能集成。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 2]  
    这样在pom.xml中就自动集成了JPA的依赖

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

1.  配置JAP和mysql  
    `application.yml`

# 数据库配置
    spring:
      datasource: # hikari
        type: com.zaxxer.hikari.HikariDataSource  # 数据库类型，默认就是hikari（如果不改的话可以不写）
        driver-class-name: com.mysql.cj.jdbc.Driver # mysql 8 需要添加时区
        username: root
        password: 861221293
        url: jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8  # serverTimezone=GMT%2B8表示东8区，不然报错time zone
    
    
      # 配置jpa
      jpa:
        database: mysql  # 使用的数据库MySQL数据库
        show-sql: true # 对框架操作，希望显示sql语句
        generate-ddl: true # 自动生成主键
        hibernate:
          ddl-auto: update  # 表的生成策略，设置为update，如果表不存在就创建表，否则直接使用操作表，配置create，就是每次都创建
          naming: # 命名生成策略，设置表的字段生成方式（小驼峰/下划线形式）
            physical-strategy: org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy  #下划线形式aa_bb_cc
            #PhysicalNamingStrategyStandardImpl小驼峰形式aaBbCc
            #SpringPhysicalNamingStrategy 下划线形式aa_bb_cc（一般数据库表字段以下划线形式生成，所以用这种）

1.  创建User类（需要生成的数据库表）

@Entity     //表示当前类，在数据库有表与它对应
    @Table(name = "tb_user")    //数据库的表，与当前类对应，这里会有下划线报错，但是无影响
    public class User { 
        @Id     //表示id
        @GeneratedValue(strategy = GenerationType.IDENTITY)     //id设为主键自增长
        private int id;
    
        private String username;
        private String password;
        private String girlFriend;  //小驼峰形式
        private String name;
        //省略get/set方法
    }

1.  创建dao来实现增删查改

> 这里我们只需要用集成JPA的JpaRepository类，就可以实现表的基本增删查改了。  
> `JpaRepository<T,ID>` ： T泛型，写类名称（对应的表），ID是表的主键。

//继承通用的JPA接口JpaRepository<T,ID>，就可以可完成增删改查
    public interface UserDao extends JpaRepository<User,Integer> { 
    }

> 里面什么都不用写，因为JpaRepository类已经满足我们需要的基本的增删查改了。

`JpaRepository`类的内容

@NoRepositoryBean
    public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> { 
        List<T> findAll();
    
        List<T> findAll(Sort var1);
    
        List<T> findAllById(Iterable<ID> var1);
    
        <S extends T> List<S> saveAll(Iterable<S> var1);
    
        void flush();
    
        <S extends T> S saveAndFlush(S var1);
    
        void deleteInBatch(Iterable<T> var1);
    
        void deleteAllInBatch();
    
        T getOne(ID var1);
    
        <S extends T> List<S> findAll(Example<S> var1);
    
        <S extends T> List<S> findAll(Example<S> var1, Sort var2);
    }

1.  创建测试类，测试通过JPA进行数据库操作

@SpringBootTest
    class Demo03JpaApplicationTests { 
    
        @Autowired
        UserDao userDao;
    
        //测试通过JPA插入数据库字段（配置jpa的时候配置了ddl-auto: update，所以如果不存在对应的表就创建，存在更新数据）
        @Test
        void test01() { 
            User user = new User();
            user.setGirlFriend("strive_day");
            user.setUsername("strive_gf@163.com");
            user.setName("jpa测试");
            userDao.save(user);//--->orm方式 -- >将对象值取出-->sql-->数据库
        }
    
        //测试查询插入的字段
        @Test
        void test02() { 
    
            List<User> allUser = userDao.findAll();
            System.out.println(allUser);
        }
    
    }

6.运行结果  
test01方法，插入数据库成功（并且生成了对应User类上的注解`@Table(name = "tb_user")`的表tb\_user）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 3]  
查看数据库  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 4]  
运行test02，通过JPA查询所有的数据  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 5]

## Lombok的使用 ##

> 我们一般编写数据库表对应的实体类（比如Person、User等等实体类），一般情况下都需要编写对应的**get/set/toString**等这些方法，但是编写这些会耗时并且会让实体类看起来比较臃肿（字段一多，就有一堆的get、set方法）。  
>   
> 这时候就**可以使用lombok插件对实体类进行简化**。  
> **Lombok**是一个**插件工具类包**，提供了一些注解像@Data、@Getter等这些注解去简化实体类中的构造方法、get、set等方法的编写。  
> **就是通过注解，简化javabean(或者叫pojo)实体类的代码，让我们不需要编写构造方法、get、set等方法又能满足我们调用构造方法、get、set等方法。**

### Idea安装Lombok插件，开启注解 ###

file -> settings -> Plugins -> Marketplace -> 搜索框输入Lombok搜索，然后点击Install下载，下载成功重启idea就可以使用了  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 6]

#### 开启Lombok的注解支持 ####

File -> Settings -> 搜索Annotation -> 打开Annotatin Processors -> 勾选Enable annotation processors -> Apply -> ok  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 7]

### Lombok的注解 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">Lombok类的注解</th> 
   <th align="left">作用描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><strong>@Data</strong></td> 
   <td align="left">在JavaBean中使用，该注解自动提供getter、setter、hashCode、equals、toString等方法</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>@getter</strong></td> 
   <td align="left">在JavaBean中使用，该注解会生成对应的getter方法</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>@setter</strong></td> 
   <td align="left">在JavaBean中使用，注解会生成对应的setter方法</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>@Slf4j</strong></td> 
   <td align="left">在需要打印日志的类中使用，项目中使用slf4j日志框架，自动在bean中提供log变量，其实就是用的slf4j的日志功能（使用sl4j调用log4j）</td> 
  </tr> 
  <tr> 
   <td align="left">@Log4j</td> 
   <td align="left">在需要打印日志的类中使用，项目中使用log4j日志框架</td> 
  </tr> 
  <tr> 
   <td align="left">@ToString</td> 
   <td align="left">在JavaBean中使用，注解会自动重写对应的toStirng方法<br><code>@ToString(exclude={"column1","column2"})</code>：排除多个column列所对应的元素<br><code>@ToString(of={"column1","column2"})</code>：只生成包含多个column列所对应的元素</td> 
  </tr> 
  <tr> 
   <td align="left">@NoArgsConstructor</td> 
   <td align="left">在JavaBean中使用，注解会生成对应的无参构造方法</td> 
  </tr> 
  <tr> 
   <td align="left">@AllArgsConstructor</td> 
   <td align="left">在JavaBean中使用，注解会生成对应的有参构造方法</td> 
  </tr> 
  <tr> 
   <td align="left">@EqualsAndHashCode</td> 
   <td align="left">在JavaBean中使用，注解会自动重写对应的equals方法和hashCode方法</td> 
  </tr> 
  <tr> 
   <td align="left">@NonNull</td> 
   <td align="left">快速判断是否为空null，为空抛出``java.lang.NullPointerException`异常</td> 
  </tr> 
  <tr> 
   <td align="left">@Synchronized</td> 
   <td align="left">该注解自动添加到同步机制，生成的代码并不是直接锁方法,而是锁代码块， 作用范围是方法上</td> 
  </tr> 
  <tr> 
   <td align="left">@Cleanup</td> 
   <td align="left">该注解用于确保已分配的资源被释放（IO的连接关闭）</td> 
  </tr> 
  <tr> 
   <td align="left">@Accessors(chain = true)</td> 
   <td align="left">链式风格，在调用set方法时，返回这个类的实例对象</td> 
  </tr> 
 </tbody> 
</table>

来自博客园【张界】：[https://www.cnblogs.com/pascall/p/10281169.html][https_www.cnblogs.com_pascall_p_10281169.html]

### Lombok的使用需要加入依赖 ###

在`pom.xml`中加入Lombok对应的依赖

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

## SpringBoot集成redis ##

redis执行流程图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 8]

1.  勾选Redis创建SpringBoot项目  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 9]
2.  创建测试类模拟Redis缓存  
    先开启Redis服务器  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 10]  
    按照你自己的需要对`application.yml`或`application.properties`文件进行修改  
    比如：`application.properties`

# redis配置
    spring.redis.host=localhost # 主机地址
    spring.redis.port=6379      # 端口号

使用RedisTemplate模拟缓存，用创建数据模拟从数据库查找数据。

@SpringBootTest
    class Demo05RedisApplicationTests { 
    
        //RedisTemplate来获取Redis连接
        @Autowired
        RedisTemplate<String, String> redisTemplate;
    
        @Test
        void test01() { 
    
            /** * (BoundValueOperations) redisTemplate.boundValueOps(key)方法 * append(String value) 在原来值的末尾添加值 * get() 获取字符串所有值 */
    
    
            //查找是否有缓存
            String cachejson = redisTemplate.boundValueOps("cacheJSON").get();
    
            //有就直接返回
            if (cachejson != null) { 
                System.out.println("来自redis缓存 ： " + cachejson);
            } else { 
                //创建数据
                String json = "{name:strive_day,age:21}";
                //保存到缓存中，再显示
                redisTemplate.boundValueOps("cacheJSON").set(json);
                System.out.println("保存json " + json);
            }
    
        }
    
    }

第一次运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 11]  
第2,3…n次运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 12]

### RedisTemplate介绍 ###

> spring 封装了 `RedisTemplate` 对象来进行对redis的各种操作，它支持所有的 redis 原生的 api。

`RedisTemplate`源码

public class RedisTemplate<K, V> extends RedisAccessor implements RedisOperations<K, V>, BeanClassLoaderAware { 
        private boolean enableTransactionSupport = false;
        private boolean exposeConnection = false;
        private boolean initialized = false;
        private boolean enableDefaultSerializer = true;
    }

`RedisTemplate`中定义的5种对数据结构操作方法

//就是对Redis五中结构类型进行操作
    redisTemplate.opsForValue();	//操作字符串String
    redisTemplate.opsForHash();		//操作hash
    redisTemplate.opsForList();		//操作list
    redisTemplate.opsForSet();		//操作set redisTemplate.opsForZSet(); //操作有序set

#### redisTemplate.boundValueOps()方法介绍 ####

> redis中通过键值对(key,value)存储数据  
> `redisTemplate.boundValueOps(key)`通过读取redis的key对value进行操作。  
> 返回的是一个`BoundValueOperations`对象。
> 
>     BoundValueOperations bvo= redisTemplate.boundValueOps("key"); 
>     bvo.append();	//原来值的末尾添加值
>     bvo.get();			// 获取字符串所有值

<table> 
 <thead> 
  <tr> 
   <th align="left">append(String value)</th> 
   <th align="left">在原来值的末尾添加值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">get(key)</td> 
   <td align="left">获取对应key的所有值</td> 
  </tr> 
  <tr> 
   <td align="left">BoundValueOperations方法(V是泛型)</td> 
   <td align="left">作用描述</td> 
  </tr> 
  <tr> 
   <td align="left">get(long start, long end)</td> 
   <td align="left">获取指定区间位置的值</td> 
  </tr> 
  <tr> 
   <td align="left">set(V value)</td> 
   <td align="left">给绑定键重新设置值</td> 
  </tr> 
  <tr> 
   <td align="left">set(V value, long offset)</td> 
   <td align="left">截取原有值的指定长度后添加新的值在后面</td> 
  </tr> 
  <tr> 
   <td align="left">Boolean setIfAbsent(V value);</td> 
   <td align="left">没有值存在就添加值</td> 
  </tr> 
  <tr> 
   <td align="left">getAndSet(V value)</td> 
   <td align="left">获取原来的值并重新赋新的值</td> 
  </tr> 
  <tr> 
   <td align="left">size()</td> 
   <td align="left">获取绑定值的长度</td> 
  </tr> 
 </tbody> 
</table>

### Redis配置属性参数 ###

<table> 
 <thead> 
  <tr> 
   <th align="left"><strong>reids配置参数</strong></th> 
   <th align="left"><strong>参数属性说明</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><strong>daemonize</strong></td> 
   <td align="left">如果值是“yes”，则启动服务的时候是后台守护进程形式，如果值是“no”，则相反</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>pidfile</strong></td> 
   <td align="left">指定存储Redis进程号的文件路径</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>port</strong></td> 
   <td align="left">指定当前Redis服务的端口，默认为6379</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>tcp-backlog</strong></td> 
   <td align="left">此参数确定了TCP连接中已完成队列(完成三次握手之后)的长度， 当然此值必须不大于Linux系统定义的/proc/sys/net/core/somaxconn值，默认是511，而Linux的默认参数值是128。当系统并发量大并且客户端速度缓慢的时候，可以将这二个参数一起参考设定。</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>timeout</strong></td> 
   <td align="left">客户端和Redis服务端的连接超时时间，默认是0，表示永不超时。</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>tcp-keepalive</strong></td> 
   <td align="left">如果值非0，单位是秒，表示将周期性的使用SO_KEEPALIVE检测客户端是否还处于健康状态，避免服务器一直阻塞，官方给出的建议值是60S。</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>loglevel</strong></td> 
   <td align="left">Redis总共支持四个级别：debug、verbose、notice、warning。Debug：记录很多信息，用于开发和测试；Varbose：有用的信息，不像debug会记录那么多；Notice：普通的verbose，常用于生产环境；Warning：只有非常重要或者严重的信息会记录到日志；默认是notice级别。</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>logfile</strong></td> 
   <td align="left">日志的存储路径</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>databases</strong></td> 
   <td align="left">可用的数据库数，默认值为16，默认数据库为0，数据库范围在0-（database-1）之间，个人觉得DB的概念类似于命名空间</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>save</strong></td> 
   <td align="left">保存数据库快照信息到磁盘，其对应的值有两个，比如save 300 10表示：300秒内至少有300个key被改变时，触发保存信息到磁盘的事件。</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>stop-writes-on-bgsave-error</strong></td> 
   <td align="left">当持久化出现错误之后，是否继续提供写服务</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>rdbcompression</strong></td> 
   <td align="left">持久化到RDB文件时，是否压缩，“yes”为压缩，“no”则反之</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>rdbchecksum</strong></td> 
   <td align="left">读取和写入的时候是否支持CRC64校验，默认是开启的</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>dbfilename</strong></td> 
   <td align="left">镜像文件的名字</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>dir</strong></td> 
   <td align="left">当前工作目录，配置文件和镜像文件等都在此目录下</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>masterauth</strong></td> 
   <td align="left">设置访问master服务器的密码</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>slave-serve-stale-data</strong></td> 
   <td align="left">当slave服务器和master服务器失去连接后，或者当数据正在复制传输的时候，如果此参数值设置“yes”，slave服务器可以继续接受客户端的请求，否则，会返回给请求的客户端如下信息“SYNC with master in progress”</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>slave-read-only</strong></td> 
   <td align="left">是否允许slave服务器节点只提供读服务</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>repl-disable-tcp-nodelay</strong></td> 
   <td align="left">指定向slave同步数据时，是否禁用socket的NO_DELAY选 项。若配置为“yes”，则禁用NO_DELAY，则TCP协议栈会合并小包统一发送，这样可以减少主从节点间的包数量并节省带宽，但会增加数据同步到 slave的时间。若配置为“no”，表明启用NO_DELAY，则TCP协议栈不会延迟小包的发送时机，这样数据同步的延时会减少，但需要更大的带宽。 通常情况下，应该配置为no以降低同步延时，但在主从节点间网络负载已经很高的情况下，可以配置为yes。</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>slave-priority</strong></td> 
   <td align="left">指定slave的优先级。在不只1个slave存在的部署环境下，当master宕机时，Redis Sentinel会将priority值最小的slave提升为master。需要注意的是，若该配置项为0，则对应的slave永远不会自动提升为master。</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>appendonly</strong></td> 
   <td align="left">开启append only 模式之后，redis 会把所接收到的每一次写操作请求都追加到appendonly.aof 文件中，当redis 重新启动时，会从该文件恢复出之前的状态。但是这样会造成appendonly.aof 文件过大，所以redis 还支持了BGREWRITEAOF指令，对appendonly.aof 进行重新整理。默认是不开启的。</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>appendfilename</strong></td> 
   <td align="left">默认为appendonly.aof。</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>appendfsync</strong></td> 
   <td align="left">设置aof的同步频率，有三种选择always、everysec、no，默认是everysec表示每秒同步一次。</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>no-appendfsync-on-rewrite</strong></td> 
   <td align="left">指定是否在后台aof文件rewrite期间调用fsync，默认为no，表示要调用fsync（无论后台是否有子进程在刷盘）。Redis在后台写RDB文件或重写afo文件期间会存在大量磁盘IO，此时，在某些linux系统中，调用fsync可能会阻塞。</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>auto-aof-rewrite-percentage</strong></td> 
   <td align="left">指定Redis重写aof文件的条件，默认为100，表示与上次rewrite的aof文件大小相比，当前aof文件增长量超过上次afo文件大小的100%时，就会触发background rewrite。若配置为0，则会禁用自动rewrite</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>auto-aof-rewrite-min-size</strong></td> 
   <td align="left">指定触发rewrite的aof文件大小。若aof文件小于该值，即使当前文件的增量比例达到auto-aof-rewrite-percentage的配置值，也不会触发自动rewrite。即这两个配置项同时满足时，才会触发rewrite。</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>lua-time-limit</strong></td> 
   <td align="left">一个Lua脚本最长的执行时间，单位为毫秒，如果为0或负数表示无限执行时间，默认为5000</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>notify-keyspace-events</strong></td> 
   <td align="left">见参考3，按键通知事件</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>aof-rewrite-incremental-fsync</strong></td> 
   <td align="left">aof rewrite过程中,是否采取增量文件同步策略,默认为“yes”。 rewrite过程中,每32M数据进行一次文件同步,这样可以减少aof大文件写入对磁盘的操作次数</td> 
  </tr> 
 </tbody> 
</table>

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/ce5855b801914fd48581ccda49cfb284.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/8155eba5687d47f2abd5ee16a1acdb87.png
[https_github.com_brettwooldridge_HikariCP]: https://github.com/brettwooldridge/HikariCP
[https_blog.csdn.net_long690276759_article_details_82259550]: https://blog.csdn.net/long690276759/article/details/82259550
[https_blog.csdn.net_wujiaqi0921_article_details_78789087]: https://blog.csdn.net/wujiaqi0921/article/details/78789087
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/45564f5b1c7d4cb2a3da532a19d2ace4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/d48ac153a19a4639ace7f51c263daf2c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/06afbd77388f4dfe8c8ff0e19233aa23.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/57d73aac8f98410eacac368062bf5f06.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221120/9bc81e14e4a544628741f8aa2aacda0a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221120/baaa9e6f3cbc402e85ea90b2046af332.png
[https_www.cnblogs.com_pascall_p_10281169.html]: https://www.cnblogs.com/pascall/p/10281169.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221120/d358c3c499d84db38e5120b906f747a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221120/ef06b8186726407aabdfb8763f197dd3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221120/51e242ebb53145c1a62116f1778647cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221120/a6b856eb9b8d4e74bb36db2146d27e58.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20221120/994ab2dac9fb4160a754debe081d8334.png