你知道如何在springboot中使用redis嗎

時間 2019-12-12

標籤知道如何 springboot 使用 redis 欄目 Spring 简体版

原文原文鏈接

特別說明：本文針對的是新版 spring boot 2.1.3，其 spring data 依賴爲 spring-boot-starter-data-redis,且其默認鏈接池爲 lettucejava

redis 做爲一個高性能的內存數據庫，若是不會用就太落伍了，以前在 node.js 中用過 redis，本篇記錄如何將 redis 集成到 spring boot 中。提供 redis 操做類，和註解使用 redis 兩種方式。主要內容以下：node

docker 安裝 redis
springboot 集成 redis
編寫 redis 操做類
經過註解使用 redis

安裝 redis

經過 docker 安裝，docker compose 編排文件以下：git

# docker-compose.yml
version: "2"
services:
 redis:
 container_name: redis
 image: redis:3.2.10
 ports:
 - "6379:6379"
複製代碼

而後在docker-compose.yml所在目錄使用docker-compose up -d命令，啓動 redis。github

集成 springboot

說明：springboot 版本爲 2.1.3redis

添加 maven 依賴

只需添加spring-boot-starter-data-redis依賴便可,並排除 lettuce 依賴，而後引入 jedis 和 jedis 的依賴 commons-pool2spring

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>

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

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>
複製代碼

編寫 springboot 配置文件

配置文件以下：sql

server:
 port: 8081
 servlet:
 context-path: /sso
spring:
 application:
 name: SSO
 cache:
 type: redis
 redis:
 database: 0
 host: 192.168.226.5
 port: 6379
    # 有密碼填密碼，沒有密碼不填
 password:
    # 鏈接超時時間（ms)
 timeout: 1000ms
    # 高版本springboot中使用jedis或者lettuce
 jedis:
 pool:
        # 鏈接池最大鏈接數（負值表示無限制）
 max-active: 8
        # 鏈接池最大阻塞等待時間（負值無限制)
 max-wait: 5000ms
        # 最大空閒連接數
 max-idle: 8
        # 最小空閒連接數
 min-idle: 0
複製代碼

編寫配置類

配置類代碼以下：docker

@EnableCaching//開啓緩存
@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    /** * 設置緩存管理器，這裏能夠配置默認過時時間等 * * @param connectionFactory 鏈接池 * @return */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration
                .defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(60));
        //注意：請勿使用先new 配置對象，而後在調用entryTtl方法的方式來操做
        //會致使配置不生效，緣由是調用.entryTtl方法會返回一個新的配置對象，而不是在原來的配置對象上修改

        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory);
        RedisCacheManager manager = new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);
        return manager;
    }

    @SuppressWarnings("all")
    @Bean
    public RedisTemplate<String, String> redisTemplate(JedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        RedisSerializer stringSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(stringSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

    //使用jedis鏈接池創建jedis鏈接工廠
    @Bean
    public JedisConnectionFactory jedisConnectionFactory() {
        logger.info("jedisConnectionFactory:初始化了");
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxIdle(maxIdle);
        config.setMinIdle(minIdle);
        config.setMaxWaitMillis(maxWaitMillis);
        config.setMaxTotal(maxActive);
        //連接耗盡時是否阻塞，默認true
        config.setBlockWhenExhausted(true);
        //是否啓用pool的jmx管理功能，默認true
        config.setJmxEnabled(true);
        JedisConnectionFactory factory = new JedisConnectionFactory();
        factory.setPoolConfig(config);
        factory.setHostName(host);
        factory.setPort(port);
        factory.setPassword(password);
        factory.setDatabase(database);
        factory.setTimeout(timeout);
        return factory;
    }
}
複製代碼

使用方法

有兩種方法來進行緩存操做，一種是在方法上添加緩存註解實現各類操做，一種是手動控制。我的比較喜歡手動控制，以爲這樣都在本身的掌控中。數據庫

經過註解使用

主要有如下 5 個註解：apache

@CacheConfig: 類級別緩存，設置緩存 key 前綴之類的
@Cacheable: 觸發緩存入口
@CacheEvict: 觸發移除緩存
@CachePut: 更新緩存
@Caching: 組合緩存

@CacheConfig

該註解能夠將緩存分類，它是類級別註解，主要用於給某個類的緩存全局配置，例子以下：

@CacheConfig(cacheNames = "redis_test")
@Service
public class RedisService {
  //....
}
複製代碼

上面 CacheConfig 會給類下經過註解生成的 key 加上 redis_test 的前綴。

@Cacheable

方法級別註解，根據 key 查詢緩存:

若是 key 不存在，將方法返回值緩存到 redis 中
若是 key 存在，直接從緩存中取值例子以下：

/** * 緩存時間，首次查詢後會緩存結果,key中的值可以使用表達式計算. * 如不提供key，將使用默認key構造方法生成一個key * @return long */
    @Cacheable(key = "'currentTime'")
    public long getTime() {
        return System.currentTimeMillis();
    }
複製代碼

屢次調用此段代碼會發現每次返回的值都是同樣的。

CachePut

用於更新緩存，每次調用都會想 db 請求，緩存數據

若是 key 存在，更新內容
若是 key 不存在，插入內容

代碼以下：

/** * 通常用於更新查插入操做，每次都會請求db */
    @CachePut(key = "'currentTime'+#id")
    public long updateTime(String id) {
        return System.currentTimeMillis();
    }
複製代碼

每次調用此方法都會根據 key 刷新 redis 中的緩存數據。

@CacheEvict

根據 key 刪除緩存中的數據。allEntries=true 表示刪除緩存中全部數據。代碼以下：

@CacheEvict(key = "'currentTime'+#id",allEntries=false)
    public void deleteTime(String id) {
    }
複製代碼

@Caching

本註解可將其餘註解組合起來使用。好比下面的例子：

//value屬性爲key指定前綴
    @Caching(put = {@CachePut(value = "user", key = "'name_'+#user.name"),
            @CachePut(value = "user", key = "'pass_'+#user.password")})
    public User testCaching(User user) {
        return user;
    }
複製代碼