04-SpringBoot核心功能之数据访问

提前预知

• 课程笔记来源于雷神的SpringBoot2教程
• 参考文档地址：参考文档
• 要学会查看官方文档！！！！！！！！！

01、SQL

• SpringBoot在内部也对数据库连接进行了整合，在Starter章节中有很多关于数据的场景启动器，例如：spring-boot-starter-data-jdbc等

1.1、数据源的自动配置

1.1.1、导入JDBC场景

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

• 从上图可以看出spring-boot-starter-data-jdbc场景启动器没有帮我们导入数据库驱动.
• 为什么导入JDBC场景，官方不导入驱动？

官方不知道我们接下要操作什么数据库

• 数据库版本和驱动版本要对应

  • SpringBoot对我们的数据驱动做了版本仲裁

  默认版本：<mysql.version>8.0.22</mysql.version>

  • 想要修改版本

  1、直接依赖引入具体版本（maven的就近依赖原则）
  2、重新声明版本（maven的属性的就近优先原则）

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <!--<version>5.1.49</version>-->
</dependency>

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

1.1.2、分析自动配置

自动配置的类，包括下面的几个，可以在自动配置包jdbc中查看:

• DataSourceAutoConfiguration ，数据源的自动配置
  • 修改数据源相关的配置，在配置文件中：spring.datasource
  • 数据库连接池的配置，当自己容器中没有DataSource才自动配置的，也就是如果自己不配置数据源，官方帮我们自动配置一个。
  • 官方底层配置好的连接池(DataSource)是：HikariDataSource

@Configuration(proxyBeanMethods = false)
@Conditional(PooledDataSourceCondition.class)
//当自己容器中没有DataSource才自动配置
@ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
@Import({ DataSourceConfiguration.Hikari.class, DataSourceConfiguration.Tomcat.class,
        DataSourceConfiguration.Dbcp2.class, DataSourceConfiguration.OracleUcp.class,
        DataSourceConfiguration.Generic.class, DataSourceJmxConfiguration.class })
protected static class PooledDataSourceConfiguration

• DataSourceTransactionManagerAutoConfiguration： 事务管理器的自动配置
• JdbcTemplateAutoConfiguration： JdbcTemplate的自动配置，可以来对数据库进行crud
  • 可以修改这个配置项@ConfigurationProperties(prefix = “spring.jdbc”) 来修改JdbcTemplate
  • @Bean@Primary JdbcTemplate；容器中有这个组件
• JndiDataSourceAutoConfiguration： jndi的自动配置
• XADataSourceAutoConfiguration： 分布式事务相关的

1.1.3、修改配置项

上面分析了使用配置文件可以修改数据库配置项，我们可以在配置文件中这样写：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db_account
    username: root
    password: 12345678
    driver-class-name: com.mysql.jdbc.Driver

1.1.4、测试

@Slf4j
@SpringBootTest
class Boot05WebAdminApplicationTests {
    @Autowired
    //导入JDBC场景的时候，自动导入的JdbcTemplate
    JdbcTemplate jdbcTemplate;
    @Test
    public void contextLoads() {
        Long aLong = jdbcTemplate.queryForObject("select count(*) from account_tbl", Long.class);
        log.info("记录总数：{}",aLong);
    }
}

1.2、使用Druid数据源

前面介绍的SpringBoot帮我们自动导入的数据源其实已经很好了，但是国内很对人喜欢使用Druid数据源，下面来谈谈这个数据源。

1.2.1、Druid概述

Druid官方github地址：地址

• 里面有参考文档，具体的可以查看参考文档

Druid监控功能可以监控很多东西，具体的配置可以参考官方文档

整合第三方技术的两种方式：

• 第一种：导入相关的包，自定义
• 第二种：找相关的场景启动器，starter

1.2.2、自定义方式

引入依赖

<!--Druid连接池-->
<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>druid</artifactId>
   <version>1.1.17</version>
</dependency>

创建数据源：SSM框架是引入依赖后编写xml配置文件，使用SpringBoot后我们可以编写数据源的配置类，在配置类中注入Bean组件：

• 方式一：在配置类中写死的方式，不太方便

@Configuration
public class MyDataSourceConfig {
    //默认的自动配置是判断容器中没有才会配@ConditionalOnMissingBean(DataSource.class)
    @Bean
    public DataSource dataSource() throws SQLException {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/db_account");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("12345678");     
        return druidDataSource;
    }
}

• 方式二：结合配置文件一起使用的方式，方便一点

@Configuration
public class MyDataSourceConfig {
	@ConfigurationProperties("spring.datasource")
	//使用这个注解从配`在这里插入代码片`置文件中获取
    @Bean
    public DataSource dataSource() throws SQLException {
        DruidDataSource druidDataSource = new DruidDataSource();
        //加入监控功能
        druidDataSource.setFilters("stat,wall");
        //最大活跃线程数
        druidDataSource.setMaxActive(10);
        return druidDataSource;
    }
}

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db_account
    username: root
    password: 12345678
    driver-class-name: com.mysql.jdbc.Driver

• 只要是Druid能在XML配置文件中配置的属性，在配置类中同样可以通过set方法设置，也可以在配置文件中配置，道理都是一样的，下面列举一些能在XML中配置的属性值：

<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<property name="maxActive" value="20" />
<property name="initialSize" value="1" />
<property name="maxWait" value="60000" />
<property name="minIdle" value="1" />
<property name="timeBetweenEvictionRunsMillis" value="60000" />
<property name="minEvictableIdleTimeMillis" value="300000" />
<property name="testWhileIdle" value="true" />
<property name="testOnBorrow" value="false" />
<property name="testOnReturn" value="false" />
<property name="poolPreparedStatements" value="true" />
<property name="maxOpenPreparedStatements" value="20" />

StatViewServlet功能：SSM框架是引入依赖后编写xml配置文件，使用SpringBoot后我们可以编写数据源的配置类，在配置类中注入Bean组件：

• StatViewServlet的用途包括：
  • 提供监控信息展示的html页面
  • 提供监控信息的JSON API

/**
* 配置 druid的监控页功能
*/
@Bean
public ServletRegistrationBean statViewServlet(){
	//创建一个视图Servlet
   StatViewServlet statViewServlet = new StatViewServlet();
   //设置Servlet映射的路径
   ServletRegistrationBean<StatViewServlet> registrationBean = new ServletRegistrationBean<>(statViewServlet, "/druid/*");
   //添加初始化参数，监控页的用户，密码
   registrationBean.addInitParameter("loginUsername","admin");
   registrationBean.addInitParameter("loginPassword","123456");
   return registrationBean;
}

StatFilter功能：SSM框架是引入依赖后编写xml配置文件，使用SpringBoot后我们可以编写数据源的配置类，在配置类中注入Bean组件：

• 用于统计监控信息，如：SQL监控、URI监控

@Bean
public FilterRegistrationBean webStatFilter(){
   WebStatFilter webStatFilter = new WebStatFilter();

   FilterRegistrationBean<WebStatFilter> filterRegistrationBean = new FilterRegistrationBean<>(webStatFilter);
   filterRegistrationBean.setUrlPatterns(Arrays.asList("/*"));
   filterRegistrationBean.addInitParameter("exclusions","*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
   return filterRegistrationBean;
}

完整的配置类如下：

• 包含，创建数据源，StatViewServlet功能，StatFilter功能

@Configuration
public class MyDataSourceConfig {

    // 默认的自动配置是判断容器中没有才会配@ConditionalOnMissingBean(DataSource.class)
    @ConfigurationProperties("spring.datasource")
     /**
     * 数据源配置 
     */
    @Bean
    public DataSource dataSource() throws SQLException {
        DruidDataSource druidDataSource = new DruidDataSource();
        //加入监控功能
        druidDataSource.setFilters("stat,wall");
        druidDataSource.setMaxActive(10);
        return druidDataSource;
    }

    /**
     * 监控功能配置 
     * @return
     */
    @Bean
    public ServletRegistrationBean statViewServlet(){
        StatViewServlet statViewServlet = new StatViewServlet();
        ServletRegistrationBean<StatViewServlet> registrationBean = new ServletRegistrationBean<>(statViewServlet, "/druid/*");
        //registrationBean.addInitParameter("loginUsername","admin");
        //registrationBean.addInitParameter("loginPassword","123456");
        return registrationBean;
    }

    /**
     * WebStatFilter 用于采集web-jdbc关联监控的数据。
     */
    @Bean
    public FilterRegistrationBean webStatFilter(){
        WebStatFilter webStatFilter = new WebStatFilter();
        FilterRegistrationBean<WebStatFilter> filterRegistrationBean = new FilterRegistrationBean<>(webStatFilter);
        //拦截路径，监控那些页面
        filterRegistrationBean.setUrlPatterns(Arrays.asList("/*"));
 		//排除那些请求路径
        filterRegistrationBean.addInitParameter("exclusions","*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        return filterRegistrationBean;
    }
}

1.2.3、使用官方starter方式

引入场景启动器依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.17</version>
</dependency>

分析自动配置：

• 配置属性类DruidStatProperties： spring.datasource.druid

• 自动配置类DruidDataSourceAutoConfigure配给容器中注入的组件：

  • DruidSpringAopConfiguration.class：监控SpringBean的

  配置项：spring.datasource.druid.aop-patterns

  • DruidStatViewServletConfiguration.class,:监控页的配置

  配置项(默认开启)：spring.datasource.druid.stat-view-servlet

  • DruidWebStatFilterConfiguration.class：web监控配置

  配置项(默认开启)：spring.datasource.druid.web-stat-filter

  • DruidFilterConfiguration.class

private static final String FILTER_STAT_PREFIX = "spring.datasource.druid.filter.stat";
private static final String FILTER_CONFIG_PREFIX = "spring.datasource.druid.filter.config";
private static final String FILTER_ENCODING_PREFIX = "spring.datasource.druid.filter.encoding";
private static final String FILTER_SLF4J_PREFIX = "spring.datasource.druid.filter.slf4j";
private static final String FILTER_LOG4J_PREFIX = "spring.datasource.druid.filter.log4j";
private static final String FILTER_LOG4J2_PREFIX = "spring.datasource.druid.filter.log4j2";
private static final String FILTER_COMMONS_LOG_PREFIX = "spring.datasource.druid.filter.commons-log";
private static final String FILTER_WALL_PREFIX = "spring.datasource.druid.filter.wall";

配置实例：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db_account
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver

    druid:
      aop-patterns: com.aismall.admin.*  #监控SpringBean
      filters: stat,wall     # 底层开启功能，stat（sql监控），wall（防火墙）

      stat-view-servlet:   # 配置监控页功能
        enabled: true
        login-username: admin
        login-password: admin
        resetEnable: false

      web-stat-filter:  # 监控web
        enabled: true
        urlPattern: /*
        exclusions: '*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*'


      filter:
        stat:    # 对上面filters里面的stat的详细配置
          slow-sql-millis: 1000
          logSlowSql: true
          enabled: true
        wall:
          enabled: true
          config:
            drop-table-allow: false

参考文档地址：配置参考地址

1.3、整合MyBatis操作

前面我们使用

• 方式一：spring-boot-starter-data-jdbc(JDBC场景启动器)+mysql-connector-java(数据库驱动)
  • JDBC场景启动器提供了默认连接池，JdbcTemplate(对数据库进行CURD操作，JdbcTemplate只对Spring的JDBC进行了简单的封装，使用起来比较麻烦)
  • 数据库驱动提供了连接数据库的驱动
• 方式二： spring-boot-starter-data-jdbc(JDBC场景启动器)+mysql-connector-java(数据库驱动)+druid-spring-boot-starter(Druid数据库连接池)
  • 使用Druid连接池替换默认的连接池

由于使用JdbcTemplate操作数据库比较复杂，我们整合MyBatis，MyBatis对Spring的JDBC进行了高度的封装使用起来比较方便：

我们先来看看MyBatis的场景启动器给我们导入了那些依赖：

• 方式一：mybatis-spring-boot-starter(mybatis场景启动器)+mysql-connector-java(数据库驱动)
  • mybatis场景启动器引入了JDBC场景启动器，所以有一个默认连接池
  • 使用Mybatis替换JdbcTemplate对数据库进行CRUD
  • 数据库驱动提供了连接数据库的驱动
• 方式二：mybatis-spring-boot-starter(mybatis场景启动器)+mysql-connector-java(数据库驱动)+druid-spring-boot-starter(Druid数据库连接池)
  • 使用Druid连接池替换默认的连接池

1.3.1、配置模式

配置属性类：MybatisProperties

@ConfigurationProperties(prefix = "mybatis")
public class MybatisProperties{}

自动配置文件类：MybatisAutoConfiguration

@Configuration
@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties({MybatisProperties.class})
@AutoConfigureAfter({DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class})
public class MybatisAutoConfiguration{}

• SqlSessionFactory: 自动配置好了
• SqlSession：自动配置了 SqlSessionTemplate 组合了SqlSession
• @Import(AutoConfiguredMapperScannerRegistrar.class)；
• Mapper：只要我们写的操作MyBatis的接口标准了 @Mapper 注解就会被自动扫描进来。

配置文件中配置：

# 配置mybatis规则
mybatis:
  config-location: classpath:mybatis/mybatis-config.xml  #全局配置文件位置
  mapper-locations: classpath:mybatis/mapper/*.xml  #sql映射文件位置

• sql映射配置文件：存放SQL语句，用于给mapper层(dao层)的接口使用

<!--mapper接口---绑定XML-->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.aismall.admin.mapper.AccountMapper">
	<!-- 接口方法:public Account getAcct(Long id);-->
    <select id="getAcct" resultType="com.aismall.admin.bean.Account">
        select * from  account_tbl where  id=#{id}
    </select>
</mapper>

• 全局配置文件(MyBatis主配置文件)：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  <!--注意！！！！  所有内容也可以通过配置文件配置-->
  <settings>
  	<!--开启驼峰命名规则-->
  	<setting name="mapUnderscoreToCamelCase" value="true">
  </settings>
</configuration>

MyBatis的全局配置文件，也可以在配置文件中配置，这样就不用再写全局配置文件：

• 对应位置：属性类中的private Configuration configuration;
• 配置方式：mybatis.configuration配置项下面，就是相当于改mybatis全局配置文件中的值

# 配置mybatis规则
mybatis:
  #config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml
  configuration:   # 全局配置位置
    map-underscore-to-camel-case: true

1.3.2、纯注解模式

• 使用纯注解的模式，就不用写映射配置文件了，直接在接口类的方法上使用注解完成SQL语句的映射。

@Mapper
public interface CityMapper {
    @Select("select * from city where id=#{id}")
    public City getById(Long id);
    public void insert(City city);
}

1.3.3、混合模式

• 混合模式就是，注解方式+SQL映射配置文件方式

@Mapper
public interface CityMapper {
	//注解方式
    @Select("select * from city where id=#{id}")
    public City getById(Long id);
    //SQL语句写在映射配置文件中
    public void insert(City city);
}

1.3.4、总结

使用步骤：

• 第一步：导入mybatis官方starter
• 第二步：编写mapper接口，标注@Mapper注解
• 第三步：可以使用纯注解，也可以使用纯映射文件，还可以二者结合使用
  • 纯注解： 直接在接口上使用注解绑定SQL语句
  • 纯映射文件：编写sql映射文件并绑定mapper接口
  • 注解+映射配置文件
• 第四步：在application.yaml中指定Mapper配置文件的位置，以及指定全局配置文件的信息

推荐方式：

• 简单SQL语句直接注解方式
• 复杂SQL语句编写mapper.xml进行绑定映射

注意：

• @MapperScan("com.aismll.admin.mapper") 简化，在主方法中使用这个注解扫描包下面的接口就可以不用标注@Mapper注解

1.4、整合 MyBatis-Plus

1.4.1、MyBatis-Plus概述

MyBatis-Plus（简称 MP）：是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

官方网址：地址

我们可以安装一下这个插件：MybatisX，安装完之后IDEA上会有小鸟提示符，挺好玩的。

1.4.2、整合MyBatis-Plus

导入场景启动器：

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.1</version>
</dependency>

• 方式一：mybatis-plus-boot-starter+mysql-connector-java(数据库驱动)
• 方式二： mybatis-plus-boot-starter+mysql-connector-java(数据库驱动)+druid-spring-boot-starter(Druid数据库连接池)

自动配置：

• 自动配置类：MybatisPlusAutoConfiguration

@Configuration
@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties({MybatisPlusProperties.class})
@AutoConfigureAfter({DataSourceAutoConfiguration.class, MybatisPlusLanguageDriverAutoConfiguration.class})
public class MybatisPlusAutoConfiguration implements InitializingBean {}

• 属性绑定类：MybatisPlusProperties

@ConfigurationProperties(prefix = "mybatis-plus")
public class MybatisPlusProperties {}

• SqlSessionFactory 自动配置好。底层是容器中的数据源
• mapperLocations 自动配置好的，有默认值：classpath*:/mapper/**/*.xml；任意包的类路径下的所有mapper文件夹下任意路径下的所有xml都是sql映射文件，建议以后sql映射文件，放在 mapper下。
• 容器中也自动配置好了 SqlSessionTemplate
• @Mapper 标注的接口也会被自动扫描；建议直接 @MapperScan("com.aismall.admin.mapper") 批量扫描就行

优点：

• 只需要我们的Mapper继承 BaseMapper ，BaseMapper接口中已经定义好了一些增删改查的抽象方法，我们继承这个接口就可以拥有crud能力，无需编写映射文件。
• BaseMapper：

/**
 * Mapper 继承该接口后，无需编写 mapper.xml 文件，即可获得CRUD功能
 * 这个 Mapper 支持 id 泛型
 */
public interface BaseMapper<T> extends Mapper<T> {
    int insert(T entity);

    int deleteById(Serializable id);

    int deleteByMap(@Param("cm") Map<String, Object> columnMap);

    int delete(@Param("ew") Wrapper<T> queryWrapper);

    int deleteBatchIds(@Param("coll") Collection<? extends Serializable> idList);

    int updateById(@Param("et") T entity);

    int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);

    T selectById(Serializable id);

    List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);

    List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);

    T selectOne(@Param("ew") Wrapper<T> queryWrapper);

    Integer selectCount(@Param("ew") Wrapper<T> queryWrapper);

    List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);

    List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> queryWrapper);

    List<Object> selectObjs(@Param("ew") Wrapper<T> queryWrapper);

    <E extends IPage<T>> E selectPage(E page, @Param("ew") Wrapper<T> queryWrapper);

    <E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param("ew") Wrapper<T> queryWrapper);
}

• 我们定义Mapper方式：

//注意这个泛型，用来封装数据的bean类
public interface UserMapper extends BaseMapper<User> {
}

1.4.3、CRUD

@Test
void testUserMapper(){
   User user = userMapper.selectById(1L);
   log.info("用户信息：{}",user);
}

使用BaseMapper注意事项：

• 封装的bean类的属性要和数据库字段一一对应，如果不是，可在bean类中使用注解去掉多出的属性值

//当前属性表中不存在
@TableField(exist = false)  
private String userName;
@TableField(exist = false)
private String password;

• 如果我们的数据表名字和bean的名字不对应，也要在bean类中使用注解指定映射的数据库表是哪一个：

@TableName("user_tbl")
public class User {
    //以下是数据库字段
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

三层结构实现逻辑：

• service层接口实现：IService<User>

public interface UserService extends IService<User> {
}

• service的实现类继承：ServiceImpl<UserMapper,User>

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper,User> implements UserService {}

• mapper层接口实现：BaseMapper<User>
• 不用编写映射文件，直接CRUD

 @GetMapping("/user/delete/{id}")
    public String deleteUser(@PathVariable("id") Long id,
                             @RequestParam(value = "pn",defaultValue = "1")Integer pn,
                             RedirectAttributes ra){
        //根据Id移除                     
        userService.removeById(id);
        //把这个值放入重定向的属性域中，默认为1
        ra.addAttribute("pn",pn);
        return "redirect:/dynamic_table";
    }

02、NoSQL

Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。

它支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。

Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions） 和不同级别的 磁盘持久化（persistence）， 并通过 Redis哨兵（Sentinel）和自动 分区（Cluster）提供高可用性（high availability）。

2.1、Redis自动配置

导入场景启动器：SpringBoot对Redis有官方的启动器

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

注意：SpringBoot原生的启动器对应的自动配置包都在一个地方

自动配置：

• 自动配置类：RedisAutoConfiguration

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisOperations.class)
//绑定的属性类
@EnableConfigurationProperties(RedisProperties.class)
//导入Lettuce和Jedis配置类，我们可以进入配置类中看看！！！！！
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {}

连接工厂是准备好的：
LettuceConnectionConfiguration
JedisConnectionConfiguration
Lettuce和Jedis都可以操作Redis数据库

通过观察使用@Import自动导入的两个配置类可以发现，我们在配置文件中配置那个客户端，就会使用哪个客户端连接Redis服务器。
但是SpringBoot的Redis场景启动器只帮我们自动导入了Lettuce客户端有关的依赖，如果我们要使用Jedis客户端，我们还需要手动导入Jedis有关的依赖包才可以。

自动注入了RedisTemplate<Object, Object> ： xxxTemplate；

自动注入了StringRedisTemplate；k：v都是String

底层只要我们使用 StringRedisTemplate、RedisTemplate就可以操作redis

• 属性类：RedisProperties

spring.redis.xxx是对redis的配置

2.2、Redis安装配置

可以参考这篇：https://editor.csdn.net/md/?articleId=117226877

2.3、使用lettuce客户端连接Redis

配置文件中配置Lettuce客户端：

spring:
	redis:
	   host: 192.168.1.1
       port: 6379
	   client-type: lettuce   
	    lettuce:
	      pool:
	        max-active: 10
	        min-idle: 5

• 注意：通过配置属性类我们可以发现，host的值默认是localhost，默认端口号是6379

测试代码：

@Autowired
StringRedisTemplate redisTemplate;
@Autowired
RedisConnectionFactory redisConnectionFactory;
@Test
void testRedis(){
   ValueOperations<String, String> operations = redisTemplate.opsForValue();

   operations.set("hello","world");

   String hello = operations.get("hello");
   System.out.println(hello);
}

2.4、使用jedis客户端连接Redis

由于场景启动器默认帮我们导入的是lettuce客户端，所以我们要使用jedis客户端连接redis就需要导入jedis的依赖包：

<!--导入jedis-->
<dependency>
   <groupId>redis.clients</groupId>
   <artifactId>jedis</artifactId>
</dependency>

配置文件中配置jedis客户端：

spring:
  redis:
      host: 192.168.1.1
      port: 6379
      # password: 12345678
      client-type: jedis
      jedis:
        pool:
          max-active: 10