1.springboot2.2.2整合redis教程很多,为此编写了比较完整的redis工具类,符合企业级开发使用的工具类

2.springboot与redis maven相关的依赖

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.2.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
<!--redis依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

3.application.yml中加入redis相关的配置

server:
port: 8080
servlet:
context-path: /project/v101
session:
timeout: 3600s
tomcat:
uri-encoding: utf-8 spring:
# 对象属性值,为 null,则不显示属性名
jackson:
default-property-inclusion: non_null
datasource:
name: demo
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&serverTimezone=GMT%2B8
# driver-class-name: com.mysql.jdbc.Driver
username: root
password: root
type: com.alibaba.druid.pool.DruidDataSource
druid:
initialSize: 5
minIdle: 5
maxActive: 20
maxWait: 60000
# 配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒
timeBetweenEvictionRunsMillis: 60000
# 配置一个连接在池中最小生存的时间,单位是毫秒
minEvictableIdleTimeMillis: 30000
validationQuery: SELECT 1 FROM DUAL
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
poolPreparedStatements: true
maxPoolPreparedStatementPerConnectionSize: 20
# 配置监控统计拦截的filters,去掉后监控界面sql无法统计,'wall'用于防火墙
filters: stat,wall,log4j
# 通过connectProperties属性来打开mergeSql功能;慢SQL记录
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
# 自定义属性,用于druid监控界面的账号、密码配置
servlet:
username: root
password: root
http:
log-request-details: true servlet:
multipart:
max-file-size: 20MB
max-request-size: 30MB
file-size-threshold: 0
enabled: true
 # redis配置
redis:
host: localhost
port: 6379
password: 123456
database: 0 mybatis-plus:
global-config:
db-config:
logic-delete-value: 1 # 逻辑已删除值(默认为 0)
logic-not-delete-value: 0 # 逻辑未删除值(默认为 1)
mapper-locations: classpath:mapper/**/*Mapper.xml
# config-location: classpath:mybatis-config.xml
# MyBaits 别名包扫描路径,通过该属性可以给包中的类注册别名
type-aliases-package: com.houtang.saas.pms.domain.entity
configuration:
# 开启驼峰匹配
map-underscore-to-camel-case: true
# 这个配置使全局的映射器启用或禁用缓存。系统默认值是true
cache-enabled: true
# 全局启用或禁用延迟加载。当禁用时,所有关联对象都会即时加载。系统默认值是true
lazy-loading-enabled: true
# 允许或不允许多种结果集从一个单独的语句中返回(需要适合的驱动)。系统默认值是true
multiple-result-sets-enabled: true
# 使用列标签代替列名。不同的驱动在这方便表现不同。参考驱动文档或充分测试两种方法来决定所使用的驱动
use-column-label: true
# 允许 JDBC 支持生成的键。需要适合的驱动。如果设置为 true 则这个设置强制生成的键被使用,尽管一些驱动拒绝兼容但仍然有效(比如Derby)
use-generated-keys: false
# 配置默认的执行器。SIMPLE 执行器没有什么特别之处。REUSE 执行器重用预处理语句。BATCH 执行器重用语句和批量更新
default-executor-type: simple
# 设置超时时间,它决定驱动等待一个数据库响应的时间
default-statement-timeout: 25000 pagehelper:
helper-dialect: mysql
reasonable: true
support-methods-arguments: true
params: count=countSql

4.编写自定义redis配置类(由于springboot 整合的redisTemplate<Object,Object> 只能操作Object对象,通过源码可以看出,SpringBoot自动帮我们在容器中生成了一个RedisTemplate和一个StringRedisTemplate,使用时需要写很多类型转换代码,用起来不切实际需求)

/**
* redis配置类
*
* @author : ywb
* @createdDate : 2019/12/31
* @updatedDate
*/
@Configuration
public class RedisConfig { /**
* 自定义 redisTemplate<String, Object>
*
* @param redisConnectionFactory
* @return
*/
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory); ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
// 不转换值为 null 的对象
// om.setSerializationInclusion(JsonInclude.Include.NON_NULL); Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
jackson2JsonRedisSerializer.setObjectMapper(om); StringRedisSerializer stringRedisSerializer = new StringRedisSerializer(); // key 采用 string 的序列化方式
template.setKeySerializer(stringRedisSerializer);
// value 采用 jackson 的序列化方式
template.setValueSerializer(jackson2JsonRedisSerializer);
// hash 的 key 采用 string 的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
// hash 的 value 采用 jackson 的序列化方式
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}

5.拦截器使用实例(拦截请求时,获取redis中的token信息,对redis中指定键对应的数据设置失效时间)

/**
* 请求拦截器
* @author : ywb
* @createdDate : 2019/12/31
* @updatedDate
*/
@Component
public class RequestInterceptor implements HandlerInterceptor { private static Log LOGGER = LogFactory.getLog(RequestInterceptor.class); @Autowired
private RedisUtils redisUtils; /**
* 请求之前执行
* @param request
* @param response
* @param handler
* @return
* @throws Exception
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//获取token
String token = request.getHeader("token");
DataCheck.isTrue(StringUtils.isBlank(token), ResultMessage.NO_TOKEN.getMsg());
// String timestamp = request.getHeader("timestamp");
// //获取生成的随机数
// String random = request.getHeader("random");
// //获取加密后的签名信息
// String sign = request.getHeader("sign");
// //组合token+timestamp+random
//// String pwd = token.concat(timestamp).concat(random);
// //SHA-256哈希加密算法
// String pwd = token;
// MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
// byte[] hash = messageDigest.digest(pwd.getBytes("UTF-8"));
// //通过SHA-256哈希加密算法生成签名信息
// String newSign = Hex.encodeHexString(hash);
//查询redis存储的用户信息
String redisUser = Constant.REDIS_USERID.replace("@uuid", token);
if (!StringUtils.isBlank(redisUser) && redisUtils.exists(redisUser)) {
//更新登录有效时间(续命)
redisUtils.expire(redisUser, Constant.REDIS_USERID_TIMEOUT);
return true;
} else {
throw new DataValidationException(ResultMessage.REQUEST_ERROR.getMsg());
}
} /**
* 请求之后生成视图之前执行
* @param request
* @param response
* @param handler
* @param modelAndView
* @throws Exception
*/
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { } /**
* 最后执行,一般用于释放资源
* @param request
* @param response
* @param handler
* @param ex
* @throws Exception
*/
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { }
}

6.编写比较完整的redis工具类RedisUtils

/**
* Redis工具类<br>
* <b>使用方法:</b>直接在类中使用@Autowired方法注入即可
* @author : ywb
* @createdDate : 2019/12/31
* @updatedDate
*/
@Slf4j
@Component
public final class RedisUtils { /**
* 从 spring 容器中注入自定义的 redisTemplate
*/
@Autowired
private RedisTemplate<String, Object> redisTemplate; /**
* 对 redis 中指定键对应的数据设置失效时间
*
* @param key 键
* @param time 时间(秒),time要大于0
* @return
*/
public boolean expire(String key, long time) {
boolean result = false; try {
if (StringUtils.isNotBlank(key) && time > 0) {
result = this.redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
} return result;
} /**
* 从 redis 中根据指定的 key 获取已设置的过期时间
*
* @param key 键,不能为null
* @return 时间(秒),返回0代表为永久有效
*/
public long getExpire(String key) {
long time = 0L; try {
if (StringUtils.isNotBlank(key)) {
time = this.redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
}
return time;
} /**
* 判断 redis 中是否存在指定的 key
*
* @param key 键,不能为null
* @return true表示存在,false表示不存在
*/
public boolean exists(String key) {
boolean result = false; try {
if (StringUtils.isNotBlank(key)) {
result = this.redisTemplate.hasKey(key);
}
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
}
return result;
} /**
* 从 redis 中移除指定 key 对应的数据
*
* @param keys 可以传一个值或多个
*/
@SuppressWarnings("unchecked")
public long remove(String... keys) {
long count = 0L; if (keys != null && keys.length > 0) {
if (keys.length == 1) {
boolean result = this.redisTemplate.delete(keys[0]); if (result) {
count = keys.length;
}
} else {
count = this.redisTemplate.delete(CollectionUtils.arrayToList(keys));
}
}
return count;
} // ============================ String =============================
/**
* 从 redis 中获取指定 key 对应的 string 数据
*
* @param key 键,不能为null
* @return key 对应的字符串数据
*/
public <T> T get(String key) {
T t = null; try {
if (StringUtils.isNotBlank(key)) {
t = (T) this.redisTemplate.opsForValue().get(key);
}
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
}
return t;
} /**
* 从 redis 中获取指定 key 对应的 string 数据,并转换为 T 类型
*
* @param key 键,不能为null
* @param clazz 类型,从 redis 获取后的对象直接转换为 T 类型
* @return key 对应的数据
*/
public <T> T get(String key, Class<T> clazz) {
T t = null; try {
if (StringUtils.isNotBlank(key)) {
String str = (String) this.redisTemplate.opsForValue().get(key); t = this.stringToBean(str, clazz);
}
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return null;
} return t;
} /**
* 判断 redis 中指定 key 的数据对应偏移位置的 bit 位是否为 1
*
* @param key 键,不能为null
* @param offset 偏移位置
* @return true表示存在,false表示不存在
*/
public boolean getBit(String key, long offset) {
boolean result = false; try {
if (StringUtils.isNotBlank(key)) {
result = this.redisTemplate.opsForValue().getBit(key, offset);
}
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
} return result;
} /**
* 将指定的 key, value 放到 redis 中
*
* @param key 键,不能为null
* @param value 值,不能为null
* @return true表示成功,false表示失败
*/
public <T> boolean set(String key, T value) {
boolean result = false; try {
if (StringUtils.isNotBlank(key)) {
this.redisTemplate.opsForValue().set(key, value); result = true;
}
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
} return result;
} /**
* 将指定的 key, value 放到 redis 中,并设置过期时间
*
* @param key 键,不能为null
* @param value 值,不能为null
* @param time 时间(秒),time要大于0,如果time小于等于0,将设置无限期
* @return true表示成功,false表示失败
*/
public <T> boolean set(String key, T value, long time) {
try {
if (time > 0) {
this.redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
this.set(key, value);
}
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
} /**
* 将 redis 中指定 key 对应数据的偏移位置的 bit 位设置为 0/1
*
* @param key 键,不能为null
* @param offset 偏移位置
* @param flag true表示设置为1,false表示设置为0
* @return true表示成功,false表示失败
*/
public boolean setBit(String key, long offset, boolean flag) {
boolean result = false; try {
if (StringUtils.isNotBlank(key)) {
this.redisTemplate.opsForValue().setBit(key, offset, flag); result = true;
}
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
} return result;
} /**
* 对 redis 中指定 key 的数据递增,并返回递增后的值
*
* @param key 键,不能为null
* @param delta 要增加几(大于0)
* @return
*/
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0。");
} return this.redisTemplate.opsForValue().increment(key, delta);
} /**
* 对 redis 中指定 key 的数据递减,并返回递减后的值
*
* @param key 键,不能为null
* @param delta 要减少几(大于0)
* @return
*/
public long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0。");
} return this.redisTemplate.opsForValue().decrement(key, delta);
} // ================================ hashmap================================= /**
* 判断 redis 中指定 key 对应的 hash 表中是否有 hashKey
*
* @param key 键,不能为null
* @param hashKey hash表中的键,不能为null
* @return true表示存在,false表示不存在
*/
public boolean hexists(String key, String hashKey) {
return this.redisTemplate.opsForHash().hasKey(key, hashKey);
} /**
* 从 redis 中获取指定 key 对应的 hash 表中的指定 hashKey 所对应的值
*
* @param key 键,不能为null
* @param hashKey hash表中的键,不能为null
* @return 值
*/
@SuppressWarnings("unchecked")
public <T> T hget(String key, String hashKey) {
return (T) this.redisTemplate.opsForHash().get(key, hashKey);
} /**
* 向 redis 中指定 key 对应的 hash 表(如果 hash 表不存在则自动创建)中放入 hashKey,value 数据
*
* @param key 键,不能为null
* @param hashKey hash表中的键,不能为null
* @param value 值,不能为null
* @return true表示成功,false表示失败
*/
public <T> boolean hset(String key, String hashKey, T value) {
try {
this.redisTemplate.opsForHash().put(key, hashKey, value);
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
} /**
* 向 redis 中指定 key 对应的 hash 表(如果 hash 表不存在则自动创建)中放入 hashKey,value 数据,并设置过期时间
*
* @param key 键,不能为null
* @param hashKey hash表中的键,不能为null
* @param value 值,不能为null
* @param time 过期时间(秒),注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true表示成功,false表示失败
*/
public <T> boolean hset(String key, String hashKey, T value, long time) {
try {
this.redisTemplate.opsForHash().put(key, hashKey, value);
if (time > 0) {
this.expire(key, time);
}
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
} /**
* 删除 redis 中指定 key 对应的 hash 表中等于 hashKeys 的数据
*
* @param key 键,不能为null
* @param hashKeys hash表中的键,可以使多个,不能为null
*/
public <T> void hdel(String key, T... hashKeys) {
this.redisTemplate.opsForHash().delete(key, hashKeys);
} /**
* 从 redis 中获取指定 key 对应的 hash 表,并返回相应的 map 对象
*
* @param key 键,不能为null
* @return map对象,包含所有的键值对
*/
public Map<?, ?> hmget(String key) {
return this.redisTemplate.opsForHash().entries(key);
} /**
* 向 redis 中放入指定 key,并设置对应的数据类型为 map
*
* @param key 键,不能为null
* @param map 多个键值对应的map,不能为null
* @return true表示成功,false表示失败
*/
public boolean hmset(String key, Map<String, ?> map) {
try {
this.redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
} /**
* 向 redis 中放入指定 key,并设置对应的数据类型为 map 以及过期时间
*
* @param key 键,不能为null
* @param map 对应多个键值,不能为null
* @param time 时间(秒),time要大于0,如果time小于等于0,将设置无限期
* @return true表示成功,false表示失败
*/
public boolean hmset(String key, Map<String, ?> map, long time) {
try {
this.redisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
this.expire(key, time);
}
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
} /**
* 对 redis 中指定 key 对应的 hash 表(如果 hash 表不存在则自动创建)递增,并返回新增后的值
*
* @param key 键,不能为null
* @param item 项,不能为null
* @param delta 要增加几(大于0)
* @return 新增后的值
*/
public double hincr(String key, String item, double delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0。");
} return this.redisTemplate.opsForHash().increment(key, item, delta);
} /**
* 对 redis 中指定 key 对应的 hash 表(如果 hash 表不存在则自动创建)递增,并返回新增后的值
*
* @param key 键,不能为null
* @param item 项,不能为null
* @param delta 要减少几(大于0)
* @return
*/
public double hdecr(String key, String item, double delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0。");
} return this.redisTemplate.opsForHash().increment(key, item, -delta);
} /**
* 从 redis 中移除指定 key 对应 hash 表中键为 values 的数据
*
* @param key 键,不能为null
* @param values 值,不能为null
* @return 移除的个数
*/
public <T> long hremove(String key, T... values) {
try {
Long count = this.redisTemplate.opsForHash().delete(key, values);
return count;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return 0;
}
} // ============================set============================= /**
* 判断 redis 中是否存在指定 key 对应的 set 对象
*
* @param key 键,不能为null
* @param value 值,不能为null
* @return true表示存在,false表示不存在
*/
public <T> boolean sexists(String key, T value) {
try {
return this.redisTemplate.opsForSet().isMember(key, value);
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
} /**
* 从 redis 中根据指定 key 对应的值,并返回 set 对象
*
* @param key 键,不能为null
* @return
*/
public Set<?> sget(String key) {
try {
return this.redisTemplate.opsForSet().members(key);
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return null;
}
} /**
* 向 redis 中放入指定 key 和数据,并设置其数据类型为 set
*
* @param key 键,不能为null
* @param values 值,不能为null
* @return 成功个数
*/
public <T> long sset(String key, T... values) {
try {
return this.redisTemplate.opsForSet().add(key, values);
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return 0;
}
} /**
* 向 redis 中放入指定 key 和数据,并设置其数据类型为 set 以及过期时间
*
* @param key 键,不能为null
* @param time 过期时间(秒),注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @param values 值,不能为null
* @return 成功个数
*/
public <T> long sset(String key, long time, T... values) {
try {
Long count = this.redisTemplate.opsForSet().add(key, values);
if (time > 0) {
expire(key, time);
}
return count;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return 0;
}
} /**
* 获取 redis 中指定 key 对应 set 的大小
*
* @param key 键,不能为null
* @return
*/
public long ssize(String key) {
try {
return this.redisTemplate.opsForSet().size(key);
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return 0;
}
} /**
* 从 redis 中移除指定 key 对应 set 中键为 values 的数据
*
* @param key 键,不能为null
* @param values 值,不能为null
* @return 移除的个数
*/
public <T> long sremove(String key, T... values) {
try {
Long count = this.redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return 0;
}
} // =============================== list ================================= /**
* 从 redis 中获取指定 key 对应 list 的大小
*
* @param key 键,不能为null
* @return
*/
public long lsize(String key) {
try {
return this.redisTemplate.opsForList().size(key);
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return 0;
}
} /**
* 从 redis 中获取指定 key 对应 list 中 index 位置的值
*
* @param key 键,不能为null
* @param index 当index>=0时,0为表头,1为第二个元素,依次类推;当index<0时,-1为表尾,-2为倒数第二个元素,依次类推
* @return
*/
@SuppressWarnings("unchecked")
public <T> T lindex(String key, long index) {
try {
return (T) this.redisTemplate.opsForList().index(key, index);
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return null;
}
} /**
* 从 redis 中获取指定 key 对应 list 指定范围的值(start~end设置为0~-1将返回所有值)
*
* @param key 键,不能为null
* @param start 起始位置,0表示起始位置
* @param end 结束位置,-1表示结束位置
* @return
*/
public List<?> lget(String key, long start, long end) {
try {
return this.redisTemplate.opsForList().range(key, start, end);
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return null;
}
} /**
* 向 redis 中放入指定 key,并设置数组类型为 list,将 value 加入到 list 尾部
*
* @param key 键,不能为null
* @param value 值,不能为null
* @return
*/
public <T> boolean lset(String key, T value) {
try {
this.redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
} /**
* 向 redis 中放入指定 key,并设置数组类型为 list,将 value 加入到 list 尾部,同时设置过期时间
*
* @param key 键,不能为null
* @param value 值,不能为null
* @param time 时间(秒),time要大于0,如果time小于等于0,将设置无限期
* @return
*/
public <T> boolean lset(String key, T value, long time) {
try {
this.redisTemplate.opsForList().rightPush(key, value);
if (time > 0) {
this.expire(key, time);
}
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
} /**
* 向 redis 中放入指定 key,并设置数组类型为 list,并以 value 填入 list
*
* @param key 键,不能为null
* @param value 值,不能为null
* @return
*/
public boolean lset(String key, List value) {
try {
this.redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
} /**
* 向 redis 中放入指定 key,并设置数组类型为 list,并以 value 填入 list,同时设置过期时间
*
* @param key 键,不能为null
* @param value 值,不能为null
* @param time 时间(秒),time要大于0,如果time小于等于0,将设置无限期
* @return
*/
public boolean lset(String key, List value, long time) {
try {
this.redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0) {
this.expire(key, time);
}
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
} /**
* 将 redis 中指定 key 对应的 list 数据中指定 index 位置的数据更新为 value
*
* @param key 键,不能为null
* @param index 索引
* @param value 值,不能为null
* @return
*/
public <T> boolean lupdate(String key, long index, T value) {
try {
this.redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
} /**
* 从 redis 中指定 key 对应的 list 中移除 n 个值为 value 的数据
*
* @param key 键,不能为null
* @param count 移除多少个
* @param value 值,不能为null
* @return 移除的个数
*/
public <T> long lremove(String key, long count, T value) {
try {
Long remove = this.redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return 0;
}
} /**
* 根据指定的类型转换字符串/JSON字符串为相应的对象
*
* @param value 字符串/JSON字符串
* @param clazz 类型
* @param <T> 任意类型
* @return
*/
@SuppressWarnings("unchecked")
public <T> T stringToBean(String value, Class<T> clazz) {
if (value == null || value.length() <= 0 || clazz == null) {
return null;
} if (clazz == byte.class || clazz == Byte.class) {
return (T) Byte.valueOf(value);
} else if (clazz == int.class || clazz == Integer.class) {
return (T) Integer.valueOf(value);
} else if (clazz == long.class || clazz == Long.class) {
return (T) Long.valueOf(value);
} else if (clazz == double.class || clazz == Double.class) {
return (T) Double.valueOf(value);
} else if (clazz == float.class || clazz == Float.class) {
return (T) Float.valueOf(value);
} else if (clazz == String.class) {
return (T) value;
} else {
return JSONUtil.toBean(value, clazz);
}
} /**
* 将 bean 转换为字符串/JSON字符串
*
* @param value 任意类型对象
* @return 字符串/JSON字符串
*/
public <T> String beanToString(T value) {
if (value == null) {
return null;
} Class<?> clazz = value.getClass();
if (clazz == byte.class || clazz == Byte.class) {
return "" + value;
} else if (clazz == int.class || clazz == Integer.class) {
return "" + value;
} else if (clazz == long.class || clazz == Long.class) {
return "" + value;
} else if (clazz == double.class || clazz == Double.class) {
return "" + value;
} else if (clazz == float.class || clazz == Float.class) {
return "" + value;
} else if (clazz == String.class) {
return (String) value;
} else {
return JSONUtil.toJsonStr(value);
}
}

springboot2.2.2企业级项目整合redis与redis 工具类大全的更多相关文章

  1. SpringBoot + Vue + ElementUI 实现后台管理系统模板 -- 后端篇(五): 数据表设计、使用 jwt、redis、sms 工具类完善注册登录逻辑

    (1) 相关博文地址: SpringBoot + Vue + ElementUI 实现后台管理系统模板 -- 前端篇(一):搭建基本环境:https://www.cnblogs.com/l-y-h/p ...

  2. Redis操作Set工具类封装,Java Redis Set命令封装

    Redis操作Set工具类封装,Java Redis Set命令封装 >>>>>>>>>>>>>>>>& ...

  3. Redis操作List工具类封装,Java Redis List命令封装

    Redis操作List工具类封装,Java Redis List命令封装 >>>>>>>>>>>>>>>> ...

  4. Redis操作Hash工具类封装,Redis工具类封装

    Redis操作Hash工具类封装,Redis工具类封装 >>>>>>>>>>>>>>>>>> ...

  5. Redis操作字符串工具类封装,Redis工具类封装

    Redis操作字符串工具类封装,Redis工具类封装 >>>>>>>>>>>>>>>>>>& ...

  6. 项目经验分享——Java常用工具类集合 转

    http://blog.csdn.net/xyw591238/article/details/51678525 写在前面     本文涉及的工具类部分是自己编写,另一部分是在项目里收集的.工具类涉及数 ...

  7. spring项目中 通过自定义applicationContext工具类获取到applicationContext上下文对象

    spring项目在服务器启动的时候 spring容器中就已经被创建好了各种对象,在我们需要使用的时候可以进行调用. 工具类代码如下 import org.springframework.beans.B ...

  8. Redis,JedisPool工具类

    Redis,JedisPool工具类 1.JedisPool 详细配置解释代码 2.Jedis工具类 导入相关依赖: commons-pool2-2.3.jar jedis-2.7.0.jar 1.J ...

  9. Redis 与Spring-data-redis 整合后封装的工具类

    此工具类方法是使用了redis 与spring 整合后,才可以使用的工具类,将 spring-data-redis 一些我们开发中常用的方法进行了封装,方便我们日常开发中进行调用: package c ...

随机推荐

  1. Netty内置的编解码器和ChannelHandler

    Netty 为许多通用协议提供了编解码器和处理器,几乎可以开箱即用,这减少了你在那些相当繁琐的事务上本来会花费的时间与精力. 通过SSL/TLS 保护Netty 应用程序 SSL和TLS这样的安全协议 ...

  2. java中数据类型占多少字节

    基本类型(primitive type) 数值类型:byte占1个字节:short占2个字节:int占4个字节:long占8个字节:float占4个字节:double占8个字节.char占2个字节. ...

  3. Springboot定时任务@Scheduled注解形式,参数详解

    参数详解 1.占位符 1 秒 是 0-59 , - * / 2 分 是 0-59 , - * / 3 时 是 0-23 , - * / 4 日 是 1-31 , - * ? / L W 5 月 是 1 ...

  4. EasyCode插件使用及模板参考

    EasyCode插件使用及模板参考 1.介绍安装 Easycode是idea的一个插件,可以直接对数据的表生成entity.controller.service.dao.mapper无需任何编码,简单 ...

  5. java之死锁

    转载自 https://www.cnblogs.com/xiaoxi/p/8311034.html 一.死锁的定义 多线程以及多进程改善了系统资源的利用率并提高了系统 的处理能力.然而,并发执行也带来 ...

  6. CCNP:重发布及实验

    重发布(又:重分布.重分发):一台设备同时运行于两个协议或两个进程,默认从两端学习到的路由条目不共享:重发布技术就是人为的进行共享. 一  满足: 1.必须存在ASBR --- 自治系统边界路由器-- ...

  7. 牛客在线习题:链表的k各节点翻转

    题目描述 将给出的链表中的节点每\ k k 个一组翻转,返回翻转后的链表如果链表中的节点数不是\ k k 的倍数,将最后剩下的节点保持原样你不能更改节点中的值,只能更改节点本身.要求空间复杂度 \ O ...

  8. DevOps Next-AI / ML虚拟会议

    这个中秋国庆,一起进阶反超呀!10月1日星期四,加入DevOps Next,可以参加有关AI和ML的免费活动,内容涉及持续测试,代码质量和DevOps生产力.优秀的你一起来加入! 关于本次活动 Dev ...

  9. 你在开发过程中使用Git Rebase还是Git Merge?

    摘要:在git里面经常的一个争论是到底用rebase还是用merge? 1. 痛苦吗?代码历史中的迷失羔羊 我们先来看一个真实的代码提交历史图形化截图: 图片源自 https://storage.kr ...

  10. Spring学习(九)--Spring的AOP

    1.配置ProxyFactoryBean Spring IOC容器中创建Spring AOP的方法. (1)配置ProxyFactoryBean的Advisor通知器 通知器实现定义了对目标对象进行增 ...