[023-1].第10节：SpringBoot中的数据访问

我的后端学习大纲

SpringBoot学习大纲

---

1.数据访问流程：

---

2.SpringBoot中数据源的自动配置

2.1.数据源的自动配置-HikariDataSource

a.导入JDBC场景：

• 2.分析自动导入的内容：
  

b.为何没有导入数据库驱动：

• 1.因为人家也不知道我要用啥数据库，所以在自己决定用什么数据库后，就自己引入数据库驱动就可以了
• 2.SpringBoot对引入的数据库有默认的版本库，想要修改版本可以有以下两个方式：
  • 1.直接依赖引入具体版本（maven的就近依赖原则）

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

• 3.重新声明版本（maven的属性的就近优先原则

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

---

2.2.分析数据库相关的自动配置

a.自动配置的类

• 1.DataSourceAutoConfiguration:数据源的自动配置
  

  • 修改数据源相关的配置：spring.datasource
    

  • 数据库连接池的配置是自己容器中没有DataSource才自动配置的，底层默认配置好的连接池是：HikariDataSource

  	@Configuration(proxyBeanMethods = false)
  	@Conditional(PooledDataSourceCondition.class)
  	@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
  

  • 对DataSourceConfiguration点入进去看看：
    
    
• 2.DataSourceTransactionManagerAutoConfiguration： 事务管理器的自动配置
• 3.JdbcTemplateAutoConfiguration： JdbcTemplate的自动配置，可以来对数据库进行crud
  
  
  • 可以修改这个配置项@ConfigurationProperties(prefix = "spring.jdbc")来修改JdbcTemplate
  • @Bean、@Primary JdbcTemplate容器中有这个组件
    
• 4.JndiDataSourceAutoConfiguration： jndi的自动配置
• 5.XA DataSourceAutoConfiguration： 分布式事务相关的配置

b.修改配置项

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

c.做个小测试

---

3.SpringBoot整合Druid作为底层数据源

3.1.druid介绍：

• 1.druid官方github地址
• 2.回顾Spring整合Druid：

3.2.整合Druid数据源:

整合第三方技术有两种方式，第一是自定义，第二种是找starter

a.方式1：自定义方式:

• 1.引入依赖：

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

• 2.创建数据源配置类

Spring中的实现方式：

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
		destroy-method="close">
		<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" />

Springboot中的实现方式：

• 3.测试数据源类型：
  
• 4.StatViewServlet，StatViewServlet的用途包括：
  • 提供监控信息展示的html页面
  • 提供监控信息的JSON API

Spring中的实现方式：

	<servlet>
		<servlet-name>DruidStatView</servlet-name>
		<servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>DruidStatView</servlet-name>
		<url-pattern>/druid/*</url-pattern>
	</servlet-mapping>

Spring中的实现方式:

• 5.StatFilter：用于统计监控信息；如SQL监控、URI监控

Spring中的配置方式：

需要给数据源中配置如下属性；可以允许多个filter，多个用，分割；如：
<property name="filters" value="stat,slf4j" />

Springboot中的配置方式：

• 6.慢SQL记录配置：

<bean id="stat-filter" class="com.alibaba.druid.filter.stat.StatFilter">
    <property name="slowSqlMillis" value="10000" />
    <property name="logSlowSql" value="true" />
</bean>

使用 slowSqlMillis 定义慢SQL的时长

b.方式2：找starter来简化上面一堆的配置：

• 1.注释自定义的配置类
  
• 2.引入场景：
  
• 3.分析自动配置：
  
  
  
• 1.扩展配置项：spring.datasource.druid
• 2.DruidSpringAopConfiguration.class, 监控SpringBean的；配置项：spring.datasource.druid.aop-patterns
  
  
• 3.DruidStatViewServletConfiguration.class, 监控页的配置：spring.datasource.druid.stat-view-servlet；默认开启
  
• 4.DruidWebStatFilterConfiguration.class, web监控配置；spring.datasource.druid.web-stat-filter；默认开启
  
• 5.DruidFilterConfiguration.class}) :所有Druid自己filter的配置:
  

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

3.3.根据方式2的配置示例：

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

    druid:
      aop-patterns: com.atguigu.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

• 2.SpringBoot配置示例：
• 3.配置项列表

---

4.SpringBoot整合MyBatis

4.1.第一种整合方式：

a.两种方式引入依赖：

• 1.直接引入场景：
  
• 2.新建模块时引入：
  
• 3.添加mybatis起步依赖， 完成mybatis对象自动配置， 对象放在容器中；已经添加插件，在pom.xml指定把src/main/java目录中的xml文件包含到classpath中

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.4.2</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.bjpowernode</groupId>
	<artifactId>017-springboot-mapper</artifactId>
	<version>0.0.1-SNAPSHOT</version>

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

	<dependencies>
		<!--web起步依赖 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<!--mybatis起步依赖-->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>2.1.4</version>
		</dependency>

		<!--mysql驱动-->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>

		<!--测试-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<!--resources插件-->
		<resources>
			<resource>
				<directory>src/main/java</directory>
				<includes>
					<!--意思是：把src/main/java这个包下或者子包下的所有xml文件输出到target目录中-->
					<include>**/*.xml</include>
				</includes>
			</resource>
		</resources>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

b.更改配置文件：

server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://192.168.148.3:3306/mybatis_test?characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver

c.创建实体类：Student

package com.bjpowernode.model;

public class Student {

    private Integer id;
    private String name;
    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

a4.创建Dao接口：

• 1.StudentDao（或者StudentMapper）
• 2.创建一个查询学生的方法;如果在Dao接口上添加@Mapper接口，那么需要给每个Dao接口添加@Mapper注解，这样才可以被容器识别到；
• 3.使用@Mapper注解：

package com.bjpowernode.dao;
import com.bjpowernode.model.Student;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
 * @Mapper：告诉MyBatis这是dao接口，创建此接口的代理对象。
 *     位置：在类的上面
 */
@Mapper
public interface StudentDao {
    Student selectById(@Param("stuId") Integer id);
}

• 3.创建Dao接口对应的Mapper文件， xml文件， 写sql语句

<?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.bjpowernode.dao.StudentDao">
    
    <!--定义sql语句-->
    <select id="selectById" resultType="com.bjpowernode.model.Student">
        select id,name,age from student where id=#{stuId}
    </select>

</mapper>

a5.创建Service层对象

• 1.创建StudentService接口和他的实现类。 去dao对象的方法。完成数据库的操作,接口如下：

package com.bjpowernode.service;

import com.bjpowernode.model.Student;

public interface StudentService {

    Student queryStudent(Integer id);
}

• 2.Service层的实现类：

package com.bjpowernode.service.impl;
import com.bjpowernode.dao.StudentDao;
import com.bjpowernode.model.Student;
import com.bjpowernode.service.StudentService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class StudentServiceImpl implements StudentService {

    @Resource
    private StudentDao studentDao;

    @Override
    public Student queryStudent(Integer id) {
        Student student = studentDao.selectById(id);
        return student;
    }
}

a6.创建Controller对象，访问Service。

package com.bjpowernode.controller;

import com.bjpowernode.model.Student;
import com.bjpowernode.service.StudentService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;

@Controller
public class StudentController {

    @Resource
    private StudentService studentService;

    @RequestMapping("/student/query")
    @ResponseBody
    public String queryStudent(Integer id){
        Student student = studentService.queryStudent(id);
        return student.toString();
    }
}

a7.此模块的代码目录：

a8.测试：

• 1.启动 Application 类, 浏览器访问http://localhost:9090/myboot/query

4.2.SpringBoot整合MyBatis的方式2：

• 1.其他地方都一样，就是只有在Dao层那不太一样，需要更改下；我们可以不在Dao接口上添加@Mapper注解；而是在主启动类上主添加注解包扫描：@MapperScan("com.bjpowernode.dao")
  
• 2.使用扫描的这种方式比较推荐，这样就可以把mapper 文件放在 resources 目录下， java 代码放在src/main/java路径下了
  • 在 resources 创建自定义目录，例如 mapper， 存放 xml 文件
  • 把原来的 xml 文件剪切并拷贝到 resources/mapper 目录
  • 在 application.properties 配置文件中指定映射文件的位置，这个配置只有接口和映射文件不在同一个包的情况下，才需要指定
    

---

4.3.分析整合MyBatis时的自动配置：

a.在Spring中的使用MyBatis的步骤：

• 1.全局配置文件
• 2.SqlSessionFactory
• 3.SqlSession
• 4.Mapper

b.在SpringBoot中的配置分析：

• 1.全局配置文件
• 2.SqlSessionFactory: 自动配置好了
• 3.SqlSession：自动配置了 SqlSessionTemplate 组合了SqlSession
• 4.@Import(AutoConfiguredMapperScannerRegistrar.class）
• 5.Mapper： 只要我们写的操作MyBatis的接口标准了 @Mapper 就会被自动扫描进来
  

---

---

---

@EnableConfigurationProperties(MybatisProperties.class) ： MyBatis配置项绑定类。
@AutoConfigureAfter({ DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class })
public class MybatisAutoConfiguration{}

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

• 2.可以修改配置文件中 mybatis 开始的所有；

# 配置mybatis规则
mybatis:
  config-location: classpath:mybatis/mybatis-config.xml  #全局配置文件位置
  mapper-locations: classpath:mybatis/mapper/*.xml  #sql映射文件位置
  
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.atguigu.admin.mapper.AccountMapper">
<!--    public Account getAcct(Long id); -->
    <select id="getAcct" resultType="com.atguigu.admin.bean.Account">
        select * from  account_tbl where  id=#{id}
    </select>
</mapper>

配置 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
    
 可以不写全局；配置文件，所有全局配置文件的配置都放在configuration配置项中即可

• 导入mybatis官方starter
• 编写mapper接口。标准@Mapper注解
• 编写sql映射文件并绑定mapper接口
• 在application.yaml中指定Mapper配置文件的位置，以及指定全局配置文件的信息 （建议；配置在mybatis.configuration）

c.注解模式

@Mapper
public interface CityMapper {

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

    public void insert(City city);

}

d.混合模式

@Mapper
public interface CityMapper {

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

    public void insert(City city);

}

e.最佳实战：

• 1.引入mybatis-starter
• 2.配置application.yaml中，指定mapper-location位置即可
• 3.编写Mapper接口并标注@Mapper注解
• 4.简单方法直接注解方式
• 5.复杂方法编写mapper.xml进行绑定映射
• 6.@MapperScan(“com.atguigu.admin.mapper”) 简化，其他的接口就可以不用标注@Mapper注解

---

5.SpringBoot整合MyBatisPlus

5.1.新建项目，选择需要的场景依赖

a. 方式1:

b.方式2：

• 1.选择默认的方式新建
  
  
• 2.去maven网站上去查询依赖，然后去boot项目中去粘贴就可以了
  

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.jianqun</groupId>
    <artifactId>boot_one_web_01</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>boot_one_web_01</name>
    <description>Demo project for Spring Boot</description>

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

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!--Lombook，一个java类库，提供一组注解，简化POJO实体类的开发-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

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

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

• 3.引入的场景依赖：
  
• 4.配置文件的内容，在配置文件中，需要给设置下表前缀
  

server:
  port: 81

spring:
  datasource:
    druid:
      url: jdbc:mysql://localhost:3306/ssm_db?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
      driver-class-name: com.mysql.cj.jdbc.Driver
      password: root
      username: root

mybatis-plus:
  global-config:
    db-config:
      table-prefix: tbl_
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

• 5.dao与domain都与上一节一样

//BookDao接口
package com.jianqun.dao;

import com.jianqun.domain.Book;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

/**
 * @author: jianqun
 * @email: 1033586391@qq.com
 * @creat: 2022-04-10-8:49
 * @Description:
 */
@Mapper
public interface BookDao {
    @Select("select * from tbl_book where id = {#id}}")
    public Book getById(Integer id);
}

//Book.java
package com.jianqun.domain;

/**
 * @author: jianqun
 * @email: 1033586391@qq.com
 * @creat: 2022-04-10-8:50
 * @Description: 实体类
 */
public class Book {
    private Integer id;
    private String type;
    private String name;
    private String description;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", type='" + type + '\'' +
                ", name='" + name + '\'' +
                ", description='" + description + '\'' +
                '}';
    }
}

• 6.定义数据层接口与映射配置，继承BaseMapper：BaseMapperl中包含了各种各样的方法
• 7.测试：
  

---

6.SpringBoot整合Redis:

6.1.Redis的介绍：

• 1.Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。
• 2.它支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。
• 3.Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions） 和不同级别的 磁盘持久化（persistence）， 并通过 Redis哨兵（Sentinel）和自动 分区（Cluster）提供高可用性（high availability）。

6.2.Redis自动配置：

a.修改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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.4.2</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.bjpowernode</groupId>
	<artifactId>021-springboot-redis</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<!--redis起步依赖： 直接在项目中使用RedisTemplate(StringRedisTemplate)-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

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

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

b.自动配置分析：

• 1.如下可知,Redis默认使用的是lettuce客户端,所以说在程序中使用RedisTemplate类的方法 操作redis数据， 实际就是调用的lettuce 客户端的中的方法
  
• 2.Redis的自动配置：
  • RedisAutoConfiguration 自动配置类。RedisProperties 属性类 --> spring.redis.xxx是对redis的配置
  • 连接工厂是准备好的。LettuceConnectionConfiguration、JedisConnectionConfiguration
  • 自动注入了RedisTemplate<Object, Object> ： xxxTemplate；
  • 自动注入了StringRedisTemplate：k：v都是String
  • key：value
  • 底层只要我们使用 StringRedisTemplate、RedisTemplate就可以操作redis
    
    

c.更改配置文件application.properities，配置redis连接的信息

server.port=9001
server.servlet.context-path=/myredis

#指定redis （host ，ip， password）
spring.redis.host=localhost
spring.redis.port=6379
#spring.redis.password=123

d.创建controller，

package com.bjpowernode.controller;

import com.bjpowernode.vo.Student;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
public class RedisController {

    /**
     * 注入RedisTemplate
     *
     * RedisTemplate 泛型
     * RedisTemplate<String,String>
     * RedisTemplate<Object,Object>
     * RedisTemplate
     *
     * 注意： RedisTemplate对象的名称 redisTemplate
     */
    @Resource
    private RedisTemplate redisTemplate;


    @Resource
    private StringRedisTemplate stringRedisTemplate;

    // 添加数据到redis
    @PostMapping("/redis/addstring")
    public String addToRedis(String name, String value){

        // 操作Redis中string类型的数据， 先获取ValueOperations对象
        ValueOperations valueOperations = redisTemplate.opsForValue();

        //添加数据到redis
        valueOperations.set("myname","lisi");

        return "向redis添加string类型的数据";
    }


    // 从redis获取数据
    @GetMapping("/redis/getk")
    public String getData(String k){
        ValueOperations valueOperations = redisTemplate.opsForValue();
        Object v = valueOperations.get(k);
        return "key是"+k+",他的值是："+v;
    }
    
    @PostMapping("/redis/{k}/{v}")
    public String addStringKV(@PathVariable  String k,
                              @PathVariable  String v){
        // 使用StringRedisTemplate对象
        stringRedisTemplate.opsForValue().set(k,v);
        return "使用StringRedisTemplate对象";
    }

    @GetMapping("/redis/getstr/{k}")
    public String getStringValue(@PathVariable  String k){

        String v  = stringRedisTemplate.opsForValue().get(k);
        return "k的value:"+v;
    }

    /** 设置 RedisTemplate 序列化
     *  可以设置 key 的序列化， 可以设置value的序列化 
     *  可以同时设置 key 和 value的序列化
     */
    @PostMapping("/redis/addstr")
    public String  addString(String k,String v){
        // 使用RedisTemplate
        // 设置 key 使用String的序列化
        redisTemplate.setKeySerializer( new StringRedisSerializer());

        // 设置 value 的序列化
        redisTemplate.setValueSerializer( new StringRedisSerializer());

        redisTemplate.opsForValue().set(k,v);
        return "定义RedisTemplate对象的key，value的序列化";
    }
    /**
     * 使用json 序列化， 把java对象转为json存储
     */
    @PostMapping("/redis/addjson")
    public String  addJson(){
        Student student  = new Student();
        student.setId(1001);
        student.setName("zhangsan");
        student.setAge(20);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 把值作为json序列化
        redisTemplate.setValueSerializer( new Jackson2JsonRedisSerializer(Student.class) );
        redisTemplate.opsForValue().set("mystudent", student);
        return "json序列化";
    }

    @PostMapping("/redis/getjson")
    public String  getJson(){
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 把值作为json序列化
        redisTemplate.setValueSerializer( new Jackson2JsonRedisSerializer(Student.class) );
        Object obj  = redisTemplate.opsForValue().get("mystudent");
        return "json反序列化="+ obj;
    }
}

e.Postman测试：

---

6.3.对比StringRedisTemplate 和 RedisTemplate

a.两者的对比：

• StringRedisTemplate ： 把k，v 都是作为String处理， 使用的是String的序列化 ， 可读性好
• RedisTemplate ： 把k，v 经过了序列化存到redis。 k，v 是序列化的内容， 不能直接识别，默认使用的jdk序列化， 可以修改为前提的序列化；
  • 序列化：把对象转化为可传输的字节序列过程称为序列化。
  • 反序列化：把字节序列还原为对象的过程称为反序列化

b.为什么需要序列化

• 序列化最终的目的是为了对象可以跨平台存储，和进行网络传输。而我们进行跨平台存储和网络传输的方式就是IO，而我们的IO支持的数据格式就是字节数组。我们必须在把对象转成字节数组的时候就制定一种规则（序列化），那么我们从IO流里面读出数据的时候再以这种规则把对象还原回来（反序列化）

c.什么情况下需要序列化：

• 通过上面已经知道了凡是需要进行“跨平台存储”和”网络传输”的数据，都需要进行序列化。
• 本质上存储和网络传输 都需要经过 把一个对象状态保存成一种跨平台识别的字节格式，然后其他的平台才可以通过字节信息解析还原对象信息。

d.序列化的方式

• 序列化只是一种拆装组装对象的规则，那么这种规则肯定也可能有多种多样，比如现在常见的序列化方式有：JDK（不支持跨语言）、JSON、XML、Hessian、Kryo（不支持跨语言）、Thrift、Protofbuff、；

e.json序列化：

• json序列化功能将对象转换为 JSON 格式或从 JSON 格式转换对象。例如把一个Student对象转换为JSON字符串{“name”:“李四”, “age”:29} )，反序列化(将JSON字符串 {“name”:“李四”, “age”:29} 转换为Student对象)
  
  
  

---

6.4.Redis环境搭建（学习学习各种云是什么）

1、阿里云按量付费redis。经典网络
2、申请redis的公网连接地址
3、修改白名单 允许0.0.0.0/0 访问

---

6.4.IDEA生成序列化版本号：

• 1.IDEA中的设置步骤：
  
• 2.找到实体类，添加UID；

---