devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringBoot接口防重复和日志切面_localvariabletableparameternamediscoverer未找到

作者：weixin_40725706 | 2024-03-14 12:30:33

赞

踩

localvariabletableparameternamediscoverer未找到

简单通过redis过期处理接口重复和日志切面token+ip+参数+spel表单式

引入redis依赖

  1. <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-data-redis</artifactId>
  4.         </dependency>

yaml配置redis

  1. spring
  2.   redis:
  3.     host: 10.*.*.37
  4.     password: ***
  5.     database: 12
  6.     port: 6379

防重复切面注解

  1. import java.lang.annotation.ElementType;
  2. import java.lang.annotation.Retention;
  3. import java.lang.annotation.RetentionPolicy;
  4. import java.lang.annotation.Target;
  5.  
  6. /**
  7.  * Description VaildApiRecommit
  8.  *
  9.  * @ClassName VaildApiRecommit
  10.  * @date 2023.03.20 19:27
  11.  **/
  12. @Target(value = ElementType.METHOD)
  13. @Retention(RetentionPolicy.RUNTIME)
  14. public @interface VaildApiRecommit {
  15.     /**
  16.      * Description ConstantUtils.EXTAPIHEAD 是否从header头部获取到Authorization 不配置则从参数获取
  17.     **/
  18.     String value();
  19.  
  20.     /**
  21.      * 提交唯一标识组合 遵循spel表达式
  22.      * primaryKeys = "#processDefineKey"
  23.      */
  24.     String[] primaryKeys() default {};
  25.  
  26.     /**
  27.      * 校验时间间隔，如果指定覆盖默认系统属性值
  28.      */
  29.     long validateInterval() default 3;
  30. }

接口防重复切面

  1. import java.lang.reflect.Method;
  2. import java.math.BigInteger;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5.  
  6. import javax.annotation.Resource;
  7. import javax.servlet.http.HttpServletRequest;
  8.  
  9. import org.apache.commons.lang3.StringUtils;
  10. import org.aspectj.lang.JoinPoint;
  11. import org.aspectj.lang.annotation.AfterThrowing;
  12. import org.aspectj.lang.annotation.Aspect;
  13. import org.aspectj.lang.annotation.Before;
  14. import org.aspectj.lang.annotation.Pointcut;
  15. import org.aspectj.lang.reflect.MethodSignature;
  16. import org.springframework.beans.factory.annotation.Value;
  17. import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
  18. import org.springframework.core.annotation.AnnotationUtils;
  19. import org.springframework.core.annotation.Order;
  20. import org.springframework.expression.EvaluationContext;
  21. import org.springframework.expression.Expression;
  22. import org.springframework.expression.ExpressionParser;
  23. import org.springframework.expression.spel.standard.SpelExpressionParser;
  24. import org.springframework.expression.spel.support.StandardEvaluationContext;
  25. import org.springframework.stereotype.Component;
  26. import org.springframework.util.CollectionUtils;
  27. import org.springframework.util.DigestUtils;
  28. import org.springframework.web.context.request.RequestContextHolder;
  29. import org.springframework.web.context.request.ServletRequestAttributes;
  30.  
  31. import com.alibaba.fastjson.JSON;
  32. import com.adapter.common.base.exception.BusinessException;
  33. import com.adapter.common.base.redis.ConstantUtils;
  34. import com.adapter.utils.RedisUtil;
  35.  
  36. import cn.hutool.core.util.StrUtil;
  37.  
  38. /**
  39.  * Description ExtApiAopIdempotent
  40.  *
  41.  * @ClassName ExtApiAopIdempotent
  42.  * @date 2023.03.20 19:28
  43.  **/
  44. @Order(0)
  45. @Aspect
  46. @Component
  47. public class ValidApiRecommitAspect {
  48.  
  49.     @Resource
  50.     private RedisUtil redisUtil;
  51.  
  52.     @Value("${app.validateInterval}")
  53.     private Long validateInterval;
  54.  
  55.     @Pointcut("execution(* com.adapter.api..*.*(..))")
  56.     public void rlAop() {
  57.  
  58.     }
  59.  
  60.     /**
  61.      * 封装数据
  62.      */
  63.     public HttpServletRequest getRequest() {
  64.         ServletRequestAttributes attributes = (ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
  65.         HttpServletRequest request = attributes.getRequest();
  66.         return request;
  67.     }
  68.  
  69.     /**
  70.      * 异常返回通知，连接点抛出异常
  71.      *
  72.      * @param joinPoint
  73.      *            切入点
  74.      * @param e
  75.      *            异常信息
  76.      */
  77.     @AfterThrowing(pointcut = "rlAop()", throwing = "e")
  78.     public void saveExceptionOperateLog(JoinPoint joinPoint, Throwable e) {
  79.         throw BusinessException.create("重复提交检验失败" + e.getMessage());
  80.  
  81.     }
  82.  
  83.     @Before("rlAop()")
  84.     public void before(JoinPoint joinPoint) {
  85.         // 获取被增强的方法相关信息 - 查看方法上是否有次注解
  86.         MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature();
  87.         Method method = methodSignature.getMethod();
  88.         VaildApiRecommit declaredAnnotation = AnnotationUtils.findAnnotation(method, VaildApiRecommit.class);
  89.         if (declaredAnnotation != null) {
  90.             String values = declaredAnnotation.value();
  91.             String token = null;
  92.             HttpServletRequest request = getRequest();
  93.             if (values.equals(ConstantUtils.EXTAPIHEAD)) {
  94.                 token = request.getHeader("Authorization");
  95.             } else {
  96.                 token = request.getParameter("Authorization");
  97.             }
  98.             // 获取不到token
  99.             if (StrUtil.isEmpty(token)) {
  100.                 throw BusinessException.create("未找到鉴权头部信息");
  101.             }
  102.             // 存入redis的键token + method + ip + 参数
  103.             String key = getValidateKey(method, joinPoint.getArgs(), declaredAnnotation.primaryKeys(), token);
  104.             // 接口获取对应的令牌,如果能够获取该(从redis获取令牌)令牌(将当前令牌删除掉) 就直接执行该访问的业务逻辑
  105.             boolean isToken = redisUtil.hasKey(key);
  106.             // 接口获取对应的令牌,如果获取不到该令牌 直接返回请勿重复提交
  107.             if (isToken) {
  108.                 throw BusinessException.create("请勿重复请求");
  109.             } else {
  110.                 redisUtil.set(key, key, validateInterval);
  111.             }
  112.         }
  113.     }
  114.  
  115.     /**
  116.      * 获取每次请求Key token + ip+uri+paramsKey
  117.      */
  118.     private String getValidateKey(Method method, Object[] args, String[] primaryKeys, String token) {
  119.  
  120.         List<String> paramsKey = evalParamsKey(method, args, primaryKeys);
  121.         ServletRequestAttributes requestAttributes =
  122.             (ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
  123.         HttpServletRequest request = requestAttributes.getRequest();
  124.         String requestURI = request.getRequestURI();
  125.         String userIp = request.getRemoteAddr();
  126.  
  127.         StringBuilder requestKey = new StringBuilder();
  128.         requestKey.append(token);
  129.         if (StringUtils.isNotEmpty(userIp)) {
  130.             requestKey.append(userIp);
  131.         }
  132.  
  133.         if (StringUtils.isNotEmpty(requestURI)) {
  134.             requestKey.append(requestURI);
  135.         }
  136.         if (!CollectionUtils.isEmpty(paramsKey)) {
  137.             for (String primaryValue : paramsKey) {
  138.                 requestKey.append(primaryValue);
  139.             }
  140.         }
  141.  
  142.         if (CollectionUtils.isEmpty(paramsKey) && args != null) {
  143.             for (Object primaryValue : args) {
  144.                 if (primaryValue != null) {
  145.                     requestKey.append(JSON.toJSONString(primaryValue));
  146.                 }
  147.             }
  148.         }
  149.         // key压缩
  150.         return new BigInteger(1, DigestUtils.md5Digest(requestKey.toString().getBytes())).toString(16);
  151.     }
  152.  
  153.     /**
  154.      * Description 解析Spel表达式获取值
  155.      * 
  156.      * @param method
  157.      *            method
  158.      * @param args
  159.      *            请求的参数
  160.      * @param primaryKeys
  161.      *            spel表达式
  162.      * @return java.util.List<java.lang.String>
  163.      * @author
  164.      * @date 20:10 2023/3/20
  165.      **/
  166.     private List<String> evalParamsKey(Method method, Object[] args, String[] primaryKeys) {
  167.         List<String> primaryValues = new ArrayList<>();
  168.         if (primaryKeys != null) {
  169.             for (String primaryKey : primaryKeys) {
  170.                 ExpressionParser expressionParser = new SpelExpressionParser();
  171.                 Expression expression = expressionParser.parseExpression(primaryKey);
  172.                 EvaluationContext context = new StandardEvaluationContext();
  173.                 LocalVariableTableParameterNameDiscoverer discoverer = new LocalVariableTableParameterNameDiscoverer();
  174.                 String[] parameterNames = discoverer.getParameterNames(method);
  175.                 for (int i = 0; i < parameterNames.length; i++) {
  176.                     if (args[i] != null) {
  177.                         context.setVariable(parameterNames[i], args[i]);
  178.                     }
  179.                 }
  180.                 Object primaryValue = expression.getValue(context);
  181.                 if (primaryValue != null) {
  182.                     primaryValues.add(JSON.toJSONString(primaryValue));
  183.                 }
  184.             }
  185.         }
  186.         return primaryValues;
  187.     }
  188.  
  189. }

日志切面

  1. import java.lang.annotation.*;
  2.  
  3. /**
  4.  * @description: 用户行为日志注解
  5.  * 
  6.  */
  7. @Target({ElementType.METHOD})
  8. @Retention(RetentionPolicy.RUNTIME)
  9. @Documented
  10. public @interface BusinessOperateLog {
  11.  
  12.     /**
  13.      * 操作模块
  14.      * @return : java.lang.String
  15.      */
  16.     String operateModule() default "";
  17.  
  18.     /**
  19.      * 操作类型
  20.      * @return
  21.      */
  22.     String operateType() default "";
  23.  
  24.     /**
  25.      * 操作说明
  26.      * @return
  27.      */
  28.     String operateDesc() default "";
  29. }
  1. import cn.hutool.core.util.ObjectUtil;
  2. import cn.hutool.json.JSONUtil;
  3. import com.adapter.dto.log.ManageOperateDTO;
  4. import com.adapter.service.ManageOperateService;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.aspectj.lang.JoinPoint;
  7. import org.aspectj.lang.annotation.AfterReturning;
  8. import org.aspectj.lang.annotation.AfterThrowing;
  9. import org.aspectj.lang.annotation.Aspect;
  10. import org.aspectj.lang.annotation.Pointcut;
  11. import org.aspectj.lang.reflect.MethodSignature;
  12. import org.springframework.core.annotation.AnnotationUtils;
  13. import org.springframework.core.annotation.Order;
  14. import org.springframework.stereotype.Component;
  15.  
  16. import javax.annotation.Resource;
  17. import java.lang.reflect.Method;
  18. import java.util.Date;
  19.  
  20. /**
  21.  * @description: 系统日志
  22.  */
  23. @Order(2)
  24. @Aspect
  25. @Component
  26. @Slf4j
  27. public class SysLogAspect {
  28.  
  29. //日志持久类   
  30.  @Resource
  31.     private ManageOperateService manageOperateService;
  32.  
  33.     /****************************************************
  34.      * 系统行为日志
  35.      ********************************************************/
  36.  
  37.     /**
  38.      * 注解切入点
  39.      */
  40.     @Pointcut(
  41.         value = "execution(* com.adapter.api..*.*(..))")
  42.     public void operateLogPointCut() {
  43.         // 这是一个切入点
  44.     }
  45.  
  46.     /**
  47.      * 前端用户操作行为成功
  48.      */
  49.     private static final String OPERATE_STATUS_SUCCESS = "1";
  50.  
  51.     /**
  52.      * 前端用户操作行为失败
  53.      */
  54.     private static final String OPERATE_STATUS_FAIL = "0";
  55.  
  56.     /**
  57.      * 正常返回通知，拦截用户操作日志，连接点正常执行完成后执行， 如果连接点抛出异常，则不会执行
  58.      *
  59.      * @param joinPoint
  60.      *            切入点
  61.      * @param keys
  62.      *            返回结果
  63.      */
  64.     @AfterReturning(value = "operateLogPointCut()", returning = "keys")
  65.     public void saveOperateLog(JoinPoint joinPoint, Object keys) {
  66.         operate(joinPoint, OPERATE_STATUS_SUCCESS);
  67.     }
  68.  
  69.     /**
  70.      * 异常返回通知，用于拦截异常日志信息 连接点抛出异常后执行
  71.      *
  72.      * @param joinPoint
  73.      *            切入点
  74.      * @param e
  75.      *            异常信息
  76.      */
  77.     @AfterThrowing(pointcut = "operateLogPointCut()", throwing = "e")
  78.     public void saveExceptionOperateLog(JoinPoint joinPoint, Throwable e) {
  79.         operate(joinPoint, OPERATE_STATUS_FAIL);
  80.  
  81.     }
  82.  
  83.     private void operate(JoinPoint joinPoint, String operateStatus) {
  84.  
  85.         // 从切面织入点处通过反射机制获取织入点处的方法
  86.         MethodSignature signature = (MethodSignature)joinPoint.getSignature();
  87.         // 获取切入点所在的方法
  88.         Method method = signature.getMethod();
  89.         String s = JSONUtil.toJsonStr(joinPoint.getArgs());
  90.         log.info("保存到日志中的参数是：{}", s);
  91.         // 获取操作
  92.         BusinessOperateLog businessOperateLog = AnnotationUtils.findAnnotation(method, BusinessOperateLog.class);
  93.         if (ObjectUtil.isNotEmpty(businessOperateLog)) {
  94.             String desc = "【" + businessOperateLog.operateModule() + "】" + "-【" + businessOperateLog.operateType()
  95.                 + "】，" + businessOperateLog.operateDesc() + ",参数：" + s;
  96.             ManageOperateDTO manageOperateDTO = new ManageOperateDTO();
  97.             // manageOperateDTO.setManageUserId(SecurityUtil.currentUserId());
  98.             manageOperateDTO.setOperateTime(new Date());
  99.             manageOperateDTO.setOperateStatus(operateStatus);
  100.             manageOperateDTO.setOperateContent(desc);
  101.             // manageOperateDTO.setCreator(SecurityUtil.getCurrentUser().getUserName());
  102.             // manageOperateDTO.setAreaCode(SecurityUtil.getVaildCodes());
  103.             manageOperateService.add(manageOperateDTO);
  104.         }
  105.     }
  106.  
  107. }

注解使用

  1.  public class OperateType {
  2.  
  3.     private OperateType() {}
  4.  
  5.     /**
  6.      * 新增
  7.      */
  8.     public final static String ADD = "ADD";
  9.  
  10.     /**
  11.      * 修改
  12.      */
  13.     public final static String UPDATE = "UPDATE";
  14.  
  15.     /**
  16.      * 删除
  17.      */
  18.     public final static String DELETE = "DELETE";
  19.  
  20.     /**
  21.      * 批量删除
  22.      */
  23.     public final static String BATCH_DELETE = "BATCH_DELETE";
  24.  
  25.     /**
  26.      * 查询
  27.      */
  28.     public final static String QUERY = "QUERY";
  29.  
  30.     /**
  31.      * 导出
  32.      */
  33.     public final static String EXPORT = "EXPORT";
  34.  
  35.     /**
  36.      * 导入
  37.      */
  38.     public final static String IMPORT = "IMPORT";
  39.  
  40.     /**
  41.      * 审核
  42.      */
  43.     public final static String AUDIT = "AUDIT";
  44. }
  45.  
  46. /**
  47.      * 新增
  48.      *
  49.      * @param entity entity
  50.      * @return boolean
  51.      */
  52.     @VaildApiRecommit(value = ConstantUtils.EXTAPIHEAD)
  53.     @ApiOperation(value = "新增", notes = "新增")
  54.     @PostMapping("/add")
  55.     @BusinessOperateLog(operateModule = "接口新增", operateType = OperateType.ADD, operateDesc = "新增接口")
  56.     public JsonResponse<Boolean> add(@RequestBody @ApiParam(value = "新增数据类", name = "entity") T entity) {
  57.         return JsonResponse.ok(baseService.insert(entity));
  58.     }

redis工具类

  1. import com.adapter.common.base.exception.BusinessException;
  2. import lombok.extern.slf4j.Slf4j;
  3. import org.springframework.data.redis.core.RedisTemplate;
  4. import org.springframework.stereotype.Component;
  5. import org.springframework.util.CollectionUtils;
  6.  
  7. import javax.annotation.Resource;
  8. import java.util.List;
  9. import java.util.Map;
  10. import java.util.Set;
  11. import java.util.concurrent.TimeUnit;
  12. @Component
  13. @Slf4j
  14. public class RedisUtil {
  15.  
  16.     @Resource
  17.     private RedisTemplate<String, Object> redisTemplate;
  18.  
  19.     private final static String GET_ERROR_MESSAGE = "获取缓存数据失败";
  20.  
  21.     private final static String SET_ERROR_MESSAGE = "设置缓存数据失败";
  22.  
  23.     private final static String DELETE_ERROR_MESSAGE = "删除缓存数据失败";
  24.  
  25.     /**
  26.      * 根据keys pattern 进行模糊匹配查询存在的key值
  27.      *
  28.      * @param keys K pattern
  29.      * @return
  30.      */
  31.     public Set<String> keys(String keys) {
  32.         try {
  33.             return redisTemplate.keys(keys);
  34.         } catch (Exception e) {
  35.             log.error(e.getMessage());
  36.             throw BusinessException.create(GET_ERROR_MESSAGE);
  37.         }
  38.     }
  39.  
  40.     /**
  41.      * 指定缓存失效时间
  42.      *
  43.      * @param key  键
  44.      * @param time 时间(秒)
  45.      * @return
  46.      */
  47.     public boolean expire(String key, long time) {
  48.         try {
  49.             if (time > 0) {
  50.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  51.             }
  52.             return true;
  53.         } catch (Exception e) {
  54.             e.printStackTrace();
  55.             log.error(e.getMessage());
  56.             throw BusinessException.create("插入缓存数据失败");
  57.             //return false;
  58.         }
  59.     }
  60.  
  61.     /**
  62.      * 根据key 获取过期时间
  63.      *
  64.      * @param key 键 不能为null
  65.      * @return 时间(秒) 返回0代表为永久有效
  66.      */
  67.     public long getExpire(String key) {
  68.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  69.     }
  70.  
  71.     /**
  72.      * 判断key是否存在
  73.      *
  74.      * @param key 键
  75.      * @return true 存在 false不存在
  76.      */
  77.     public boolean hasKey(String key) {
  78.         try {
  79.             return redisTemplate.hasKey(key);
  80.         } catch (Exception e) {
  81.             //e.printStackTrace();
  82.             log.error(e.getMessage());
  83.             throw BusinessException.create("判断缓存数据失败");
  84.             //return false;
  85.         }
  86.     }
  87.  
  88.     /**
  89.      * 删除缓存
  90.      *
  91.      * @param key 可以传一个值 或多个
  92.      */
  93.     @SuppressWarnings("unchecked")
  94.     public void del(String... key) {
  95.         if (key != null && key.length > 0) {
  96.             try {
  97.                 if (key.length == 1) {
  98.                     redisTemplate.delete(key[0]);
  99.                 } else {
  100.                     redisTemplate.delete(CollectionUtils.arrayToList(key));
  101.                 }
  102.             } catch (Exception e) {
  103.                 log.error(e.getMessage());
  104.                 throw BusinessException.create("删除缓存数据失败");
  105.             }
  106.         }
  107.     }
  108.  
  109.     /**
  110.      * 普通缓存获取
  111.      *
  112.      * @param key 键
  113.      * @return 值
  114.      */
  115.     public Object get(String key) {
  116.  
  117.         try {
  118.             return key == null ? null : redisTemplate.opsForValue().get(key);
  119.         } catch (Exception e) {
  120.             e.printStackTrace();
  121.             log.error(e.getMessage());
  122.             throw BusinessException.create(GET_ERROR_MESSAGE);
  123.         }
  124.     }
  125.  
  126.     /**
  127.      * 普通缓存放入
  128.      *
  129.      * @param key   键
  130.      * @param value 值
  131.      * @return true成功 false失败
  132.      */
  133.     public boolean set(String key, Object value) {
  134.         try {
  135.             redisTemplate.opsForValue().set(key, value);
  136.             return true;
  137.         } catch (Exception e) {
  138.             //e.printStackTrace();
  139.             log.error(e.getMessage());
  140.             throw BusinessException.create("插入缓存数据失败");
  141.             //return false;
  142.         }
  143.     }
  144.  
  145.     /**
  146.      * 普通缓存放入并设置时间
  147.      *
  148.      * @param key   键
  149.      * @param value 值
  150.      * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
  151.      * @return true成功 false 失败
  152.      */
  153.     public boolean set(String key, Object value, long time) {
  154.         try {
  155.             if (time > 0) {
  156.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  157.             } else {
  158.                 set(key, value);
  159.             }
  160.             return true;
  161.         } catch (Exception e) {
  162.             e.printStackTrace();
  163.             log.error(e.getMessage());
  164.             throw BusinessException.create("插入缓存数据失败");
  165.             //return false;
  166.         }
  167.     }
  168.  
  169.     /**
  170.      * 递增
  171.      *
  172.      * @param key   键
  173.      * @param delta 要增加几(大于0)
  174.      * @return
  175.      */
  176.     public long incr(String key, long delta) {
  177.         if (delta < 0) {
  178.             throw new RuntimeException("递增因子必须大于0");
  179.         }
  180.         return redisTemplate.opsForValue().increment(key, delta);
  181.     }
  182.  
  183.     /**
  184.      * 递减
  185.      *
  186.      * @param key   键
  187.      * @param delta 要减少几(小于0)
  188.      * @return
  189.      */
  190.     public long decr(String key, long delta) {
  191.         if (delta < 0) {
  192.             throw new RuntimeException("递减因子必须大于0");
  193.         }
  194.         return redisTemplate.opsForValue().increment(key, -delta);
  195.     }
  196.  
  197.     // ===============================Hash=================================
  198.  
  199.     /**
  200.      * HashGet
  201.      *
  202.      * @param key  键 不能为null
  203.      * @param item 项 不能为null
  204.      * @return 值
  205.      */
  206.     public Object hget(String key, String item) {
  207.         try {
  208.             return redisTemplate.opsForHash().get(key, item);
  209.         } catch (Exception e) {
  210.             log.error(e.getMessage());
  211.             throw BusinessException.create(GET_ERROR_MESSAGE);
  212.         }
  213.     }
  214.  
  215.     /**
  216.      * 获取hashKey对应的所有键值
  217.      *
  218.      * @param key 键
  219.      * @return 对应的多个键值
  220.      */
  221.     public Map<Object, Object> hmget(String key) {
  222.         try {
  223.             return redisTemplate.opsForHash().entries(key);
  224.         } catch (Exception e) {
  225.             log.error(e.getMessage());
  226.             throw BusinessException.create(GET_ERROR_MESSAGE);
  227.         }
  228.     }
  229.  
  230.     /**
  231.      * HashSet
  232.      *
  233.      * @param key 键
  234.      * @param map 对应多个键值
  235.      * @return true 成功 false 失败
  236.      */
  237.     public boolean hmset(String key, Map<String, Object> map) {
  238.         try {
  239.             redisTemplate.opsForHash().putAll(key, map);
  240.             return true;
  241.         } catch (Exception e) {
  242.             //e.printStackTrace();
  243.             log.error(e.getMessage());
  244.             throw BusinessException.create(GET_ERROR_MESSAGE);
  245.             //return false;
  246.         }
  247.     }
  248.  
  249.     /**
  250.      * HashSet 并设置时间
  251.      *
  252.      * @param key  键
  253.      * @param map  对应多个键值
  254.      * @param time 时间(秒)
  255.      * @return true成功 false失败
  256.      */
  257.     public boolean hmset(String key, Map<String, Object> map, long time) {
  258.         try {
  259.             redisTemplate.opsForHash().putAll(key, map);
  260.             if (time > 0) {
  261.                 expire(key, time);
  262.             }
  263.             return true;
  264.         } catch (Exception e) {
  265.             //e.printStackTrace();
  266.             log.error(e.getMessage());
  267.             throw BusinessException.create(GET_ERROR_MESSAGE);
  268.             //return false;
  269.         }
  270.     }
  271.  
  272.     /**
  273.      * 向一张hash表中放入数据,如果不存在将创建
  274.      *
  275.      * @param key   键
  276.      * @param item  项
  277.      * @param value 值
  278.      * @return true 成功 false失败
  279.      */
  280.     public boolean hset(String key, String item, Object value) {
  281.         try {
  282.             redisTemplate.opsForHash().put(key, item, value);
  283.             return true;
  284.         } catch (Exception e) {
  285.             //e.printStackTrace();
  286.             log.error(e.getMessage());
  287.             throw BusinessException.create(GET_ERROR_MESSAGE);
  288.             //return false;
  289.         }
  290.     }
  291.  
  292.     /**
  293.      * 向一张hash表中放入数据,如果不存在将创建
  294.      *
  295.      * @param key   键
  296.      * @param item  项
  297.      * @param value 值
  298.      * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
  299.      * @return true 成功 false失败
  300.      */
  301.     public boolean hset(String key, String item, Object value, long time) {
  302.         try {
  303.             redisTemplate.opsForHash().put(key, item, value);
  304.             if (time > 0) {
  305.                 expire(key, time);
  306.             }
  307.             return true;
  308.         } catch (Exception e) {
  309.             //e.printStackTrace();
  310.             log.error(e.getMessage());
  311.             throw BusinessException.create(GET_ERROR_MESSAGE);
  312.             //return false;
  313.         }
  314.     }
  315.  
  316.     /**
  317.      * 删除hash表中的值
  318.      *
  319.      * @param key  键 不能为null
  320.      * @param item 项 可以使多个 不能为null
  321.      */
  322.     public void hdel(String key, Object... item) {
  323.         try {
  324.             redisTemplate.opsForHash().delete(key, item);
  325.         } catch (Exception e) {
  326.             log.error(e.getMessage());
  327.             throw BusinessException.create("删除缓存数据失败");
  328.         }
  329.     }
  330.  
  331.     /**
  332.      * 判断hash表中是否有该项的值
  333.      *
  334.      * @param key  键 不能为null
  335.      * @param item 项 不能为null
  336.      * @return true 存在 false不存在
  337.      */
  338.     public boolean hHasKey(String key, String item) {
  339.         try {
  340.             return redisTemplate.opsForHash().hasKey(key, item);
  341.         } catch (Exception e) {
  342.             log.error(e.getMessage());
  343.             throw BusinessException.create(GET_ERROR_MESSAGE);
  344.         }
  345.     }
  346.  
  347.     /**
  348.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
  349.      *
  350.      * @param key  键
  351.      * @param item 项
  352.      * @param by   要增加几(大于0)
  353.      * @return
  354.      */
  355.     public double hincr(String key, String item, double by) {
  356.         return redisTemplate.opsForHash().increment(key, item, by);
  357.     }
  358.  
  359.     /**
  360.      * hash递减
  361.      *
  362.      * @param key  键
  363.      * @param item 项
  364.      * @param by   要减少记(小于0)
  365.      * @return
  366.      */
  367.     public double hdecr(String key, String item, double by) {
  368.         return redisTemplate.opsForHash().increment(key, item, -by);
  369.     }
  370.  
  371.     // ===============================Set=================================
  372.  
  373.     /**
  374.      * 根据key获取Set中的所有值
  375.      *
  376.      * @param key 键
  377.      * @return
  378.      */
  379.     public Set<Object> sGet(String key) {
  380.         try {
  381.             return redisTemplate.opsForSet().members(key);
  382.         } catch (Exception e) {
  383.             log.error(e.getMessage());
  384.             throw BusinessException.create(GET_ERROR_MESSAGE);
  385.         }
  386.     }
  387.  
  388.     /**
  389.      * 根据value从一个set中查询,是否存在
  390.      *
  391.      * @param key   键
  392.      * @param value 值
  393.      * @return true 存在 false不存在
  394.      */
  395.     public boolean sHasKey(String key, Object value) {
  396.         try {
  397.             return redisTemplate.opsForSet().isMember(key, value);
  398.         } catch (Exception e) {
  399.             log.error(e.getMessage());
  400.             throw BusinessException.create(GET_ERROR_MESSAGE);
  401.         }
  402.     }
  403.  
  404.     /**
  405.      * 将数据放入set缓存
  406.      *
  407.      * @param key    键
  408.      * @param values 值 可以是多个
  409.      * @return 成功个数
  410.      */
  411.     public long sSet(String key, Object... values) {
  412.         try {
  413.             return redisTemplate.opsForSet().add(key, values);
  414.         } catch (Exception e) {
  415.             log.error(e.getMessage());
  416.             throw BusinessException.create(SET_ERROR_MESSAGE);
  417.         }
  418.     }
  419.  
  420.     /**
  421.      * 将set数据放入缓存
  422.      *
  423.      * @param key    键
  424.      * @param time   时间(秒)
  425.      * @param values 值 可以是多个
  426.      * @return 成功个数
  427.      */
  428.     public long sSetAndTime(String key, long time, Object... values) {
  429.         try {
  430.             Long count = redisTemplate.opsForSet().add(key, values);
  431.             if (time > 0) {
  432.                 expire(key, time);
  433.             }
  434.             return count;
  435.         } catch (Exception e) {
  436.             log.error(e.getMessage());
  437.             throw BusinessException.create(SET_ERROR_MESSAGE);
  438.         }
  439.     }
  440.  
  441.     /**
  442.      * 获取set缓存的长度
  443.      *
  444.      * @param key 键
  445.      * @return
  446.      */
  447.     public long sGetSetSize(String key) {
  448.         try {
  449.             return redisTemplate.opsForSet().size(key);
  450.         } catch (Exception e) {
  451.             log.error(e.getMessage());
  452.             throw BusinessException.create(GET_ERROR_MESSAGE);
  453.         }
  454.     }
  455.  
  456.     /**
  457.      * 移除值为value的
  458.      *
  459.      * @param key    键
  460.      * @param values 值 可以是多个
  461.      * @return 移除的个数
  462.      */
  463.     public long setRemove(String key, Object... values) {
  464.         try {
  465.             Long count = redisTemplate.opsForSet().remove(key, values);
  466.             return count;
  467.         } catch (Exception e) {
  468.             log.error(e.getMessage());
  469.             throw BusinessException.create(DELETE_ERROR_MESSAGE);
  470.         }
  471.     }
  472.  
  473.     // ===============================list=================================
  474.  
  475.     /**
  476.      * 获取list缓存的内容
  477.      *
  478.      * @param key   键
  479.      * @param start 开始
  480.      * @param end   结束 0 到 -1代表所有值
  481.      * @return
  482.      */
  483.     public List<Object> lGet(String key, long start, long end) {
  484.         try {
  485.             return redisTemplate.opsForList().range(key, start, end);
  486.         } catch (Exception e) {
  487.             log.error(e.getMessage());
  488.             throw BusinessException.create(GET_ERROR_MESSAGE);
  489.         }
  490.     }
  491.  
  492.     /**
  493.      * 获取list缓存的长度
  494.      *
  495.      * @param key 键
  496.      * @return
  497.      */
  498.     public long lGetListSize(String key) {
  499.         try {
  500.             return redisTemplate.opsForList().size(key);
  501.         } catch (Exception e) {
  502.             log.error(e.getMessage());
  503.             throw BusinessException.create(GET_ERROR_MESSAGE);
  504.         }
  505.     }
  506.  
  507.     /**
  508.      * 通过索引 获取list中的值
  509.      *
  510.      * @param key   键
  511.      * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  512.      * @return
  513.      */
  514.     public Object lGetIndex(String key, long index) {
  515.         try {
  516.             return redisTemplate.opsForList().index(key, index);
  517.         } catch (Exception e) {
  518.             log.error(e.getMessage());
  519.             throw BusinessException.create(GET_ERROR_MESSAGE);
  520.         }
  521.     }
  522.  
  523.     /**
  524.      * 将list放入缓存
  525.      *
  526.      * @param key   键
  527.      * @param value 值
  528.      * @return
  529.      */
  530.     public boolean lSet(String key, Object value) {
  531.         try {
  532.             redisTemplate.opsForList().rightPush(key, value);
  533.             return true;
  534.         } catch (Exception e) {
  535.             log.error(e.getMessage());
  536.             throw BusinessException.create(SET_ERROR_MESSAGE);
  537.         }
  538.     }
  539.  
  540.     /**
  541.      * 将list放入缓存
  542.      *
  543.      * @param key   键
  544.      * @param value 值
  545.      * @param time  时间(秒)
  546.      * @return
  547.      */
  548.     public boolean lSet(String key, Object value, long time) {
  549.         try {
  550.             redisTemplate.opsForList().rightPush(key, value);
  551.             if (time > 0) {
  552.                 expire(key, time);
  553.             }
  554.             return true;
  555.         } catch (Exception e) {
  556.             log.error(e.getMessage());
  557.             throw BusinessException.create(SET_ERROR_MESSAGE);
  558.         }
  559.     }
  560.  
  561.     /**
  562.      * 将list放入缓存
  563.      *
  564.      * @param key   键
  565.      * @param value 值
  566.      * @return
  567.      */
  568.     public boolean lSet(String key, List<Object> value) {
  569.         try {
  570.             redisTemplate.opsForList().rightPushAll(key, value);
  571.             return true;
  572.         } catch (Exception e) {
  573.             log.error(e.getMessage());
  574.             throw BusinessException.create(SET_ERROR_MESSAGE);
  575.         }
  576.     }
  577.  
  578.     /**
  579.      * 将list放入缓存
  580.      *
  581.      * @param key   键
  582.      * @param value 值
  583.      * @param time  时间(秒)
  584.      * @return
  585.      */
  586.     public boolean lSet(String key, List<Object> value, long time) {
  587.         try {
  588.             redisTemplate.opsForList().rightPushAll(key, value);
  589.             if (time > 0) {
  590.                 expire(key, time);
  591.             }
  592.             return true;
  593.         } catch (Exception e) {
  594.             log.error(e.getMessage());
  595.             throw BusinessException.create(SET_ERROR_MESSAGE);
  596.         }
  597.     }
  598.  
  599.     /**
  600.      * 根据索引修改list中的某条数据
  601.      *
  602.      * @param key   键
  603.      * @param index 索引
  604.      * @param value 值
  605.      * @return
  606.      */
  607.     public boolean lUpdateIndex(String key, long index, Object value) {
  608.         try {
  609.             redisTemplate.opsForList().set(key, index, value);
  610.             return true;
  611.         } catch (Exception e) {
  612.             log.error(e.getMessage());
  613.             throw BusinessException.create(SET_ERROR_MESSAGE);
  614.         }
  615.     }
  616.  
  617.     /**
  618.      * 移除N个值为value
  619.      *
  620.      * @param key   键
  621.      * @param count 移除多少个
  622.      * @param value 值
  623.      * @return 移除的个数
  624.      */
  625.     public long lRemove(String key, long count, Object value) {
  626.         try {
  627.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  628.             return remove;
  629.         } catch (Exception e) {
  630.             log.error(e.getMessage());
  631.             throw BusinessException.create(DELETE_ERROR_MESSAGE);
  632.         }
  633.     }
  634.  
  635. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/234434
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号