SpringBoot系列(2)：SpringBoot集成單機版Redis

本節內容

目錄

前言

SpringBoot項目集成單機版Redis

1、pom.xml依賴配置

2、配置中心(application.yml)加入redis參數配置

3、RedisTemplate配置

4、RedisUtils工具類

5、Congtroller測試

---

前言

最近項目上用到redis，主要就是在SpringBoot項目中集成Redis，在做拓展開發。關於SpringBoot集成Redis開發，實際上比較簡單，網上也有很多的教程，這裏還是自己總結一下實踐過程，鞏固學習。

工欲善其事必先利其器，不管是練習還是項目開發，我們要在SpringBoot中集成Redis，肯定得先安裝Redis(廢話了)。關於Redis的安裝，這裏不再贅述，詳細安裝步驟參見《(2)Linux環境下安裝和使用Redis》，接下來步入正題。

SpringBoot項目集成單機版Redis

1、pom.xml依賴配置

在pom.xml文件裏，需要什麼jar包就引入什麼依賴配置，即爲方便，當然離線/斷網/單機就算了。。。

<!--redis啓動依賴-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-redis</artifactId>
</dependency>

更直觀地來看一下依賴配置。 

2、配置中心(application.yml)加入redis參數配置

在yml文件裏配置redis參數，如目標主機地址host、redis服務端口port、超時時間timeout、redis訪問連接的密碼password、以及連接池參數配置，如下：

#連接池最大連接數（負值表示沒有限制）
spring.redis.pool.max-active=8
#連接池最大阻塞等待時間（負值表示沒有限制）
spring.redis.pool.max-wait= -1ms
#連接池中的最大空閒連接
spring.redis.pool.max-idle=8
#連接池中的最小空閒連接
spring.redis.pool.min-idle=0

具體配置：

#redis配置
 redis:
    host: 192.168.0.143
    port: 6379
    timeout: 10s
    lettuce:
      pool:
        min-idle: 0
        max-idle: 8
        max-active: 8
        max-wait: -1ms
    password:

3、RedisTemplate配置

關於redis配置，其實可以直接注入RedisTemplate對象，但是爲什麼，我們還要去自定義一個redisTemplate模板類？這裏，我們看一下RedisAutoConfiguration自動化配置類的源碼。

@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate")
	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

	@Bean
	@ConditionalOnMissingBean
	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

}

註解@Import內容告訴我們，關於Redis連接池配置，提供了兩種配置方式：Lettuce和Jedis。知道這兩種方式即可，暫且跳過，以後再詳細分析。

繼續往下看，RedisAutoConfiguration類給出了兩個生成模板類的方法，即SpringBoot集成Redis時，會自動幫我們在容器中生成一個RedisTemplate和一個StringRedisTemplate。但是，RedisTemplate是個泛型類，對於泛型<Object,Object>需要寫好多類型轉換的代碼。相比較而言，我們需要一個泛型爲<String,Object>形式的RedisTemplate。並且，這個RedisTemplate沒有設置數據存在Redis時，key及value的序列化方式。

        註解@ConditionalOnMissingBean，表示如果容器中已經存在有RedisTemplate對象了，這個自動配置的RedisTemplate將不會被實例化。因此，可以直接自定義一個配置類，配置RedisTemplate。

RedisConfig類：

@Configuration
public class RedisConfig {

    @SuppressWarnings({ "unchecked", "rawtypes" })
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(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);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key採用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也採用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式採用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式採用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

注意：設置key和value的序列化方式，不然存到Redis的中數據看起來亂七八糟的。 

4、RedisUtils工具類

直接用RedisTemplate操作Redis，代碼量太大，體力怕是跟不上。因此直接封裝一個RedisUtils，交給Spring容器實例化，使用時直接註解注入即可。

/**
 * RedisUtils類
 */
@Component
public class RedisUtils {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 寫入緩存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 寫入緩存設置時效時間
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime, TimeUnit timeUnit) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, timeUnit);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 批量刪除對應的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 批量刪除key
     *
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0) {
            redisTemplate.delete(keys);
        }
    }

    /**
     * 刪除對應的value
     *
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判斷緩存中是否有對應的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 讀取緩存
     *
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 哈希 添加
     *
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key, hashKey, value);
    }

    /**
     * 哈希獲取數據
     *
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }

    /**
     * 列表添加
     *
     * @param k
     * @param v
     */
    public void lPush(String k, Object v) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }

    /**
     * 列表獲取
     *
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }

    /**
     * 集合添加
     *
     * @param key
     * @param value
     */
    public void add(String key, Object value) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key, value);
    }

    /**
     * 集合獲取
     *
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    /**
     * 有序集合獲取
     *
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }
}

5、Controller中測試

@RestController
@RequestMapping("/sysUser")
public class SysUserController  extends BaseController<ISysUserService> {
    private final static Logger logger = LoggerFactory.getLogger(SysUserController.class);
    @Autowired
    private RedisUtils redisUtils;

    /**
     * 根據ID查詢系統用戶
     */
    @RequestMapping(value = "/getUserById", method = RequestMethod.GET)
    public ResponseMessage getUserById(@RequestParam(value = "id") String id) {
        String str = "";
        boolean hasKey  = redisUtils.exists(id);
        if (hasKey ) {
            //獲取緩存
            Object object  = redisUtils.get(id);
            logger.info("從緩存獲取到的數據" + object);
            str = object.toString();
        } else {
            //從數據庫中獲取數據
            logger.info("從數據庫中獲取數據");
            SysUser infoById = baseService.selectById(id);
            System.out.println(infoById);
            str = infoById.getUserName();
            //數據插入緩存（set中的參數含義：key值，user對象，緩存存在時間10（long類型），時間單位）
            redisUtils.set(id, str,10L, TimeUnit.MINUTES);
            logger.info("數據插入緩存" + str);
        }
        return new ResponseMessage(ResponseStatus.SUCCESS.getStatus(), ResponseStatus.SUCCESS.getMessage(), str);
    }
}

---

願你就像早晨八九點鐘的太陽，活力十足，永遠年輕。