Spring Boot學習筆記（十四）Spring Boot Redis 數據緩存實例

Spring Boot Redis 數據緩存實例

這節我就不逼逼了，直接上代碼
訪問 https://start.spring.io/ 生成項目壓縮包
解壓後用IDEA打開，項目結構如下

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.8.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>wen</groupId>
    <artifactId>datacache</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>datacache</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</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</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.47</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

        <dependency>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

    </dependencies>

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

</project>

配置文件：logback.xml

<configuration scan="true">
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <encoder charset="UTF-8">
            <pattern>
                [%thread] %highlight(%-5level) %cyan(%logger{15}) - %highlight(%msg) %n
            </pattern>
        </encoder>
    </appender>
    <root level="INFO">
        <appender-ref ref="stdout"/>
    </root>
    <logger name="wen.datacache" level="DEBUG"/>
</configuration>

application.properties

logging.config=classpath:logback.xml
server.port=8080
server.servlet.session.timeout=1800
server.max-http-header-size=20971520
# redis
# Redis數據庫索引（默認爲0）
spring.redis.database=0
# Redis服務器地址
spring.redis.host=localhost
# Redis服務器連接端口
spring.redis.port=6379
# Redis服務器連接密碼（默認爲空）
spring.redis.password=
# 連接池最大連接數（使用負值表示沒有限制）
spring.redis.jedis.pool.max-active=8
# 連接池最大阻塞等待時間（使用負值表示沒有限制）
spring.redis.jedis.pool.max-wait=-1
# 連接池中的最大空閒連接
spring.redis.jedis.pool.max-idle=8
# 連接池中的最小空閒連接
spring.redis.jedis.pool.min-idle=0
# 連接超時時間（毫秒）
spring.redis.timeout=6000
# 連接池最大連接數（使用負值表示沒有限制） 默認 8
spring.redis.lettuce.pool.max-active=8
# 連接池最大阻塞等待時間（使用負值表示沒有限制） 默認 -1
spring.redis.lettuce.pool.max-wait=-1
# 連接池中的最大空閒連接 默認 8
spring.redis.lettuce.pool.max-idle=8
# 連接池中的最小空閒連接 默認 0
spring.redis.lettuce.pool.min-idle=0

啓動類：

package wen.datacache;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;

@Configuration
@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
@ComponentScan("wen.datacache")
@EnableCaching
@EnableScheduling
public class DatacacheApplication {

    public static void main(String[] args) throws Exception {
        SpringApplication.run(DatacacheApplication.class, args);
    }

}

實體類：CityInfo.java

package wen.datacache.entity;

import java.io.Serializable;

public class CityInfo implements Serializable {

    private int id;

    private String city;

    public CityInfo() {

    }

    public CityInfo(int id, String city) {
        this.id = id;
        this.city = city;
    }

    public int getId() {
        return id;
    }

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

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

定義接口 RedisMapper.java

package wen.datacache.mapper;

import org.springframework.data.redis.core.ListOperations;
import java.util.List;
import java.util.Set;

public interface RedisMapper {

    boolean cacheValue(String k, String v, Long time);

    boolean cacheValue(String k, String v);

    boolean containsValueKey(String k);

    boolean containsSetKey(String k);

    boolean containsListKey(String k);

    boolean containsKey(String k);

    String getValue(String k);

    boolean removeValue(String k);

    boolean removeSet(String k);

    boolean removeList(String k);

    boolean cacheSet(String k, String v, long time);

    boolean cacheSet(String k, String v);

    boolean cacheSet(String k, Set<String> v, long time);

    boolean cacheSet(String k, Set<String> v);

    Set<String> getSet(String k);

    boolean cacheList(String k, String v, long time);

    boolean cacheList(String k, String v);

    boolean cacheList(String k, List<String> v, long time);

    boolean cacheList(String k, List<String> v);

    List<String> getList(String k, long start, long end);

    long getListSize(String k);

    long getListSize(ListOperations<String, String> listOps, String k);

    boolean removeOneOfList(String k);
}

RedisMapperImpl.java, 實現類記得加上@Repository 註解

package wen.datacache.mapper.impl;

import wen.datacache.mapper.RedisMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Repository;

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

@Repository
public class RedisMapperImpl implements RedisMapper {

    private static final String KEY_PREFIX_VALUE = "wen:datacache:value:";
    private static final String KEY_PREFIX_SET = "wen:datacache:set:";
    private static final String KEY_PREFIX_LIST = "wen:datacache:list:";

    private final RedisTemplate<String, String> redisTemplate;

    private final Logger LOGGER = LoggerFactory.getLogger(this.getClass());

    @Autowired
    public RedisMapperImpl(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @Override
    public boolean cacheValue(String k, String v, Long time) {
        String key = KEY_PREFIX_VALUE + k;
        try {
            ValueOperations<String, String> valueOps = redisTemplate.opsForValue();
            valueOps.set(key, v);
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Throwable t) {
            LOGGER.error("緩存[" + key + "]失敗, value[" + v + "]", t);
        }
        return false;
    }

    @Override
    public boolean cacheValue(String k, String v) {
        return cacheValue(k, v, -1L);
    }

    @Override
    public boolean containsValueKey(String k) {
        return containsKey(KEY_PREFIX_VALUE + k);
    }

    @Override
    public boolean containsSetKey(String k) {
        return containsKey(KEY_PREFIX_SET + k);
    }

    @Override
    public boolean containsListKey(String k) {
        return containsKey(KEY_PREFIX_LIST + k);
    }

    @Override
    public boolean containsKey(String k) {
        try {
            return redisTemplate.hasKey(k);
        } catch (Throwable t) {
            LOGGER.error("判斷緩存存在失敗key[" + k + ", Code or[" + t + "]");
        }
        return false;
    }

    @Override
    public String getValue(String k) {
        try {
            ValueOperations<String, String> valueOps = redisTemplate.opsForValue();
            return valueOps.get(KEY_PREFIX_VALUE + k);
        } catch (Throwable t) {
            LOGGER.error("獲取緩存失敗key[" + KEY_PREFIX_VALUE + k + ", Code or[" + t + "]");
        }
        return null;
    }

    @Override
    public boolean removeValue(String k) {
        return remove(KEY_PREFIX_VALUE + k);
    }

    @Override
    public boolean removeSet(String k) {
        return remove(KEY_PREFIX_SET + k);
    }

    @Override
    public boolean removeList(String k) {
        return remove(KEY_PREFIX_LIST + k);
    }

    @Override
    public boolean cacheSet(String k, String v, long time) {
        String key = KEY_PREFIX_SET + k;
        try {
            SetOperations<String, String> setOps = redisTemplate.opsForSet();
            setOps.add(key, v);
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Throwable t) {
            LOGGER.error("緩存[" + key + "]失敗, value[" + v + "]", t);
        }
        return false;
    }

    @Override
    public boolean cacheSet(String k, String v) {
        return cacheSet(k, v, -1);
    }

    @Override
    public boolean cacheSet(String k, Set<String> v, long time) {
        String key = KEY_PREFIX_SET + k;
        try {
            SetOperations<String, String> setOps = redisTemplate.opsForSet();
            setOps.add(key, v.toArray(new String[v.size()]));
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Throwable t) {
            LOGGER.error("緩存[" + key + "]失敗, value[" + v + "]", t);
        }
        return false;
    }

    @Override
    public boolean cacheSet(String k, Set<String> v) {
        return cacheSet(k, v, -1);
    }

    @Override
    public Set<String> getSet(String k) {
        try {
            SetOperations<String, String> setOps = redisTemplate.opsForSet();
            return setOps.members(KEY_PREFIX_SET + k);
        } catch (Throwable t) {
            LOGGER.error("獲取set緩存失敗key[" + KEY_PREFIX_SET + k + ", Codeor[" + t + "]");
        }
        return null;
    }

    @Override
    public boolean cacheList(String k, String v, long time) {
        String key = KEY_PREFIX_LIST + k;
        try {
            ListOperations<String, String> listOps = redisTemplate.opsForList();
            listOps.rightPush(key, v);
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Throwable t) {
            LOGGER.error("緩存[" + key + "]失敗, value[" + v + "]", t);
        }
        return false;
    }

    @Override
    public boolean cacheList(String k, String v) {
        return cacheList(k, v, -1);
    }

    @Override
    public boolean cacheList(String k, List<String> v, long time) {
        String key = KEY_PREFIX_LIST + k;
        try {
            ListOperations<String, String> listOps = redisTemplate.opsForList();
            listOps.rightPushAll(key, v);
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Throwable t) {
            LOGGER.error("緩存[" + key + "]失敗, value[" + v + "]", t);
        }
        return false;
    }

    @Override
    public boolean cacheList(String k, List<String> v) {
        return cacheList(k, v, -1);
    }

    @Override
    public List<String> getList(String k, long start, long end) {
        try {
            ListOperations<String, String> listOps = redisTemplate.opsForList();
            return listOps.range(KEY_PREFIX_LIST + k, start, end);
        } catch (Throwable t) {
            LOGGER.error("獲取list緩存失敗key[" + KEY_PREFIX_LIST + k + ", Code or[" + t + "]");
        }
        return null;
    }

    @Override
    public long getListSize(String k) {
        try {
            ListOperations<String, String> listOps = redisTemplate.opsForList();
            return listOps.size(KEY_PREFIX_LIST + k) + 1;
        } catch (Throwable t) {
            LOGGER.error("獲取list長度失敗key[" + KEY_PREFIX_LIST + k + "], Code or[" + t + "]");
        }
        return 0;
    }

    @Override
    public long getListSize(ListOperations<String, String> listOps, String k) {
        try {
            return listOps.size(KEY_PREFIX_LIST + k);
        } catch (Throwable t) {
            LOGGER.error("獲取list長度失敗key[" + KEY_PREFIX_LIST + k + "], Code or[" + t + "]");
        }
        return 0;
    }

    @Override
    public boolean removeOneOfList(String k) {
        String key = KEY_PREFIX_LIST + k;
        try {
            ListOperations<String, String> listOps = redisTemplate.opsForList();
            listOps.rightPop(key);
            return true;
        } catch (Throwable t) {
            LOGGER.error("移除list緩存失敗key[" + KEY_PREFIX_LIST + k + ", Code or[" + t + "]");
        }
        return false;
    }

    private boolean remove(String k) {
        try {
            redisTemplate.delete(k);
            return true;
        } catch (Throwable t) {
            LOGGER.error("獲取緩存失敗key[" + k + ", Code or[" + t + "]");
        }
        return false;
    }
}

CityService.java

package wen.datacache.service;

import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;
import wen.datacache.entity.CityInfo;

@Component
@CacheConfig(cacheNames = "CityService")
public class CityService {

    @Cacheable
    public CityInfo getCity(int id, String city) {
        return new CityInfo(id, city);
    }
}

CityInfoController.java

package wen.datacache.web;

import org.springframework.beans.factory.annotation.Autowired;
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 wen.datacache.mapper.RedisMapper;

@RestController
@RequestMapping("/redis")
public class CityInfoController {

    private RedisMapper redisMapper;

    @Autowired
    public CityInfoController(RedisMapper redisMapper) {
        this.redisMapper = redisMapper;
    }

    @RequestMapping(value = "get/{key}", method = RequestMethod.GET)
    public String find(@PathVariable("key") String key) {
        return redisMapper.getValue(key);
    }

    @RequestMapping(value = "add/{key}/{value}", method = RequestMethod.GET)
    public Boolean add(@PathVariable("key") String key, @PathVariable("value") String value) {
        return redisMapper.cacheValue(key, value);
    }

    @RequestMapping(value = "del/{key}", method = RequestMethod.GET)
    public Boolean del(@PathVariable("key") String key) {
        return redisMapper.removeValue(key);
    }

    @RequestMapping(value = "count/{key}", method = RequestMethod.GET)
    public Long count(@PathVariable("key") String key) {
        return redisMapper.getListSize(key);
    }
}

開啓項目
項目源碼：https://github.com/StephaineWYT/datacache
下一篇：Spring Boot學習筆記（十五）Spring Boot Session共享實例

Spring Boot學習筆記（十四）Spring Boot Redis 數據緩存實例

Spring Boot Redis 數據緩存實例

公司剛入職了一名 Java 中級開發，短短 4 行代碼居然湊齊了 3 個 bug！我哭了~~

公衆號5月C#/.NET熱文一覽

git 下載大陸鏡像地址

Spring Boot學習筆記（九）Spring Boot Jpa 與 Thymeleaf 實現增刪改查

AS: Caused by: org.codehaus.groovy.control.MultipleCompilationErrorsException: startup failed:

Spring Boot org.hibernate.LazyInitializationException: could not initialize proxy [XX.#1]

Spring Boot學習筆記（十四）Spring Boot Redis 數據緩存實例

Spring Boot學習筆記（十七）Spring Boot RabbitMQ基本使用以及Topic Exchange, Fanout Exchange -- 實戰篇

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結