package com.gcyh.core.base.cache.redis;
import com.gcyh.core.base.log.Log;
import com.gcyh.core.base.log.LogFactory;
import com.gcyh.core.base.utils.CloseableUtils;
import com.gcyh.core.base.utils.MapUtils;
import com.gcyh.core.base.utils.SerializeUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import redis.clients.jedis.*;
import java.util.*;
/**
* jedis工具类
*
*/
public abstract class JedisUtils {
private static Log log = LogFactory.getLog(JedisUtils.class);
private static JedisPool pool;
private static JedisPoolConfig config;
private static JedisShardInfo shardInfo;
static {
// 初始化池配置
config = new JedisPoolConfig();
config.setMaxTotal(JedisFileConfig.getIntValue("max.total"));
config.setMaxIdle(JedisFileConfig.getIntValue("max.idle"));
config.setMinIdle(JedisFileConfig.getIntValue("min.idle"));
config.setMaxWaitMillis(JedisFileConfig.getIntValue("max.wait.millis"));
config.setTestOnBorrow(JedisFileConfig.getBooleanValue("test.on.borrow"));
config.setBlockWhenExhausted(JedisFileConfig.getBooleanValue("block.when.exhausted"));
// 初始化jedis池
String host = JedisFileConfig.getValue("host");
int port = JedisFileConfig.getIntValue("port");
int timeout = JedisFileConfig.getIntValue("connection.timeout");
String password = JedisFileConfig.getValue("password");
if (StringUtils.isNotBlank(password)) {
pool = new JedisPool(config, host, port, timeout, password);
}
else {
pool = new JedisPool(config, host, port, timeout);
}
// 初始化分片信息
shardInfo = new JedisShardInfo(host, port);
shardInfo.setConnectionTimeout(timeout);
if (StringUtils.isNotBlank(password)) {
shardInfo.setPassword(password);
}
shardInfo.setSoTimeout(timeout);
}
/**
* 获取指定键的值
*
* @param key 键
* @return 键值
*/
public static String get(String key) {
if (StringUtils.isBlank(key)) {
return null;
}
return doExecute(jedis -> jedis.get(key));
}
/**
* 获取指定键的值
*
* @param key 键
* @return 值
*/
@SuppressWarnings("unchecked")
public static <T> T get(byte[] key) {
return doExecute(jedis -> {
byte[] data = jedis.get(key);
return (T) SerializeUtils.unserialize(data);
});
}
/**
* 获取指定键的值
*
* @param key 键
* @return 值集合
*/
public static List<String> lrange(String key) {
return lrange(key, 0, -1);
}
/**
* 获取指定键的值
*
* @param key 键
* @param start 开始索引
* @param end 结束索引
* @return 值集合
*/
public static List<String> lrange(String key, long start, long end) {
if (StringUtils.isBlank(key)) {
return null;
}
return doExecute(jedis -> jedis.lrange(key, start, end));
}
/**
* 获取指定键的值
*
* @param key 键
* @return 值集合
*/
public static Set<String> smembers(String key) {
if (StringUtils.isBlank(key)) {
return null;
}
return doExecute(jedis -> jedis.smembers(key));
}
/**
* 获取指定键的值
*
* @param key 键
* @return 值集合
*/
public static List<String> srandmember(String key, int count) {
return doExecute(jedis -> jedis.srandmember(key, count));
}
/**
* 获取指定键的值
*
* @param key 键
* @return 有序值集合
*/
public static Set<String> zrange(String key) {
return zrange(key, 0, -1);
}
/**
* 获取指定键的值
*
* @param key 键
* @param start 开始索引
* @param end 结束索引
* @return 有序值集合
*/
public static Set<String> zrange(String key, long start, long end) {
if (StringUtils.isBlank(key)) {
return null;
}
return doExecute(jedis -> jedis.zrange(key, start, end));
}
/**
* 合并多个有序集的值到目标键
*
* @param destKey 目标键
* @param params 合并时的参数
* @param sourceKey 源键
* @return 目标键中值的数量
*/
public static Long zinterstore(String destKey, ZParams params, String... sourceKey) {
if (StringUtils.isBlank(destKey)) {
return null;
}
return doExecute(jedis -> jedis.zinterstore(destKey, params, sourceKey));
}
/**
* 获取有序集合中元素的倒序
*
* @param key 键
* @param member 元素
* @return 倒序
*/
public static Long zrevrank(String key, String member) {
if (StringUtils.isBlank(key) || StringUtils.isBlank(member)) {
return null;
}
return doExecute(jedis -> {
Long result = jedis.zrevrank(key, member);
return result != null ? result + 1 : null;
});
}
/**
* 按分数倒序获取缓存中的值
*
* @param key 键
* @return 缓存中的值
*/
public static Set<SortedSetElement> zrevrangeByScoreWithScores(String key) {
if (StringUtils.isBlank(key)) {
return null;
}
return zrevrangeByScoreWithScores(key, Double.MAX_VALUE, Double.MIN_VALUE, 0, -1);
}
/**
* 按分数倒序分页获取缓存中的值
*
* @param key 键
* @param offset 起始数
* @param count 获取的总数
* @return 缓存中的值
*/
public static Set<SortedSetElement> zrevrangeByScoreWithScores(String key, int offset, int count) {
if (StringUtils.isBlank(key)) {
return null;
}
return zrevrangeByScoreWithScores(key, Double.MAX_VALUE, Double.MIN_VALUE, offset, count);
}
/**
* 按分数倒序分页获取缓存中的值
*
* @param key 键
* @param max 分数最大值
* @param min 分数最小值
* @param offset 起始数
* @param count 获取的总数
* @return 缓存中的值
*/
public static Set<SortedSetElement> zrevrangeByScoreWithScores(String key, Double max, Double min, int offset, int count) {
if (StringUtils.isBlank(key)) {
return null;
}
return doExecute(jedis -> {
Set<Tuple> set = jedis.zrevrangeByScoreWithScores(key, max, min, offset, count);
if (set != null) {
Set<SortedSetElement> result = new LinkedHashSet<>();
for (Tuple each : set) {
result.add(new SortedSetElement(each.getElement(), each.getScore()));
}
return result;
}
return null;
});
}
/**
* 获取指定键的值
*
* @param key 键
* @return 值map
*/
public static Map<String, String> hgetAll(String key) {
if (StringUtils.isBlank(key)) {
return null;
}
return doExecute(jedis -> jedis.hgetAll(key));
}
/**
* 获取指定键的值
*
* @param key 键
* @return 值map
*/
@SuppressWarnings("unchecked")
public static <T> Map<String, T> hgetAll(byte[] key) {
if (key == null) {
return null;
}
return doExecute(jedis -> {
Map<String, T> result = null;
Map<byte[], byte[]> map = jedis.hgetAll(key);
if (map != null) {
result = new HashMap<>();
for (Map.Entry<byte[], byte[]> entry : map.entrySet()) {
result.put(new String(entry.getKey()), (T) SerializeUtils.unserialize(entry.getValue()));
}
}
return result;
});
}
/**
* 获取指定键的值
*
* @param key 键
* @param field map中的键
* @return 值
*/
public static String hget(String key, String field) {
if (StringUtils.isBlank(key)) {
return null;
}
return doExecute(jedis -> jedis.hget(key, field));
}
/**
* 获取指定键的值
*
* @param key 键
* @param field map中的键
* @return 值
*/
@SuppressWarnings("unchecked")
public static <T> T hget(byte[] key, byte[] field) {
return doExecute(jedis -> {
byte[] result = jedis.hget(key, field);
return (T) SerializeUtils.unserialize(result);
});
}
/**
* 获取指定键的值
*
* @param key 键
* @param field map中的键
* @return 值
*/
public static List<String> hmget(String key, String... field) {
if (StringUtils.isBlank(key)) {
return null;
}
return doExecute(jedis -> jedis.hmget(key, field));
}
/**
* 是否包含指定的键
*
* @param key 键
* @return 若存在则返回true
*/
public static Boolean exists(String key) {
if (StringUtils.isBlank(key)) {
return false;
}
return doExecute(jedis -> jedis.exists(key));
}
/**
* 缓存指定的键值
*
* @param key 键
* @param value 值
*/
public static Boolean set(String key, String value) {
if (StringUtils.isBlank(key)) {
return false;
}
return doExecute(jedis -> {
String result = jedis.set(key, value);
return isSuccess(result);
});
}
/**
* 若指定的键不存在时则缓存
* <p><b>获取值时需用getObject方法</b></p>
*
* @param key 键
* @param value 值
* @return 若设置成功则返回true
*/
public static boolean setObjectIfNotExist(String key, String value) {
return setObjectIfNotExist(key, value, -1);
}
/**
* 若指定的键不存在时则缓存
* <p><b>获取值时需用getObject方法</b></p>
*
* @param key 键
* @param value 值
* @param milliseconds 缓存的时间（单位毫秒）
* @return 若设置成功则返回true
*/
public static boolean setObjectIfNotExist(String key, String value, int milliseconds) {
return setObjectIfNotExist(key, (Object) value, milliseconds);
}
/**
* 加锁
* <p><b>获取值时需用getObject方法</b></p>
*
* @param key 键
* @param value 值
* @return 若加锁成功则返回true
*/
public static boolean lockObject(String key, String value) {
return lockObject(key, value, 0);
}
/**
* 加锁
* <p><b>获取值时需用getObject方法</b></p>
*
* @param key 键
* @param value 值
* @param milliseconds 缓存的时间（单位毫秒）
* @return 若加锁成功则返回true
*/
public static boolean lockObject(String key, String value, int milliseconds) {
if (StringUtils.isBlank(key) || value == null) {
return false;
}
return doExecute(jedis -> {
String result;
if (milliseconds > 0) {
result = jedis.set(key.getBytes(), value.getBytes(), JedisEnum.NXXX.NX.getValue().getBytes(), JedisEnum.EXPX.PX.getValue().getBytes(), milliseconds);
}
else {
result = jedis.set(key.getBytes(), value.getBytes(), JedisEnum.NXXX.NX.getValue().getBytes());
}
return isSuccess(result);
});
}
/**
* 解锁：条件值相等
*
* @param key 键
* @param value 值
* @return 若解锁成功则返回true
*/
public static boolean unlock(String key, String value) {
StringBuilder sb = new StringBuilder();
sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] then").append(" ");
sb.append("return redis.call(\"del\",KEYS[1])").append(" ");
sb.append("else").append(" ");
sb.append("return 0").append(" ");
sb.append("end");
return doExecute(jedis -> (long) jedis.eval(sb.toString(), Collections.singletonList(key), Collections.singletonList(value)) > 0);
}
/**
* 若指定的键存在时则缓存
* <p><b>获取值时需用getObject方法</b></p>
*
* @param key 键
* @param value 值
* @return 若设置成功则返回true
*/
public static boolean setObjectIfExist(String key, String value) {
return setObjectIfExist(key, value, 0);
}
/**
* 若指定的键存在时则缓存
* <p><b>获取值时需用getObject方法</b></p>
*
* @param key 键
* @param value 值
* @param seconds 缓存的时间（单位秒）
* @return 若设置成功则返回true
*/
public static boolean setObjectIfExist(String key, String value, int seconds) {
return setObjectIfExist(key, (Object) value, seconds);
}
/**
* 缓存指定的键值并放在头部
*
* @param key 键
* @param value 值
* @return 集合的大小
*/
public static Long lpush(String key, String... value) {
if (StringUtils.isBlank(key) || ArrayUtils.isEmpty(value)) {
return 0L;
}
return doExecute(jedis -> jedis.lpush(key, value));
}
/**
* 缓存指定的键值并放在尾部
*
* @param key 键
* @param value 值
* @return 集合的大小
*/
public static Long rpush(String key, String... value) {
if (StringUtils.isBlank(key) || ArrayUtils.isEmpty(value)) {
return 0L;
}
return doExecute(jedis -> jedis.rpush(key, value));
}
/**
* 从List集合头部获取元素并删除
*
* @param key 键
* @return list头部的一个元素
*/
public static String lpop(String key) {
if (StringUtils.isBlank(key)) {
return null;
}
return doExecute(jedis -> jedis.lpop(key));
}
/**
* 从List集合中删除指定的值
*
* @param key 键
* @param count count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 COUNT；
* count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 COUNT 的绝对值；
* count = 0 : 移除表中所有与 VALUE 相等的值。
* @param value 删除的值
* @return 删除的元素数量
*/
public static Long lrem(String key, long count, String value) {
if (StringUtils.isBlank(key)) {
return null;
}
return doExecute(jedis -> jedis.lrem(key, count, value));
}
/**
* 从List集合尾部获取元素并删除
*
* @param key 键
* @return list尾部的一个元素
*/
public static String rpop(String key) {
if (StringUtils.isBlank(key)) {
return null;
}
return doExecute(jedis -> jedis.rpop(key));
}
/**
* 往set缓存指定的键值
*
* @param key 键
* @param value 值
* @return 若设置成功则返回true
*/
public static Boolean sadd(String key, String... value) {
if (StringUtils.isBlank(key) || ArrayUtils.isEmpty(value)) {
return false;
}
return doExecute(jedis -> {
Long result = jedis.sadd(key, value);
return result >= 1;
});
}
/**
* 缓存指定的键值
*
* @param key 键
* @param value 值
* @param score 分数
*/
public static Boolean zadd(String key, String value, double score) {
if (StringUtils.isBlank(key) || value == null) {
return false;
}
return doExecute(jedis -> {
Long result = jedis.zadd(key, score, value);
return result >= 1;
});
}
/**
* 缓存指定的键值
*
* @param key 键
* @param value 格式：{值：分数}
*/
public static Boolean zadd(String key, Map<String, Double> value) {
if (StringUtils.isBlank(key) || MapUtils.isEmpty(value)) {
return false;
}
return doExecute(jedis -> {
Long result = jedis.zadd(key, value);
return result >= 1;
});
}
/**
* 把sorted set里指定的成员增加分值
*
* @param key 键
* @param member 成员
* @param score 分值
* @return 新的分值
*/
public static Double zincrby(String key, String member, double score) {
if (StringUtils.isBlank(key) || StringUtils.isBlank(member) || score == 0) {
return 0D;
}
return doExecute(jedis -> jedis.zincrby(key, score, member));
}
/**
* 从sorted set里删除元素
*
* @param key 键
* @param members 删除的元素
* @return 删除的数量
*/
public static Long zrem(String key, String... members) {
if (StringUtils.isBlank(key) || ArrayUtils.isEmpty(members)) {
return 0L;
}
return doExecute(jedis -> jedis.zrem(key, members));
}
/**
* 缓存指定的键值
*
* @param key 键
* @param field map中的键
* @param value map中的值
*/
public static Boolean hset(String key, String field, String value) {
if (StringUtils.isBlank(key) || StringUtils.isBlank(field)) {
return false;
}
return doExecute(jedis -> {
Long result = jedis.hset(key, field, value);
return result >= 1;
});
}
/**
* 缓存指定的键值
*
* @param key 键
* @param field map中的键
* @param value map中的值
*/
public static Boolean hset(String key, byte[] field, Object value) {
if (StringUtils.isBlank(key) || ArrayUtils.isEmpty(field)) {
return false;
}
return doExecute(jedis -> {
Long result = jedis.hset(key.getBytes(), field, SerializeUtils.serialize(value));
return result >= 1;
});
}
/**
* 缓存指定的键值
* <p><b>获取值时需用getObject方法</b></p>
*
* @param key 键
* @param value 值
*/
public static Boolean setObject(String key, Object value) {
if (StringUtils.isBlank(key)) {
return false;
}
return doExecute(jedis -> {
String result = jedis.set(key.getBytes(), SerializeUtils.serialize(value));
return isSuccess(result);
});
}
/**
* 若指定的键不存在时则缓存
* <p><b>获取值时需用getObject方法</b></p>
*
* @param key 键
* @param value 值
* @return 若设置成功则返回true
*/
public static boolean setObjectIfNotExist(String key, Object value) {
return setObjectIfNotExist(key, value, 0);
}
/**
* 若指定的键不存在时则缓存
* <p><b>获取值时需用getObject方法</b></p>
*
* @param key 键
* @param value 值
* @param milliseconds 缓存的时间（单位毫秒）
* @return 若设置成功则返回true
*/
public static Boolean setObjectIfNotExist(String key, Object value, int milliseconds) {
if (StringUtils.isBlank(key)) {
return false;
}
return doExecute(jedis -> {
String result;
if (milliseconds > 0) {
result = jedis.set(key.getBytes(), SerializeUtils.serialize(value), JedisEnum.NXXX.NX.getValue().getBytes(), JedisEnum.EXPX.PX.getValue().getBytes(), milliseconds);
}
else {
result = jedis.set(key.getBytes(), SerializeUtils.serialize(value), JedisEnum.NXXX.NX.getValue().getBytes());
}
return isSuccess(result);
});
}
/**
* 若指定的键存在时则缓存
* <p><b>获取值时需用getObject方法</b></p>
*
* @param key 键
* @param value 值
* @return 若设置成功则返回true
*/
public static boolean setObjectIfExist(String key, Object value) {
return setObjectIfExist(key, value, 0);
}
/**
* 若指定的键存在时则缓存
* <p><b>获取值时需用getObject方法</b></p>
*
* @param key 键
* @param value 值
* @param seconds 缓存的时间（单位秒）
* @return 若设置成功则返回true
*/
public static Boolean setObjectIfExist(String key, Object value, int seconds) {
if (StringUtils.isBlank(key)) {
return false;
}
return doExecute(jedis -> {
String result;
if (seconds > 0) {
result = jedis.set(key.getBytes(), SerializeUtils.serialize(value), JedisEnum.NXXX.XX.getValue().getBytes(), JedisEnum.EXPX.EX.getValue().getBytes(), seconds);
}
else {
result = jedis.set(key.getBytes(), SerializeUtils.serialize(value), JedisEnum.NXXX.XX.getValue().getBytes());
}
return isSuccess(result);
});
}
/**
* 批量缓存map中的键值
* <p><b>获取值时需用getObject方法</b></p>
*
* @param map 键值map
*/
public static <T> void setObject(Map<String, T> map) {
if (MapUtils.isEmpty(map)) {
return;
}
doExecute(jedis -> {
Pipeline pipeline = jedis.pipelined();
try {
for (Map.Entry<String, T> entry : map.entrySet()) {
pipeline.set(entry.getKey().getBytes(), SerializeUtils.serialize(entry.getValue()));
}
pipeline.sync();
}
finally {
CloseableUtils.close(pipeline);
}
return null;
});
}
/**
* 增加指定的值
*
* @param key 键
* @param value 增加的值
* @return 增加后的值
*/
public static Long incrBy(String key, int value) {
if (StringUtils.isBlank(key) || value == 0) {
return 0L;
}
return doExecute(jedis -> jedis.incrBy(key, value));
}
/**
* 增加指定的值
*
* @param key 键
* @param field map中的键
* @param value 增加的值
* @return 增加后的值
*/
public static Long hincrBy(String key, String field, int value) {
if (StringUtils.isBlank(key) || StringUtils.isBlank(field) || value == 0) {
return 0L;
}
return doExecute(jedis -> jedis.hincrBy(key, field, value));
}
/**
* 减少指定的值
*
* @param key 键
* @param value 减少的值
* @return 减少后的值
*/
public static Long decrBy(String key, long value) {
if (StringUtils.isBlank(key) || value == 0) {
return 0L;
}
return doExecute(jedis -> jedis.decrBy(key, value));
}
/**
* 给指定的键设置过期时间
*
* @param key 键
* @param seconds 过期时间（单位：秒）
* @return 若设置成功则返回true
*/
public static Boolean expire(String key, int seconds) {
if (StringUtils.isBlank(key) || seconds <= 0) {
return false;
}
return doExecute(jedis -> {
Long result = jedis.expire(key, seconds);
return result == 1;
});
}
/**
* 删除指定的键
*
* @param key 键
* @return 删除键的数量
*/
public static Long del(String... key) {
if (ArrayUtils.isEmpty(key)) {
return 0L;
}
return doExecute(jedis -> jedis.del(key));
}
/**
* 删除map中指定的字段
*
* @param key 键
* @param field 字段
* @return 删除字段的数量
*/
public static Long hdel(String key, String... field) {
if (StringUtils.isBlank(key) || ArrayUtils.isEmpty(field)) {
return 0L;
}
return doExecute(jedis -> jedis.hdel(key, field));
}
/**
* 获取以指定格式的键
*
* @param pattern 正则表达式
* @return 匹配的值
*/
public static Set<String> keys(String pattern) {
if (StringUtils.isBlank(pattern)) {
return null;
}
return doExecute(jedis -> jedis.keys(pattern));
}
/**
* 获取set的大小
*
* @param key 键
* @return set大小
*/
public static Long scard(String key) {
if (StringUtils.isBlank(key)) {
return 0L;
}
return doExecute(jedis -> jedis.scard(key));
}
/**
* 获取sorted set的大小
*
* @param key 键
* @return 获取sorted set大小
*/
public static Long zcard(String key) {
if (StringUtils.isBlank(key)) {
return 0L;
}
return doExecute(jedis -> jedis.zcard(key));
}
/**
* 获取sorted set中指定成员的分数
*
* @param key 键
* @param member 成员
* @return 指定成员的分数
*/
public static Double zscore(String key, String member) {
if (StringUtils.isBlank(key)) {
return null;
}
return doExecute(jedis -> jedis.zscore(key, member));
}
/**
* 校验set里是否已存在元素
*
* @param key 键
* @param member 元素
* @return 若存在则返回true
*/
public static Boolean sismember(String key, String member) {
if (StringUtils.isBlank(key)) {
return false;
}
return doExecute(jedis -> jedis.sismember(key, member));
}
/**
* 从set里面删除元素
*
* @param key 键
* @param member 元素
* @return 删除的数量
*/
public static Long srem(String key, String... member) {
if (StringUtils.isBlank(key) || ArrayUtils.isEmpty(member)) {
return 0L;
}
return doExecute(jedis -> jedis.srem(key, member));
}
/**
* 返回键的过期时间（单位：秒）
*
* @param key 键
* @return 键的过期时间
*/
public static Long ttl(String key) {
if (StringUtils.isBlank(key)) {
return null;
}
return doExecute(jedis -> jedis.ttl(key));
}
/**
* @return 获取jedis对象
*/
public static Jedis getJedis() {
return pool.getResource();
}
/**
* 清空所有的缓存
*/
public static void flushDB() {
doExecute(jedis -> jedis.flushDB());
}
/**
* @return 缓存池配置
*/
public static JedisPoolConfig getConfig() {
return config;
}
/**
* @return 分片信息
*/
public static JedisShardInfo getShardInfo() {
return shardInfo;
}
/**
* 关闭jedis对象
*
* @param jedis jedis对象
*/
private static void close(Jedis jedis) {
if (jedis != null) {
jedis.close();
}
}
private static boolean isSuccess(String value) {
return "OK".equals(value);
}
private static <T> T doExecute(Executor<T> executor) {
Jedis jedis = getJedis();
try {
return executor.execute(jedis);
}
catch (Throwable t) {
log.error("缓存出现异常", t);
return null;
}
finally {
close(jedis);
}
}
private interface Executor<T> {
T execute(Jedis jedis);
}
}单个对象，可以存入String类型，一组集合，就存入list类型
/**
* 添加前台展示用户
*
* @param userInfo
*/
private void addShowUser(UserInfo userInfo) {
User User = new User();
User.setAvatar(userInfo.getHeadImgUrl());
User.setName(userInfo.getNickName());
User.setStatus(1);
User.setUserAccountUuid(userInfo.getId() + "");
Long showUser = JedisUtils.lpush(RedisConstant.USER, GsonUtil.toJson(User));
}
//获取首页展示的5个用户
@Override
public List<User> getUserList() {
List<String> users = JedisUtils.lrange(RedisConstant.USER);
List<User> list = new ArrayList<>();
for (String str : users) {
User User = GsonUtil.jsonStrToObject(str, User.class);
list.add(User);
}
return list;
}package com.sz.gcyh.crazyad.utils;
import com.gcyh.core.base.json.JsonUtils;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.TypeAdapter;
import com.google.gson.TypeAdapterFactory;
import com.google.gson.internal.bind.DateTypeAdapter;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.JsonWriter;
import com.sz.gcyh.crazyad.dto.CrazyAdHomeResDto;
import com.sz.gcyh.crazyad.vo.InitvalueJson;
import io.netty.util.internal.StringUtil;
import java.io.IOException;
import java.lang.reflect.Type;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* 处理json字符串与对象之间关系的工具类
*
*/
public final class GsonUtil {
private GsonUtil() {
}
/**
* @param obj
* @return
*/
public static String toJson(Object obj) {
return toJson(obj, null, false);
}
/**
* @param obj
* @param isExportNull
* @return
*/
public static String toJson(Object obj, Boolean isExportNull) {
return toJson(obj, null, false, isExportNull);
}
/**
* @param obj
* @param datePattern
* @return
*/
public static String toJson(Object obj, String datePattern) {
return toJson(obj, datePattern, false);
}
/**
* @param obj
* @param datePattern
* @param isPrettyPrinting
* @return
*/
public static String toJson(Object obj, String datePattern, Boolean isPrettyPrinting) {
return toJson(obj, datePattern, isPrettyPrinting, null);
}
/**
* @param obj
* @param datePattern
* @param isPrettyPrinting
* @param isExportNull
* @return
*/
public static String toJson(Object obj, String datePattern, Boolean isPrettyPrinting, Boolean isExportNull) {
GsonBuilder builder = new GsonBuilder();
if (isPrettyPrinting != null && isPrettyPrinting) {
builder.setPrettyPrinting();
}
if (StringUtil.isNullOrEmpty(datePattern)) {
datePattern = "yyyy-MM-dd HH:mm:ss";
}
if (isExportNull != null && isExportNull) {
builder.serializeNulls();
}
builder.disableHtmlEscaping();
builder.setDateFormat(datePattern);
Gson gson = builder.create();
return gson.toJson(obj);
}
/**
* 序列化成为字符串（空字符串转为 ""）
*
* @param obj 待转换的对象
* @param datePattern 日期格式，允许空==》默认：yyyy-MM-dd HH:mm:ss
* @param isNeedEmptyStr 是否要将null转换成为空字符
* @return Json数据
*/
public static String toJsonWithEmptyStr(Object obj, String datePattern, Boolean isNeedEmptyStr) {
GsonBuilder builder = new GsonBuilder();
if (StringUtil.isNullOrEmpty(datePattern)) {
datePattern = "yyyy-MM-dd HH:mm:ss";
}
if (isNeedEmptyStr != null && isNeedEmptyStr) {
builder.registerTypeAdapterFactory(new NullStringToEmptyAdapterFactory<>());
}
builder.disableHtmlEscaping();
builder.setDateFormat(datePattern);
Gson gson = builder.create();
return gson.toJson(obj);
}
/**
* @param jsonStr
* @param clazz
* @param <T>
* @return
*/
public static <T> T jsonStrToObject(String jsonStr, Class<T> clazz) {
// Gson gson = new GsonBuilder().registerTypeAdapter(Date.class, new DateTypeAdapter()).setDateFormat("yyyy-MM-dd HH:mm:ss").create();
// return gson.fromJson(jsonStr, clazz);
T result = JsonUtils.jsonToObject(jsonStr, clazz);
return result;
}
public static void main(String[] args) {
String str = "{\n" +
" \"name\": \"2018001期\",\n" +
" \"beginDate\": \"2018-10-19 02:00:00\",\n" +
" \"gameId\": 45,\n" +
" \"crazyId\": 43,\n" +
" \"adNum\": 200.0,\n" +
" \"ad\": 75.0,\n" +
" \"gameStatus\": 0\n" +
"}";
CrazyAdHomeResDto test = jsonStrToObject(str, CrazyAdHomeResDto.class);
System.out.println(test);
}
/**
* 用Type来转换Json
*
* @param jsonStr Json字符串
* @param type 类型
* @param <T> 返回类型
* @return 数据
*/
public static <T> T jsonStrToObjectByType(String jsonStr, Type type) {
// Gson gson = new GsonBuilder().registerTypeAdapter(Date.class, new DateTypeAdapter()).setDateFormat("yyyy-MM-dd HH:mm:ss").create();
Gson gson = new GsonBuilder().registerTypeAdapter(Date.class, new DateTypeAdapter()).setDateFormat("yyyy-MM-dd HH:mm:ss:SSS").create();
return gson.fromJson(jsonStr, type);
}
/**
* pretty json string to object,replace null to empty string
*
* @param jsonStr
* @param typeToken
* @param <T>
* @return
*/
public static <T> T jsonStrToObjectWithEmptyStr(String jsonStr, TypeToken<T> typeToken) {
GsonBuilder builder = new GsonBuilder();
builder.registerTypeAdapter(Date.class, new DateTypeAdapter()).setDateFormat("yyyy-MM-dd HH:mm:ss");
builder.registerTypeAdapter(String.class, new StringNullAdapter());
Gson gson = builder.create();
return gson.fromJson(jsonStr, typeToken.getType());
}
/**
* 转化Json成为Map<String, Object>
*
* @param json 待转化的Json
* @return Map类型的结果
*/
public static Map<String, Object> parse2Map(String json) {
Type stringStringMap = new TypeToken<Map<String, Object>>() {
}.getType();
Gson gson = new Gson();
Map<String, Object> map = gson.fromJson(json, stringStringMap);
return map;
}
/**
* 转化Json成为Map<String, String>
*
* @param json 待转化的Json
* @return Map类型的结果
*/
public static Map<String, String> parse2Mapstr(String json) {
Type stringStringMap = new TypeToken<Map<String, String>>() {
}.getType();
Gson gson = new Gson();
Map<String, String> map = gson.fromJson(json, stringStringMap);
return map;
}
/**
* 转化Json成为List
*
* @param json 待转化的Json
* @return List类型的结果
*/
public static List<InitvalueJson> parseInitvalue(String json) {
Gson gson = new Gson();
List<InitvalueJson> list = gson.fromJson(json, new TypeToken<List<InitvalueJson>>() {
}.getType());
return list;
}
}
class NullStringToEmptyAdapterFactory<T> implements TypeAdapterFactory {
@SuppressWarnings("unchecked")
@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
Class<T> rawType = (Class<T>) type.getRawType();
if (rawType != String.class) {
return null;
}
return (TypeAdapter<T>) new StringNullAdapter();
}
}
class StringNullAdapter extends TypeAdapter<String> {
@Override
public String read(JsonReader reader) throws IOException {
if (reader.peek() == JsonToken.NULL) {
reader.nextNull();
return "";
}
return reader.nextString();
}
@Override
public void write(JsonWriter writer, String value) throws IOException {
if (value == null) {
writer.nullValue();
return;
}
writer.value(value);
}
}