大家好，我是中恒。工作中我们经常使用到自定义的开发工具类，本文就列举几个中恒在实际工作中常用的几个工具类，供弟兄们参考。如果本文对您有帮助，欢迎关注、点赞或分享您在工作中经常使用到的工具类。
日期处理
public class dateutils {
// 日志
private static final logger logger = logger.getlogger(dateutils.class);
/**
* 时间格式(yyyy-mm-dd)
*/
public final static string date_pattern = "yyyy-mm-dd";
/**
* 无分隔符日期格式 "yyyymmddhhmmsssss"
*/
public static string date_time_pattern_yyyy_mm_dd_hh_mm_ss_sss = "yyyymmddhhmmsssss";
/**
* 时间格式(yyyy-mm-dd hh:mm:ss)
*/
public final static string date_time_pattern = "yyyy-mm-dd hh:mm:ss";
private static string[] parsepatterns = {"yyyy-mm-dd", "yyyy-mm-dd hh:mm:ss", "yyyy-mm-dd hh:mm", "yyyy-mm", "yyyy/mm/dd", "yyyy/mm/dd hh:mm:ss", "yyyy/mm/dd hh:mm", "yyyy" +
"/mm", "yyyy.mm.dd", "yyyy.mm.dd hh:mm:ss", "yyyy.mm.dd hh:mm", "yyyy.mm"};
// 日期转换格式数组
public static string[][] regularexp = new string[][]{
// 默认格式
{"\\d{4}-((([0][1,3-9]|[1][0-2]|[1-9])-([0-2]\\d|[3][0,1]|[1-9]))|((02|2)-(([1-9])|[0-2]\\d)))\\s+([0,1]\\d|[2][0-3]|\\d):([0-5]\\d|\\d):([0-5]\\d|\\d)",
date_time_pattern},
// 仅日期格式 年月日
{"\\d{4}-((([0][1,3-9]|[1][0-2]|[1-9])-([0-2]\\d|[3][0,1]|[1-9]))|((02|2)-(([1-9])|[0-2]\\d)))", date_pattern},
// 带毫秒格式
{"\\d{4}((([0][1,3-9]|[1][0-2]|[1-9])([0-2]\\d|[3][0,1]|[1-9]))|((02|2)(([1-9])|[0-2]\\d)))([0,1]\\d|[2][0-3])([0-5]\\d|\\d)([0-5]\\d|\\d)\\d{1,3}",
date_time_pattern_yyyy_mm_dd_hh_mm_ss_sss}};
public static string format(date date) {
return format(date, date_pattern);
}
public static string format(date date, string pattern) {
if (date != null) {
simpledateformat df = new simpledateformat(pattern);
return df.format(date);
}
return null;
}
public static string timetostr(long time, string pattern) {
simpledateformat dateformat = new simpledateformat(pattern);
if (time.tostring().length() < 13) {
time = time * 1000l;
}
date date = new date(time);
string value = dateformat.format(date);
return value;
}
public static long strtotime(string timestr) {
date time = strtodate(timestr);
return time.gettime() / 1000;
}
/**
* 转换为时间类型格式
* @param strdate 日期
* @return
*/
public static date strtodate(string strdate) {
try {
string strtype = getdateformat(strdate);
simpledateformat sf = new simpledateformat(strtype);
return new date((sf.parse(strdate).gettime()));
} catch (exception e) {
return null;
}
}
/**
* 根据传入的日期格式字符串，获取日期的格式
* @return 秒
*/
public static string getdateformat(string date_str) {
string style = null;
if (stringutils.isempty(date_str)) {
return null;
}
boolean b = false;
for (int i = 0; i < regularexp.length; i++) {
b = date_str.matches(regularexp[i][0]);
if (b) {
style = regularexp[i][1];
}
}
if (stringutils.isempty(style)) {
logger.info("date_str:" + date_str);
logger.info("日期格式获取出错，未识别的日期格式");
}
return style;
}
/**
* 将字符串类型的转换成date类型
* @param datestr 字符串类型的日期 yyyy-mm-dd
* @return date类型的日期
* @throws parseexception
*/
public static date convertstringtodate(string datestr) {
// 返回的日期
date resultdate = null;
try {
// 日期格式转换
simpledateformat sdf = new simpledateformat("yyyy-mm-dd");
resultdate = sdf.parse(datestr);
} catch (parseexception e) {
e.printstacktrace();
}
return resultdate;
}
/**
* 日期型字符串转化为日期 格式
*/
public static date parsedate(object str) {
if (str == null) {
return null;
}
try {
return org.apache.commons.lang3.time.dateutils.parsedate(str.tostring(), parsepatterns);
} catch (parseexception e) {
return null;
}
}
}base64加密和解密
public class base64utils {
/**
* 加密
* @param str
* @return
*/
public static string encode(string str) {
base64.encoder encoder = base64.getencoder();
byte[] b = str.getbytes(standardcharsets.utf_8);
return encoder.encodetostring(b);
}
/**
* 解密
* @param s
* @return
*/
public static string decode(string s) {
base64.decoder decoder = base64.getdecoder();
return new string(decoder.decode(s), standardcharsets.utf_8);
}
}bean工具类
public class beanutils extends org.springframework.beans.beanutils {
/**
* 默认忽略字段<br>
*/
private static string[] ignore_properties = {"createuser", "createtime"};
/**
* 重写copyproperties，null值,可以拷贝
* @param source 拷贝元实体
* @param target 拷贝目标实体
* @throws beansexception 抛出异常
*/
public static void copyproperties(object source, object target, string[] ignorelist) throws beansexception {
assert.notnull(source, "source must not be null");
assert.notnull(target, "target must not be null");
list<string> ignorepropertylist = new arraylist<string>();
ignorepropertylist.addall(arrays.aslist(ignore_properties));
// 传入的忽略数组非空扩展忽略数组
if (ignorelist != null && ignorelist.length != 0) {
ignorepropertylist.addall(arrays.aslist(ignorelist));
}
class<?> actualeditable = target.getclass();
propertydescriptor[] targetpds = getpropertydescriptors(actualeditable);
for (propertydescriptor targetpd : targetpds) {
if (targetpd.getwritemethod() != null) {
propertydescriptor sourcepd = getpropertydescriptor(source.getclass(), targetpd.getname());
if (sourcepd != null && sourcepd.getreadmethod() != null && !ignorepropertylist.contains(targetpd.getname())) {
try {
method readmethod = sourcepd.getreadmethod();
if (!modifier.ispublic(readmethod.getdeclaringclass().getmodifiers())) {
readmethod.setaccessible(true);
}
object value = readmethod.invoke(source);
// 这里判断value是否为空,过滤integer类型字段 当然这里也能进行一些特殊要求的处理 例如绑定时格式转换等等
// if (value != null &&
// !"java.lang.integer".equals(readmethod.getreturntype().getname())) {
// if (value != null && !"".equals(value)) {
method writemethod = targetpd.getwritemethod();
if (!modifier.ispublic(writemethod.getdeclaringclass().getmodifiers())) {
writemethod.setaccessible(true);
}
writemethod.invoke(target, value);
// }
} catch (throwable ex) {
throw new fatalbeanexception("could not copy properties '" + targetpd.getname() + "' from source to target", ex);
}
}
}
}
}
/**
* 重写copyproperties，忽略null值
* @param source
* @param target
* @throws beansexception
*/
public static void copyproperties(object source, object target) throws beansexception {
assert.notnull(source, "source must not be null");
assert.notnull(target, "target must not be null");
class<?> actualeditable = target.getclass();
propertydescriptor[] targetpds = getpropertydescriptors(actualeditable);
for (propertydescriptor targetpd : targetpds) {
if (targetpd.getwritemethod() != null) {
propertydescriptor sourcepd = getpropertydescriptor(source.getclass(), targetpd.getname());
if (sourcepd != null && sourcepd.getreadmethod() != null) {
try {
method readmethod = sourcepd.getreadmethod();
if (!modifier.ispublic(readmethod.getdeclaringclass().getmodifiers())) {
readmethod.setaccessible(true);
}
object value = readmethod.invoke(source);
// 这里判断value是否为空,过滤integer类型字段 当然这里也能进行一些特殊要求的处理 例如绑定时格式转换等等
// if (value != null && !"java.lang.integer".equals(readmethod.getreturntype().getname())) {
if (value != null && !"".equals(value)) {
method writemethod = targetpd.getwritemethod();
if (!modifier.ispublic(writemethod.getdeclaringclass().getmodifiers())) {
writemethod.setaccessible(true);
}
writemethod.invoke(target, value);
}
} catch (throwable ex) {
throw new fatalbeanexception("could not copy properties '" + targetpd.getname() + "' from source to target", ex);
}
}
}
}
}
/**
* bean 转为map
* @param obj bean对象
* @param isallownull 空字段是否转换 false 不转换
* @return map值
*/
public static map<string, object> bean2map(object obj, boolean isallownull) {
if (obj == null) {
return null;
}
map<string, object> map = new hashmap<string, object>();
try {
beaninfo beaninfo = introspector.getbeaninfo(obj.getclass());
propertydescriptor[] propertydescriptors = beaninfo.getpropertydescriptors();
for (propertydescriptor property : propertydescriptors) {
string key = property.getname();
// 过滤class属性
if (!key.equals("class")) {
// 得到property对应的getter方法
method getter = property.getreadmethod();
object value = getter.invoke(obj);
if (isallownull || value != null && !value.tostring().isempty()) {
map.put(key, value);
}
}
}
} catch (exception e) {
system.out.println("transbean2map error " + e);
}
return map;
}
/**
* map转bean
* @param targetmap 被转化的map
* @param obj 对象
*/
public static void map2bean(map<string, object> targetmap, object obj) {
map<string, object> map = new hashmap<string, object>();
for (string key : targetmap.keyset()) {
object value = targetmap.get(key);
map.put(stringutils.linetohump(key), value);
}
try {
beaninfo beaninfo = introspector.getbeaninfo(obj.getclass());
propertydescriptor[] propertydescriptors = beaninfo.getpropertydescriptors();
for (propertydescriptor property : propertydescriptors) {
string key = property.getname();
if (map.containskey(key)) {
try {
object value = map.get(key);
// 得到property对应的setter方法
method setter = property.getwritemethod();
setter.invoke(obj, value);
} catch (exception e) {
throw new runtimeexception("实体转换错误:" + key);
}
}
}
} catch (exception e) {
e.getstacktrace();
throw new runtimeexception("数据转换异常！");
}
}
}cookie处理工具类
public class cookieutils {
/**
* 得到cookie的值, 不编码
* @param request
* @param cookiename
* @return
*/
public static string getcookievalue(httpservletrequest request, string cookiename) {
return getcookievalue(request, cookiename, false);
}
/**
* 得到cookie的值,
* @param request
* @param cookiename
* @return
*/
public static string getcookievalue(httpservletrequest request, string cookiename, boolean isdecoder) {
cookie[] cookielist = request.getcookies();
if (cookielist == null || cookiename == null) {
return null;
}
string retvalue = null;
try {
for (int i = 0; i < cookielist.length; i++) {
if (cookielist[i].getname().equals(cookiename)) {
if (isdecoder) {
retvalue = urldecoder.decode(cookielist[i].getvalue(), "utf-8");
} else {
retvalue = cookielist[i].getvalue();
}
break;
}
}
} catch (unsupportedencodingexception e) {
e.printstacktrace();
}
return retvalue;
}
/**
* 得到cookie的值,
* @param request
* @param cookiename
* @return
*/
public static string getcookievalue(httpservletrequest request, string cookiename, string encodestring) {
cookie[] cookielist = request.getcookies();
if (cookielist == null || cookiename == null) {
return null;
}
string retvalue = null;
try {
for (int i = 0; i < cookielist.length; i++) {
if (cookielist[i].getname().equals(cookiename)) {
retvalue = urldecoder.decode(cookielist[i].getvalue(), encodestring);
break;
}
}
} catch (unsupportedencodingexception e) {
e.printstacktrace();
}
return retvalue;
}
/**
* 设置cookie的值 不设置生效时间默认浏览器关闭即失效,也不编码
*/
public static void setcookie(httpservletrequest request, httpservletresponse response, string cookiename, string cookievalue) {
setcookie(request, response, cookiename, cookievalue, -1);
}
/**
* 设置cookie的值 在指定时间内生效,但不编码
*/
public static void setcookie(httpservletrequest request, httpservletresponse response, string cookiename, string cookievalue, int cookiemaxage) {
setcookie(request, response, cookiename, cookievalue, cookiemaxage, false);
}
/**
* 设置cookie的值 不设置生效时间,但编码
*/
public static void setcookie(httpservletrequest request, httpservletresponse response, string cookiename, string cookievalue, boolean isencode) {
setcookie(request, response, cookiename, cookievalue, -1, isencode);
}
/**
* 设置cookie的值 在指定时间内生效, 编码参数
*/
public static void setcookie(httpservletrequest request, httpservletresponse response, string cookiename, string cookievalue, int cookiemaxage, boolean isencode) {
dosetcookie(request, response, cookiename, cookievalue, cookiemaxage, isencode);
}
/**
* 设置cookie的值 在指定时间内生效, 编码参数(指定编码)
*/
public static void setcookie(httpservletrequest request, httpservletresponse response, string cookiename, string cookievalue, int cookiemaxage, string encodestring) {
dosetcookie(request, response, cookiename, cookievalue, cookiemaxage, encodestring);
}
/**
* 删除cookie带cookie域名
*/
public static void deletecookie(httpservletrequest request, httpservletresponse response, string cookiename) {
dosetcookie(request, response, cookiename, "", -1, false);
}
/**
* 设置cookie的值，并使其在指定时间内生效
* @param cookiemaxage cookie生效的最大秒数
*/
public static final void dosetcookie(httpservletrequest request, httpservletresponse response, string cookiename, string cookievalue, int cookiemaxage, boolean isencode) {
try {
if (cookievalue == null) {
cookievalue = "";
} else if (isencode) {
cookievalue = urlencoder.encode(cookievalue, "utf-8");
}
cookie cookie = new cookie(cookiename, cookievalue);
if (cookiemaxage > 0) {
cookie.setmaxage(cookiemaxage);
}
string domainname = getdomainname(request);
cookie.setdomain(domainname);
cookie.setpath("/");
response.addcookie(cookie);
} catch (exception e) {
e.printstacktrace();
}
}
/**
* 设置cookie的值，并使其在指定时间内生效
* @param cookiemaxage cookie生效的最大秒数
*/
public static final void dosetcookie(httpservletrequest request, httpservletresponse response, string cookiename, string cookievalue, int cookiemaxage, string encodestring) {
try {
if (cookievalue == null) {
cookievalue = "";
} else {
cookievalue = urlencoder.encode(cookievalue, encodestring);
}
cookie cookie = new cookie(cookiename, cookievalue);
if (cookiemaxage > 0) {
cookie.setmaxage(cookiemaxage);
}
if (null != request) {// 设置域名的cookie
string domainname = getdomainname(request);
cookie.setdomain(domainname);
}
cookie.setpath("/");
response.addcookie(cookie);
} catch (exception e) {
e.printstacktrace();
}
}
/**
* 得到cookie的域名
*/
private static final string getdomainname(httpservletrequest request) {
string domainname = null;
string servername = request.getrequesturl().tostring();
if (servername == null || servername.equals("")) {
domainname = "";
} else {
servername = servername.tolowercase();
servername = servername.substring(7);
final int end = servername.indexof("/");
servername = servername.substring(0, end);
final string[] domains = servername.split("\\.");
int len = domains.length;
if (len > 3) {
// www.xxx.com.cn
domainname = "." + domains[len - 3] + "." + domains[len - 2] + "." + domains[len - 1];
} else if (len <= 3 && len > 1) {
// xxx.com or xxx.cn
domainname = "." + domains[len - 2] + "." + domains[len - 1];
} else {
domainname = servername;
}
}
if (domainname != null && domainname.indexof(":") > 0) {
string[] ary = domainname.split("\\:");
domainname = ary[0];
}
return domainname;
}
}id 生成工具类
public class idutils {
/**
* 主要功能:生成流水号 yyyymmddhhmmsssss + 3位随机数
* 注意事项:无
* @return 流水号
*/
public static string createidbydate() {
// 精确到毫秒
simpledateformat fmt = new simpledateformat("(yyyymmddhhmmsssss)");
string suffix = fmt.format(new date());
suffix = suffix + "-" + math.round((math.random() * 100000));
return suffix;
}
/**
* 主要功能:生成uuid
* 注意事项:无
* @return uuid 32 位
*/
public static string createidbyuuid() {
return uuid.randomuuid().tostring().replaceall("-", "");
}
/**
* 获取随机uuid
* @return 随机uuid
*/
public static string randomuuid() {
return uuid.randomuuid().tostring();
}
/**
* 简化的uuid，去掉了横线
* @return 简化的uuid，去掉了横线
*/
public static string simpleuuid() {
return uuid.randomuuid().tostring(true);
}
/**
* 获取随机uuid，使用性能更好的threadlocalrandom生成uuid
* @return 随机uuid
*/
public static string fastuuid() {
return uuid.fastuuid().tostring();
}
/**
* 简化的uuid，去掉了横线，使用性能更好的threadlocalrandom生成uuid
* @return 简化的uuid，去掉了横线
*/
public static string fastsimpleuuid() {
return uuid.fastuuid().tostring(true);
}
}redis工具类
@component
public class redisutils {
private logger log = loggerfactory.getlogger(this.getclass());
/**
* 默认编码
*/
private static final charset default_charset = standardcharsets.utf_8;
/**
* key序列化
*/
private static final stringredisserializer string_serializer = new stringredisserializer();
/**
* value 序列化
*/
private static final jdkserializationredisserializer object_serializer = new jdkserializationredisserializer();
/**
* spring redis template
*/
private redistemplate<string, object> redistemplate;
/**
* spring自动调用注入redistemplate
*/
public redisutils(redistemplate<string, object> redistemplate) {
this.redistemplate = redistemplate;
//设置序列化器
this.redistemplate.setkeyserializer(string_serializer);
this.redistemplate.setvalueserializer(object_serializer);
this.redistemplate.sethashkeyserializer(string_serializer);
this.redistemplate.sethashvalueserializer(object_serializer);
}
/**
* 获取链接工厂
*/
public redisconnectionfactory getconnectionfactory() {
return this.redistemplate.getconnectionfactory();
}
/**
* 获取 redistemplate对象
*/
public redistemplate<string, object> getredistemplate() {
return redistemplate;
}
/**
* 清空db
* @param node redis 节点
*/
public void flushdb(redisclusternode node) {
this.redistemplate.opsforcluster().flushdb(node);
}
/**
* 添加到带有 过期时间的 缓存
* @param key redis主键
* @param value 值
* @param time 过期时间(单位秒)
*/
public void setexpire(final byte[] key, final byte[] value, final long time) {
redistemplate.execute((rediscallback<long>) connection -> {
connection.setex(key, time, value);
log.debug("[redistemplate redis]放入 缓存 url:{} ========缓存时间为{}秒", key, time);
return 1l;
});
}
/**
* 添加到带有 过期时间的 缓存
* @param key redis主键
* @param value 值
* @param time 过期时间(单位秒)
*/
public void setexpire(final string key, final object value, final long time) {
redistemplate.execute((rediscallback<long>) connection -> {
redisserializer<string> serializer = getredisserializer();
byte[] keys = serializer.serialize(key);
byte[] values = object_serializer.serialize(value);
connection.setex(keys, time, values);
return 1l;
});
}
/**
* 一次性添加数组到 过期时间的 缓存，不用多次连接，节省开销
* @param keys redis主键数组
* @param values 值数组
* @param time 过期时间(单位秒)
*/
public void setexpire(final string[] keys, final object[] values, final long time) {
redistemplate.execute((rediscallback<long>) connection -> {
redisserializer<string> serializer = getredisserializer();
for (int i = 0; i < keys.length; i++) {
byte[] bkeys = serializer.serialize(keys[i]);
byte[] bvalues = object_serializer.serialize(values[i]);
connection.setex(bkeys, time, bvalues);
}
return 1l;
});
}
/**
* 一次性添加数组到 过期时间的 缓存，不用多次连接，节省开销
* @param keys the keys
* @param values the values
*/
public void set(final string[] keys, final object[] values) {
redistemplate.execute((rediscallback<long>) connection -> {
redisserializer<string> serializer = getredisserializer();
for (int i = 0; i < keys.length; i++) {
byte[] bkeys = serializer.serialize(keys[i]);
byte[] bvalues = object_serializer.serialize(values[i]);
connection.set(bkeys, bvalues);
}
return 1l;
});
}
/**
* 添加到缓存
*
* @param key the key
* @param value the value
*/
public void set(final string key, final object value) {
redistemplate.execute((rediscallback<long>) connection -> {
redisserializer<string> serializer = getredisserializer();
byte[] keys = serializer.serialize(key);
byte[] values = object_serializer.serialize(value);
connection.set(keys, values);
log.debug("[redistemplate redis]放入 缓存 url:{}", key);
return 1l;
});
}
/**
* 查询在这个时间段内即将过期的key
* @param key the key
* @param time the time
* @return the list
*/
public list<string> willexpire(final string key, final long time) {
final list<string> keyslist = new arraylist<>();
redistemplate.execute((rediscallback<list<string>>) connection -> {
set<string> keys = redistemplate.keys(key + "*");
for (string key1 : keys) {
long ttl = connection.ttl(key1.getbytes(default_charset));
if (0 <= ttl && ttl <= 2 * time) {
keyslist.add(key1);
}
}
return keyslist;
});
return keyslist;
}
/**
* 查询在以keypatten的所有 key
*
* @param keypatten the key patten
* @return the set
*/
public set<string> keys(final string keypatten) {
return redistemplate.execute((rediscallback<set<string>>) connection -> redistemplate.keys(keypatten + "*"));
}
/**
* 根据key获取对象
*
* @param key the key
* @return the byte [ ]
*/
public byte[] get(final byte[] key) {
byte[] result = redistemplate.execute((rediscallback<byte[]>) connection -> connection.get(key));
log.debug("[redistemplate redis]取出 缓存 url:{} ", key);
return result;
}
/**
* 根据key获取对象
*
* @param key the key
* @return the string
*/
public object get(final string key) {
object resultstr = redistemplate.execute((rediscallback<object>) connection -> {
redisserializer<string> serializer = getredisserializer();
byte[] keys = serializer.serialize(key);
byte[] values = connection.get(keys);
return object_serializer.deserialize(values);
});
log.debug("[redistemplate redis]取出 缓存 url:{} ", key);
return resultstr;
}
/**
* 根据key获取对象
* @param keypatten the key patten
* @return the keys values
*/
public map<string, object> getkeysvalues(final string keypatten) {
log.debug("[redistemplate redis] getvalues() patten={} ", keypatten);
return redistemplate.execute((rediscallback<map<string, object>>) connection -> {
redisserializer<string> serializer = getredisserializer();
map<string, object> maps = new hashmap<>(16);
set<string> keys = redistemplate.keys(keypatten + "*");
if (collectionutils.isnotempty(keys)) {
for (string key : keys) {
byte[] bkeys = serializer.serialize(key);
byte[] bvalues = connection.get(bkeys);
object value = object_serializer.deserialize(bvalues);
maps.put(key, value);
}
}
return maps;
});
}
/**
* ops for hash hash operations.
*
* @return the hash operations
*/
public hashoperations<string, string, object> opsforhash() {
return redistemplate.opsforhash();
}
/**
* 对hashmap操作
*
* @param key the key
* @param hashkey the hash key
* @param hashvalue the hash value
*/
public void puthashvalue(string key, string hashkey, object hashvalue) {
//log.debug("[redistemplate redis] puthashvalue() key={},hashkey={},hashvalue={} ", key, hashkey, hashvalue);
opsforhash().put(key, hashkey, hashvalue);
}
/**
* 获取单个field对应的值
*
* @param key the key
* @param hashkey the hash key
* @return the hash values
*/
public object gethashvalues(string key, string hashkey) {
log.debug("[redistemplate redis] gethashvalues() key={},hashkey={}", key, hashkey);
return opsforhash().get(key, hashkey);
}
/**
* 根据key值删除
*
* @param key the key
* @param hashkeys the hash keys
*/
public void delhashvalues(string key, object... hashkeys) {
log.debug("[redistemplate redis] delhashvalues() key={}", key);
opsforhash().delete(key, hashkeys);
}
/**
* key只匹配map
*
* @param key the key
* @return the hash value
*/
public map<string, object> gethashvalue(string key) {
log.debug("[redistemplate redis] gethashvalue() key={}", key);
return opsforhash().entries(key);
}
/**
* 批量添加
*
* @param key the key
* @param map the map
*/
public void puthashvalues(string key, map<string, object> map) {
opsforhash().putall(key, map);
}
/**
* 集合数量
*
* @return the long
*/
public long dbsize() {
return redistemplate.execute(redisservercommands::dbsize);
}
/**
* 清空redis存储的数据
*
* @return the string
*/
public string flushdb() {
return redistemplate.execute((rediscallback<string>) connection -> {
connection.flushdb();
return "ok";
});
}
/**
* 判断某个主键是否存在
*
* @param key the key
* @return the boolean
*/
public boolean exists(final string key) {
return redistemplate.execute((rediscallback<boolean>) connection -> connection.exists(key.getbytes(default_charset)));
}
/**
* 删除key
*
* @param keys the keys
* @return the long
*/
public long del(final string... keys) {
return redistemplate.execute((rediscallback<long>) connection -> {
long result = 0;
for (string key : keys) {
result = connection.del(key.getbytes(default_charset));
}
return result;
});
}
/**
* 获取 redisserializer
*
* @return the redis serializer
*/
protected redisserializer<string> getredisserializer() {
return redistemplate.getstringserializer();
}
/**
* 对某个主键对应的值加一,value值必须是全数字的字符串
*
* @param key the key
* @return the long
*/
public long incr(final string key) {
return redistemplate.execute((rediscallback<long>) connection -> {
redisserializer<string> redisserializer = getredisserializer();
return connection.incr(redisserializer.serialize(key));
});
}
/**
* redis list 引擎
*
* @return the list operations
*/
public listoperations<string, object> opsforlist() {
return redistemplate.opsforlist();
}
/**
* redis list数据结构 : 将一个或多个值 value 插入到列表 key 的表头
*
* @param key the key
* @param value the value
* @return the long
*/
public long leftpush(string key, object value) {
return opsforlist().leftpush(key, value);
}
/**
* redis list数据结构 : 移除并返回列表 key 的头元素
*
* @param key the key
* @return the string
*/
public object leftpop(string key) {
return opsforlist().leftpop(key);
}
/**
* redis list数据结构 :将一个或多个值 value 插入到列表 key 的表尾(最右边)。
*
* @param key the key
* @param value the value
* @return the long
*/
public long in(string key, object value) {
return opsforlist().rightpush(key, value);
}
/**
* redis list数据结构 : 移除并返回列表 key 的末尾元素
*
* @param key the key
* @return the string
*/
public object rightpop(string key) {
return opsforlist().rightpop(key);
}
/**
* redis list数据结构 : 返回列表 key 的长度 ; 如果 key 不存在，则 key 被解释为一个空列表，返回 0 ; 如果 key 不是列表类型，返回一个错误。
*
* @param key the key
* @return the long
*/
public long length(string key) {
return opsforlist().size(key);
}
/**
* redis list数据结构 : 根据参数 i 的值，移除列表中与参数 value 相等的元素
*
* @param key the key
* @param i the
* @param value the value
*/
public void remove(string key, long i, object value) {
opsforlist().remove(key, i, value);
}
/**
* redis list数据结构 : 将列表 key 下标为 index 的元素的值设置为 value
*
* @param key the key
* @param index the index
* @param value the value
*/
public void set(string key, long index, object value) {
opsforlist().set(key, index, value);
}
/**
* redis list数据结构 : 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 end 指定。
*
* @param key the key
* @param start the start
* @param end the end
* @return the list
*/
public list<object> getlist(string key, int start, int end) {
return opsforlist().range(key, start, end);
}
/**
* redis list数据结构 : 批量存储
*
* @param key the key
* @param list the list
* @return the long
*/
public long leftpushall(string key, list<string> list) {
return opsforlist().leftpushall(key, list);
}
/**
* redis list数据结构 : 将值 value 插入到列表 key 当中，位于值 index 之前或之后,默认之后。
*
* @param key the key
* @param index the index
* @param value the value
*/
public void insert(string key, long index, object value) {
opsforlist().set(key, index, value);
}
}如果您在实际工作中有比较实用的工具类，欢迎分享一下，一起学习提高！
