高并发项目-分布式Session解决方案

立山  金牌会员 | 2024-6-29 13:27:49 | 来自手机 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 867|帖子 867|积分 2601

分布式Session解决方案

1.生存Session，进入商品列表页面

1.生存Session

1.编写工具类

1.MD5Util.java

  1. package com.sxs.seckill.utils;
  3. import org.apache.commons.codec.digest.DigestUtils;
  5. /**
  6. * Description: MD5加密工具类
  7. *
  8. * @Author sun
  9. * @Create 2024/5/5 14:23
  10. * @Version 1.0
  11. */
  12. public class MD5Util {
  13.     /**
  14.      * 将一个字符串转换为MD5
  15.      * @param src
  16.      * @return
  17.      */
  18.     public static String md5(String src) {
  19.         return DigestUtils.md5Hex(src);
  20.     }
  22.     // 固定的salt
  23.     public static final String SALT = "4tIY5VcX";
  24.     // 第一次加密加盐
  25.     public static String inputPassToMidPass(String inputPass) {
  26.         // 加盐
  27.         String str = SALT.charAt(0) + inputPass + SALT.charAt(6);
  28.         return md5(str);
  29.     }
  31.     /**
  32.      * 第二次加密加盐
  33.      * @param midPass
  34.      * @param salt
  35.      * @return
  36.      */
  37.     public static String midPassToDBPass(String midPass, String salt) {
  38.         String str = salt.charAt(0) + midPass + salt.charAt(5);
  39.         return md5(str);
  40.     }
  42.     /**
  43.      * 两次加密
  44.      * @param input
  45.      * @param saltDB
  46.      * @return
  47.      */
  48.     public static String inputPassToDBPass(String input, String saltDB) {
  49.         String midPass = inputPassToMidPass(input);
  50.         String dbPass = midPassToDBPass(midPass, saltDB);
  51.         return dbPass;
  52.     }
  53. }
复制代码
2.CookieUtil.java

  1. package com.sxs.seckill.utils;
  3. import javax.servlet.http.Cookie;
  4. import javax.servlet.http.HttpServletRequest;
  5. import javax.servlet.http.HttpServletResponse;
  6. import java.io.UnsupportedEncodingException;
  7. import java.net.URLDecoder;
  8. import java.net.URLEncoder;
  10. /**
  11. * Description: Cookie工具类
  12. *
  13. * @Author sun
  14. * @Create 2024/5/6 16:04
  15. * @Version 1.0
  16. */
  19. public class CookieUtil {
  20.     /**
  21.      * 得到 Cookie 的值, 不编码
  22.      *
  23.      * @param request
  24.      * @param cookieName
  25.      * @return
  26.      */
  27.     public static String getCookieValue(HttpServletRequest request, String
  28.             cookieName) {
  29.         return getCookieValue(request, cookieName, false);
  30.     }
  32.     /**
  33.      * 得到 Cookie 的值, *
  34.      *
  35.      * @param request
  36.      * @param cookieName
  37.      * @return
  38.      */
  39.     public static String getCookieValue(HttpServletRequest request, String
  40.             cookieName, boolean isDecoder) {
  41.         Cookie[] cookieList = request.getCookies();
  42.         if (cookieList == null || cookieName == null) {
  43.             return null;
  44.         }
  45.         String retValue = null;
  46.         try {
  47.             for (int i = 0; i < cookieList.length; i++) {
  48.                 if (cookieList[i].getName().equals(cookieName)) {
  49.                     if (isDecoder) {
  50.                         retValue = URLDecoder.decode(cookieList[i].getValue(), "UTF-8");
  51.                     } else {
  52.                         retValue = cookieList[i].getValue();
  53.                     }
  54.                     break;
  55.                 }
  56.             }
  57.         } catch (UnsupportedEncodingException e) {
  58.             e.printStackTrace();
  59.         }
  60.         return retValue;
  61.     }
  63.     /**
  64.      * 得到 Cookie 的值, *
  65.      *
  66.      * @param request
  67.      * @param cookieName
  68.      * @param encodeString
  69.      * @return
  70.      */
  71.     public static String getCookieValue(HttpServletRequest request, String
  72.             cookieName, String encodeString) {
  73.         Cookie[] cookieList = request.getCookies();
  74.         if (cookieList == null || cookieName == null) {
  75.             return null;
  76.         }
  77.         String retValue = null;
  78.         try {
  79.             for (int i = 0; i < cookieList.length; i++) {
  80.                 if (cookieList[i].getName().equals(cookieName)) {
  81.                     retValue = URLDecoder.decode(cookieList[i].getValue(), encodeString);
  82.                     break;
  83.                 }
  84.             }
  85.         } catch (UnsupportedEncodingException e) {
  86.             e.printStackTrace();
  87.         }
  88.         return retValue;
  89.     }
  91.     /**
  92.      * 设置 Cookie 的值 不设置生效时间默认浏览器关闭即失效,也不编码
  93.      */
  94.     public static void setCookie(HttpServletRequest request, HttpServletResponse
  95.             response, String cookieName, String cookieValue) {
  96.         setCookie(request, response, cookieName, cookieValue, -1);
  97.     }
  99.     /**
  100.      * 设置 Cookie 的值 在指定时间内生效,但不编码
  101.      */
  102.     public static void setCookie(HttpServletRequest request, HttpServletResponse
  103.             response, String cookieName, String cookieValue, int cookieMaxage) {
  104.         setCookie(request, response, cookieName, cookieValue, cookieMaxage,
  105.                 false);
  106.     }
  108.     /**
  109.      * 设置 Cookie 的值 不设置生效时间,但编码
  110.      */
  111.     public static void setCookie(HttpServletRequest request, HttpServletResponse
  112.             response, String cookieName, String cookieValue, boolean isEncode) {
  113.         setCookie(request, response, cookieName, cookieValue, -1, isEncode);
  114.     }
  116.     /**
  117.      * 设置 Cookie 的值 在指定时间内生效, 编码参数
  118.      */
  119.     public static void setCookie(HttpServletRequest request, HttpServletResponse
  120.             response, String cookieName, String cookieValue, int cookieMaxage, boolean
  121.                                          isEncode) {
  122.         doSetCookie(request, response, cookieName, cookieValue, cookieMaxage,
  123.                 isEncode);
  124.     }
  126.     /**
  127.      * 设置 Cookie 的值 在指定时间内生效, 编码参数(指定编码)
  128.      */
  129.     public static void setCookie(HttpServletRequest request, HttpServletResponse
  130.             response, String cookieName, String cookieValue, int cookieMaxage, String
  131.                                          encodeString) {
  132.         doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, encodeString);
  133.     }
  135.     /**
  136.      * 删除 Cookie 带 cookie 域名
  137.      */
  138.     public static void deleteCookie(HttpServletRequest request, HttpServletResponse response, String cookieName) {
  139.         doSetCookie(request, response, cookieName, "", -1, false);
  140.     }
  142.     /**
  143.      * 设置 Cookie 的值，并使其在指定时间内生效
  144.      *
  145.      * @param cookieMaxage cookie 生效的最大秒数
  146.      */
  147.     private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue,
  148.                                           int cookieMaxage, boolean isEncode) {
  149.         try {
  150.             if (cookieValue == null) {
  151.                 cookieValue = "";
  152.             } else if (isEncode) {
  153.                 cookieValue = URLEncoder.encode(cookieValue, "utf-8");
  154.             }
  155.             Cookie cookie = new Cookie(cookieName, cookieValue);
  156.             if (cookieMaxage > 0) {
  157.                 cookie.setMaxAge(cookieMaxage);
  158.             }
  159.             // if (null != request) {// 设置域名的 cookie
  160.             // String domainName = getDomainName(request);
  161.             // if (!"localhost".equals(domainName)) {
  162.             // cookie.setDomain(domainName);
  163.             // }
  164.             // }
  165.             cookie.setPath("/");
  166.             response.addCookie(cookie);
  167.         } catch (Exception e) {
  168.             e.printStackTrace();
  169.         }
  170.     }
  172.     /**
  173.      * 设置 Cookie 的值，并使其在指定时间内生效
  174.      *
  175.      * @param cookieMaxage cookie 生效的最大秒数
  176.      */
  177.     private static final void doSetCookie(HttpServletRequest request,
  178.                                           HttpServletResponse response, String cookieName, String cookieValue,
  179.                                           int cookieMaxage, String encodeString) {
  180.         try {
  181.             if (cookieValue == null) {
  182.                 cookieValue = "";
  183.             } else {
  184.                 cookieValue = URLEncoder.encode(cookieValue, encodeString);
  185.             }
  186.             Cookie cookie = new Cookie(cookieName, cookieValue);
  187.             if (cookieMaxage > 0) {
  188.                 cookie.setMaxAge(cookieMaxage);
  189.             }
  190.             if (null != request) {// 设置域名的 cookie
  191.                 String domainName = getDomainName(request);
  192.                 System.out.println(domainName);
  193.                 if (!"localhost".equals(domainName)) {
  194.                     cookie.setDomain(domainName);
  195.                 }
  196.             }
  197.             cookie.setPath("/");
  198.             response.addCookie(cookie);
  199.         } catch (Exception e) {
  200.             e.printStackTrace();
  201.         }
  202.     }
  204.     /**
  205.      * 得到 cookie 的域名
  206.      */
  207.     private static final String getDomainName(HttpServletRequest request) {
  208.         String domainName = null;
  209.         // 通过 request 对象获取访问的 url 地址
  210.         String serverName = request.getRequestURL().toString();
  211.         if ("".equals(serverName)) {
  212.             domainName = "";
  213.         } else {
  214.             // 将 url 地下转换为小写
  215.             serverName = serverName.toLowerCase();
  216.             // 如果 url 地址是以 http://开头 将 http://截取
  217.             if (serverName.startsWith("http://")) {
  218.                 serverName = serverName.substring(7);
  219.             }
  220.             int end = serverName.length();
  221.             // 判断 url 地址是否包含"/"
  222.             if (serverName.contains("/")) {
  223.                 // 得到第一个"/"出现的位置
  224.                 end = serverName.indexOf("/");
  225.             }
  226.             // 截取
  227.             serverName = serverName.substring(0, end);
  228.             // 根据"."进行分割
  229.             final String[] domains = serverName.split("\\.");
  230.             int len = domains.length;
  231.             if (len > 3) {
  232.                 // www.abc.com.cn
  233.                 domainName = domains[len - 3] + "." + domains[len - 2] + "." +
  234.                         domains[len - 1];
  235.             } else if (len > 1) {
  236.                 // abc.com or abc.cn
  237.                 domainName = domains[len - 2] + "." + domains[len - 1];
  238.             } else {
  239.                 domainName = serverName;
  240.             }
  241.         }
  242.         if (domainName.indexOf(":") > 0) {
  243.             String[] ary = domainName.split("\\:");
  244.             domainName = ary[0];
  245.         }
  246.         return domainName;
  247.     }
  248. }
复制代码
2.关于session和cookie关系的回顾



  • 当欣赏器请求到服务端时cookie会携带sessionid
  • 然后在服务端getSession时会得到当前用户的session
  • cookie-sessionid 连接到session
3.修改UserServiceImpl.java的doLogin方法，增长生存信息到session的逻辑


4.测试，用户票据成功生存到cookie中


2.访问到商品列表页面

1.编写GoodsController.java 验证用户登录后进入商品列表页

  1. package com.sxs.seckill.controller;
  3. import com.sxs.seckill.pojo.User;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.springframework.stereotype.Controller;
  6. import org.springframework.ui.Model;
  7. import org.springframework.web.bind.annotation.CookieValue;
  8. import org.springframework.web.bind.annotation.RequestMapping;
  10. import javax.servlet.http.HttpSession;
  12. /**
  13. * Description:
  14. *
  15. * @Author sun
  16. * @Create 2024/5/6 18:16
  17. * @Version 1.0
  18. */
  19. @Controller
  20. @Slf4j
  21. @RequestMapping("/goods")
  22. public class GoodsController {
  23.     // 进入到商品首页
  24.     @RequestMapping("/toList")
  25.     public String toList(HttpSession session, Model model, @CookieValue("userTicket") String ticket) {
  26.         // 首先判断是否有票据
  27.         if (null == ticket) {
  28.             return "login";
  29.         }
  30.         // 根据票据来获取用户信息
  31.         User user = (User) session.getAttribute(ticket);
  32.         if (null == user) {
  33.             return "login";
  34.         }
  35.         // 将用户信息存入model中，返回到前端
  36.         model.addAttribute("user", user);
  37.         return "goodsList";
  38.     }
  39. }
复制代码
2.商品列表页goodsList.html

  1. <!DOCTYPE html>
  2. <html lang="en" xmlns:th="http://www.thymeleaf.org">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>商品列表</title>
  6. </head>
  7. <body>
  8. <h1>商品列表</h1>
  9. <p th:text="'hi: ' + ${user.nickname}"></p>
  10. </body>
  11. </html>
复制代码
3.测试登录成功后进入商品列表页



2.分布式session解决方案

1.session绑定/粘滞（不常用）



2.session复制



3.前端存储


4.后端会合存储


3.方案一：SpringSession实现分布式Session

1.安装使用redis-desktop-manager

1.不停下一步，安装到D盘


2.起首要确保redis集群的端口是开放的并使其支持远程访问（之前配置过）

3.使用telnet指令测试某个服务是否能够连接成功

  1. telnet 140.143.164.206 7489
复制代码

4.连接Redis，先测试连接然后确定


5.在redis下令行设置两个键


6.在可视化工具检察


2.项目整合Redis并配置分布式session

1.pom.xml引入依赖

  1.         <!--spring data redis 依赖, 即 spring 整合 redis-->
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-data-redis</artifactId>
  5.             <version>2.4.5</version>
  6.         </dependency>
  7.         <!--pool2 对象池依赖-->
  8.         <dependency>
  9.             <groupId>org.apache.commons</groupId>
  10.             <artifactId>commons-pool2</artifactId>
  11.             <version>2.9.0</version>
  12.         </dependency>
  13.         <!--实现分布式 session, 即将 Session 保存到指定的 Redis-->
  14.         <dependency>
  15.             <groupId>org.springframework.session</groupId>
  16.             <artifactId>spring-session-data-redis</artifactId>
  17.         </dependency>
复制代码
2.application.yml配置Redis

  1. spring:
  2.   redis:
  3.     password:  # Redis服务器密码
  4.     database: 0 # 默认数据库为0号
  5.     timeout: 10000ms # 连接超时时间是10000毫秒
  6.     lettuce:
  7.       pool:
  8.         max-active: 8 # 最大活跃连接数,使用负值表示没有限制，最佳配置为核数*2
  9.         max-wait: 10000ms # 最大等待时间,单位为毫秒,使用负值表示没有限制，这里设置为10秒
  10.         max-idle: 200 # 最大空闲连接数
  11.         min-idle: 5 # 最小空闲连接数
  12.     cluster:
  13.       nodes:
  14.         -
  15.         -
复制代码

3.启动测试

1.登录


2.Redis可视化工具发现session成功存到redis



4.方案二：统一存放用户信息到Redis

1.修改pom.xml，去掉分布式springsession的依赖


2.将用户信息放到Redis

1.添加Redis配置类 com/sxs/seckill/config/RedisConfig.java

  1. package com.sxs.seckill.config;
  3. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  4. import com.fasterxml.jackson.annotation.JsonTypeInfo;
  5. import com.fasterxml.jackson.annotation.PropertyAccessor;
  6. import com.fasterxml.jackson.databind.ObjectMapper;
  7. import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
  8. import org.springframework.cache.CacheManager;
  9. import org.springframework.cache.annotation.CachingConfigurerSupport;
  10. import org.springframework.cache.annotation.EnableCaching;
  11. import org.springframework.context.annotation.Bean;
  12. import org.springframework.context.annotation.Configuration;
  13. import org.springframework.data.redis.cache.RedisCacheConfiguration;
  14. import org.springframework.data.redis.cache.RedisCacheManager;
  15. import org.springframework.data.redis.connection.RedisConnectionFactory;
  16. import org.springframework.data.redis.core.RedisTemplate;
  17. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  18. import org.springframework.data.redis.serializer.RedisSerializationContext;
  19. import org.springframework.data.redis.serializer.RedisSerializer;
  20. import org.springframework.data.redis.serializer.StringRedisSerializer;
  22. import java.time.Duration;
  24. /**
  25. * Description:
  26. *
  27. * @Author sun
  28. * @Create 2024/4/29 21:29
  29. * @Version 1.0
  30. */
  31. @EnableCaching
  32. @Configuration
  33. public class RedisConfig extends CachingConfigurerSupport {
  34.     @Bean
  35.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
  36.         RedisTemplate<String, Object> template =
  37.                 new RedisTemplate<>();
  38.         System.out.println("template=>" + template);
  39.         RedisSerializer<String> redisSerializer =
  40.                 new StringRedisSerializer();
  41.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer =
  42.                 new Jackson2JsonRedisSerializer(Object.class);
  43.         ObjectMapper om = new ObjectMapper();
  44.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  45.         om.activateDefaultTyping(
  46.                 LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
  47.         jackson2JsonRedisSerializer.setObjectMapper(om);
  48.         template.setConnectionFactory(factory);
  49.         // key 序列化方式
  50.         template.setKeySerializer(redisSerializer);
  51.         // value 序列化
  52.         template.setValueSerializer(jackson2JsonRedisSerializer);
  53.         // value hashmap 序列化
  54.         template.setHashValueSerializer(jackson2JsonRedisSerializer);
  55.         return template;
  56.     }
  58.     @Bean
  59.     public CacheManager cacheManager(RedisConnectionFactory factory) {
  60.         RedisSerializer<String> redisSerializer =
  61.                 new StringRedisSerializer();
  62.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new
  63.                 Jackson2JsonRedisSerializer(Object.class);
  64.         // 解决查询缓存转换异常的问题
  65.         ObjectMapper om = new ObjectMapper();
  66.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  67.         om.activateDefaultTyping(
  68.                 LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
  69.         jackson2JsonRedisSerializer.setObjectMapper(om);
  70.         // 配置序列化（解决乱码的问题）,过期时间 600 秒
  71.         RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
  72.                 .entryTtl(Duration.ofSeconds(600))
  73.                 .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
  74.                 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
  75.                 .disableCachingNullValues();
  76.         RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
  77.                 .cacheDefaults(config)
  78.                 .build();
  79.         return cacheManager;
  80.     }
  81. }
复制代码
2.修改 com/sxs/seckill/service/impl/UserServiceImpl.java

1.注入RedisTemplate


2.修改doLogin方法，将用户信息放到Redis中


3.启动测试

1.登录


2.可视化工具检察用户信息


3.实现使用Redis + Cookie实现登录，可以访问商品列表页面

1.刚才已经实现了Redis记录信息的功能，但是校验还没实现，修改GoodsController.java完成校验

1.注入RedisTemplate


2.从Redis中获取校验信息，举行校验


2.测试

1.登录成功后访问商品列表页面


5.扩展：自定义参数剖析器，直接获取User

1.修改 com/sxs/seckill/controller/GoodsController.java 使参数直接为User

  1.     // 进入到商品首页
  2.     @RequestMapping("/toList")
  3.     public String toList(Model model, User user) {
  4.         // 判断是否有用户信息
  5.         if (null == user) {
  6.             return "login";
  7.         }
  8.         // 将用户信息存入model中，返回到前端
  9.         model.addAttribute("user", user);
  10.         return "goodsList";
  11.     }
复制代码
2.service层添加方法，通过票据从Redis中获取User对象

1.UserService.java

  1.     /**
  2.      * 根据cookie获取用户
  3.      * @param userTicket
  4.      * @param request
  5.      * @param response
  6.      * @return
  7.      */
  8.     public User getUserByCookie(String userTicket, HttpServletRequest request, HttpServletResponse response);
复制代码
2.UserServiceImpl.java



  • 这里需要留意，每次获取完User，需要重新设置Cookie，来革新Cookie的时间
  • 缘故原由是，调用这个的目标是为了校验，而用户访问每个页面都要举行校验，如果每次校验之后都不革新Cookie的时间，一旦Cookie失效了，用户就要重新登岸
  1.     @Override
  2.     public User getUserByCookie(String userTicket, HttpServletRequest request, HttpServletResponse response) {
  3.         // 判断是否有票据
  4.         if (null == userTicket) {
  5.             return null;
  6.         }
  7.         // 根据票据来获取用户信息，从redis中获取
  8.         User user = (User) redisTemplate.opsForValue().get("user:" + userTicket);
  9.         if (null == user) {
  10.             return null;
  11.         }
  12.         // 重新设置cookie的有效时间
  13.         CookieUtil.setCookie(request, response, "userTicket", userTicket);
  14.         return user;
  15.     }
复制代码
3.编写自定义参数剖析器对User范例参数举行剖析 config/UserArgumentResolver.java

  1. package com.sxs.seckill.config;
  3. import com.sxs.seckill.pojo.User;
  4. import com.sxs.seckill.service.UserService;
  5. import com.sxs.seckill.utils.CookieUtil;
  6. import org.springframework.core.MethodParameter;
  7. import org.springframework.stereotype.Component;
  8. import org.springframework.web.bind.support.WebDataBinderFactory;
  9. import org.springframework.web.context.request.NativeWebRequest;
  10. import org.springframework.web.method.support.HandlerMethodArgumentResolver;
  11. import org.springframework.web.method.support.ModelAndViewContainer;
  13. import javax.annotation.Resource;
  14. import javax.servlet.http.HttpServletRequest;
  15. import javax.servlet.http.HttpServletResponse;
  17. /**
  18. * Description: 自定义参数解析器
  19. *
  20. * @Author sun
  21. * @Create 2024/5/7 14:39
  22. * @Version 1.0
  23. */
  24. @Component
  25. public class UserArgumentResolver implements HandlerMethodArgumentResolver {
  26.     @Resource
  27.     private UserService userService;
  28.     /*
  29.      * 判断是否支持要转换的参数类型，简单来说，就是在这里设置要解析的参数类型
  30.      */
  31.     @Override
  32.     public boolean supportsParameter(MethodParameter methodParameter) {
  33.         // 如果参数类型是User，则进行解析
  34.         Class<?> parameterType = methodParameter.getParameterType();
  35.         if (parameterType == User.class) {
  36.             return true;
  37.         }
  38.         return false;
  39.     }
  41.     /**
  42.      * 编写参数解析的逻辑
  43.      *
  44.      * @param methodParameter
  45.      * @param modelAndViewContainer
  46.      * @param nativeWebRequest
  47.      * @param webDataBinderFactory
  48.      * @return
  49.      * @throws Exception
  50.      */
  51.     @Override
  52.     public Object resolveArgument(MethodParameter methodParameter, ModelAndViewContainer modelAndViewContainer, NativeWebRequest nativeWebRequest, WebDataBinderFactory webDataBinderFactory) throws Exception {
  53.         // 首先获取request和response
  54.         HttpServletRequest request = nativeWebRequest.getNativeRequest(HttpServletRequest.class);
  55.         HttpServletResponse response = nativeWebRequest.getNativeResponse(HttpServletResponse.class);
  56.         // 从cookie中获取票据
  57.         String userTicket = CookieUtil.getCookieValue(request, "userTicket");
  58.         // 如果票据为空，则返回null
  59.         if (null == userTicket) {
  60.             return null;
  61.         }
  62.         // 如果票据不为空，则根据票据获取用户信息
  63.         User user = this.userService.getUserByCookie(userTicket, request, response);
  64.         return user;
  65.     }
  66. }
复制代码
4.编写config/WebConfig.java 将自定义参数剖析器放到 resolvers 才气见效

  1. package com.sxs.seckill.config;
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.web.method.support.HandlerMethodArgumentResolver;
  5. import org.springframework.web.servlet.config.annotation.EnableWebMvc;
  6. import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
  7. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  9. import javax.annotation.Resource;
  10. import java.util.List;
  12. /**
  13. * Description:
  14. *
  15. * @Author sun
  16. * @Create 2024/5/7 14:53
  17. * @Version 1.0
  18. */
  19. @Configuration
  20. // @EnableWebMvc 使用这个注解会导致SpringBoot的自动配置失效，一切都要自己配置，所以建议不要使用这个注解
  21. public class WebConfig implements WebMvcConfigurer {
  22.     // 注入自定义参数解析器
  23.     @Resource
  24.     private UserArgumentResolver userArgumentResolver;
  25.     /**
  26.      * 静态资源加载，静态资源放在哪里就怎么配置
  27.      * @param registry
  28.      */
  29.     @Override
  30.     public void addResourceHandlers(ResourceHandlerRegistry registry) {
  31.         registry.addResourceHandler("/**").addResourceLocations("classpath:/static/");
  32.     }
  34.     /**
  35.      * 添加自定义参数解析器到resolvers中，才能生效
  36.      * @param resolvers
  37.      */
  38.     @Override
  39.     public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
  40.         resolvers.add(userArgumentResolver);
  41.     }
  42. }
复制代码
5.测试

1.在登录之后，可以正常访问商品列表页面



免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

立山

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表