Springboot+Mybatis+Redis简单案例展示

MySQL数据库：

DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `num` varchar(11) DEFAULT NULL,
  `name` varchar(255) DEFAULT NULL,
  `gender` varchar(255) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of student
-- ----------------------------
INSERT INTO `student` VALUES ('1', '324324', '第五期定期', '女', '34');
INSERT INTO `student` VALUES ('2', '42522', '几点回去', '男', '32');
INSERT INTO `student` VALUES ('3', '243532', '黑奴', '女', '23');

目录结构：

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.1.14.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.zhang</groupId>
	<artifactId>SpringRedis</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>SpringRedis</name>
	<description>Demo project for Spring Boot</description>

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

	<dependencies>
		<!--   redis 依赖     -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>2.1.2</version>
		</dependency>
 		<!--    web 依赖    -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--    tomcat插件    -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>5.1.46</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<!-- Gson json 格式化 -->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.5</version>
        </dependency>
	</dependencies>

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

</project>

controller接口

@RestController
@RequestMapping(path = "/student")
public class StudentController {

    @Autowired
    private StudentService studentService;

    @GetMapping( path = "/getList")
    public List<Student> getList(){
        List<Student> students = studentService.selectAll();
        return students;
    }

    @GetMapping( path = "/getStudent")
    public String getList(@Param("num") String num){
        Student students = studentService.getStudent(num);
        String str = new Gson().toJson(students);
        return str;
    }

    @PostMapping(path = "/insert")
    public String insert(@RequestBody Student student){
        int insert = studentService.insert(student);
        String msg = "";
        if( insert > 0 ){
            msg = "{\"msg\":\"新增成功\",\"flag\":true}";
        }else {
            msg = "{\"msg\":\"新增失败\",\"flag\":false}";
        }
        return msg;
    }

    @GetMapping(path = "/delete")
    public String delete(@Param("numberCode") String numberCode){
        int delete = studentService.delete(numberCode);
        String msg = "";
        if( delete > 0 ){
            msg = "{\"msg\":\"删除成功！！\",\"flag\":true}";
        }else {
            msg = "{\"msg\":\"删除失败！！\",\"flag\":false}";
        }
        return msg;
    }

    @PostMapping(path = "/update")
    public String update(@RequestBody Student student){
        int update = studentService.update(student);
        String msg = "";
        if( update > 0 ){
            msg = "{\"msg\":\"更新成功！！！\",\"flag\":true}";
        }else {
            msg = "{\"msg\":\"更新失败！！！\",\"flag\":false}";
        }
        return msg;
    }

}

Service接口：

public interface StudentService {
	
	List<Student> selectAll();

    Student getStudent(String numberCode);

    int delete(String numberCode);

    int update(Student student);

    int insert(Student student);

}

@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public List<Student> selectAll() {

        String key = "student_list";
        Boolean hasKey = redisTemplate.hasKey(key);

        ValueOperations operations = redisTemplate.opsForValue();

        if (hasKey) {
            String redisList = (String) operations.get(key);

            Type type = new TypeToken<List<Student>>() {}.getType();
            List<Student> list =  new Gson().fromJson(redisList,type);

            System.out.println("StudentServiceImpl.selectAll() : 从缓存取得数据，条数：" + list.size());
            return list;
        }
        List<Student> list = studentMapper.selectAll();
        String toJson = new Gson().toJson(list);
        // 存在到缓存中
        operations.set(key, toJson, 10, TimeUnit.SECONDS);
        return list;
    }

    /**
     * 获取 一位 学生逻辑：
     * 如果缓存存在，从缓存中获取学生信息
     * 如果缓存不存在，从 DB 中获取学生信息，然后插入缓存
     */
    @Override
    public Student getStudent(String numberCode) {
        // 从缓存中 取出学生信息
        String key = "student_" + numberCode;
        Boolean hasKey = redisTemplate.hasKey(key);

        ValueOperations operations = redisTemplate.opsForValue();
        // 缓存存在
        if (hasKey) {
            String str = (String) operations.get(key);
            Student student = new Gson().fromJson(str, Student.class);
            System.out.println("StudentServiceImpl.getStudent() : 从缓存取得数据--------> " + student.toString());
            return student;
        }
        Student student = studentMapper.getStudent(numberCode);
        String str = new Gson().toJson(student);
        // 插入缓存中
        operations.set(key, str, 10, TimeUnit.SECONDS);
        System.out.println("StudentServiceImpl.getStudent() : 学生信息插入缓存--------> " + student.toString());
        return student;
    }

    @Override
    public int delete(String num) {

        String key = "student_" + num;
        Boolean hasKey = redisTemplate.hasKey(key);
        int delete = studentMapper.delete(num);
        if( delete > 0){
            // 缓存存在，进行删除
            if (hasKey) {
                redisTemplate.delete(key);
                System.out.println("StudentServiceImpl.update() : 从缓存中删除编号学生 ---------> " + num);
            }
        }
        return delete;
    }

    /**
     * 更新学生信息逻辑：
     * 如果缓存存在，删除
     * 如果缓存不存在，不操作
     */
    @Override
    public int update(Student student) {

        String key = "student_" + student.getNum();
        Boolean hasKey = redisTemplate.hasKey(key);

        int update = studentMapper.update(student);

        if( update > 0 ){
            // 缓存存在，进行删除
            if (hasKey) {
                redisTemplate.delete(key);
                System.out.println("StudentServiceImpl.update() : 从缓存中删除学生 -----------> " + student.toString());
            }
        }
        return update;
    }

    @Override
    public int insert(Student student) {

        String key = "student_list";

        int insert = studentMapper.insert(student);
        if (insert > 0) {
            redisTemplate.delete(key);
        }
        return insert;
    }

	

	
}

dao层：

@Repository
@Mapper
public interface StudentMapper {

    @Select("select * from student")
    List<Student> selectAll();

    @Select("select * from student where num = #{num}")
    Student getStudent(@Param("num") String num);

    @Delete("delete from student where num = #{num}")
    int delete(@Param("num") String num);

    int update(Student student);

    int insert(Student student);
}

Student.java

@Data
public class Student {

	    private Integer id;

	    private String num;

	    private String name;

	    private String gender;

	    private Integer age;

	

}

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.zhang.dao.StudentMapper">
  <resultMap id="BaseResultMap" type="com.zhang.bean.Student">
    <result column="id" jdbcType="INTEGER" property="id" />
    <result column="num" jdbcType="VARCHAR" property="num" />
    <result column="name" jdbcType="VARCHAR" property="name" />
    <result column="gender" jdbcType="VARCHAR" property="gender" />
    <result column="age" jdbcType="INTEGER" property="age" />
  </resultMap>
  <insert id="insert" parameterType="com.zhang.model.Student">
    <selectKey keyProperty="id" order="BEFORE" resultType="java.lang.Integer">
        SELECT LAST_INSERT_ID()   
    </selectKey>
    insert into student ( num, name, 
      gender, age)  
      values ( #{num,jdbcType=VARCHAR}, #{name,jdbcType=VARCHAR}, 
      #{gender,jdbcType=VARCHAR}, #{age,jdbcType=INTEGER})  
  </insert>

  <update id="update"> 
    update student set name = #{name},gender = #{gender},age= #{age} 
    where num = #{num} 
  </update>


</mapper>

yml的配置：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/student?useUnicode=true&zeroDateTimeBehavior=CONVERT_TO_NULL&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2B8
    username: root
    password: zhang@123
    driver-class-name: com.mysql.cj.jdbc.Driver
  # 配置 redis
  redis:
    # redis 数据库索引（默认为0）
    database: 0
    # redis 服务地址
    host: 127.0.0.1
    # redis 连接端口
    port: 6379
    # redis 服务器链接密码 （默认为空）
    password:
    # 连接超时时间 （毫秒）
    timeout: 5000
    # 配置 redis 连接池
    jedis:
      pool:
        # 连接池最大连接数　（使用负值表示没有限制）
        max-active: 8
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1
        # 连接池的最大空闲连接
        max-idle: 8
        # 连接池中 最小空闲连接
        min-idle: 0
# 配置 mybatis
mybatis:
  # 设置 实体类所在的包名
  typeAliasesPackage: com.zhang.model
  # mybatis xml 映射关系
  mapper-locations: classpath:mapper/*.xml

测试结果：