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>