Springboot整合Redis和redis常用操作演示

Springboot整合Redis

springboot整合Redis相当的简单，只要引入redis相关的jar包，然后再做一些连接Redis的配置即可。

引入redis相关jar包

在pom.xml中添加如下代码，即可引入redis相关jar包：

• 引入redis自身的jar包

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

• 引入redis连接池的包

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

springboot配置redis连接信息

在springboot项目的application.properties中配置redis的连接信息，代码如下：

spring.redis.lettuce.pool.max-active=20
spring.redis.lettuce.pool.max-idle=2
spring.redis.lettuce.pool.max-wait=10
spring.redis.lettuce.pool.min-idle=2
spring.redis.lettuce.shutdown-timeout=1


spring.redis.host=127.0.0.1
spring.redis.password=666
spring.redis.port=6379

spring.redis.lettuce相关的配置，是关于redis连接池的配置。lettuce在springboot的较新版本中，替代了jedis成为了默认的连接池工具。关于性能、连接机制方面，和jedis其实有很多区别，这块后面单独写篇文章介绍。

spring.redis相关的配置都是redis数据库的连接信息，密码如果没有，就删除掉spring.redis.password即可。

通过springboot操作执行redis命令

redis有很多命令，在springboot中，你可以通过直接@Autowired注入StringRedisTemplate或者RedisTemplate来使用。（下面代码中的stringRedisTemplate、redisTemplate对象就是通过@Autowired注入的，完整代码可以参考文末代码）

下面案例代码中的key、value变量都是String类型，因为我们使用的是StringRedisTemplate。

• redis SETNX：stringRedisTemplate.opsForValue().setIfAbsent(key, value)
• redis GETSET：stringRedisTemplate.opsForValue().getAndSet(key, value)
• redis INCR：stringRedisTemplate.opsForValue().increment(key)
• redis INCRBY：stringRedisTemplate.opsForValue().increment(key,val)
• redis DECR：stringRedisTemplate.opsForValue().decrement(key)
• redis DECRBY：stringRedisTemplate.opsForValue().decrement(key, val)
• redis SADD：stringRedisTemplate.opsForSet().add(key, value)
• redis SISMEMBER：stringRedisTemplate.opsForSet().isMember(key, member)
• redis SMEMBERS：stringRedisTemplate.opsForSet().members(key)
• redis SCARD：stringRedisTemplate.opsForSet().size(key)
• redis SET：stringRedisTemplate.opsForValue().set(key, value)或stringRedisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS)该命令有很多可选参数，更复杂的应用可以参考文末代码。
• redis GET：stringRedisTemplate.opsForValue().get(key)
• redis EXISTS：stringRedisTemplate.hasKey(key)
• redis TTL：stringRedisTemplate.getExpire(key, TimeUnit.SECONDS)
• redis EXPIRE：stringRedisTemplate.expire(key, time, TimeUnit.SECONDS)
• redis DEL：stringRedisTemplate.delete(key)
• redis HSET：stringRedisTemplate.opsForHash().put(key, field, value)
• redis LPOP：redisTemplate.opsForList().leftPop(key)
• redis LPUSH：redisTemplate.opsForList().leftPush(key, val)
• redis LREM：redisTemplate.opsForList().remove(key, 0, val)

还有很多，就不单独列出了，可参考文末的完整代码。

封装常用的Redis操作

作者把自己常用的一些redis操作封装了一个springboot的service，里面包含了大部分的redis数据结构的操作，仅供参考。如果你要参考，有需要可以联系作者（点击右侧“联系作者”按钮即可）。

package com.coderbbb.blogv2.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.geo.Circle;
import org.springframework.data.geo.Distance;
import org.springframework.data.geo.GeoResults;
import org.springframework.data.geo.Point;
import org.springframework.data.redis.connection.RedisGeoCommands;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @author longge93 on 2018/6/16.
 */
@Service
public class RedisService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 对应Redis SETNX
     *
     * @param key
     * @param value
     * @return
     */
    public Boolean setnx(String key, String value) {
        return stringRedisTemplate.opsForValue().setIfAbsent(key, value);
    }

    /**
     * 对应Redis GETSET
     *
     * @param key
     * @param value
     * @return
     */
    public String setGet(String key, String value) {
        return stringRedisTemplate.opsForValue().getAndSet(key, value);
    }

    /**
     * 对应Redis INCR
     *
     * @param key
     * @return
     */
    public Long incr(String key) {
        return stringRedisTemplate.opsForValue().increment(key);
    }

    /**
     * 对应Redis INCRBY
     *
     * @param key
     * @param val
     * @return
     */
    public Long incr(String key, long val) {
        return stringRedisTemplate.opsForValue().increment(key, val);
    }

    /**
     * 对应Redis DECR
     *
     * @param key
     * @return
     */
    public Long decr(String key) {
        return stringRedisTemplate.opsForValue().decrement(key);
    }

    /**
     * 对应Redis DECRBY
     *
     * @param key
     * @param val
     * @return
     */
    public Long decr(String key, long val) {
        return stringRedisTemplate.opsForValue().decrement(key, val);
    }

    /**
     * 对应Redis SMEMBERS
     * @param key
     * @return
     */
    public Set<String> setList(String key) {
        return stringRedisTemplate.opsForSet().members(key);
    }

    /**
     * 对应Redis SCARD
     * @param key
     * @return
     */
    public Long setSize(String key) {
        return stringRedisTemplate.opsForSet().size(key);
    }

    /**
     * 对应Redis SET
     * @param key
     * @param value
     */
    public void putString(String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
    }

    /**
     * 对应Redis SET
     * s为单位。
     * @param key
     * @param value
     * @param time
     */
    public void putString(String key, String value, long time) {
        stringRedisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
    }

    /**
     * 对应Redis SET
     * 详细命令：SET key value [EX seconds] [PX milliseconds] [NX|XX]
     * @param key
     * @param value
     * @param time
     * @return
     */
    public Boolean zPutString(String key, String value, long time) {
        return stringRedisTemplate.opsForValue().setIfAbsent(key, value, time, TimeUnit.SECONDS);
    }

    /**
     * 对应Redis SET
     * @param key
     * @param value
     * @param time
     * @param unit
     */
    public void putString(String key, String value, long time, TimeUnit unit) {
        stringRedisTemplate.opsForValue().set(key, value, time, unit);
    }

    public String getString(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }

    public void putObject(String key, Object value, long time, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, time, unit);
    }

    public Object getObject(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 对应Redis EXISTS
     * @param key
     * @return
     */
    public Boolean exist(String key) {
        return stringRedisTemplate.hasKey(key);
    }

    /**
     * 对应Redis TTL
     * key有效时间
     *
     * @param key
     * @return
     */
    public Long expire(String key) {
        return stringRedisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 对应Redis DEL
     * @param key
     * @return
     */
    public Boolean del(String key) {
        return stringRedisTemplate.delete(key);
    }

    /**
     * 对应Redis HSET
     * @param key
     * @param field
     * @param value
     */
    public void hset(String key, String field, String value) {
        stringRedisTemplate.opsForHash().put(key, field, value);
    }

    /**
     * 对应Redis HGET
     * @param key
     * @param field
     * @return
     */
    public String hget(String key, String field) {
        HashOperations<String, String, String> ops = stringRedisTemplate.opsForHash();
        return ops.get(key, field);
    }

    /**
     * 对应Redis HMGET
     * @param key
     * @return
     */
    public Map<String, String> hmget(String key) {
        HashOperations<String, String, String> ops = stringRedisTemplate.opsForHash();
        return ops.entries(key);
    }

    /**
     * 对应Redis HMSET
     * @param key
     * @param data
     */
    public void hmset(String key, HashMap<String, String> data) {
        HashOperations<String, String, String> ops = stringRedisTemplate.opsForHash();
        ops.putAll(key, data);
    }

    /**
     * 对应Redis HDEL
     * @param key
     * @param field
     */
    public void hdel(String key, String field) {
        HashOperations<String, String, String> ops = stringRedisTemplate.opsForHash();
        ops.delete(key, field);
    }

    /**
     * 对应Redis SADD
     * @param key
     * @param value
     */
    public void sadd(String key, String value) {
        stringRedisTemplate.opsForSet().add(key, value);
    }

    /**
     * 对应Redis SISMEMBER
     * @param key
     * @param val
     * @return
     */
    public Boolean setIsMember(String key, String val) {
        return stringRedisTemplate.opsForSet().isMember(key, val);
    }

    public void channel(String channel, String value) {
        stringRedisTemplate.convertAndSend(channel, value);
    }


    /**
     * 对应Redis ZREM
     * @param key
     * @param member
     * @return
     */
    public Long zSetDel(String key, String member) {
        return stringRedisTemplate.boundZSetOps(key).remove(member);
    }

    public void geoAdd(String key, double lat, double lng, String member) {
        Point point = new Point(lng, lat);
        RedisGeoCommands.GeoLocation<String> geoLocation = new RedisGeoCommands.GeoLocation<>(member, point);
        stringRedisTemplate.boundGeoOps(key).add(geoLocation);
    }

    public GeoResults<RedisGeoCommands.GeoLocation<String>> geoSearch(String key, double lat, double lng, double distanceVal, long count) {
        Point point = new Point(lng, lat);
        Distance distance = new Distance(distanceVal);
        Circle circle = new Circle(point, distance);
        RedisGeoCommands.GeoRadiusCommandArgs commandArgs = RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs();
        commandArgs.sortAscending();
        if (count != 0) {
            commandArgs.limit(count);
        }
        return stringRedisTemplate.boundGeoOps(key).radius(circle, commandArgs);
        //.geoRadius(circle);
    }

    /**
     * 对应Redis EXPIRE
     * @param key
     * @param time
     */
    public void setExpire(String key, long time) {
        stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
    }

    /**
     * 对应Redis EXPIRE
     * @param key
     * @param time
     */
    public void setExpireMills(String key, long time) {
        stringRedisTemplate.expire(key, time, TimeUnit.MILLISECONDS);
    }

    /**
     * 对应Redis MGET
     * @param keys
     * @return
     */
    public List<String> mget(List<String> keys) {
        return stringRedisTemplate.opsForValue().multiGet(keys);
    }


    /**
     * 对应Redis LPUSH
     * 设置key 类型为list
     *
     * @param key
     * @param value
     * @return
     */
    public Long listAddAll(String key, Collection<?> value) {
        return redisTemplate.opsForList().leftPushAll(key, value.toArray());
    }

    /**
     * 对应Redis LPOP
     * 移出并获取列表的第一个元素
     *
     * @param key
     * @return 删除的元素
     */
    public Object lLeftPop(String key) {
        return redisTemplate.opsForList().leftPop(key);
    }

    /**
     * 对应Redis LPUSH
     * @param key
     * @param val
     * @return
     */
    public Long listAdd(String key, Integer val) {
        return redisTemplate.opsForList().leftPush(key, val);
    }

    /**
     * 对应Redis LREM
     * @param key
     * @param val
     */
    public void listRemove(String key, String val) {
        redisTemplate.opsForList().remove(key, 0, val);
    }

    /**
     * 对应Redis LPUSH
     * @param key
     * @param val
     * @return
     */
    public Long listAddForString(String key, String val) {
        return redisTemplate.opsForList().leftPush(key, val);
    }

    /**
     * 对应Redis LRANGE
     * @param key
     * @return
     */
    public List<Object> listGetAll(String key) {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 对应Redis LLEN
     * @param key
     * @return
     */
    public Long listSize(String key) {
        return redisTemplate.opsForList().size(key);
    }
}