### 歡迎訪問我的GitHub
> 這裡分類和彙總了欣宸的全部原創(含配套原始碼)：[https://github.com/zq2599/blog_demos](https://github.com/zq2599/blog_demos)

### 關於這個demo工程
- 開發springboot應用的時候，經常用到redis、mybatis、restTemplate這些技術，在此將常用程式碼和配置都整理出來，以後有需要就能直接拿來用了；
### demo的功能簡介
- 此demo是個父子結構的maven工程，兩個子工程特點如下：

- 整個服務如下圖所示：
- 寫操作：使用者透過瀏覽器向service-a發起請求，透過service-a將資料寫入mysql，然後service-a會呼叫service-b的介面，將資料寫入redis；
- 讀操作：使用者透過瀏覽器向service-a發起請求，service-a會呼叫service-b的介面從redis中取資料，如果取到了就返回給瀏覽器，如果取不到，就從mysql中取，如果從mysql中能取到，就先透過service-b寫入redis，再返回給瀏覽器，如果mysql中也沒有，就返回無資料；
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20191003160856142.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly94aW5jaGVuLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70)
### 版本資訊參考
1. 作業系統：CentOS Linux release 7.7.1908
2. docker：Community 19.03.2
3. springboot：2.0.5.RELEASE
4. mysql：5.7.27
5. redis：5.0.6
### demo原始碼下載
- 如果您不想編碼，可以直接從GitHub下載完整的demo工程原始碼，地址和連結資訊如下表所示：

| 名稱      |   連結 |   備註|
| :-------- | :----| :----|
| 專案主頁| https://github.com/zq2599/blog_demos | 該專案在GitHub上的主頁 |
| git倉庫地址(https)| https://github.com/zq2599/blog_demos.git | 該專案原始碼的倉庫地址，https協議 |
| git倉庫地址(ssh)| git@github.com:zq2599/blog_demos.git | 該專案原始碼的倉庫地址，ssh協議 |

- 這個git專案中有多個資料夾，本章的應用在 **pinpoint185demo** 資料夾下，如下圖紅框所示：
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20191003173843718.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly94aW5jaGVuLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70)

### 快速部署mysql
- 為了快速準備好mysql服務用來測試，我這裡是用docker來完成的，一行命令即可：
```shell
docker run --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=888888 -idt mysql:5.7.27
```

- 建立資料庫demo和表student，表結構非常簡單：
```sql
CREATE DATABASE demo;
USE demo;
CREATE TABLE student (id INT(11), name VARCHAR(128));
```

### 快速部署redis
- 為了快速準備好redis服務用來測試，我這裡是用docker來完成的，一行命令即可：
```shell
docker run --name redis -p 6379:6379 -idt redis:5.0.6 redis-server --appendonly yes
```
### 父工程
- 首先建立名為 **pinpoint185demo** 的maven工程，pom.xml內容如下：
```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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelversion>4.0.0</modelversion>
    <modules>
        <module>service-a</module>
        <module>service-b</module>
    </modules>
    <parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>2.0.5.RELEASE</version>
        <relativepath></relativepath> 
    </parent>
    <groupid>com.bolingcavalry</groupid>
    <artifactid>pinpoint185demo</artifactid>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceencoding>UTF-8</project.build.sourceencoding>
        <project.reporting.outputencoding>UTF-8</project.reporting.outputencoding>
        <java.version>1.8</java.version>
        <spring.boot.version>2.0.5.RELEASE</spring.boot.version>
    </properties>
    
    <build>
        <plugins>
            <plugin>
                <groupid>org.apache.maven.plugins</groupid>
                <artifactid>maven-compiler-plugin</artifactid>
                <configuration>
                    <source>${java.version}<source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
```
### 子工程service-a編碼
- 在此工程下建立子工程 **service-a** ，其pom.xml內容如下：
```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>com.bolingcavalry</groupid>
        <artifactid>pinpoint185demo</artifactid>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactid>service-a</artifactid>
    <name>service-a</name>
    <description>服務a</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>org.mybatis.spring.boot</groupid>
            <artifactid>mybatis-spring-boot-starter</artifactid>
            <version>1.3.2</version>
        </dependency>

<dependency>
            <groupid>mysql</groupid>
            <artifactid>mysql-connector-java</artifactid>
        </dependency>

<dependency>
            <groupid>com.alibaba</groupid>
            <artifactid>fastjson</artifactid>
            <version>1.2.28</version>
        </dependency>

<dependency>
            <groupid>org.apache.commons</groupid>
            <artifactid>commons-lang3</artifactid>
            <version>3.9</version>
        </dependency>
    </dependencies>

<build>
        <plugins>
            <plugin>
                <groupid>org.springframework.boot</groupid>
                <artifactid>spring-boot-maven-plugin</artifactid>
            </plugin>
        </plugins>
    </build>
</project>
```
- 以上內容有幾點需要注意：
a. 要提供web服務，所以依賴了spring-boot-starter-web；
b. 要使用mybaits，所以依賴了mybatis-spring-boot-starter；
c. 要連線mysql，所以依賴了mysql-connector-java；
d. commons-lang3、fastjson作為工具類，在程式碼中會用到它們的API；

- service-a的系統配置application.yml內容如下，注意資料庫和mybaits的配置：
```yml
server:
  port: 8080
spring:
  datasource:
    username: root
    password: 888888
    url: jdbc:mysql://192.168.121.143:3306/demo?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    driver-class-name: com.mysql.jdbc.Driver

mybatis:
  mapper-locations: classpath:mapping/*Mapping.xml
  type-aliases-package: com.bolingcavalry.servicea.entity

logging:
  level:
    com:
      bolingcavalry:
        servicea: debug

# service-b的服務url
serviceb:
  baseurl: http://localhost:8081/
```
- mybatis的mapping檔案在 **src\main\resources\mapping** 目錄，名為StudentMapping.xml，對應student表的定義和操作：
```xml
<?xml version="1.0" encoding="UTF-8"?>

<mapper namespace="com.bolingcavalry.servicea.mapper.StudentMapper">
    <resultmap id="BaseResultMap" type="com.bolingcavalry.servicea.entity.Student">
        <result column="id" jdbctype="INTEGER" property="id"></result>
        <result column="name" jdbctype="VARCHAR" property="name"></result>
    </resultmap>
    <select id="getById" resulttype="com.bolingcavalry.servicea.entity.Student">
        select * from student where id = #{id}
    </select>
    <insert id="insert" parametertype="com.bolingcavalry.servicea.entity.Student">
        insert into student (id, name) values (#{id,jdbcType=INTEGER}, #{name,jdbcType=VARCHAR})
    </insert>
</mapper>
```
- student表對應的實體類：
```java
package com.bolingcavalry.servicea.entity;

/**
 * @Description: student entity
 * @author: willzhao E-mail: zq2599@gmail.com
 * @date: 2019/10/3 9:55
 */
public class Student {

private Integer id;

private String name;

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;
    }
}
```
- student對應的mapper介面：
```java
package com.bolingcavalry.servicea.mapper;

import com.bolingcavalry.servicea.entity.Student;
import org.springframework.stereotype.Repository;

/**
 * @Description: mybatis mapper
 * @author: willzhao E-mail: zq2599@gmail.com
 * @date: 2019/10/3 9:58
 */
@Repository
public interface StudentMapper {

Student getById(Integer id);

void insert(Student student);
}
```

- 由於要用到restTemplate訪問service-b，因此要增加對應的配置類：
```java
package com.bolingcavalry.servicea.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

/**
 * @Description: 遠端請求的配置
 * @author: willzhao E-mail: zq2599@gmail.com
 * @date: 2019/10/3 11:45
 */
@Configuration
public class RestTemplateConfig {

@Bean
    public RestTemplate restTemplate(ClientHttpRequestFactory factory){
        return new RestTemplate(factory);
    }

@Bean
    public ClientHttpRequestFactory simpleClientHttpRequestFactory(){
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        factory.setConnectTimeout(15000);
        factory.setReadTimeout(5000);
        return factory;
    }
}
```
- 接下來是提供web服務的controller：
```java
package com.bolingcavalry.servicea.controller;

import com.alibaba.fastjson.JSON;
import com.bolingcavalry.servicea.entity.Student;
import com.bolingcavalry.servicea.mapper.StudentMapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 * @Description: 提供學生服務相關的web介面
 * @author: willzhao E-mail: zq2599@gmail.com
 * @date: 2019/10/3 8:51
 */
@RestController
public class StudentController {

@Autowired
    StudentMapper studentMapper;

@Autowired
    private RestTemplate restTemplate;

@Value("${serviceb.baseurl}")
    private String baseUrl;

@RequestMapping(value = "/get/{id}", method = RequestMethod.GET)
    public String get(@PathVariable("id") Integer id) {

String rlt = restTemplate.getForObject(baseUrl + "get/" + id,String.class);

if(StringUtils.isNotBlank(rlt)){
            return "From redis :" + rlt;
        }

//redis中查不到，就去資料庫裡面查
        Student student = studentMapper.getById(id);
        //mysql裡面也沒有就報錯
        if(null==student) {
            return "student with id["+id+"] not exist";
        }
        //呼叫service-b的介面，寫入redis
        restTemplate.getForObject(baseUrl + "set/"+id+"/"+student.getName(),String.class);

return "From mysql :"+JSON.toJSONString(student);
    }

@RequestMapping(value = "/add/{id}/{name}", method = RequestMethod.GET)
    public String add(@PathVariable("id") Integer id, @PathVariable("name") String name) {
        Student student = new Student();
        student.setId(id);
        student.setName(name);
        //寫入資料庫
        studentMapper.insert(student);
        //呼叫service-b的介面，寫入redis
        restTemplate.getForObject(baseUrl + "set/"+id+"/"+name,String.class);
        return "insert success";
    }
}
```

- 整個應用的啟動類，增加了MapperScan註解：
```java
package com.bolingcavalry.servicea;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.bolingcavalry.servicea.mapper")
public class ServiceAApplication {

public static void main(String[] args) {
        SpringApplication.run(ServiceAApplication.class, args);
    }
}
```
- 以上就是service-a的全部原始碼了，包括mybatis和restTmeplate操作；

### service-b原始碼
- 建立名為service-b的子工程，pom.xml如下，要注意的是依賴了spring-boot-starter-data-redis和commons-pool2：
```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>com.bolingcavalry</groupid>
        <artifactid>pinpoint185demo</artifactid>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactid>service-b</artifactid>
    <name>service-b</name>
    <description>服務b</description>
    <dependencies>
        <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>com.alibaba</groupid>
            <artifactid>fastjson</artifactid>
            <version>1.2.28</version>
        </dependency>
        <dependency>
            <groupid>org.apache.commons</groupid>
            <artifactid>commons-pool2</artifactid>
            <version>2.0</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupid>org.springframework.boot</groupid>
                <artifactid>spring-boot-maven-plugin</artifactid>
            </plugin>
        </plugins>
    </build>
</project>
```

- 應用的配置檔案application.properties內容如下：
```properties
server.port=8081
#redis
spring.redis.host=192.168.121.144
spring.redis.port=6379
# 資料庫連線超時時間，2.0 中該引數的型別為Duration,這裡在配置的時候需要指明單位
spring.redis.timeout=60s
# 連線池配置,2.0中直接使用jedis或者lettuce配置連線池
# 最大活躍連線數，負數為不限制
spring.redis.lettuce.pool.max-active=50
# 等待可用連線的最大時間，負數為不限制
spring.redis.lettuce.pool.max-wait=-1ms
# 最大空閒連線數
spring.redis.lettuce.pool.max-idle=10
# 最小空閒連線數
spring.redis.lettuce.pool.min-idle=2
```
3. redis的配置類：
```java
package com.example.serviceb.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @Description: (這裡用一句話描述這個類的作用)
 * @author: willzhao E-mail: zq2599@gmail.com
 * @date: 2019/10/3 11:06
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

/**
     * retemplate相關配置
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<string object=""> redisTemplate(RedisConnectionFactory factory) {

RedisTemplate<string object=""> template = new RedisTemplate<>();
        // 配置連線工廠
        template.setConnectionFactory(factory);

//使用Jackson2JsonRedisSerializer來序列化和反序列化redis的value值（預設使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);

ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修飾符範圍，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化輸入的型別，類必須是非final修飾的，final修飾的類，比如String,Integer等會跑出異常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(om);

// 值採用json序列化
        template.setValueSerializer(jacksonSeial);
        //使用StringRedisSerializer來序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());

// 設定hash key 和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jacksonSeial);
        template.afterPropertiesSet();

return template;
    }

/**
     * 對hash型別的資料操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public HashOperations<string string="" object=""> hashOperations(RedisTemplate<string object=""> redisTemplate) {
        return redisTemplate.opsForHash();
    }

/**
     * 對redis字串型別資料操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ValueOperations<string object=""> valueOperations(RedisTemplate<string object=""> redisTemplate) {
        return redisTemplate.opsForValue();
    }

/**
     * 對連結串列型別的資料操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ListOperations<string object=""> listOperations(RedisTemplate<string object=""> redisTemplate) {
        return redisTemplate.opsForList();
    }

/**
     * 對無序集合型別的資料操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public SetOperations<string object=""> setOperations(RedisTemplate<string object=""> redisTemplate) {
        return redisTemplate.opsForSet();
    }

/**
     * 對有序集合型別的資料操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ZSetOperations<string object=""> zSetOperations(RedisTemplate<string object=""> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}
```
- redis的工具類：
```java
package com.example.serviceb.util;

/**
 * @Description: (這裡用一句話描述這個類的作用)
 * @author: willzhao E-mail: zq2599@gmail.com
 * @date: 2019/10/3 11:09
 */
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * redisTemplate封裝
 */
@Component
public class RedisUtil {

@Autowired
    private RedisTemplate<string object=""> redisTemplate;

public RedisUtil(RedisTemplate<string object=""> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

/**
     * 指定快取失效時間
     * @param key 鍵
     * @param time 時間(秒)
     * @return
     */
    public boolean expire(String key,long time){
        try {
            if(time>0){
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

/**
     * 根據key 獲取過期時間
     * @param key 鍵 不能為null
     * @return 時間(秒) 返回0代表為永久有效
     */
    public long getExpire(String key){
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    }

/**
     * 判斷key是否存在
     * @param key 鍵
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key){
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

/**
     * 刪除快取
     * @param key 可以傳一個值 或多個
     */
    @SuppressWarnings("unchecked")
    public void del(String ... key){
        if(key!=null&&key.length>0){
            if(key.length==1){
                redisTemplate.delete(key[0]);
            }else{
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

//============================String=============================
    /**
     * 普通快取獲取
     * @param key 鍵
     * @return 值
     */
    public Object get(String key){
        return key==null?null:redisTemplate.opsForValue().get(key);
    }

/**
     * 普通快取放入
     * @param key 鍵
     * @param value 值
     * @return true成功 false失敗
     */
    public boolean set(String key,Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

/**
     * 普通快取放入並設定時間
     * @param key 鍵
     * @param value 值
     * @param time 時間(秒) time要大於0 如果time小於等於0 將設定無限期
     * @return true成功 false 失敗
     */
    public boolean set(String key,Object value,long time){
        try {
            if(time>0){
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            }else{
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

/**
     * 遞增
     * @param key 鍵
     * @param delta 要增加幾(大於0)
     * @return
     */
    public long incr(String key, long delta){
        if(delta<0){
            throw new RuntimeException("遞增因子必須大於0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

/**
     * 遞減
     * @param key 鍵
     * @param delta 要減少幾(小於0)
     * @return
     */
    public long decr(String key, long delta){
        if(delta<0){
            throw new RuntimeException("遞減因子必須大於0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

//================================Map=================================
    /**
     * HashGet
     * @param key 鍵 不能為null
     * @param item 項 不能為null
     * @return 值
     */
    public Object hget(String key,String item){
        return redisTemplate.opsForHash().get(key, item);
    }

/**
     * 獲取hashKey對應的所有鍵值
     * @param key 鍵
     * @return 對應的多個鍵值
     */
    public Map<object> hmget(String key){
        return redisTemplate.opsForHash().entries(key);
    }

/**
     * HashSet
     * @param key 鍵
     * @param map 對應多個鍵值
     * @return true 成功 false 失敗
     */
    public boolean hmset(String key, Map<string> map){
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

/**
     * HashSet 並設定時間
     * @param key 鍵
     * @param map 對應多個鍵值
     * @param time 時間(秒)
     * @return true成功 false失敗
     */
    public boolean hmset(String key, Map<string> map, long time){
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if(time>0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

/**
     * 向一張hash表中放入資料,如果不存在將建立
     * @param key 鍵
     * @param item 項
     * @param value 值
     * @return true 成功 false失敗
     */
    public boolean hset(String key,String item,Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

/**
     * 向一張hash表中放入資料,如果不存在將建立
     * @param key 鍵
     * @param item 項
     * @param value 值
     * @param time 時間(秒)  注意:如果已存在的hash表有時間,這裡將會替換原有的時間
     * @return true 成功 false失敗
     */
    public boolean hset(String key,String item,Object value,long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if(time>0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

/**
     * 刪除hash表中的值
     * @param key 鍵 不能為null
     * @param item 項 可以使多個 不能為null
     */
    public void hdel(String key, Object... item){
        redisTemplate.opsForHash().delete(key,item);
    }

/**
     * 判斷hash表中是否有該項的值
     * @param key 鍵 不能為null
     * @param item 項 不能為null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item){
        return redisTemplate.opsForHash().hasKey(key, item);
    }

/**
     * hash遞增 如果不存在,就會建立一個 並把新增後的值返回
     * @param key 鍵
     * @param item 項
     * @param by 要增加幾(大於0)
     * @return
     */
    public double hincr(String key, String item,double by){
        return redisTemplate.opsForHash().increment(key, item, by);
    }

/**
     * hash遞減
     * @param key 鍵
     * @param item 項
     * @param by 要減少記(小於0)
     * @return
     */
    public double hdecr(String key, String item,double by){
        return redisTemplate.opsForHash().increment(key, item,-by);
    }

//============================set=============================
    /**
     * 根據key獲取Set中的所有值
     * @param key 鍵
     * @return
     */
    public Set<object> sGet(String key){
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

/**
     * 根據value從一個set中查詢,是否存在
     * @param key 鍵
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key,Object value){
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

/**
     * 將資料放入set快取
     * @param key 鍵
     * @param values 值 可以是多個
     * @return 成功個數
     */
    public long sSet(String key, Object...values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

/**
     * 將set資料放入快取
     * @param key 鍵
     * @param time 時間(秒)
     * @param values 值 可以是多個
     * @return 成功個數
     */
    public long sSetAndTime(String key,long time,Object...values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if(time>0) {
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

/**
     * 獲取set快取的長度
     * @param key 鍵
     * @return
     */
    public long sGetSetSize(String key){
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

/**
     * 移除值為value的
     * @param key 鍵
     * @param values 值 可以是多個
     * @return 移除的個數
     */
    public long setRemove(String key, Object ...values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    //===============================list=================================

/**
     * 獲取list快取的內容
     * @param key 鍵
     * @param start 開始
     * @param end 結束  0 到 -1代表所有值
     * @return
     */
    public List<object> lGet(String key, long start, long end){
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

/**
     * 獲取list快取的長度
     * @param key 鍵
     * @return
     */
    public long lGetListSize(String key){
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

/**
     * 透過索引 獲取list中的值
     * @param key 鍵
     * @param index 索引  index>=0時， 0 表頭，1 第二個元素，依次類推；index<0時，-1，表尾，-2倒數第二個元素，依次類推
     * @return
     */
    public Object lGetIndex(String key,long index){
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

/**
     * 將list放入快取
     * @param key 鍵
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

/**
     * 將list放入快取
     * @param key 鍵
     * @param value 值
     * @param time 時間(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

/**
     * 將list放入快取
     * @param key 鍵
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

/**
     * 將list放入快取
     * @param key 鍵
     * @param value 值
     * @param time 時間(秒)
     * @return
     */
    public boolean lSet(String key, List<object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

/**
     * 根據索引修改list中的某條資料
     * @param key 鍵
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index,Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

/**
     * 移除N個值為value
     * @param key 鍵
     * @param count 移除多少個
     * @param value 值
     * @return 移除的個數
     */
    public long lRemove(String key,long count,Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

}
```
- 儲存student資料的實體類：
```java
package com.example.serviceb.entity;

import java.io.Serializable;

/**
 * @Description: (這裡用一句話描述這個類的作用)
 * @author: willzhao E-mail: zq2599@gmail.com
 * @date: 2019/10/3 11:11
 */
public class Student implements Serializable {
    private Integer id;
    private String name;

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;
    }
}
```
- 提供http服務的controller類：
```java
package com.example.serviceb.controller;

import com.alibaba.fastjson.JSON;
import com.example.serviceb.entity.Student;
import com.example.serviceb.util.RedisUtil;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @Description: redis服務
 * @author: willzhao E-mail: zq2599@gmail.com
 * @date: 2019/10/3 11:13
 */
@RestController
public class StudentRedisController {

@Resource
    private RedisUtil redisUtil;

@RequestMapping(value = "/set/{id}/{name}", method = RequestMethod.GET)
    public String set(@PathVariable("id") Integer id, @PathVariable("name") String name) {
        Student student = new Student();
        student.setId(id);
        student.setName(name);
        //寫入redis，有效期是30秒
        redisUtil.set("student:"+id, student, 30);
        return "set successful, id ["+id+"], name ["+name+"]";
    }

@RequestMapping(value = "/get/{id}", method = RequestMethod.GET)
    public String get(@PathVariable("id") Integer id) {
        Object object = redisUtil.get("student:"+id);
        return null==object ? "" : JSON.toJSONString(object);
    }
}
```
- 最後是應用啟動類：
```java
package com.example.serviceb;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ServiceBApplication {

public static void main(String[] args) {
        SpringApplication.run(ServiceBApplication.class, args);
    }
}
```

- 以上就是整個demo的所有程式碼，接下來驗證服務
### 驗證
- 先呼叫service-a的add介面寫資料：http://localhost:8080/add/1/tom ：
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/2019100317182141.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly94aW5jaGVuLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70)
- 檢查資料庫，寫入成功：
```shell
mysql> select * from student;
+------+------+
| id   | name |
+------+------+
|    1 | tom  |
+------+------+
1 row in set (0.00 sec)
```
- 檢查redis，寫入成功(注意：千萬不要在生產環境使用keys命令！！！)：
```shell
127.0.0.1:6379> keys *
1) "student:1"
127.0.0.1:6379> get "student:1"
"[\"com.example.serviceb.entity.Student\",{\"id\":1,\"name\":\"tom\"}]"
```
- 等待超過30秒，呼叫讀介面試試：http://localhost:8080/get/1 ，由於redis中的資料只有30秒有效期，所以此時頁面提示資料來自mysql
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20191003172453649.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly94aW5jaGVuLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70)
- 立即再呼叫讀介面，由於前面的一次讀介面會將資料寫入redis，所以此時頁面提示資料來自redis：
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20191003172639728.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly94aW5jaGVuLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70)

- 至此，整個demo已經完成開發和驗證，希望你在著手開發一個資料、快取相關的springboot應用時，此demo能給你提供一些參考。

### 參考並致謝
- 本文的原始碼中，RedisConfig和RedisUtil這兩個類參考了這篇文章的程式碼：https://www.jianshu.com/p/b9154316227e ，在此致謝作者；

### 歡迎關注ITpub：程式設計師欣宸
> [學習路上，你不孤單，欣宸原創一路相伴...](http://blog.itpub.net/70017844/)</object></object></object></object></string></string></object></string></string></string></string></string></string></string></string></string></string></string></string></string></string>

立即可用的實戰原始碼(springboot+redis+mybatis+restTemplate)

相關文章