SpringBoot 实现用户登录，分布式Session功能

avatar 2019年07月22日16:32:56 9 28598 views
博主分享免费Java教学视频，B站账号：Java刘哥 ，长期提供技术问题解决、项目定制：本站商品点此
之前介绍过不少关于登录功能的代码，本文介绍一下关于分布式Session 的功能实现，

完整代码（以后写博客，尽量给 git 地址）在 https://github.com/saysky/sensboot



通常，我们的项目都是多实例部署的，生产环境通常一个模块可能都会部署四五台服务器。

我们知道用户登录后，需要存储 session 信息，session 信息通常是存储在服务器的内存中的，不能持久化(服务器重启失效)，多台服务器也不能共存。为了解决这个问题，我们可以将 session 存到几个服务器共享的地方里去，比如 Redis，只要在一个内网中，几台服务器可以共享 Redis (Redis本质也是装在某台服务器中)。

具体怎么实现呢？这里简单描述下：
  1. 用户登录成功，通过UUID生成一个随机唯一字符串，命名为 token，通过向 redis 中 set 一个值，key 为 token 字符串，value 为用户对象序列化后的字符串。
  2. 当用户访问其他页面，请求方法时，检验请求参数或 cookie 中是否有 token
  3. 如果有，则从 redis 查询 token，验证 token 是否有效
  4. 如果没有，则抛出异常 “用户未登录”



关于参数验证，这里可以通过 SpringMVC 的 resolveArgument 方法来统一解决，即所有方法参数验证时都会验证用户名是否登录。而不需要在每个方法里都写一段检查用户名是否登录，这样就太冗余了。



下面是具体实现，由上到下(重要到次要)贴代码，完整代码在 GitHub 中可以获取。


一、基本登录

  1. LoginController

登录的实现在 UserServiceImpl 中
  1. package com.liuyanzhao.sens.controller;
  3. import com.liuyanzhao.sens.result.Result;
  4. import com.liuyanzhao.sens.service.UserService;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Controller;
  8. import org.springframework.web.bind.annotation.PostMapping;
  9. import org.springframework.web.bind.annotation.RequestParam;
  10. import org.springframework.web.bind.annotation.ResponseBody;
  12. import javax.servlet.http.HttpServletResponse;
  14. /**
  15.  * @author 言曌
  16.  * @date 2019-07-22 14:07
  17.  */
  18. @Controller
  19. @Slf4j
  20. public class LoginController {
  22.     @Autowired
  23.     private UserService userService;
  26.     /**
  27.      * 登录功能
  28.      * 验证用户名和密码，登录成功，生成token，存入到redis中
  29.      * 登录成功
  30.      *
  31.      * @param response
  32.      * @param username
  33.      * @param password
  34.      * @return
  35.      */
  36.     @PostMapping("/doLogin")
  37.     @ResponseBody
  38.     public Result<String> doLogin(HttpServletResponse response,
  39.                                   @RequestParam("username") String username,
  40.                                   @RequestParam("password") String password) {
  41.         //登录
  42.         log.info("用户登录：username:{}, password:{}", username, password);
  44.         //判断用户名是否存在
  45.         String token = userService.login(response, username, password);
  46.         return Result.success(token);
  47.     }
  50. }



2. UserServiceImpl

为了代码简洁，UserService 接口这里就不贴了
  1. package com.liuyanzhao.sens.service.impl;
  3. import com.alibaba.fastjson.JSON;
  4. import com.baomidou.mybatisplus.plugins.Page;
  5. import com.liuyanzhao.sens.entity.User;
  6. import com.liuyanzhao.sens.exception.GlobalException;
  7. import com.liuyanzhao.sens.mapper.UserMapper;
  8. import com.liuyanzhao.sens.result.CodeMsg;
  9. import com.liuyanzhao.sens.service.UserService;
  10. import com.liuyanzhao.sens.utils.RedisUtil;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.stereotype.Service;
  13. import org.springframework.util.StringUtils;
  15. import javax.servlet.http.Cookie;
  16. import javax.servlet.http.HttpServletResponse;
  17. import java.util.UUID;
  19. /**
  20.  * 用户业务逻辑实现类
  21.  * MyBatis Plus 版本
  22.  */
  23. @Service
  24. public class UserServiceImpl implements UserService {
  27.     public static final String COOKIE_NAME_TOKEN = "token";
  29.     /**
  30.      * token过期时间，2天
  31.      */
  32.     public static final int TOKEN_EXPIRE = 3600 * 24 * 2;
  35.     @Autowired
  36.     private UserMapper userMapper;
  38.     @Autowired
  39.     private RedisUtil redisUtil;
  41.     @Override
  42.     public User findByUsername(String username) {
  43.         return userMapper.findByUsername(username);
  44.     }
  47.     @Override
  48.     public String login(HttpServletResponse response, String username, String password) {
  50.         //判断用户名是否存在
  51.         User user = findByUsername(username);
  52.         if (user == null) {
  53.             throw new GlobalException(CodeMsg.USERNAME_NOT_EXIST);
  54.         }
  56.         //验证密码，这里为了例子简单，密码没有加密
  57.         String dbPass = user.getPassword();
  58.         if (!password.equals(dbPass)) {
  59.             throw new GlobalException(CodeMsg.PASSWORD_ERROR);
  60.         }
  62.         //生成cookie
  63.         String token = UUID.randomUUID().toString().replace("-", "");
  64.         addCookie(response, token, user);
  65.         return token;
  66.     }
  68.     @Override
  69.     public User getByToken(HttpServletResponse response, String token) {
  70.         if (StringUtils.isEmpty(token)) {
  71.             return null;
  72.         }
  73.         User user = JSON.parseObject(redisUtil.get(COOKIE_NAME_TOKEN + "::" + token), User.class);
  74.         //重置有效期
  75.         if (user == null) {
  76.             throw new GlobalException(CodeMsg.USER_NOT_LOGIN);
  77.         }
  78.         addCookie(response, token, user);
  79.         return user;
  80.     }
  82.     private void addCookie(HttpServletResponse response, String token, User user) {
  83.         //将token存入到redis
  84.         redisUtil.set(COOKIE_NAME_TOKEN + "::" + token, JSON.toJSONString(user), TOKEN_EXPIRE);
  85.         //将token写入cookie
  86.         Cookie cookie = new Cookie(COOKIE_NAME_TOKEN, token);
  87.         cookie.setMaxAge(TOKEN_EXPIRE);
  88.         cookie.setPath("/");
  89.         response.addCookie(cookie);
  90.     }
  93. }







3. UserMapper Dao层 和 User 实体 这里也不贴了

我相信你都学到了分布式 Session 这里，MyBatis 的基本使用应该不成问题吧

GitHub里也有完整代码



登录成功，目前密码是没有加密的，登录成功，data里有 token 字符串，前端可以将 token

存起来，比如 APP 端，没有 cookie 这种东西的话，可以存在 localStorage，然后请求的时候携带 token 到参数上即可。

目前我们后端是将 token 存在 cookie 里，所以前端非APP端，无需携带参数。






二、封装参数验证

  1. UserArgumentResolver
  1. package com.liuyanzhao.sens.config;
  3. import com.liuyanzhao.sens.entity.User;
  4. import com.liuyanzhao.sens.exception.GlobalException;
  5. import com.liuyanzhao.sens.result.CodeMsg;
  6. import com.liuyanzhao.sens.service.UserService;
  7. import com.liuyanzhao.sens.service.impl.UserServiceImpl;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.core.MethodParameter;
  10. import org.springframework.stereotype.Service;
  11. import org.springframework.util.StringUtils;
  12. import org.springframework.web.bind.support.WebDataBinderFactory;
  13. import org.springframework.web.context.request.NativeWebRequest;
  14. import org.springframework.web.method.support.HandlerMethodArgumentResolver;
  15. import org.springframework.web.method.support.ModelAndViewContainer;
  17. import javax.servlet.http.Cookie;
  18. import javax.servlet.http.HttpServletRequest;
  19. import javax.servlet.http.HttpServletResponse;
  22. /**
  23.  * 用户参数验证，验证是否有token
  24.  */
  25. @Service
  26. public class UserArgumentResolver implements HandlerMethodArgumentResolver {
  28.     @Autowired
  29.     private UserService userService;
  31.     @Override
  32.     public boolean supportsParameter(MethodParameter parameter) {
  33.         Class<?> clazz = parameter.getParameterType();
  34.         return clazz == User.class;
  35.     }
  37.     @Override
  38.     public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
  39.                                   NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
  40.         HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
  41.         HttpServletResponse response = webRequest.getNativeResponse(HttpServletResponse.class);
  43.         String paramToken = request.getParameter(UserServiceImpl.COOKIE_NAME_TOKEN);
  44.         String cookieToken = getCookieValue(request, UserServiceImpl.COOKIE_NAME_TOKEN);
  45.         if (StringUtils.isEmpty(cookieToken) && StringUtils.isEmpty(paramToken)) {
  46.             // return null;
  47.             throw new GlobalException(CodeMsg.USER_NOT_LOGIN);
  48.         }
  49.         String token = StringUtils.isEmpty(paramToken) ? cookieToken : paramToken;
  50.         return userService.getByToken(response, token);
  51.     }
  53.     private String getCookieValue(HttpServletRequest request, String cookiName) {
  54.         Cookie[] cookies = request.getCookies();
  55.         if (cookies == null || cookies.length <= 0) {
  56.             // return null;
  57.             throw new GlobalException(CodeMsg.TOKEN_INVALID);
  58.         }
  59.         for (Cookie cookie : cookies) {
  60.             if (cookie.getName().equals(cookiName)) {
  61.                 return cookie.getValue();
  62.             }
  63.         }
  64.         return null;
  65.     }
  68. }



2. WebConfig
  1. package com.liuyanzhao.sens.config;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.web.cors.CorsConfiguration;
  7. import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
  8. import org.springframework.web.filter.CorsFilter;
  9. import org.springframework.web.method.support.HandlerMethodArgumentResolver;
  10. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  12. import java.util.List;
  14. /**
  15.  * @author 言曌
  16.  * @date 2019-06-26 22:37
  17.  */
  18. @Configuration
  19. public class WebConfig implements WebMvcConfigurer {
  21.     @Autowired
  22.     UserArgumentResolver userArgumentResolver;
  25.     @Override
  26.     public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
  27.         //所有方法执行前，都会验证参数，检查token是否存在
  28.         argumentResolvers.add(userArgumentResolver);
  29.     }
  31.     /**
  32.      * 解决跨域
  33.      * @return
  34.      */
  35.     @Bean
  36.     public CorsFilter corsFilter() {
  37.         UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
  38.         source.registerCorsConfiguration("/**", buildConfig());
  39.         return new CorsFilter(source);
  40.     }
  42.     private CorsConfiguration buildConfig() {
  43.         CorsConfiguration corsConfiguration = new CorsConfiguration();
  44.         corsConfiguration.addAllowedOrigin("*");
  45.         corsConfiguration.setAllowCredentials(true);
  46.         corsConfiguration.addAllowedHeader("*");
  47.         corsConfiguration.addAllowedMethod("*");
  49.         return corsConfiguration;
  50.     }
  51. }



如上配置，可以实现 SpringMVC 验证参数时，会执行上面我们重写的 resolveArgument  方法，该方法的目的是验证请求参数或 cookie 中是否有 token，如果有则根据 token 查询用户，然后返回(如果返回了 user 对象，会自动注入到 参数中)，如下 UserController 中 current 方法示例，User user 里已有用户信息。



3. 验证请求

UserController
  1. package com.liuyanzhao.sens.controller;
  3. import com.liuyanzhao.sens.entity.User;
  4. import com.liuyanzhao.sens.result.Result;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.web.bind.annotation.*;
  9. /**
  10.  * 后台用户管理控制器
  11.  * 异常不用捕获，用统一异常捕获处理
  12.  *
  13.  * @author liuyanzhao
  14.  */
  15. @Slf4j
  16. @RestController
  17. @RequestMapping(value = "/user")
  18. public class UserController {
  20.     /**
  21.      * 当前登录用户
  22.      *
  23.      * @param user 用户信息，由封装注入
  24.      * @return
  25.      */
  26.     @RequestMapping("/current")
  27.     @ResponseBody
  28.     public Result<User> current(User user) {
  29.         return Result.success(user);
  30.     }
  31. }



这是登录后的，调用查询查询当前登录用户信息接口，即对应上面的方法

注意：cookies 不用自己客户端(请求方)管理，如果 浏览器或者 PostMan 对应该域名有 cookie 的话，会自动携带的，后端能直接获取的。





如果我这里，浏览器(或PostMan)清除 cookie，或者 token 过期，再次请求，就会返回用户未登录的状态信息




三、返回体和响应码封装

  1. 封装返回对象
  1. package com.liuyanzhao.sens.result;
  3. public class Result<T> {
  5.     private int code;
  6.     private String msg;
  7.     private T data;
  9.     /**
  10.      * 成功时候的调用
  11.      */
  12.     public static <T> Result<T> success() {
  13.         return new Result<T>(200, "成功");
  14.     }
  16.     /**
  17.      * 成功时候的调用
  18.      */
  19.     public static <T> Result<T> success(T data) {
  20.         return new Result<T>(200, "成功", data);
  21.     }
  23.     /**
  24.      * 失败时候的调用
  25.      */
  26.     public static <T> Result<T> error(CodeMsg codeMsg) {
  27.         return new Result<T>(codeMsg);
  28.     }
  30.     private Result(T data) {
  31.         this.data = data;
  32.     }
  34.     private Result(int code, String msg) {
  35.         this.code = code;
  36.         this.msg = msg;
  37.     }
  39.     private Result(int code, String msg, T data) {
  40.         this.code = code;
  41.         this.msg = msg;
  42.         this.data = data;
  43.     }
  45.     private Result(CodeMsg codeMsg) {
  46.         if (codeMsg != null) {
  47.             this.code = codeMsg.getCode();
  48.             this.msg = codeMsg.getMsg();
  49.         }
  50.     }
  53.     public int getCode() {
  54.         return code;
  55.     }
  57.     public void setCode(int code) {
  58.         this.code = code;
  59.     }
  61.     public String getMsg() {
  62.         return msg;
  63.     }
  65.     public void setMsg(String msg) {
  66.         this.msg = msg;
  67.     }
  69.     public T getData() {
  70.         return data;
  71.     }
  73.     public void setData(T data) {
  74.         this.data = data;
  75.     }
  76. }



2. 状态码
  1. package com.liuyanzhao.sens.result;
  3. /**
  4.  * 状态码，错误码
  5.  * @author liuyanzhao
  6.  */
  7. public class CodeMsg {
  9.     private int code;
  10.     private String msg;
  12.     //通用的错误码
  13.     public static CodeMsg SUCCESS = new CodeMsg(200, "成功");
  14.     public static CodeMsg SERVER_ERROR = new CodeMsg(500100, "服务端异常");
  15.     public static CodeMsg BIND_ERROR = new CodeMsg(500101, "参数校验异常：%s");
  16.     public static CodeMsg REQUEST_ILLEGAL = new CodeMsg(500102, "请求非法");
  17.     public static CodeMsg ACCESS_LIMIT_REACHED = new CodeMsg(500103, "访问太频繁！");
  19.     //登录模块 5002XX
  20.     public static CodeMsg USER_NOT_LOGIN = new CodeMsg(500200, "用户未登录");
  21.     public static CodeMsg TOKEN_INVALID = new CodeMsg(500201, "token无效");
  22.     public static CodeMsg USERNAME_NOT_EXIST = new CodeMsg(500202, "用户名不存在");
  23.     public static CodeMsg PASSWORD_ERROR = new CodeMsg(500203, "密码错误");
  26.     private CodeMsg() {
  27.     }
  29.     private CodeMsg(int code, String msg) {
  30.         this.code = code;
  31.         this.msg = msg;
  32.     }
  34.     public int getCode() {
  35.         return code;
  36.     }
  38.     public void setCode(int code) {
  39.         this.code = code;
  40.     }
  42.     public String getMsg() {
  43.         return msg;
  44.     }
  46.     public void setMsg(String msg) {
  47.         this.msg = msg;
  48.     }
  50.     public CodeMsg fillArgs(Object... args) {
  51.         int code = this.code;
  52.         String message = String.format(this.msg, args);
  53.         return new CodeMsg(code, message);
  54.     }
  56.     @Override
  57.     public String toString() {
  58.         return "CodeMsg [code=" + code + ", msg=" + msg + "]";
  59.     }
  62. }




四、统一异常处理

  1. 自定义统一异常
  1. package com.liuyanzhao.sens.exception;
  4. import com.liuyanzhao.sens.result.CodeMsg;
  6. /**
  7.  * 统一异常
  8.  */
  9. public class GlobalException extends RuntimeException{
  11.     private static final long serialVersionUID = 1L;
  13.     private CodeMsg cm;
  15.     public GlobalException(CodeMsg cm) {
  16.         super(cm.toString());
  17.         this.cm = cm;
  18.     }
  20.     public CodeMsg getCm() {
  21.         return cm;
  22.     }
  24. }



2. 统一异常处理类
  1. package com.liuyanzhao.sens.exception;
  3. import java.util.List;
  5. import javax.servlet.http.HttpServletRequest;
  7. import com.liuyanzhao.sens.result.CodeMsg;
  8. import com.liuyanzhao.sens.result.Result;
  9. import org.springframework.validation.BindException;
  10. import org.springframework.validation.ObjectError;
  11. import org.springframework.web.bind.annotation.ControllerAdvice;
  12. import org.springframework.web.bind.annotation.ExceptionHandler;
  13. import org.springframework.web.bind.annotation.ResponseBody;
  15. /**
  16.  * 统一异常处理
  17.  */
  18. @ControllerAdvice
  19. @ResponseBody
  20. public class GlobalExceptionHandler {
  22.     @ExceptionHandler(value = Exception.class)
  23.     public Result<String> exceptionHandler(HttpServletRequest request, Exception e) {
  24.         e.printStackTrace();
  25.         if (e instanceof GlobalException) {
  26.             GlobalException ex = (GlobalException) e;
  27.             return Result.error(ex.getCm());
  28.         } else if (e instanceof BindException) {
  29.             BindException ex = (BindException) e;
  30.             List<ObjectError> errors = ex.getAllErrors();
  31.             ObjectError error = errors.get(0);
  32.             String msg = error.getDefaultMessage();
  33.             return Result.error(CodeMsg.BIND_ERROR.fillArgs(msg));
  34.         } else {
  35.             return Result.error(CodeMsg.SERVER_ERROR);
  36.         }
  37.     }
  38. }


五、Redis 封装类

  1. package com.liuyanzhao.sens.utils;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.data.redis.core.StringRedisTemplate;
  5. import org.springframework.stereotype.Component;
  7. import java.util.Map;
  8. import java.util.Set;
  9. import java.util.concurrent.TimeUnit;
  11. /**
  12.  * @author 言曌
  13.  * @date 2018/12/16 下午6:57
  14.  */
  15. @Component
  16. public class RedisUtil {
  18.     @Autowired
  19.     private StringRedisTemplate redisTemplate;
  22.     // Key（键），简单的key-value操作
  23.     /**
  24.      * 实现命令：TTL key，以秒为单位，返回给定 key的剩余生存时间(TTL, time to live)。
  25.      *
  26.      * @param key
  27.      * @return
  28.      */
  29.     public long ttl(String key) {
  30.         return redisTemplate.getExpire(key);
  31.     }
  32.     /**
  33.      * 实现命令：expire 设置过期时间，单位秒
  34.      *
  35.      * @param key
  36.      * @return
  37.      */
  38.     public void expire(String key, long timeout) {
  39.         redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
  40.     }
  41.     /**
  42.      * 实现命令：INCR key，增加key一次
  43.      *
  44.      * @param key
  45.      * @return
  46.      */
  47.     public long incr(String key, long delta) {
  48.         return redisTemplate.opsForValue().increment(key, delta);
  49.     }
  52.     /**
  53.      * 实现命令： key，减少key一次
  54.      *
  55.      * @param key
  56.      * @return
  57.      */
  58.     public long decr(String key, long delta) {
  59.         if(delta<0){
  60. //            throw new RuntimeException("递减因子必须大于0");
  61.             del(key);
  62.             return 0;
  63.         }
  64.         return redisTemplate.opsForValue().increment(key, -delta);
  65.     }
  66.     /**
  67.      * 实现命令：KEYS pattern，查找所有符合给定模式 pattern的 key
  68.      */
  69.     public Set<String> keys(String pattern) {
  70.         return redisTemplate.keys(pattern);
  71.     }
  72.     /**
  73.      * 实现命令：DEL key，删除一个key
  74.      *
  75.      * @param key
  76.      */
  77.     public void del(String key) {
  78.         redisTemplate.delete(key);
  79.     }
  80.     // String（字符串）
  81.     /**
  82.      * 实现命令：SET key value，设置一个key-value（将字符串值 value关联到 key）
  83.      *
  84.      * @param key
  85.      * @param value
  86.      */
  87.     public void set(String key, String value) {
  88.         redisTemplate.opsForValue().set(key, value);
  89.     }
  90.     /**
  91.      * 实现命令：SET key value EX seconds，设置key-value和超时时间（秒）
  92.      *
  93.      * @param key
  94.      * @param value
  95.      * @param timeout （以秒为单位）
  96.      */
  97.     public void set(String key, String value, long timeout) {
  98.         redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
  99.     }
  100.     /**
  101.      * 实现命令：GET key，返回 key所关联的字符串值。
  102.      *
  103.      * @param key
  104.      * @return value
  105.      */
  106.     public String get(String key) {
  107.         return (String) redisTemplate.opsForValue().get(key);
  108.     }
  109.     // Hash（哈希表）
  110.     /**
  111.      * 实现命令：HSET key field value，将哈希表 key中的域 field的值设为 value
  112.      *
  113.      * @param key
  114.      * @param field
  115.      * @param value
  116.      */
  117.     public void hset(String key, String field, Object value) {
  118.         redisTemplate.opsForHash().put(key, field, value);
  119.     }
  120.     /**
  121.      * 实现命令：HGET key field，返回哈希表 key中给定域 field的值
  122.      *
  123.      * @param key
  124.      * @param field
  125.      * @return
  126.      */
  127.     public String hget(String key, String field) {
  128.         return (String) redisTemplate.opsForHash().get(key, field);
  129.     }
  130.     /**
  131.      * 实现命令：HDEL key field [field ...]，删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
  132.      *
  133.      * @param key
  134.      * @param fields
  135.      */
  136.     public void hdel(String key, Object... fields) {
  137.         redisTemplate.opsForHash().delete(key, fields);
  138.     }
  139.     /**
  140.      * 实现命令：HGETALL key，返回哈希表 key中，所有的域和值。
  141.      *
  142.      * @param key
  143.      * @return
  144.      */
  145.     public Map<Object, Object> hgetall(String key) {
  146.         return redisTemplate.opsForHash().entries(key);
  147.     }
  148.     // List（列表）
  149.     /**
  150.      * 实现命令：LPUSH key value，将一个值 value插入到列表 key的表头
  151.      *
  152.      * @param key
  153.      * @param value
  154.      * @return 执行 LPUSH命令后，列表的长度。
  155.      */
  156.     public long lpush(String key, String value) {
  157.         return redisTemplate.opsForList().leftPush(key, value);
  158.     }
  159.     /**
  160.      * 实现命令：LPOP key，移除并返回列表 key的头元素。
  161.      *
  162.      * @param key
  163.      * @return 列表key的头元素。
  164.      */
  165.     public String lpop(String key) {
  166.         return (String) redisTemplate.opsForList().leftPop(key);
  167.     }
  168.     /**
  169.      * 实现命令：RPUSH key value，将一个值 value插入到列表 key的表尾(最右边)。
  170.      *
  171.      * @param key
  172.      * @param value
  173.      * @return 执行 LPUSH命令后，列表的长度。
  174.      */
  175.     public long rpush(String key, String value) {
  176.         return redisTemplate.opsForList().rightPush(key, value);
  177.     }
  178. }



代码GitHub地址：https://github.com/saysky/sensboot

欢迎 star 和 fork

历史上的今天
七月
22日
  • 微信
  • 交流学习，资料分享
  • weinxin
  • 个人淘宝
  • 店铺名：言曌博客咨询部

  • (部分商品未及时上架淘宝)
avatar

发表评论

avatar 登录者：匿名
匿名评论，评论回复后会有邮件通知

  

已通过评论：3   待审核评论数：0
  1. avatar 蔷薇
    回复 2019年09月06日 11:38:22

    大佬能给文章排个序嘛 :evil:

  2. avatar 风中小筑
    回复 2019年07月30日 17:04:17

    非技术的路过。

  3. avatar 膜拜
    回复 2019年07月23日 16:08:23

    支持，挺好的 :!: