springboot整合Redis

---

1、新建项目，并添加所需要的jar包：

分析：

（1）在springboot中已经继承了Redis，就是说一旦我们启动项目，它是可以根据properties配置文件中的配置信息自动创建Jedis对象的

（2）我们想要的是自己定义配置信息的名称，再根据自己定义的配置信息配置一个有关配置信息的类，最后根据这个类来创建一个我们想要的Jedis对象。

（3）springboot项目在加载的时候，由于springboot无法从配置文件中获取想要的信息，所以不会自动创建属于springboot的Jedis对象，而是根据我们自定义

的配置信息进行创建一个Jedis对象

（4）在使用Jedis对象的时候，我们给我们的Jedis对象加上了@Bean注解，在要使用Jedis的类中使用@Autowired注解，所以spring中的BeanFactory工厂自动创建对象，

，且是单例的；此处直接在@Autowire的注解下注入的是（3）中的对象，也就是根据我们自定义信息创建的对象

springboot-parent
spring-boot-web-start
mysql驱动包
druid(德鲁伊)连接池
springboot和mybatis的整合包
thymeleaf模板jar包
thymeleaf忽略语法的jar包

springboot和redis的整合包
jedis的包:
    jedis就是通过Java实现对redis集群的增删改查，就是操作redis数据库
redis最终只支持5种数据格式:
    String类型是最常用的
    如果需要把User对象存入到redis中===>需要把User对象转换为json字符串===>再把字符串存入到redis中
json的jar包
configuration-processer包（为了使用其中的@ConfigurationProperties()注解，在下文中的RedisProperties类中所使用）

<!-- springboot的jar -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.10.RELEASE</version>
</parent>

<dependencies>
    <!--
        springboot-starter-web
    -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--
        springboot-mybatis整合包
    -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.3.0</version>
    </dependency>
    <!--
        mysql的驱动包
    -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.38</version>
    </dependency>
    <!--
        druid连接池
    -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.10</version>
    </dependency>
    <!--
        html的thymeleaf模板
    -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <!--
        redis的jar包以及jedis的jar包
    -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>
    <!--
        redis和springboot的整合包
    -->
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
    </dependency>
    <!--
        fastjson包
    -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.8.1</version>
    </dependency>
    <!--
        添加springboot的进程jar包
            里面包含了properties文件的读取(其实就是包含了@ConfigurationProperties()注解)
    -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>

    <dependency>
        <groupId>net.sourceforge.nekohtml</groupId>
        <artifactId>nekohtml</artifactId>
        <version>1.9.21</version>
    </dependency>
</dependencies>

2、在springboot框架中，已经整合了Redis，可以直接使用。
　　此处根据springboot整合Redis的源码来实现自己的Redis，原因：springboot自带的Redis已经非常完善，一旦出错，很难找到错误的地方
　　例如：当服务器的IP变动，端口号的问题等，可以通过在自己的配置类中打断点等方法判断错误的地方

3、在config中配置application.properties配置信息：

server.port=8081
server.context-path=/

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?userSSL=false
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

mybatis.type-aliases-package=com.aaa.liu.redis.model
mybatis.mapper-locations=classpath:mapper/*Mapper.xml

#开始自定义配置
# 配置redis集群的端口号和IP
spring.redis.nodes=192.168.134.130:6380,192.168.134.130:6381,192.168.134.130:6382,192.168.134.130:6383,192.168.134.130:6384,192.168.134.130:6385
# 配置了redistribution的最大连接数
spring.redis.maxAttempts=1000
# 配置了redis最大超时时间
spring.redis.commandTimeout=500000
# 配置了redis的失效时间
spring.redis.expire=1000

# 定义图书的key值
book_key=bookKey1

# 配置thymeleaf模板（不配置也可以，直接使用）
# 配置thymeleaf缓存：默认值true，需要手动修改为false
spring.thymeleaf.cache=false
# 配置不严谨的html
spring.thymeleaf.mode=LEGACYHTML5

4、在Java中新建一个config包，在包中新建RedisPro类，将刚刚application.properties的配置信息引入此类中：

package com.aaa.liu.redis.config;

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

/**
 * @Author 刘其佳
 * @DateTime 2019/8/28 19:49
 * @Project_Name SpringBootRedis
 *
 *  1、@Component:把RedisProperties作为spring的一个组件
 *  作用是 把Redis所需要配置和连接信息封装进RedisProperties类中
 *   该组件可拆分
 *   配置该组件类的作用是从application.properties文件中读取自定义的信息
 *  2、@ConfigurationPrperties:作用是把application.properties中的属性读进RedisProperties类中
 *      当使用该注解的时候必须要使用spring-boot-configuration-processor的jar包
 *   prefx="spring.redis"；作用是选中在application.properties文件中的 属性名 进行对用（必须一致）
 *  3、本来按理说在此类中定义属性过后，只有get方法，不应该有set方法，因为不能别其他类修改
 *      但若是真的不放入set方法的话，在使用此类时，无法传递进来参数（属性是私有的）
 *      ！！！所以最终还是要有set方法，只要注意其他的类在调用RedisProperties类中的属性的时候，
 *              一定不能修改！！！
 *
 */

@Component
/**
 * 所有以spring.redis开头的配置信息
 */
@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {

    /**
     * 下列属性对应application.properties文件中的自定义的配置：
     * redis集群的节点
     * 最大连接数
     * 最大超时时间
     * 失效时间
     */
    private String nodes;
    private String maxAttempts;
    private String commandTimeout;
    private String expire;

    public String getNodes() {
        return nodes;
    }

    public void setNodes(String nodes) {
        this.nodes = nodes;
    }

    public String getMaxAttempts() {
        return maxAttempts;
    }

    public void setMaxAttempts(String maxAttempts) {
        this.maxAttempts = maxAttempts;
    }

    public String getCommandTimeout() {
        return commandTimeout;
    }

    public void setCommandTimeout(String commandTimeout) {
        this.commandTimeout = commandTimeout;
    }

    public String getExpire() {
        return expire;
    }

    public void setExpire(String expire) {
        this.expire = expire;
    }
}

5、仍然在config包中新建类：RedisConfiguration,将RedisProperties类注入进来：

package com.aaa.liu.redis.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;

import java.util.HashSet;
import java.util.Set;

/**
 * @Author 刘其佳
 * @DateTime 2019/8/28 20:34
 * @Project_Name SpringBootRedis
 */

/**
 * 此处加上注解@Configuration或者@SpringBootApplication
 *
 * 因为在SpringBootApplication是一个组合注解
 * 进入其中可以看到@SpringBootConfiguration  @EnableAutoConfiguration  @ComponentScan
 * 再次进入@SpringBootConfiguration可以看到@Configuration
 * 因此SpringBootConfiguration是EnableAutoConfiguration、ComponentScan和Configuration的组合注解
 *
 * 在较低版本的SpringBoot中：
 * @Configuration是启用基于Java的配置
 * @ComponentScan是启用组件扫描。
 * @EnableAutoConfiguration是启用SpringBoot的自动配置功能
 * 引用自：https://blog.csdn.net/qq_37939251/article/details/83058065
 */

/**
 * 通过SpringBootApplication/Configuration注解将RedisConfiguration类标识为springboot的配置类
 *
 * 使用Jedis的jar包操作Redis集群数据库
 *  1、Redis：标识了Redis是单节点模式（只有一台Redis）
 *      源码中：protected static class RedisConfiguration {}
 *  2、RedisCluster：标识了Redis的Redis集群模式
 *      源码中：protected final RedisClusterConfiguration getClusterConfiguration() {}
 *  本次只配置集群版的Redis
 *
 * @Bean：  相当于applicationContext.xml中的<bean id=""> class="JedisCluster.class"</bean>
 *
 * @EnableConfirgurationProperties({RedisProperties.class})是源码中使用的注解
 * 在本类中我们使用@Autowired来代替掉
 */
@SpringBootApplication
public class RedisConfiguration {
    @Autowired
    private RedisProperties redisProperties;

    @Bean
    public JedisCluster getJedisCluster(){
        //1、获取到application.properties文件中的Redis集群的节点信息
        String nodes=redisProperties.getNodes();
        //2、使用split来将多个node进行拆分
        String[] nodeArray = nodes.split(",");
        //3、创建一个set集合，以HostAndPort对象作为泛型
        Set<HostAndPort> hostAndPortSet=new HashSet<HostAndPort>();
        //4、遍历刚刚得到的节点数组
        for (String node : nodeArray) {
            //5、继续使用split将node拆分成IP和端口号(host、port)
            String[] hostAndPortArray = node.split(":");
            //6、创建HostAndPort对象,并将得到的IP和端口号作为构造方法的参数传入
            HostAndPort hostAndPort=new HostAndPort(hostAndPortArray[0],Integer.parseInt(hostAndPortArray[1]));
            //7、把每一个HostAndPort对象装进Set集合中
            hostAndPortSet.add(hostAndPort);
        }
        //8、返回一个JedisCluster对象
        return new JedisCluster(hostAndPortSet,Integer.parseInt(redisProperties.getCommandTimeout()),Integer.parseInt(redisProperties.getMaxAttempts()));
    }
}

6、在Service层中新建RedisService

package com.aaa.liu.redis.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import redis.clients.jedis.JedisCluster;

/**
 * @Author 刘其佳
 * @DateTime 2019/8/28 21:39
 * @Project_Name SpringBootRedis
 * 在以前的UserService中注入UserMapper，对数据库进行操作
 * 现在的RedisService中注入JedisCluster，对Redis数据库进行操作
 */
@Service
public class RedisService {

    @Autowired
    private JedisCluster jedisCluster;

    /**
     * 在Redis数据库中的增删查（没有修改）分别为：
     * set del get
     * 在下面分别定义
     */

    /**
    * @author 刘其佳
    * @description
     *      向Redis数据库中存入String类型的数据
     *      set的时候返回值是"ok"
    * @param * param *:key
    * @date 2019/8/28
    * @return java.lang.String
    * @throws
    */
    public String set(String key,String value){
        return jedisCluster.set(key,value);
    }

    /**
    * @author 刘其佳
    * @description
     *      从Redis数据库中通过key取出数据
    * @param * param *:key
    * @date 2019/8/28
    * @return java.lang.String
    * @throws
    */
    public String get(String key){
        return jedisCluster.get(key);
    }

    /**
    * @author 刘其佳
    * @description
     *      1、在此处的参数key是一个可变参
     *      2、在Redis中删除的返回值是Integer类型
     *          在Java中被转成了Long类型
    * @param * param *:key
    * @date 2019/8/28
    * @return java.lang.Long
    * @throws
    */
    public Long del(String key){
        return jedisCluster.del(key);
    }

    /**
    * @author 刘其佳
    * @description
     *      通过key设置失效时间（单位是秒）
    * @param * param *:key
    * param *:seconds
    * @date 2019/8/28
    * @return java.lang.Long
    * @throws
    */
    public Long expire(String key,Integer seconds){
        return jedisCluster.expire(key,seconds);
    }
}

查询图书信息的service：

/**
    * @author 刘其佳
    * @description
     *  注意：service层不允许注入service
     *  因为在applicationContext.xml中配置事务后,事务都是在service中的
     *  当service注入另一个事务时，会造成事务串线（如果线程是并行的没有问题）
     *  applicationContext.xml配置文件中进行注解扫描：
     *  controller：必须要在springmvc中进行扫描
     *  service：必须要在spring中进行扫描
     *
    * @param * param *:null
    * @date 2019/8/28
    * @return
    * @throws
    */
    public Map<String ,Object> selectAllBooks(RedisService redisService){
        /**
         * 1、从Redis中查询所有图书信息
         * 2、判断从Redis中是否查询出数据
         * 3、没有查询到的话再从数据库中查询数据
         * 4、判断是否从数据库中查询到数据
         * 5、若查询到数据，则返回结果，并且将数据放入Redis中
         * 6、利用try...catch判断是否存入Redis中
         * 7、若没有存入Redis中，要做出处理，此处为再次往Redis中存放一次
         */
        Map<String,Object> resultMap=new HashMap<String, Object>();
        //1、
        String bookString=redisService.get(bookKey);
        //2、
        if(null==bookString||"".equals(bookString)){
            //3、
            List<Book> bookList = bookMapper.selectAll();
            //4、
            if(bookList.size()>0){
                //6、
                try {
                    //5、
                    redisService.set(bookKey, JSONUtil.toJsonString(bookList));
                    //将从数据库中查询到的数据存入resultMap中
                    resultMap.put(StatusEnum.SUCCESS.getCodeName(), StatusEnum.SUCCESS.getCode());
                    resultMap.put(StatusEnum.SUCCESS.getResultName(),bookList);
                } catch (Exception e) {
                    //7、
                    redisService.set(bookKey, JSONUtil.toJsonString(bookList));
                    //如果还是没有将数据放入Redis中，此时我们将resultMap里面的code换成404，但是用户还是能够查询到数据
                    resultMap.put(StatusEnum.FAILED.getCodeName(),StatusEnum.FAILED.getCode());
                    resultMap.put(StatusEnum.FAILED.getResultName(),bookList);
                    e.printStackTrace();
                    return resultMap;
                }
            }else {
                //说明数据库中没有数据，放入500
                resultMap.put(StatusEnum.ERROR.getCodeName(),StatusEnum.ERROR.getCode());
            }
        }else {
            //!!!可能会存在Redis中的数据与数据库中的数据不一致的情况
            //所以此处从Redis中获取到数据后与从数据库中查询到的数据做出一个判断（长度是否一致）
            List<Book> bookList = JSONUtil.toList(bookString, Book.class);
            List<Book> bookList1 = bookMapper.selectAll();
            if(bookList.size()==bookList1.size()){
                //将查询从Redis中查询到的数据存入到resultMap
                //因为是从Redis中查询到的数据，此处给转回正常状态下的List集合类型的数据，
                //正好从数据库中查询到的数据也是List，保持一致
                resultMap.put(StatusEnum.SUCCESS.getCodeName(), StatusEnum.SUCCESS.getCode());
                resultMap.put(StatusEnum.SUCCESS.getResultName(),JSONUtil.toList(bookString,Book.class));
        }else {
                //发现数据不一致时，丢弃Redis中的数据，并将数据库中的数据存入Redis中
                redisService.set(bookKey,JSONUtil.toJsonString(bookList));
                resultMap.put(StatusEnum.SUCCESS.getCodeName(), StatusEnum.SUCCESS.getCode());
                resultMap.put(StatusEnum.SUCCESS.getResultName(),bookList1);
            }

    }
        return resultMap;
    }

7、控制层的BookController：

/**
 * @Author 刘其佳
 * @DateTime 2019/8/28 22:25
 * @Project_Name SpringBootRedis
 */
@RestController
public class BookController {

    @Autowired
    private BookService bookService;
    @Autowired
    private RedisService redisService;

    @RequestMapping("/")
    public List<Book> selectAllBooks(){
        Map<String, Object> resultMap = bookService.selectAllBooks(redisService);
        List<Book> bookList=null;
        //如果查询到的resultMap中的code值为200，说明直接从Redis中查到数据了
        if(StatusEnum.SUCCESS.getCode().equals((resultMap.get(StatusEnum.SUCCESS.getCodeName())))){
            bookList= (List<Book>) resultMap.get(StatusEnum.SUCCESS.getResultName());
            System.out.println("everything is ok!");
        }else {
            //如果code值不为200，则有两种情况:404即Redis错误； 500即mysql错误
            if(StatusEnum.ERROR.getCode().equals((resultMap.get(StatusEnum.SUCCESS.getCodeName())))){
                //1、result到最后也没存进去值，数据库都出现了问题
                System.out.println("数据库出现了问题");
            }else{
                //2、result有值，Redis出现了问题，但从数据库查询了数据
                bookList= (List<Book>) resultMap.get(StatusEnum.SUCCESS.getResultName());
                System.out.println("redis出现了问题");
            }
        }
        return bookList;
    }

在本次项目中为了避免魔法值问题，使用了枚举：
新建一个包statuscode ,在其中新建类：StatusEnum

package com.aaa.liu.redis.statuscode;

/**
 * @Author 刘其佳
 * @DateTime 2019/8/29 20:08
 * @Project_Name SpringBootRedis
 */
public enum StatusEnum {
    SUCCESS(200,"操作失败","code","result"),
    FAILED(404,"操作成功","code","result"),
    ERROR(500,"操作失败","code","result");

    private Integer code;
    private String msg;
    private String codeName;
    private String resultName;

    /**
     * 给枚举赋值
     * @param code
     * @param msg
     * @param codeName
     */
     StatusEnum(Integer code, String msg, String codeName,String resultName) {
        this.code = code;
        this.msg = msg;
        this.codeName = codeName;
        this.resultName=resultName;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public String getCodeName() {
        return codeName;
    }

    public void setCodeName(String codeName) {
        this.codeName = codeName;
    }

    public String getResultName() {
        return resultName;
    }

    public void setResultName(String resultName) {
        this.resultName = resultName;
    }
}

mapper中的BookMapper查询所有图书：

/**
 * @Author 刘其佳
 * @DateTime 2019/8/27 20:19
 * @Project_Name springbootshiro
 */
@Mapper
public interface BookMapper {
    //查询所有书籍
    @Select("select id,book_name bookName,book_price bookPrice from book ")
    List<Book> selectAll();
}

其中的注意事项已在代码中写出！

---

此处插入一个关于ajax的用法：

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity4">
<head>
    <meta charset="UTF-8">
    <title>Index</title>
    <script type="text/javascript" src="/jquery-3.2.1.min.js"></script>
</head>

<script>
    /**
     * 1.页面自动加载完成后，函数自动执行，查询出数据并拼接处table表单，将数据放入其中
     * */
    $(document).ready( selectBookTest());

    function selectBookTest(){
        $.ajax({
            type:"POST",
            url:"selectBooks",
            dataType:"JSON",
            success:function (msg) {
                var tr="";
                for(var i=0;i<msg.length;i++){
                    tr+="<tr><td>"+msg[i].id+"</td>";
                    tr+="<td>"+msg[i].bookName+"</td>";
                    tr+="<td>"+msg[i].bookPrice+"</td></tr>";
                    //不能直接使用下面的方式，否则会只有一行数据；要使用+=
                    // tr="<tr><td>"+msg[i].id+"</td><td>"+msg[i].bookName+"</td><td>"+msg[i].bookPrice+"</td></tr>"
                }
                tr+="<tr><td onclick='testBookAdd()'>添加</td></tr>";
                $("#test_Book").append("<table border='1px solid black'>" +
                    "<thead>" +
                    "<tr >" +
                    "<th>图书编号</th>" +
                    "<th>图书名称</th>" +
                    "<th>图书价格</th>" +
                    "</tr>" +
                    tr +
                    "</thead>" +
                    "</table>")
            }

        })
    }

    /**
     * 2.点击添加按钮，将查询所得的数据清空，并拼接出新的form表单用以输入要添加的数据
     */
    function testBookAdd() {
        $("#test_Book").empty();
        $("#test_Book").append("<form id='formBook'><table border='1px solid red'>" +
            "<tr><td>图书名称：</td><td><input type='text' name='bookName'/></td></tr>" +
            "<tr><td>图书价格：</td><td><input type='text' name='bookPrice'/></td></tr>"+
            "<tr><td><input type='button' value='submit' onclick='bookAdd()'/></td></tr>"+
            "</table></form>")
    }

    /**
     * 3.输入完数据，使用ajax调用添加方法添加
     */
    function bookAdd() {
        $.ajax({
            type:"POST",
            url:"testAddBook",
            data:$("#formBook").serialize(),
            dataType:"json",
            success:function (msg) {
                if(null==msg){
                    alert("添加失败")
                }else{
                    $("#test_Book").empty();
                    selectBookTest();
                }
            }
        })
    }

</script>
<body>

<div id="test_Book"></div>
</body>


</html>