redistemplate常用方法封装

序列化和配置

package com.gitee.ccsert.mall.common.redis.config;

import com.fasterxml.jackson.annotation.jsonautodetect;
import com.fasterxml.jackson.annotation.propertyaccessor;
import com.fasterxml.jackson.databind.objectmapper;
import com.fasterxml.jackson.databind.jsontype.impl.laissezfairesubtypevalidator;
import com.gitee.ccsert.mall.common.redis.redisservice;
import com.gitee.ccsert.mall.common.redis.impl.redisserviceimpl;
import org.springframework.context.annotation.bean;
import org.springframework.data.redis.cache.rediscacheconfiguration;
import org.springframework.data.redis.cache.rediscachemanager;
import org.springframework.data.redis.cache.rediscachewriter;
import org.springframework.data.redis.connection.redisconnectionfactory;
import org.springframework.data.redis.core.redistemplate;
import org.springframework.data.redis.serializer.jackson2jsonredisserializer;
import org.springframework.data.redis.serializer.redisserializationcontext;
import org.springframework.data.redis.serializer.redisserializer;
import org.springframework.data.redis.serializer.stringredisserializer;

import java.time.duration;

/**
 * classname: redisconfig <br/>
 * description: redis连接配置类 <br/>
 */
@configuration
public class baseredisconfig {
    @bean
    public redistemplate<string, object> redistemplate(redisconnectionfactory redisconnectionfactory) {
        redisserializer<object> serializer = redisserializer();
        redistemplate<string, object> redistemplate = new redistemplate<>();
        redistemplate.setconnectionfactory(redisconnectionfactory);
        redistemplate.setkeyserializer(new stringredisserializer());
        redistemplate.setvalueserializer(serializer);
        redistemplate.sethashkeyserializer(new stringredisserializer());
        redistemplate.sethashvalueserializer(serializer);
        redistemplate.afterpropertiesset();
        return redistemplate;
    }

    @bean
    public redisserializer<object> redisserializer() {

        //创建json序列化器
        jackson2jsonredisserializer<object> serializer = new jackson2jsonredisserializer<>(object.class);
        objectmapper objectmapper = new objectmapper();
        objectmapper.setvisibility(propertyaccessor.all, jsonautodetect.visibility.any);
        //必须设置，否则无法将json转化为对象，会转化成map类型
        objectmapper.activatedefaulttyping(laissezfairesubtypevalidator.instance,objectmapper.defaulttyping.non_final);
        serializer.setobjectmapper(objectmapper);
        return serializer;
    }
    @bean
    public rediscachemanager rediscachemanager(redisconnectionfactory redisconnectionfactory) {
        rediscachewriter rediscachewriter = rediscachewriter.nonlockingrediscachewriter(redisconnectionfactory);
        //设置redis缓存有效期为1天
        rediscacheconfiguration rediscacheconfiguration = rediscacheconfiguration.defaultcacheconfig()
                .serializevalueswith(redisserializationcontext.serializationpair.fromserializer(redisserializer())).entryttl(duration.ofdays(1));
        return new rediscachemanager(rediscachewriter, rediscacheconfiguration);
    }
    @bean
    public redisservice redisservice(){
        return new redisserviceimpl();
    }
}

接口

package com.gitee.ccsert.mall.common.redis;

import org.springframework.data.domain.sort;
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 java.util.list;
import java.util.map;
import java.util.set;

/**
 * classname: redisservice <br/>
 * description: redis操作接口 <br/>
 */
public interface redisservice {
    /**
     * 保存属性
     *
     * @param key   key值
     * @param value value值
     * @param time  时间戳
     */
    void set(string key, object value, long time);

    /**
     * 保存属性
     *
     * @param key   key值
     * @param value value值
     */
    void set(string key, object value);

    /**
     * 获取属性
     *
     * @param key key值
     * @return 返回对象
     */
    object get(string key);

    /**
     * 删除属性
     *
     * @param key key值
     * @return 返回成功
     */
    boolean del(string key);

    /**
     * 批量删除属性
     *
     * @param keys key值集合
     * @return 返回删除数量
     */
    long del(list<string> keys);

    /**
     * 设置过期时间
     *
     * @param key  key值
     * @param time 时间戳
     * @return 返回成功
     */
    boolean expire(string key, long time);

    /**
     * 获取过期时间
     *
     * @param key key值
     * @return 返回时间戳
     */
    long getexpire(string key);

    /**
     * 判断key是否存在
     *
     * @param key key值
     * @return 返回
     */
    boolean haskey(string key);

    /**
     * 按delta递增
     *
     * @param key   key值
     * @param delta delta值
     * @return 返回递增后结果
     */
    long incr(string key, long delta);

    /**
     * 按delta递减
     *
     * @param key   key值
     * @param delta delta值
     * @return 返回递减后结果
     */
    long decr(string key, long delta);

    /**
     * 获取hash结构中的属性
     *
     * @param key     外部key值
     * @param hashkey 内部key值
     * @return 返回内部key的value
     */
    object hget(string key, string hashkey);

    /**
     * 向hash结构中放入一个属性
     *
     * @param key     外部key
     * @param hashkey 内部key
     * @param value   内部key的value
     * @param time    过期时间
     * @return 返回是否成功
     */
    boolean hset(string key, string hashkey, object value, long time);

    /**
     * 向hash结构中放入一个属性
     *
     * @param key     外部key
     * @param hashkey 内部key
     * @param value   内部key的value
     */
    void hset(string key, string hashkey, object value);

    /**
     * 直接获取整个hash结构
     *
     * @param key 外部key值
     * @return 返回hashmap
     */
    map<object, object> hgetall(string key);

    /**
     * 直接设置整个hash结构
     *
     * @param key  外部key
     * @param map  hashmap值
     * @param time 过期时间
     * @return 返回是否成功
     */
    boolean hsetall(string key, map<string, object> map, long time);

    /**
     * 直接设置整个hash结构
     *
     * @param key 外部key
     * @param map hashmap值
     */
    void hsetall(string key, map<string, ?> map);

    /**
     * 删除hash结构中的属性
     *
     * @param key     外部key值
     * @param hashkey 内部key值
     */
    void hdel(string key, object... hashkey);

    /**
     * 判断hash结构中是否有该属性
     *
     * @param key     外部key
     * @param hashkey 内部key
     * @return 返回是否存在
     */
    boolean hhaskey(string key, string hashkey);

    /**
     * hash结构中属性递增
     *
     * @param key     外部key
     * @param hashkey 内部key
     * @param delta   递增条件
     * @return 返回递增后的数据
     */
    long hincr(string key, string hashkey, long delta);

    /**
     * hash结构中属性递减
     *
     * @param key     外部key
     * @param hashkey 内部key
     * @param delta   递增条件
     * @return 返回递减后的数据
     */
    long hdecr(string key, string hashkey, long delta);

    /**
     * 获取set结构
     *
     * @param key key
     * @return 返回set集合
     */
    set<object> smembers(string key);

    /**
     * 向set结构中添加属性
     *
     * @param key    key
     * @param values value集
     * @return 返回增加数量
     */
    long sadd(string key, object... values);

    /**
     * 向set结构中添加属性
     *
     * @param key    key
     * @param time   过期时间
     * @param values 值集合
     * @return 返回添加的数量
     */
    long sadd(string key, long time, object... values);

    /**
     * 是否为set中的属性
     *
     * @param key   key
     * @param value value
     * @return 返回是否存在
     */
    boolean sismember(string key, object value);

    /**
     * 获取set结构的长度
     *
     * @param key key
     * @return 返回长度
     */
    long ssize(string key);

    /**
     * 删除set结构中的属性
     *
     * @param key    key
     * @param values value集合
     * @return 删除掉的数据量
     */
    long sremove(string key, object... values);

    /**
     * 获取list结构中的属性
     *
     * @param key   key
     * @param start 开始
     * @param end   结束
     * @return 返回查询的集合
     */
    list<object> lrange(string key, long start, long end);

    /**
     * 获取list结构的长度
     *
     * @param key key
     * @return 长度
     */
    long lsize(string key);

    /**
     * 根据索引获取list中的属性
     *
     * @param key   key
     * @param index 索引
     * @return 对象
     */
    object lindex(string key, long index);

    /**
     * 向list结构中添加属性
     *
     * @param key   key
     * @param value value
     * @return 增加后的长度
     */
    long lpush(string key, object value);

    /**
     * 向list结构中添加属性
     *
     * @param key   key
     * @param value value
     * @param time  过期时间
     * @return 增加后的长度
     */
    long lpush(string key, object value, long time);

    /**
     * 向list结构中批量添加属性
     *
     * @param key    key
     * @param values value 集合
     * @return 增加后的长度
     */
    long lpushall(string key, object... values);

    /**
     * 向list结构中批量添加属性
     *
     * @param key    key
     * @param time   过期时间
     * @param values value集合
     * @return 增加后的长度
     */
    long lpushall(string key, long time, object... values);

    /**
     * 从list结构中移除属性
     *
     * @param key   key
     * @param count 总量
     * @param value value
     * @return 返回删除后的长度
     */
    long lremove(string key, long count, object value);

    /**
     * 向bitmap中新增值
     *
     * @param key    key
     * @param offset 偏移量
     * @param b      状态
     * @return 结果
     */
    boolean bitadd(string key, int offset, boolean b);

    /**
     * 从bitmap中获取偏移量的值
     *
     * @param key    key
     * @param offset 偏移量
     * @return 结果
     */
    boolean bitget(string key, int offset);

    /**
     * 获取bitmap的key值总和
     *
     * @param key key
     * @return 总和
     */
    long bitcount(string key);

    /**
     * 获取bitmap范围值
     *
     * @param key    key
     * @param limit  范围
     * @param offset 开始偏移量
     * @return long类型集合
     */
    list<long> bitfield(string key, int limit, int offset);

    /**
     * 获取所有bitmap
     *
     * @param key key
     * @return 以二进制字节数组返回
     */
    byte[] bitgetall(string key);

    /**
     * 增加坐标
     *
     * @param key  key
     * @param x    x
     * @param y    y
     * @param name 地点名称
     * @return 返回结果
     */
    long geoadd(string key, double x, double y, string name);

    /**
     * 根据城市名称获取坐标集合
     *
     * @param key   key
     * @param place 地点
     * @return 坐标集合
     */
    list<point> geogetpointlist(string key, object... place);

    /**
     * 计算两个城市之间的距离
     *
     * @param key      key
     * @param placeone 地点1
     * @param placetow 地点2
     * @return 返回距离
     */
    distance geocalculationdistance(string key, string placeone, string placetow);

    /**
     * 获取附该地点附近的其他地点
     *
     * @param key      key
     * @param place    地点
     * @param distance 附近的范围
     * @param limit    查几条
     * @param sort     排序规则
     * @return 返回附近的地点集合
     */
    georesults<redisgeocommands.geolocation<object>> geonearbyplace(string key, string place, distance distance, long limit, sort.direction sort);

    /**
     * 获取地点的hash
     *
     * @param key   key
     * @param place 地点
     * @return 返回集合
     */
    list<string> geogethash(string key, string... place);
}

实现

package com.gitee.ccsert.mall.common.redis.impl;

import com.gitee.ccsert.mall.common.redis.redisservice;
import org.springframework.data.domain.sort;
import org.springframework.data.geo.distance;
import org.springframework.data.geo.georesults;
import org.springframework.data.geo.point;
import org.springframework.data.redis.connection.bitfieldsubcommands;
import org.springframework.data.redis.connection.redisgeocommands;
import org.springframework.data.redis.core.rediscallback;
import org.springframework.data.redis.core.redistemplate;

import javax.annotation.resource;
import java.util.list;
import java.util.map;
import java.util.set;
import java.util.concurrent.timeunit;

/**
 * classname: redisserviceimpl <br/>
 * description: redis操作的具体时间类 <br/>
 */
public class redisserviceimpl implements redisservice {
    @resource
    private redistemplate<string, object> redistemplate;

    @override
    public void set(string key, object value, long time) {
        redistemplate.opsforvalue().set(key, value, time, timeunit.seconds);
    }

    @override
    public void set(string key, object value) {
        redistemplate.opsforvalue().set(key, value);
    }

    @override
    public object get(string key) {
        return redistemplate.opsforvalue().get(key);
    }

    @override
    public boolean del(string key) {
        return redistemplate.delete(key);
    }

    @override
    public long del(list<string> keys) {
        return redistemplate.delete(keys);
    }

    @override
    public boolean expire(string key, long time) {
        return redistemplate.expire(key, time, timeunit.seconds);
    }

    @override
    public long getexpire(string key) {
        return redistemplate.getexpire(key, timeunit.seconds);
    }

    @override
    public boolean haskey(string key) {
        return redistemplate.haskey(key);
    }

    @override
    public long incr(string key, long delta) {
        return redistemplate.opsforvalue().increment(key, delta);
    }

    @override
    public long decr(string key, long delta) {
        return redistemplate.opsforvalue().increment(key, -delta);
    }

    @override
    public object hget(string key, string hashkey) {
        return redistemplate.opsforhash().get(key, hashkey);
    }

    @override
    public boolean hset(string key, string hashkey, object value, long time) {
        redistemplate.opsforhash().put(key, hashkey, value);
        return expire(key, time);
    }

    @override
    public void hset(string key, string hashkey, object value) {
        redistemplate.opsforhash().put(key, hashkey, value);
    }

    @override
    public map<object, object> hgetall(string key) {
        return redistemplate.opsforhash().entries(key);
    }

    @override
    public boolean hsetall(string key, map<string, object> map, long time) {
        redistemplate.opsforhash().putall(key, map);
        return expire(key, time);
    }

    @override
    public void hsetall(string key, map<string, ?> map) {
        redistemplate.opsforhash().putall(key, map);
    }

    @override
    public void hdel(string key, object... hashkey) {
        redistemplate.opsforhash().delete(key, hashkey);
    }

    @override
    public boolean hhaskey(string key, string hashkey) {
        return redistemplate.opsforhash().haskey(key, hashkey);
    }

    @override
    public long hincr(string key, string hashkey, long delta) {
        return redistemplate.opsforhash().increment(key, hashkey, delta);
    }

    @override
    public long hdecr(string key, string hashkey, long delta) {
        return redistemplate.opsforhash().increment(key, hashkey, -delta);
    }

    @override
    public set<object> smembers(string key) {
        return redistemplate.opsforset().members(key);
    }

    @override
    public long sadd(string key, object... values) {
        return redistemplate.opsforset().add(key, values);
    }

    @override
    public long sadd(string key, long time, object... values) {
        long count = redistemplate.opsforset().add(key, values);
        expire(key, time);
        return count;
    }

    @override
    public boolean sismember(string key, object value) {
        return redistemplate.opsforset().ismember(key, value);
    }

    @override
    public long ssize(string key) {
        return redistemplate.opsforset().size(key);
    }

    @override
    public long sremove(string key, object... values) {
        return redistemplate.opsforset().remove(key, values);
    }

    @override
    public list<object> lrange(string key, long start, long end) {
        return redistemplate.opsforlist().range(key, start, end);
    }

    @override
    public long lsize(string key) {
        return redistemplate.opsforlist().size(key);
    }

    @override
    public object lindex(string key, long index) {
        return redistemplate.opsforlist().index(key, index);
    }

    @override
    public long lpush(string key, object value) {
        return redistemplate.opsforlist().rightpush(key, value);
    }

    @override
    public long lpush(string key, object value, long time) {
        long index = redistemplate.opsforlist().rightpush(key, value);
        expire(key, time);
        return index;
    }

    @override
    public long lpushall(string key, object... values) {
        return redistemplate.opsforlist().rightpushall(key, values);
    }

    @override
    public long lpushall(string key, long time, object... values) {
        long count = redistemplate.opsforlist().rightpushall(key, values);
        expire(key, time);
        return count;
    }

    @override
    public long lremove(string key, long count, object value) {
        return redistemplate.opsforlist().remove(key, count, value);
    }

    @override
    public boolean bitadd(string key, int offset, boolean b) {
        return redistemplate.opsforvalue().setbit(key, offset, b);
    }

    @override
    public boolean bitget(string key, int offset) {
        return redistemplate.opsforvalue().getbit(key, offset);
    }

    @override
    public long bitcount(string key) {
        return redistemplate.execute((rediscallback<long>) con -> con.bitcount(key.getbytes()));
    }

    @override
    public list<long> bitfield(string key, int limit, int offset) {
        return redistemplate.execute((rediscallback<list<long>>) con ->
                con.bitfield(key.getbytes(),
                        bitfieldsubcommands.create().get(bitfieldsubcommands.bitfieldtype.unsigned(limit)).valueat(offset)));
    }

    @override
    public byte[] bitgetall(string key) {
        return redistemplate.execute((rediscallback<byte[]>) con -> con.get(key.getbytes()));
    }

    @override
    public long geoadd(string key, double x, double y, string name) {
        return redistemplate.opsforgeo().add(key, new point(x, y), name);
    }

    @override
    public list<point> geogetpointlist(string key, object... place) {
        return redistemplate.opsforgeo().position(key, place);
    }

    @override
    public distance geocalculationdistance(string key, string placeone, string placetow) {
        return redistemplate.opsforgeo()
                .distance(key, placeone, placetow, redisgeocommands.distanceunit.kilometers);
    }

    @override
    public georesults<redisgeocommands.geolocation<object>> geonearbyplace(string key, string place, distance distance, long limit, sort.direction sort) {
        redisgeocommands.georadiuscommandargs args = redisgeocommands.georadiuscommandargs.newgeoradiusargs().includedistance().includecoordinates();
        // 判断排序方式
        if (sort.direction.asc == sort) {
            args.sortascending();
        } else {
            args.sortdescending();
        }
        args.limit(limit);
        return redistemplate.opsforgeo()
                .radius(key, place, distance, args);
    }

    @override
    public list<string> geogethash(string key, string... place) {
        return redistemplate.opsforgeo()
                .hash(key, place);
    }

}