关于RedisTemplate常用方法封装_Redis

redistemplate常用方法封装

1. 序列化和配置

package com.xxx.redis;
 
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.xxx.redis.service.redisservice;
import com.xxx.redis.service.impl.defaultredisserviceimpl;
import org.springframework.boot.autoconfigure.data.redis.redisautoconfiguration;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
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.redisserializer;
 
/**
 * redisconfiguration 
 *
 * @author xm.z
 */
@configuration
public class redisconfiguration {
 
	@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 redistemplate<string, object> redistemplate(redisconnectionfactory redisconnectionfactory,
			redisserializer<object> redisserializer) {
		redistemplate<string, object> redistemplate = new redistemplate<>();
		redistemplate.setconnectionfactory(redisconnectionfactory);
		redistemplate.setkeyserializer(redisserializer.string());
		redistemplate.setvalueserializer(redisserializer);
		redistemplate.sethashkeyserializer(redisserializer.string());
		redistemplate.sethashvalueserializer(redisserializer);
		redistemplate.afterpropertiesset();
		return redistemplate;
	}
 
	@bean
	public redisservice redisservice(redistemplate<string, object> redistemplate) {
		return new defaultredisserviceimpl(redistemplate);
	}
 
}

2. 基础常量

package com.xxx.redis.constant;
 
import org.springframework.data.redis.core.script.defaultredisscript;
 
/**
 * redisconstants
 *
 * @author xm.z
 */
public final class redisconstants {
 
	/**
	 * 递增并设置过期时间的 lua 脚本
	 */
	public static final defaultredisscript<long> incr_by_expire_lua_script = new defaultredisscript<>(
			"local r = redis.call('incrby', keys[1], argv[1]) redis.call('expire', keys[1], argv[2]) return r",
			long.class);
 
	/**
	 * 递减并设置过期时间的 lua 脚本
	 */
	public static final defaultredisscript<long> decr_by_expire_lua_script = new defaultredisscript<>(
			"local r = redis.call('decrby', keys[1], argv[1]) redis.call('expire', keys[1], argv[2]) return r",
			long.class);
 
	private redisconstants() {
	}
 
}

3. 接口及实现

package com.xxx.redis.service.impl;
 
import com.xxx.redis.service.redisservice;
import lombok.extern.slf4j.slf4j;
import org.springframework.data.redis.core.*;
 
/**
 * abstractredisservice
 *
 * @author xm.z
 */
@slf4j
public abstract class abstractredisservice implements redisservice {
 
	/**
	 * get helper class that simplifies redis data access code.
	 * @return redistemplate 获取
	 */
	protected abstract redistemplate<string, object> gettemplate();
 
	public hashoperations<string, object, object> hashops() {
		return this.gettemplate().opsforhash();
	}
 
	public valueoperations<string, object> valueops() {
		return this.gettemplate().opsforvalue();
	}
 
	public listoperations<string, object> listops() {
		return this.gettemplate().opsforlist();
	}
 
	public setoperations<string, object> setops() {
		return this.gettemplate().opsforset();
	}
 
	public zsetoperations<string, object> zsetops() {
		return this.gettemplate().opsforzset();
	}
 
	public streamoperations<string, object, object> streamops() {
		return this.gettemplate().opsforstream();
	}
 
	public geooperations<string, object> geoops() {
		return this.gettemplate().opsforgeo();
	}
 
}

package com.xxx.redis.service;
 
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.collection;
import java.util.list;
import java.util.map;
import java.util.set;
 
/**
 * redis 服务
 *
 * @author xm.z
 */
public interface redisservice {
 
	/**
	 * 获取所有符合指定表达式的 key
	 * @param pattern 表达式
	 * @return java.util.set
	 * @see <a href="http://redis.io/commands/keys" rel="external nofollow"  rel="external nofollow" >keys command</a>
	 */
	set<string> keys(string pattern);
 
	/**
	 * 保存属性
	 * @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);
 
	/**
	 * 从指定的 keys 批量获取属性
	 * @param keys keys
	 * @return values list，当值为空时，该 key 对应的 value 为 null
	 * @see <a href="http://redis.io/commands/mget" rel="external nofollow"  rel="external nofollow" >mget command</a>
	 */
	list<object> mget(collection<string> keys);
 
	/**
	 * 批量获取 keys 的属性，并返回一个 map
	 * @param keys keys
	 * @return map，key 和 value 的键值对集合，当 value 获取为 null 时，不存入此 map
	 */
	map<string, object> mgettomap(collection<string> keys);
 
	/**
	 * 删除属性
	 * @param key key值
	 * @return 返回成功
	 */
	boolean del(string key);
 
	/**
	 * 批量删除属性
	 * @param keys key值集合
	 * @return 返回删除数量
	 */
	long del(collection<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值
	 * @param timeout 过期时间（单位：秒）
	 * @return 返回递增后结果
	 */
	long incrandexpire(string key, long delta, long timeout);
 
	/**
	 * 按delta递减
	 * @param key key值
	 * @param delta delta值
	 * @return 返回递减后结果
	 */
	long decr(string key, long delta);
 
	/**
	 * 按delta递减并设置过期时间
	 * @param key key值
	 * @param delta delta值
	 * @param timeout 过期时间（单位：秒）
	 * @return 返回递减后结果
	 */
	long decrandexpire(string key, long delta, long timeout);
 
	/**
	 * 获取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.xxx.redis.service.impl;
 
import lombok.requiredargsconstructor;
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 java.util.*;
import java.util.concurrent.timeunit;
 
import static com.xxx.redis.constant.redisconstants.decr_by_expire_lua_script;
import static com.xxx.redis.constant.redisconstants.incr_by_expire_lua_script;
 
/**
 * 默认 redis 服务实现
 *
 * @author xm.z
 */
@requiredargsconstructor
public class defaultredisserviceimpl extends abstractredisservice {
 
	private final redistemplate<string, object> redistemplate;
 
	/**
	 * 获取所有符合指定表达式的 key
	 * @param pattern 表达式
	 * @return java.util.set
	 * @see <a href="http://redis.io/commands/keys" rel="external nofollow"  rel="external nofollow" >keys command</a>
	 */
	@override
	public set<string> keys(string pattern) {
		return redistemplate.keys(pattern);
	}
 
	/**
	 * 保存属性
	 * @param key key值
	 * @param value value值
	 * @param time 时间戳
	 */
	@override
	public void set(string key, object value, long time) {
		valueops().set(key, value, time, timeunit.seconds);
	}
 
	/**
	 * 保存属性
	 * @param key key值
	 * @param value value值
	 */
	@override
	public void set(string key, object value) {
		valueops().set(key, value);
	}
 
	/**
	 * 获取属性
	 * @param key key值
	 * @return 返回对象
	 */
	@override
	public object get(string key) {
		return valueops().get(key);
	}
 
	/**
	 * 从指定的 keys 批量获取属性
	 * @param keys keys
	 * @return values list，当值为空时，该 key 对应的 value 为 null
	 * @see <a href="http://redis.io/commands/mget" rel="external nofollow"  rel="external nofollow" >mget command</a>
	 */
	@override
	public list<object> mget(collection<string> keys) {
		return valueops().multiget(keys);
	}
 
	/**
	 * 批量获取 keys 的属性，并返回一个 map
	 * @param keys keys
	 * @return map，key 和 value 的键值对集合，当 value 获取为 null 时，不存入此 map
	 */
	@override
	public map<string, object> mgettomap(collection<string> keys) {
		list<object> values = valueops().multiget(keys);
		map<string, object> map = new hashmap<>(keys.size());
		if (values == null || values.isempty()) {
			return map;
		}
 
		iterator<string> keysiterator = keys.iterator();
		iterator<object> valuesiterator = values.iterator();
		while (keysiterator.hasnext()) {
			string key = keysiterator.next();
			object value = valuesiterator.next();
			if (value != null) {
				map.put(key, value);
			}
		}
		return map;
	}
 
	/**
	 * 删除属性
	 * @param key key值
	 * @return 返回成功
	 */
	@override
	public boolean del(string key) {
		return redistemplate.delete(key);
	}
 
	/**
	 * 批量删除属性
	 * @param keys key值集合
	 * @return 返回删除数量
	 */
	@override
	public long del(collection<string> keys) {
		return redistemplate.delete(keys);
	}
 
	/**
	 * 设置过期时间
	 * @param key key值
	 * @param time 时间戳
	 * @return 返回成功
	 */
	@override
	public boolean expire(string key, long time) {
		return redistemplate.expire(key, time, timeunit.seconds);
	}
 
	/**
	 * 获取过期时间
	 * @param key key值
	 * @return 返回时间戳
	 */
	@override
	public long getexpire(string key) {
		return redistemplate.getexpire(key, timeunit.seconds);
	}
 
	/**
	 * 判断key是否存在
	 * @param key key值
	 * @return 返回
	 */
	@override
	public boolean haskey(string key) {
		return redistemplate.haskey(key);
	}
 
	/**
	 * 按delta递增
	 * @param key key值
	 * @param delta delta值
	 * @return 返回递增后结果
	 */
	@override
	public long incr(string key, long delta) {
		return valueops().increment(key, delta);
	}
 
	/**
	 * 按delta递增并设置过期时间
	 * @param key key值
	 * @param delta delta值
	 * @param timeout 过期时间（单位：秒）
	 * @return 返回递增后结果
	 */
	@override
	public long incrandexpire(string key, long delta, long timeout) {
		return redistemplate.execute(incr_by_expire_lua_script, collections.singletonlist(key), string.valueof(delta),
				string.valueof(timeout));
	}
 
	/**
	 * 按delta递减
	 * @param key key值
	 * @param delta delta值
	 * @return 返回递减后结果
	 */
	@override
	public long decr(string key, long delta) {
		return valueops().decrement(key, delta);
	}
 
	/**
	 * 按delta递减并设置过期时间
	 * @param key key值
	 * @param delta delta值
	 * @param timeout 过期时间（单位：秒）
	 * @return 返回递减后结果
	 */
	@override
	public long decrandexpire(string key, long delta, long timeout) {
		return redistemplate.execute(decr_by_expire_lua_script, collections.singletonlist(key), string.valueof(delta),
				string.valueof(timeout));
	}
 
	/**
	 * 获取hash结构中的属性
	 * @param key 外部key值
	 * @param hashkey 内部key值
	 * @return 返回内部key的value
	 */
	@override
	public object hget(string key, string hashkey) {
		return hashops().get(key, hashkey);
	}
 
	/**
	 * 向hash结构中放入一个属性
	 * @param key 外部key
	 * @param hashkey 内部key
	 * @param value 内部key的value
	 * @param time 过期时间
	 * @return 返回是否成功
	 */
	@override
	public boolean hset(string key, string hashkey, object value, long time) {
		hashops().put(key, hashkey, value);
		return expire(key, time);
	}
 
	/**
	 * 向hash结构中放入一个属性
	 * @param key 外部key
	 * @param hashkey 内部key
	 * @param value 内部key的value
	 */
	@override
	public void hset(string key, string hashkey, object value) {
		hashops().put(key, hashkey, value);
	}
 
	/**
	 * 直接获取整个hash结构
	 * @param key 外部key值
	 * @return 返回hashmap
	 */
	@override
	public map<object, object> hgetall(string key) {
		return hashops().entries(key);
	}
 
	/**
	 * 直接设置整个hash结构
	 * @param key 外部key
	 * @param map hashmap值
	 * @param time 过期时间
	 * @return 返回是否成功
	 */
	@override
	public boolean hsetall(string key, map<string, object> map, long time) {
		hashops().putall(key, map);
		return expire(key, time);
	}
 
	/**
	 * 直接设置整个hash结构
	 * @param key 外部key
	 * @param map hashmap值
	 */
	@override
	public void hsetall(string key, map<string, ?> map) {
		hashops().putall(key, map);
	}
 
	/**
	 * 删除hash结构中的属性
	 * @param key 外部key值
	 * @param hashkey 内部key值
	 */
	@override
	public void hdel(string key, object... hashkey) {
		hashops().delete(key, hashkey);
	}
 
	/**
	 * 判断hash结构中是否有该属性
	 * @param key 外部key
	 * @param hashkey 内部key
	 * @return 返回是否存在
	 */
	@override
	public boolean hhaskey(string key, string hashkey) {
		return hashops().haskey(key, hashkey);
	}
 
	/**
	 * hash结构中属性递增
	 * @param key 外部key
	 * @param hashkey 内部key
	 * @param delta 递增条件
	 * @return 返回递增后的数据
	 */
	@override
	public long hincr(string key, string hashkey, long delta) {
		return hashops().increment(key, hashkey, delta);
	}
 
	/**
	 * hash结构中属性递减
	 * @param key 外部key
	 * @param hashkey 内部key
	 * @param delta 递增条件
	 * @return 返回递减后的数据
	 */
	@override
	public long hdecr(string key, string hashkey, long delta) {
		return hashops().increment(key, hashkey, -delta);
	}
 
	/**
	 * 获取set结构
	 * @param key key
	 * @return 返回set集合
	 */
	@override
	public set<object> smembers(string key) {
		return setops().members(key);
	}
 
	/**
	 * 向set结构中添加属性
	 * @param key key
	 * @param values value集
	 * @return 返回增加数量
	 */
	@override
	public long sadd(string key, object... values) {
		return setops().add(key, values);
	}
 
	/**
	 * 向set结构中添加属性
	 * @param key key
	 * @param time 过期时间
	 * @param values 值集合
	 * @return 返回添加的数量
	 */
	@override
	public long sadd(string key, long time, object... values) {
		long count = setops().add(key, values);
		expire(key, time);
		return count;
	}
 
	/**
	 * 是否为set中的属性
	 * @param key key
	 * @param value value
	 * @return 返回是否存在
	 */
	@override
	public boolean sismember(string key, object value) {
		return setops().ismember(key, value);
	}
 
	/**
	 * 获取set结构的长度
	 * @param key key
	 * @return 返回长度
	 */
	@override
	public long ssize(string key) {
		return setops().size(key);
	}
 
	/**
	 * 删除set结构中的属性
	 * @param key key
	 * @param values value集合
	 * @return 删除掉的数据量
	 */
	@override
	public long sremove(string key, object... values) {
		return setops().remove(key, values);
	}
 
	/**
	 * 获取list结构中的属性
	 * @param key key
	 * @param start 开始
	 * @param end 结束
	 * @return 返回查询的集合
	 */
	@override
	public list<object> lrange(string key, long start, long end) {
		return listops().range(key, start, end);
	}
 
	/**
	 * 获取list结构的长度
	 * @param key key
	 * @return 长度
	 */
	@override
	public long lsize(string key) {
		return listops().size(key);
	}
 
	/**
	 * 根据索引获取list中的属性
	 * @param key key
	 * @param index 索引
	 * @return 对象
	 */
	@override
	public object lindex(string key, long index) {
		return listops().index(key, index);
	}
 
	/**
	 * 向list结构中添加属性
	 * @param key key
	 * @param value value
	 * @return 增加后的长度
	 */
	@override
	public long lpush(string key, object value) {
		return listops().rightpush(key, value);
	}
 
	/**
	 * 向list结构中添加属性
	 * @param key key
	 * @param value value
	 * @param time 过期时间
	 * @return 增加后的长度
	 */
	@override
	public long lpush(string key, object value, long time) {
		long index = listops().rightpush(key, value);
		expire(key, time);
		return index;
	}
 
	/**
	 * 向list结构中批量添加属性
	 * @param key key
	 * @param values value 集合
	 * @return 增加后的长度
	 */
	@override
	public long lpushall(string key, object... values) {
		return listops().rightpushall(key, values);
	}
 
	/**
	 * 向list结构中批量添加属性
	 * @param key key
	 * @param time 过期时间
	 * @param values value集合
	 * @return 增加后的长度
	 */
	@override
	public long lpushall(string key, long time, object... values) {
		long count = listops().rightpushall(key, values);
		expire(key, time);
		return count;
	}
 
	/**
	 * 从list结构中移除属性
	 * @param key key
	 * @param count 总量
	 * @param value value
	 * @return 返回删除后的长度
	 */
	@override
	public long lremove(string key, long count, object value) {
		return listops().remove(key, count, value);
	}
 
	/**
	 * 向bitmap中新增值
	 * @param key key
	 * @param offset 偏移量
	 * @param b 状态
	 * @return 结果
	 */
	@override
	public boolean bitadd(string key, int offset, boolean b) {
		return valueops().setbit(key, offset, b);
	}
 
	/**
	 * 从bitmap中获取偏移量的值
	 * @param key key
	 * @param offset 偏移量
	 * @return 结果
	 */
	@override
	public boolean bitget(string key, int offset) {
		return valueops().getbit(key, offset);
	}
 
	/**
	 * 获取bitmap的key值总和
	 * @param key key
	 * @return 总和
	 */
	@override
	public long bitcount(string key) {
		return redistemplate.execute((rediscallback<long>) con -> con.bitcount(key.getbytes()));
	}
 
	/**
	 * 获取bitmap范围值
	 * @param key key
	 * @param limit 范围
	 * @param offset 开始偏移量
	 * @return long类型集合
	 */
	@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)));
	}
 
	/**
	 * 获取所有bitmap
	 * @param key key
	 * @return 以二进制字节数组返回
	 */
	@override
	public byte[] bitgetall(string key) {
		return redistemplate.execute((rediscallback<byte[]>) con -> con.get(key.getbytes()));
	}
 
	/**
	 * 增加坐标
	 * @param key key
	 * @param x x
	 * @param y y
	 * @param name 地点名称
	 * @return 返回结果
	 */
	@override
	public long geoadd(string key, double x, double y, string name) {
		return geoops().add(key, new point(x, y), name);
	}
 
	/**
	 * 根据城市名称获取坐标集合
	 * @param key key
	 * @param place 地点
	 * @return 坐标集合
	 */
	@override
	public list<point> geogetpointlist(string key, object... place) {
		return geoops().position(key, place);
	}
 
	/**
	 * 计算两个城市之间的距离
	 * @param key key
	 * @param placeone 地点1
	 * @param placetow 地点2
	 * @return 返回距离
	 */
	@override
	public distance geocalculationdistance(string key, string placeone, string placetow) {
		return geoops().distance(key, placeone, placetow, redisgeocommands.distanceunit.kilometers);
	}
 
	/**
	 * 获取附该地点附近的其他地点
	 * @param key key
	 * @param place 地点
	 * @param distance 附近的范围
	 * @param limit 查几条
	 * @param sort 排序规则
	 * @return 返回附近的地点集合
	 */
	@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 geoops().radius(key, place, distance, args);
	}
 
	/**
	 * 获取地点的hash
	 * @param key key
	 * @param place 地点
	 * @return 返回集合
	 */
	@override
	public list<string> geogethash(string key, string... place) {
		return geoops().hash(key, place);
	}
 
	/**
	 * get helper class that simplifies redis data access code.
	 * @return redistemplate 获取
	 */
	@override
	protected redistemplate<string, object> gettemplate() {
		return redistemplate;
	}
 
}