1.7 认证服务

1.7.1 环境搭建

1）、创建认证服务微服务

我们添加的依赖如上图所示。主要是springbootDevTools + Lombok + spring Web + Thymeleaf + OpenFeign(远程调用情况)

2）、引入依赖

<dependencies>
        <dependency>
            <groupId>com.atguigu.gulimall</groupId>
            <artifactId>gulimall-common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
            <exclusions>
                <exclusion>
                    <groupId>com.baomidou</groupId>
                    <artifactId>mybatis-plus-boot-starter</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

3)、添加相应的域名

4）、动静分离

• 我们需要将登陆页面（login.html）和认证页面(reg.html)都放到新创建的认证服务下的templates下。

• 同理在nginx中的静态文件夹下的html中创建两个login文件夹和reg的文件夹。
• 修改login.html和reg.html页面中的静态资源路径。将href=" 改为href=“/static/login/ 和 src=” 改为src="/static/login/ 。同理reg.html页面中我们也要进行相同的修改。

5）、nacos中注册

• application.properties

spring.application.name=gulimall-auth-server
spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848
server.port=50000

• GulimallAuthServerApplication

@EnableFeignClients    //加入远程调用
@EnableDiscoveryClient  //加入服务注册发现功能
@SpringBootApplication
public class GulimallAuthServerApplication {

• http://localhost:8848/nacos/#/login 输入这个网址之后，本机才能打开naocs注册中心地址。否则不行。

6）、配置网关

        - id: gulimall_auth_route
          uri: lb://gulimall-auth-server
          predicates:
            - Host=auth.gulimall.com

7)、测试访问登录页面

• 我们暂时将login.html改为index.html页面，这样因为是默认的会被模板引擎解析。但是这个是暂时的。

8）、实现各个页面之间跳转

1、实现登录页面点击”谷粒商城“图标能跳转到首页：

login.html

2、实现首页点击登录和注册能跳转到登录和注册页面：

修改商品服务下的首页index.html

认证服务编写 controller 实现跳转

@Controller
public class LoginController {


    @GetMapping("/login.html")
    public String loginPage(){

        return "login";
    }

    @GetMapping("/reg.html")
    public String regPage(){

        return "reg";
    }

}

登录页面点击“立即注册”能够跳转到注册页面。

注册页面点击“请登录”能够跳转到登录页面。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QykLGWJ1-1673532968095)(null)]

ps：这里可以稍微修改一下 登录页面的宽度，让页面更好看一点。

1.7.2 验证码功能

1)、验证码功能

①把 reg.html页面中这一处修改为 “发送验证码”

发送验证码，有60秒倒计时：

 $(function (){
            	$("#sendCode").click(function () {
					//2、倒计时
					if ($(this).hasClass("disabled")){
						//正在倒计时。
					}else{
						//1、给指定手机号码发送验证码
						timeoutChangeStyle();
					}
				});
			})
			var num = 60;
            function timeoutChangeStyle(){
            	$("#sendCode").attr("class","disabled");
            	if (num == 0){
					$("#sendCode").text("发送验证码");
					num = 60;
					$("#sendCode").attr("class","");
				}else{
            		var str = num +"s 后再次发送";
					$("#sendCode").text(str);
                    //每隔1s调用timeoutChangeStyle()
					setTimeout("timeoutChangeStyle()",1000);
				}
            	num --;
			}

效果：

②修改后台代码

如果编写一个接口仅仅是为了跳转页面，没有数据的处理，如果这样的跳转接口多了则可以使用SpringMVC的view Controller(视图控制器)将请求与页面进行绑定.

新建 GulimallWebConfig

@Configuration
public class GulimallWebConfig implements WebMvcConfigurer {


    /**
     * 视图映射
     * @param registry
     */
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        /**
         *      *   @GetMapping("/login.html")
         *      *    public String loginPage(){
         *      *
         *      *        return "login";
         *      *     }
         *      * @param registry
         */

        registry.addViewController("/login.html").setViewName("login");
        registry.addViewController("/reg.html").setViewName("reg");

    }
}

ps：idea快捷键：实现接口方法

  																														alt + shift + p

以前的 LoginController 里面的 方法就可以注释掉了。（这个地方编写的代码仅仅是帮助我们实现跳转页面的）

@Controller
public class LoginController {


    /**
     * 发送一个请求直接跳转到一个页面。
     * springMVC viewcontroller:将请求和页面映射过来。
     */

    // @GetMapping("/login.html")
    // public String loginPage(){
    //
    //     return "login";
    // }
    //
    // @GetMapping("/reg.html")
    // public String regPage(){
    //
    //     return "reg";
    // }

}

• 为了我们内存问题，我们可以将认证微服务的内存修改为只占用100m

2）、整合验证码

• 我们可以去阿里云云市场中购买三网短信接口，使用这个来进行完成我们的短信验证码功能。

• 试试调试功能

• 请求示例

public static void main(String[] args) {
	    String host = "https://dfsns.market.alicloudapi.com";
	    String path = "/data/send_sms";
	    String method = "POST";
	    String appcode = "你自己的AppCode";
	    Map<String, String> headers = new HashMap<String, String>();
	    //最后在header中的格式(中间是英文空格)为Authorization:APPCODE 83359fd73fe94948385f570e3c139105
	    headers.put("Authorization", "APPCODE " + appcode);
	    //根据API的要求，定义相对应的Content-Type
	    headers.put("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
	    Map<String, String> querys = new HashMap<String, String>();
	    Map<String, String> bodys = new HashMap<String, String>();
	    bodys.put("content", "code:1234");
	    bodys.put("phone_number", "156*****140");
	    bodys.put("template_id", "TPL_0000");


	    try {
	    	/**
	    	* 重要提示如下:
	    	* HttpUtils请从
	    	* https://github.com/aliyun/api-gateway-demo-sign-java/blob/master/src/main/java/com/aliyun/api/gateway/demo/util/HttpUtils.java
	    	* 下载
	    	*
	    	* 相应的依赖请参照
	    	* https://github.com/aliyun/api-gateway-demo-sign-java/blob/master/pom.xml
	    	*/
	    	HttpResponse response = HttpUtils.doPost(host, path, method, headers, querys, bodys);
	    	System.out.println(response.toString());
	    	//获取response的body
	    	//System.out.println(EntityUtils.toString(response.getEntity()));
	    } catch (Exception e) {
	    	e.printStackTrace();
	    }
	}

ps：当我们在页面上点击“发送验证码”，我们不能通过js代码带上我们的APPCODE ，这样就直接将APPCODE 暴露给别人了，然后别人使用它发送大量短信(让短信服务崩溃)，这样就有危机了。我们通过后台来发送验证码，这样比较保险。

• 在第三方微服务下进行简单的测试
  • 直接将上面的请求示例的代码放到test中，手机号写自己的，测试看看。
  • 我们发现需要引入依赖，所以我们package com.atguigu.gulimall.thirdparty.utils;这个包下面将请求示例中给我们提供的地址中的HttpUtils这个java代码复制到utils包中。
  • 测试，发现发送成功

①短信远程服务准备

• 我们可以进行自定义，不要短信验证码写死。将请求实例中的代码抽取为一个组件 — SmsComponent

package com.atguigu.gulimall.thirdparty.component;

@ConfigurationProperties(prefix = "spring.cloud.alicloud.sms")
@Data
@Component
public class SmsComponent {
    private String host;
    private String path;
    private String appcode;

    public void sendSmsCode(String phone, String content) {
        String method = "POST";
        Map<String, String> headers = new HashMap<String, String>();
        headers.put("Authorization", "APPCODE " + appcode);
        headers.put("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        Map<String, String> querys = new HashMap<String, String>();
        Map<String, String> bodys = new HashMap<String, String>();
        bodys.put("content", "code: " +content);
        bodys.put("phone_number", phone);
        bodys.put("template_id", "TPL_0000");


        try {

            HttpResponse response = HttpUtils.doPost(host, path, method, headers, querys, bodys);
            System.out.println(response.toString());
            //获取response的body
            //System.out.println(EntityUtils.toString(response.getEntity()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

• 在pom.xml文件中将下面的这个依赖引入，这样我们在application.yml文件中编写的时候就有提示了

• application.yml文件中编写我们自定义的。

• 在test中进行测试

  @Test
    public void testSms(){
        smsComponent.sendSmsCode("15642848274","8639");
    }

随便写一个，发现测试通过。

• 编写controller，提供给别的服务进行调用。

@RestController
@RequestMapping("/sms")
public class SmsSendController {

    @Autowired
    SmsComponent smsComponent;

    /**
     * 提供给别的服务进行调用
     *
     * @return
     */
    @GetMapping("/sendcode")
    public R sendCode(@RequestParam("phone") String phone,@RequestParam("content") String content){
        smsComponent.sendSmsCode(phone,content);
        return R.ok();
    }
}

②认证服务远程调用短信

• 在认证微服务中编写一个feign接口(相应的主启动类上要加入@EnableFeignClients这个注解)

package com.atguigu.gulimall.auth.feign;

@FeignClient("gulimall-third-party")
public interface ThirdPartFeignService {

    @GetMapping("/sms/sendcode")
    public R sendCode(@RequestParam("phone") String phone, @RequestParam("content") String content);
}

③ 验证码防刷

• 我们将发送的验证码要按照一定的规则存储到redis中，到时候认证的时候需要根据用户输入的和实际存储的验证码进行对比。而且还要防止其他人利用网页刷新，将原来60s重新设置60s,导致短信服务崩溃。

• redis保存验证码

注意引入：redis依赖

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>

• 设置redis中保存的前缀

package com.atguigu.common.constant;

public class AuthServerConstant {
   public static final String SMS_CODE_CACHE_PREFIX = "sms:code:"; 
}

• 如果没有超过60s,设置错误代码

• 修改LoginController

  • @Controller
    public class LoginController {
    
        @Autowired
        ThirdPartFeignService thirdPartFeignService;
    
        @Autowired
        StringRedisTemplate redisTemplate;
        /**
         * 发送一个请求直接跳转到一个页面
         * SpringMVC viewcontroller;将请求和页面映射过来
         * @return
         */
        @ResponseBody  //返回json数据
        @GetMapping("/sms/sendcode")
        public R sendCode(@RequestParam("phone")String phone){
    
    
            //TODO     //1.接口防刷
            //相同手机号，即使再次刷新页面，但是手机号是相同的，你再次发送也不会生效
            String redisContent = redisTemplate.opsForValue().get(AuthServerConstant.SMS_CODE_CACHE_PREFIX + phone);
            if(!StringUtils.isEmpty(redisContent)){
                long l = Long.parseLong(redisContent.split("_")[1]);
                if(System.currentTimeMillis() - l < 60000){
                    //系统当前时间减去保存redis的时间间隔小于60s
                    return  R.error(BizCodeEnume.SMS_CODE_EXCEPTION.getCode(), BizCodeEnume.SMS_CODE_EXCEPTION.getMsg());
                }
            }
    
            //2.验证码的再次校验。redis.存key-phone,value-code sms:code:17512080612 -> 45678
            String content = UUID.randomUUID().toString().substring(0, 5);
            String substring = content + "_"+System.currentTimeMillis();
            //redis缓存验证码，防止同一个phone在60秒内再次发送验证码
            redisTemplate.opsForValue().set(AuthServerConstant.SMS_CODE_CACHE_PREFIX+phone,substring,10, TimeUnit.MILLISECONDS);
    
           thirdPartFeignService.sendCode(phone,content);
            return  R.ok();
        }
    
        @PostMapping("/regist")
        public String regist(@Valid UserRegistVo vo, BindingResult result, Model model){
    
            if(result.hasErrors()){
    
                Map<String, String> errors = result.getFieldErrors().stream().collect((Collectors.toMap(FieldError::getField, FieldError::getDefaultMessage)));
                model.addAttribute("errors",errors);
                //校验出错，转发到注册页
                return "forward:/reg.html";
            }
            //真正注册，调用远程服务进行注册
            //注册成功回到首页，回到登录页
            return "redirect:/login.html";
        }
    
    
    }
    

  • 为页面设置的输入验证码功能

• 回调函数

1.7.3 一步一坑的注册页环境

1）、编写 vo封装注册页内容

package com.atguigu.gulimall.auth.vo;

@Data
public class UserRegistVo {
    @NotEmpty(message = "用户名必须提交")
    @Length(min = 6,max = 18,message = "用户名必须是6-18位字符")
    private String userName;

    @NotEmpty(message = "密码必须填写")
    @Length(min = 6,max = 18,message = "密码必须是6-18位字符")
    private String password;

    @NotEmpty(message = "手机号必须填写")
    @Pattern(regexp = "^[1]([3-9])[0-9]{9}$",message = "手机号格式不正确")
    private  String phone;

    @NotEmpty(message = "验证码必须填写")
    private String content;
}

后端使用jsr303校验。

JSR303校验的结果，被封装到 BindingResult ，再结合 BindingResult.getFieldErrors() 方法获取错误信息， 有错误就重定向至注册页面。

2）、编写 controller接口

使用@Valid注解开启数据校验功能，将校验后的结果封装到BindingResult中。 LoginController

package com.atguigu.gulimall.auth.controller;

@PostMapping("/regist")
   public String regist(@Valid UserRegistVo vo, BindingResult result) { 
       if (result.hasErrors()) {
           //校验出错，转发到注册页
           return "redirect:http://auth.gulimall.com/reg.html"; 
     }
       //注册成功回到首页，回到登录页
       return "redirect:/login.html"; 
 }

3)、编写注册页面

为每个input框设置name属性，值需要与Vo的属性名一一对应

点击注册按钮没有发送请求，说明：为注册按钮绑定了单击事件，禁止了默认行为。将绑定的单击事件注释掉

4）、为Model绑定校验错误信息

使用方法引用的方式。

5)、编写前端页面获取错误信息

<form action="/regist" method="post" class="one">0
				<div class="register-box">
					<label class="username_label">用 户 名
						<input name="userName" maxlength="20" type="text" placeholder="您的用户名和登录名">
					</label>
					<div class="tips" style="color:red" th:text="${errors!=null?(#maps.containsKey(errors, 'userName')?errors.userName:''):''}">

					</div>
				</div>
				<div class="register-box">
					<label  class="other_label">设 置 密 码
						<input name="password" maxlength="20" type="password" placeholder="建议至少使用两种字符组合">
					</label>
					<div class="tips" style="color:red" th:text="${errors!=null?(#maps.containsKey(errors, 'password')?errors.password:''):''}">

					</div>
				</div>
				<div class="register-box">
					<label  class="other_label">确 认 密 码
						<input maxlength="20" type="password" placeholder="请再次输入密码">
					</label>
					<div class="tips">

					</div>
				</div>
				<div class="register-box">
					<label  class="other_label">
						<span>中国 0086∨</span>
						<input name="phone" class="phone" id="phoneNum" maxlength="20" type="text" placeholder="建议使用常用手机">
					</label>
					<div class="tips" style="color:red" th:text="${errors!=null?(#maps.containsKey(errors, 'phone')?errors.phone:''):''}">

					</div>
				</div>
				<div class="register-box">
					<label  class="other_label">验 证 码
						<input name="code" maxlength="20" type="text" placeholder="请输入验证码" class="caa">
					</label>
					<a id="sendCode">发送验证码</a>
					<div class="tips" style="color:red" th:text="${errors!=null?(#maps.containsKey(errors, 'code')?errors.code:''):''}">

					</div>

6)、测试–踩坑

1. 第一个踩坑

• 我的错误却是````Request method ‘GET’ not supported ```````Resolved [org.springframework.web.HttpRequestMethodNotSupportedException: Request method ‘GET’ not supported]```

这个是我百度找到的结果，使用@RequestMapping

2. 第二个踩坑
   • 刷新页面，会重复提交表单

5. 出现问题：分布式下重定向使用session存储数据会出现一些问题（这个后续来解决）

6. 完整代码

/**
     *   //TODO 重定向携带数据，利用session原理。将数据放在session中，只要跳到下一个页面取出这个数据以后，session里面的数据就会删掉
     *
     *
     *
     *   // TODO 1、分布式下的session问题。
     * RedirectAttributes redirectAttributes : 模拟重定向携带数据
     * @param vo
     * @param result
     * @param redirectAttributes
     * @return
     */
    @PostMapping("/regist")
    public String regist(@Valid UserRegistVo vo, BindingResult result, RedirectAttributes redirectAttributes, HttpSession session) {

        if (result.hasErrors()) {
            /**
             * .map(fieldError ->{
             *                  String field = fieldError.getField();
             *                  String defaultMessage = fieldError.getDefaultMessage();
             *                  errors.put(field,defaultMessage);
             *                  return
             *                  })
             *
             *
             */
            Map<String, String> errors = result.getFieldErrors().stream().collect(Collectors.toMap(FieldError::getField, FieldError::getDefaultMessage));
            // model.addAttribute("errors", errors);
            redirectAttributes.addFlashAttribute("errors",errors);
            // Request method 'POST' not supported
            //用户注册 -》/regist[post] ---->转发/reg.html（路径映射默认都是get方法访问的。）

            //真正注册。调用远程服务进行注册

            //校验出错，转发到注册页
            return "redirect:http://auth.gulimall.com/reg.html";
        }
        //注册成功回到首页，回到登录页
        return "redirect:/login.html";
    }

ps: 以上内容是注册用户
在 gulimall-auth-server服务中编写注册的主体逻辑

• 从redis中确认手机验证码是否正确，一致则删除验证码，（令牌机制）
• 会员服务调用成功后，重定向至登录页（防止表单重复提交），否则封装远程服务返回的错误信息返回至注册页面
• 重定向的请求数据，可以利用RedirectAttributes参数转发
  • 但是他是利用的session原理，所以后期我们需要解决分布式的session问题
  • 重定向取一次后，session数据就消失了，因为使用的是.addFlashAttribute(
• 重定向时，如果不指定host，就直接显示了注册服务的ip，所以我们重定义写http://…
  注： RedirectAttributes可以通过session保存信息并在重定向的时候携带过去

1.7.4 异常机制

1)、校验验证码

@PostMapping("/regist")
    public String regist(@Valid UserRegistVo vo, BindingResult result, RedirectAttributes redirectAttributes, HttpSession session) {

        if (result.hasErrors()) {
            /**
             * .map(fieldError ->{
             *                  String field = fieldError.getField();
             *                  String defaultMessage = fieldError.getDefaultMessage();
             *                  errors.put(field,defaultMessage);
             *                  return
             *                  })
             */
            Map<String, String> errors = result.getFieldErrors().stream().collect(Collectors.toMap(FieldError::getField, FieldError::getDefaultMessage));
            // model.addAttribute("errors", errors);
            redirectAttributes.addFlashAttribute("errors",errors);
            // Request method 'POST' not supported
            //用户注册 -》/regist[post] ---->转发/reg.html（路径映射默认都是get方法访问的。）

            //校验出错，重定向到注册页
            return "redirect:http://auth.gulimall.com/reg.html";
        }

        //1、校验验证码
        String code = vo.getCode();
        String s = redisTemplate.opsForValue().get(AuthServerConstant.SMS_CODE_CACHE_PREFIX + vo.getPhone());
        if (!StringUtils.isEmpty(s)){
            if (code.equals(s.split("_")[0])){
                //删除验证码；令牌机制
                redisTemplate.delete(AuthServerConstant.SMS_CODE_CACHE_PREFIX + vo.getPhone());
                //验证通过。//真正注册。调用远程服务进行注册。
            }else{
                Map<String, String> errors = new HashMap<>();
                errors.put("code","验证码错误");
                redirectAttributes.addFlashAttribute("errors",errors);
                return "redirect:http://auth.gulimall.com/reg.html";
            }
        }else{
            Map<String, String> errors = new HashMap<>();
            errors.put("code","验证码错误");
            redirectAttributes.addFlashAttribute("errors",errors);
            return "redirect:http://auth.gulimall.com/reg.html";
        }

        //注册成功回到首页，回到登录页
        return "redirect:/login.html";
    }

验证短信验证码通过，下面开始去数据库保存。

• member远程服务 ------- 通过gulimall-member会员服务注册逻辑

  • 通过异常机制判断当前注册会员名和电话号码是否已经注册，如果已经注册，则抛出对应的自定义异常，并在返回时封装对应的错误信息

  • 如果没有注册，则封装传递过来的会员信息，并设置默认的会员等级、创建时间

2)、会员服务中编写Vo接受数据

package com.atguigu.gulimall.member.vo;


@Data
public class MemberRegistVo {
    /**
     * 这个地方就不需要校验了，因为只有正确了，才会进行保存
     */
    private String userName;
    private String password;
    private String phone;
}

3)、编写会员服务的用户注册接口

• MemberController

  //因为我们注册会提交很多的东西，所以是 post方式提交
    @RequestMapping("/regist")
    public R regist(@RequestBody MemberRegistVo vo){
        memberService.regist(vo);
        return R.ok();
    }

• MemberServiceImpl

 @Override
    public void regist(MemberRegistVo vo) {
        MemberDao memberDao = this.baseMapper;
        MemberEntity entity = new MemberEntity();

        //设置默认等级
       MemberLevelEntity levelEntity =  memberLevelDao.getDefaultLevel();
       entity.setLevelId(levelEntity.getId());


       //检查用户名和手机号是否唯一。为了让controller能够感知异常，使用异常机制：一直往上抛
        checkPhoneUnique(vo.getPhone());
        checkUsernameUnique(vo.getUserName());


        entity.setMobile(vo.getPhone());
        entity.setUsername(vo.getUserName());


        //密码要进行加密存储。


        memberDao.insert(entity);
    }

• MemberLevelDao.xml -> :查询会员的默认等级

      <select id="getDefaultLevel" resultType="com.atguigu.gulimall.member.entity.MemberLevelEntity">
          SELECT  * FROM `ums_member_level` WHERE default_status = 1
  
      </select>
  

4)、异常类的编写

• PhoneExistException

package com.atguigu.gulimall.member.exception;


public class PhoneExistException extends  RuntimeException{
    public PhoneExistException(){
        super("手机号存在");
    }
}

• UsernameExistException

public class UsernameExistException extends  RuntimeException {
    public  UsernameExistException(){

        super("用户名存在");
    }
}

• 检查方法编写->MemberServiceI

 void checkPhoneUnique(String phone) throws PhoneExistException;

    void checkUsernameUnique(String username) throws UsernameExistException;

• MemberServiceImpl

 @Override
    public void checkPhoneUnique(String phone) throws PhoneExistException{

        MemberDao memberDao = this.baseMapper;
        Integer mobile = memberDao.selectCount(new QueryWrapper<MemberEntity>().eq("mobile", phone));
        if (mobile > 0){
            throw new PhoneExistException();
        }
    }

    @Override
    public void checkUsernameUnique(String username) throws UsernameExistException {

        MemberDao memberDao = this.baseMapper;
        Integer count = memberDao.selectCount(new QueryWrapper<MemberEntity>().eq("username", username));
        if (count > 0){
            throw new UsernameExistException();
        }
    }

如果抛出异常，则进行捕获

 @Test
    public void contextLoads() {

        //e10adc3949ba59abbe56e057f20f883e
        //抗修改性：彩虹表。 123456 -> xxxx
        String s = DigestUtils.md5Hex("123456");

        //MD5不能直接进行密码的加密存储：可以被直接暴力破解

        // System.out.println(s);

    }

1.7.5 MD5&盐值&BCrypt

@Test
    public void contextLoads() {

        //e10adc3949ba59abbe56e057f20f883e
        //抗修改性：彩虹表。 123456 -> xxxx
        String s = DigestUtils.md5Hex("123456");

        //MD5不能直接进行密码的加密存储：可以被直接暴力破解

        // System.out.println(s);

    }

 //盐值加密：随机值  加盐：$1$+8位字符

        //$1$qqqqqqqq$AZofg3QwurbxV3KEOzwuI1
        //验证： 123456进行盐值（去数据库查）加密
        // String s1 = Md5Crypt.md5Crypt("123456".getBytes(), "$1$qqqqqqqq");
        // System.out.println(s1);

//使用 spring家的
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
        //$2a$10$R/VBymW1UA.VzeBedBcspe.iypJIyQiWkka/Ds5SDG7h6r0wQsF6G
        String encode = passwordEncoder.encode("123456");

        boolean matches = passwordEncoder.matches("123456", "$2a$10$R/VBymW1UA.VzeBedBcspe.iypJIyQiWkka/Ds5SDG7h6r0wQsF6G");

        // $2a$10$jLJp4edbLb9pnCg9quGk0u2uvsm4E/6TD5zi1wqHY4jz/f1ydS.LS=>true
        System.out.println(encode+"=>"+matches);

//密码要进行加密存储。
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
        String encode = passwordEncoder.encode(vo.getPassword());
        entity.setPassword(encode);

1.7.6 注册完成

1)、在common的exception包下，编写异常枚举

  USER_EXIST_EXCEPTION(15001,"用户存在"),
    PHONE_EXIST_EXCEPTION(15002,"手机号存在"),

2)、进行异常的捕获

• MemberController

 package com.atguigu.gulimall.member.controller;


// @PostMapping("/regist")
    @RequestMapping("/regist")

    public R regist(@RequestBody MemberRegistVo vo ){

        try {
            memberService.regist(vo);
        } catch (PhoneExistException e) {
            return R.error(BizCodeEnume.PHONE_EXIST_EXCEPTION.getCode(), BizCodeEnume.PHONE_EXIST_EXCEPTION.getMsg());
        }catch (UsernameExistException e){
            R.error(BizCodeEnume.USER_EXIST_EXCEPTION.getCode(), BizCodeEnume.USER_EXIST_EXCEPTION.getMsg());
        }
        return R.ok();
    }

3)、远程服务接口编写

• 在 auth 服务下新建 MemberFeignService

@FeignClient("gulimall-member")
public interface MemberFeignService {

    @PostMapping("/member/member/regist")
    public R regist(@RequestBody UserRegistVo vo);

}

4)、 远程服务调用

package com.atguigu.gulimall.auth.controller; 


/**
     * //todo  重定向携带数据，利用的是session原理，将数据放在session中，只要跳到下一个页面，取出这个数据以后，session里面的数据就会删掉
     * RedirectAttributes redirectAttributes :模拟重定向携带数据
     *
     * @param vo
     * @param result
     * @param redirectAttributes
     * @return
     */
    // @PostMapping("/regist")
    @RequestMapping("/regist")    //这个地方和老师不一样，写成postmapping的话，
    // 会报 Request method 'GET' not supported，百度下改为requestmapping才行
    public String regist(@Valid UserRegistVo vo, BindingResult result, RedirectAttributes redirectAttributes,
                         HttpSession session) {

        if (result.hasErrors()) {

            Map<String, String> errors = result.getFieldErrors().stream().collect(Collectors.toMap(FieldError::getField, FieldError::getDefaultMessage));
            // model.addAttribute("errors",errors);
            redirectAttributes.addFlashAttribute("errors", errors);
            // Request method 'GET' not supported
            //  用户注册 -》 /regist[约定是post表单提交] - 》转发/reg.html(路径映射默认都是get方式访问的)

            //校验出错，转发到注册页
            return "redirect:http://auth.gulimall.com/reg.html";
            // return "forward:/reg.html";
        }
        //1.校验验证码
        String content = vo.getContent();

        String s = redisTemplate.opsForValue().get(AuthServerConstant.SMS_CODE_CACHE_PREFIX + vo.getPhone());
        if (!StringUtils.isEmpty(s)) {
            if (content.equals(s.split("_")[0])) {
                //删除验证码  ；令牌机制
                redisTemplate.delete(AuthServerConstant.SMS_CODE_CACHE_PREFIX + vo.getPhone());
                //验证通过   //真正注册，调用远程服务进行注册
                R r = memberFeignService.regist(vo);
                if(r.getCode() == 0){
                    //成功
                    return "redirect:http://auth.gulimall.com/login.html";
                }else{
                    HashMap<String,String> errors = new HashMap<>();
                    errors.put("msg",r.getData("msg",new TypeReference<String>(){
                  }));
                    redirectAttributes.addFlashAttribute("errors",errors);
                    return "redirect:http://auth.gulimall.com/reg.html";
                }
            } else {
                Map<String, String> errors = new HashMap<>();
                errors.put("content", "验证码错误");
                redirectAttributes.addFlashAttribute("errors", errors);
                return "redirect:http://auth.gulimall.com/reg.html";
            }
        } else {
            Map<String, String> errors = new HashMap<>();
            errors.put("content", "验证码错误");
            redirectAttributes.addFlashAttribute("errors", errors);
            //校验出错，转发到注册页
            return "redirect:http://auth.gulimall.com/reg.html";
        }

        //真正注册，调用远程服务进行注册
        //注册成功回到首页，回到登录页

    }
}

5)、注册页错误消息提示

6)、测试

• 注册页面输入之后，跳转到登录页面

• 数据库中也有数据

• 报错：

status 400 reading MemberFeignService#regist(UserRegistVo)

这个地方最开始写成@RequestParam了。

1.7.7 账户密码登录完成

1）、编写vo

package com.atguigu.gulimall.auth.vo;


@Data
public class UserLoginVo {
    private String loginacct;
    private String password;
}

2)、数据绑定

我们进行输入账号密码进行提交，我们必须要采用表单的方式。

3）、编写登录接口

package com.atguigu.gulimall.auth.controller;

@PostMapping("/login")
    public String login(UserLoginVo vo,RedirectAttributes redirectAttributes){
        //因为请求第一次过来传过来的是kv键值对（form表单），不是Json，所以不加@requestBody，调用远程服务时将其又转换为了json
        //远程登录
       R login =  memberFeignService.login(vo);
       if(login.getCode() == 0){
           //成功
           return "redirect:http://gulimall.com";
           // return "redirect:http//gulimall.com";

       }else {
           //失败 ，回到登录页
        Map<String, String> errors = new HashMap<>();
        errors.put("msg",login.getData("msg",new TypeReference<String>(){}));
        redirectAttributes.addFlashAttribute("errors",errors);
        return "redirect:http://auth.gulimall.com/login.html";
       }
    }

4)、MemberLoginVo

package com.atguigu.gulimall.member.vo;

@Data
public class MemberLoginVo { 
   private String loginacct;
   private String password; 
}

5)、登录校验功能

• MemberController

//login
    @PostMapping("/login")
    // @RequestMapping("/login")
    public R login(@RequestBody MemberLoginVo vo){
        MemberEntity entity = memberService.login(vo);
        if(entity!=null){
            return R.ok();
        }else{
            return R.error(BizCodeEnume.LOGINACCT_PASSWORD_INVALID_EXCEPTION.getCode(), BizCodeEnume.LOGINACCT_PASSWORD_INVALID_EXCEPTION.getMsg());
        }
    }

• MemberServiceImpl

package com.atguigu.gulimall.member.service.impl;

@Override
    public MemberEntity login(MemberLoginVo vo) {
        String loginacct = vo.getLoginacct();
        String password = vo.getPassword();

        //1.去数据库查询 SELECT * FROM `ums_member` WHERE username=? OR mobile = ?
        MemberDao memberDao = this.baseMapper;
        MemberEntity entity = memberDao.selectOne(new QueryWrapper<MemberEntity>().eq("username", loginacct)
                .or().eq("mobile", loginacct));
        if (entity == null){
            //登录失败
            return null;
        }else{
            //1.获取到数据库的password
            String passwordDb = entity.getPassword();
            BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
            //2.密码匹配
            boolean matches = passwordEncoder.matches(password, passwordDb);
            if(matches){
                return entity;
            }else {
                return null;
            }
        }

    }

6）、编写异常枚举

7）、远程服务接口编写

认证服务调用会员服务中的登录校验功能进行登录验证

• MemberFeignService

 package com.atguigu.gulimall.auth.feign;

@PostMapping("/member/member/login") 
   R login(@RequestBody UserLoginVo vo);

• LoginController

   @PostMapping("/login")
      public String login(UserLoginVo vo,RedirectAttributes redirectAttributes){
          //因为请求第一次过来传过来的是kv键值对（form表单），不是Json，所以不加@requestBody，调用远程服务时将其又转换为了json
          //远程登录
         R login =  memberFeignService.login(vo);
         if(login.getCode() == 0){
             //成功
             return "redirect:http://gulimall.com";
             // return "redirect:http//gulimall.com";
  
         }else {
             //失败 ，回到登录页
          Map<String, String> errors = new HashMap<>();
          errors.put("msg",login.getData("msg",new TypeReference<String>(){}));
          redirectAttributes.addFlashAttribute("errors",errors);
          return "redirect:http://auth.gulimall.com/login.html";
         }
      }
  

8)、页面错误消息提示

• 在 form 表单下面新增一个 div存放错误消息提示

9）、测试

• 专门输入错误的账号密码看看到时会不会有错误消息提示

• 踩坑报错：

报这个错误

404 找不到资源，其实我们来看登录成功之后跳转的页面可看到重定向的网址写错了

1.7.8 社交登录

1）、OAuth 2.0

2）、微博登陆准备工作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5xjVyrAN-1673533054932)(null)]

3）、微博登陆测试（课件）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KgJFdp2M-1673533055880)(null)]

4）、实际操作（gitee+weibo）

• oauth2.0的原理

① Gitee测试

注册地址：https://gitee.com/oauth/applications/

对应文档：Gitee OAuth 文档:https://gitee.com/api/v5/oauth_doc#/

api 文档：https://gitee.com/api/v5/swagger#/getV5User

1. 创建一个第三方应用

2. oauth2认证基本流程

3. 修改认证服务下的login.html页面

https://gitee.com/oauth/authorize?client_id={client_id}&redirect_uri={redirect_uri}&response_type=code

• 这个地方就是填自己的client_id和redirect_uri

• 图片随便找一个，将下方<src=“/static/login/JD_img/gitee.png”>即可。（相应的图标这些需要传到nginx中，根据图片路径来即可）。

4. 测试获取code码

• 页面点击gitee图片登录

  • 

• 引导到指定页面登录

  • 
  • 
  • http://gulimall.com/success?code=a87db26189f45222eef70f4382d006b57eaefeefb7ea8f38da2f00af71990a26 获得code码

5. 利用apifox获取access_token

• https://gitee.com/oauth/token?grant_type=authorization_code&code={code}&client_id={client_id}&redirect_uri={redirect_uri}&client_secret={client_secret}
  

  • 将上面获得的code码和uri和client_secret和client_id这些都填进去
  • 得到access_token

{
    "access_token": "289e10c1952bd8a7613d400b87b7b53d",
    "token_type":"bearer",
    "expires_in": 86400,
    "refresh_token": "427b4f1c7bfc5948a07d62879782476bb23bccdc342f3174c8aeb17be83528a5",
    "scope": "user_info",
    "created_at": 1670673346
}

获取到这个令牌之后，我们就可以获取到公开的所有api。

6. 比如说获取授权用户的所有资料

可以看到我们需要发送一个GET请求：https://gitee.com/api/v5/user 带上access_token即可。

② 微博测试

1. 创建一个网页应用

2.授权机制说明：https://open.weibo.com/wiki/%E6%8E%88%E6%9D%83%E6%9C%BA%E5%88%B6%E8%AF%B4%E6%98%8E

高级信息：https://open.weibo.com/apps/2475976673/info/advanced

用户普通读取信息：https://open.weibo.com/wiki/2/users/show

3. 其他测试我们在老师的课件中可以明确的看到。这里不再过多赘述。

③操作

我们发现获取的code等这些敏感数据都直接被显示到浏览器上，所以我们需要使用后台代码将这些隐藏在后台代码中。

1. 首先设置回调地址

• 回调地址是用户授权后，码云回调到应用，并且回传授权码的地址

• 比如说qq:用户点击QQ登录跳转到QQ登录页面，登录成功后，应该跳转回网站。回调地址即在这里用来指定跳转回网站的URL。回调地址注册的目的是为了保障第三方APPID帐户的安全，以免被其他恶意网站盗用。

• 个人理解：我们在csdn中进行社交登录，选择qq,qq登录成功之后，会跳回csdn，微博也一样，登录成功之后，要跳回哪个页面，这个页面就是指的回调地址。

• 这就是我们设置的回调地址，即用户登录成功之后。
  • gitee

   -  微博

• 相应的我们在认证服务下的login.html的页面中设置的redirect_uri也要改回我们设置的这个回调地址

  • gitee：http://auth.gulimall.com/oauth2.0/gitee/success
  • 微博：http://auth.gulimall.com/oauth2.0/weibo/success

2. 将第三方服务中短信验证码中使用到的HTTPutils这个工具类复制到common服务中，并按照要求引入依赖。----主要是为了后面发送请求方便，而且放在common中也可以让其他微服务能调用

• 依赖地址： https://github.com/aliyun/api-gateway-demo-sign-java/blob/master/pom.xml

  将里面的依赖导入到公共服务中

 <dependencies>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.15</version>
		</dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.2.1</version>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-util</artifactId>
            <version>9.3.7.v20160115</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.5</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

test依赖暂时不需要。

• 我们需要注意的是gitee和微博登录之后返回的数据是不一样的，具体返回的结果是有一些差异的。

3. 认证服务包下新建SocialUser

• 我们使用这个用户普通读取接口来进行获取用户信息
  • 

• 这个是返回的数据，我们可以使用Json工具将其转换为java实体类

package com.atguigu.gulimall.auth.vo;


@Data
public class SocialUser {
    
    //gitee
    /**
    private String access_token;
    private Long expires_in;
    private String uid;
    */
    
    //微博
    private String access_token;
    private String remind_in;
    private Long expires_in;
    private String uid;
    private String isRealName;
    

}

4. 修改数据库中ums_member表，增加三个属性

5. 认证服务下编写OAuth2Controller

package com.atguigu.gulimall.auth.controller;

@Controller
@Slf4j
public class OAuth2Controller {
    @Autowired
    MemberFeignService memberFeignService;

    // @GetMapping("/oauth2.0/gitee/success")   ----- gitee
    //登录成功之后处理回调
    @GetMapping ("/oauth2.0/weibo/success")   //  ----- 微博
    public String gitee(@RequestParam("code")String code) throws Exception {
        Map<String, String> map = new HashMap<>();

        /**  ----- gitee
        map.put("grant_type","authorization_code");
        map.put("code",code);
        map.put("client_id","882f054cba88fb88b67f402b6e458dd7d0938ce2483ebeaea220ddc54b8eebb5");
        map.put("client_secret","1f87cb951c4faa8350673b6d7f0a56b6c6a8f442d19de0f2031756737359abe3");

         */

        //微博
        map.put("client_id", "2475976673");
        map.put("client_secret", "a9298e9d9cad1d01d45574ba8a56d6d0");
        map.put("grant_type", "authorization_code");
        map.put("redirect_uri", "http://auth.gulimall.com/oauth2.0/weibo/success");
        map.put("code", code);
        Map<String, String> headers = new HashMap<>();
        Map<String, String> querys = new HashMap<>();
        //1.根据code换取access_token    ----- gitee
        // HttpResponse response = HttpUtils.doPost("http://gitee.com", "/oauth/token", "post", headers, querys, map);

        //获取返回结果
        HttpResponse response = HttpUtils.doPost("https://api.weibo.com", "/oauth2/access_token", "post", headers, querys, map);
        //2.处理   getStatusLine() ：获取响应状态行，响应状态行中有响应状态码
        if(response.getStatusLine().getStatusCode() == 200){
            //获取到了accessToken
            //response.getEntity()：获取响应实体，EntityUtils.toString：将httpentityzhaun'h
            String json = EntityUtils.toString(response.getEntity());
            SocialUser socialUser = JSON.parseObject(json, SocialUser.class);

            /**  ----- gitee
            JSONObject jsonObject = JSON.parseObject(json);
            String accessTtoken = jsonObject.getString("access_token");
            Long expiresIn = Long.valueOf(jsonObject.getString("expires_in"));
            //通过access_token获取用户id
           Map<String, String> map1 = new HashMap<>();
           map1.put("access_token",accessTtoken);
            HttpResponse response1 = HttpUtils.doGet("http://gitee.com", "/api/v5/user", "get", new HashMap<>(), map1);
            String json1 = EntityUtils.toString(response1.getEntity());
            JSONObject jsonObject1 = JSON.parseObject(json1);
            String id = jsonObject1.getString("id");
            //将access_token  expires_id uid封装到SocialUser
            SocialUser socialUser = new SocialUser();
            socialUser.setUid(id);
            socialUser.setAccess_token(accessTtoken);
            socialUser.setExpires_in(expiresIn);
             */

            //知道当前是哪个社交用户
            //1.当前用户如果是第一次进入网站，自动注册（为当前社交用户生成一个会员信息账号，以后这个社交账号就对应指定的会员账户）
            //登录或注册这个社交用户
          R oauthLogin =  memberFeignService.oauthLogin(socialUser);
          if(oauthLogin.getCode() == 0){
              MemberRespVo data   =     oauthLogin.getData("data",new TypeReference<MemberRespVo>(){});
              log.info("登录成功：用户信息：{}",data.toString());
              //2.登录成功就跳回首页
              return "redirect:http://gulimall.com";
          }else {
              return "redirect:http://auth.gulimall.com/login.html";
          }

        }else {
            return "redirect:http://auth.gulimall.com/login.html";
        }
    }
}

6. 会员服务下编写 处理社交登录的类（认证服务会远程调用会员服务中的社交登录）

• MemberEntity实体类下新增3个字段(因为如果是以前没有登录过得，我们要为其快速创建一个用户)

private String socialUid;
private String accessToken;
private Long expiresIn;

• MemberController

     //社交登录
        @PostMapping("/oauth2/login")
        public R oauthLogin(@RequestBody  SocialUser socialUser) throws  Exception{
        MemberEntity entity =     memberService.login(socialUser);
        if(entity != null){
            //TODO1.登录成功处理
            return R.ok().setData(entity);
        }else {
            return R.error(BizCodeEnume.LOGINACCT_PASSWORD_INVALID_EXCEPTION.getCode(),BizCodeEnume.LOGINACCT_PASSWORD_INVALID_EXCEPTION.getMsg());
        }
        }

• MemberServiceImpl

 @Override
    public MemberEntity login(SocialUser socialUser) throws  Exception{
        //登录和注册合并逻辑
        String uid = socialUser.getUid();
        //1.判断当前社交用户是否已经登录过系统
        MemberDao memberDao = this.baseMapper;
        MemberEntity memberEntity = memberDao.selectOne(new QueryWrapper<MemberEntity>().eq("social_uid", uid));
        if(memberEntity != null){
            //这个用户已经注册
            MemberEntity update = new MemberEntity();
            update.setId(memberEntity.getId());
            update.setAccessToken(socialUser.getAccess_token());
            update.setExpiresIn(socialUser.getExpires_in());
            memberDao.updateById(update);

            memberEntity.setAccessToken(socialUser.getAccess_token());
            memberEntity.setExpiresIn(socialUser.getExpires_in());
            return memberEntity;
        }else{
            //2.没有查询到当前社交用户对应的记录我们就需要注册一个
            MemberEntity regiset = new MemberEntity();
            try {
                Map<String, String> query = new HashMap<>();
                /**
                query.put("access_token", socialUser.getAccess_token());
                 */
                query.put("access_token", socialUser.getAccess_token());
                query.put("uid",socialUser.getUid());
                // HttpResponse response = HttpUtils.doGet("http://gitee.com", "/api/v5/user", "get", new HashMap<>(), query);  ----- gitee
                HttpResponse response = HttpUtils.doGet("https://api.weibo.com", "/2/users/show.json", "get", new HashMap<>(), query);
                if(response.getStatusLine().getStatusCode() == 200){
                    //查询成功
                    String json = EntityUtils.toString(response.getEntity());
                    JSONObject jsonObject = JSON.parseObject(json);
                    /**
                    //昵称    ----- gitee
                    String name = jsonObject.getString("name");
                    regiset.setNickname(name);
                     */
                    String name = jsonObject.getString("name");
                    String gender = jsonObject.getString("gender");
                    regiset.setGender("m".equals(gender)?1:0);
                    regiset.setNickname(name);
                }
            } catch (Exception e) {

            }
            regiset.setSocialUid(socialUser.getUid());
            regiset.setAccessToken(socialUser.getAccess_token());
            regiset.setExpiresIn(socialUser.getExpires_in());
            memberDao.insert(regiset) ;
            return  regiset;
        }
    }

• SocialUser类复制到member服务的vo包下,因为需要这个类型的数据，我们直接复制即可。

7. 远程调用：认证服务调用会员服务

• 认证服务

package com.atguigu.gulimall.auth.feign;

 @PostMapping("/member/member/oauth2/login")
    public R oauthLogin(@RequestBody SocialUser socialUser) throws  Exception;

• 为数据封装方便，将会员服务中的 MemberEntity 复制到认证服务下，重命名为 MemberRespVo

package com.atguigu.gulimall.auth.vo;

import lombok.Data;
import lombok.ToString;

import java.util.Date;

@ToString
@Data
public class MemberRespVo {

    private Long id;
    /**
     * 会员等级id
     */
    private Long levelId;
    /**
     * 用户名
     */
    private String username;
    /**
     * 密码
     */
    private String password;
    /**
     * 昵称
     */
    private String nickname;
    /**
     * 手机号码
     */
    private String mobile;
    /**
     * 邮箱
     */
    private String email;
    /**
     * 头像
     */
    private String header;
    /**
     * 性别
     */
    private Integer gender;
    /**
     * 生日
     */
    private Date birth;
    /**
     * 所在城市
     */
    private String city;
    /**
     * 职业
     */
    private String job;
    /**
     * 个性签名
     */
    private String sign;
    /**
     * 用户来源
     */
    private Integer sourceType;
    /**
     * 积分
     */
    private Integer integration;
    /**
     * 成长值
     */
    private Integer growth;
    /**
     * 启用状态
     */
    private Integer status;
    /**
     * 注册时间
     */
    private Date createTime;

    private  String socialUid;
    private String accessToken;
    private Long expiresIn;
}

8. 测试

• 登录成功-授权–返回首页（数据库中有记录）

1.7.9 springsession

1）、session共享问题

2）、SpringSession核心原理

• 

• @EnableRedisHttpSession注解导入了RedisHttpSessionConfiguration.class这个配置类

• 在 RedisHttpSessionConfiguration.class这个配置类，为容器中注入了一个组件 sessionRepository -> sessionRedisOperations : redis操作session，实现session的增删改查

• 调用SpringHttpSessionConfiguration中的springSessionRepositoryFilter()方法，获取一个SessionRepositoryFilter对象，调用doFilterInternal()对原生的request和response对象进行封装即装饰者模式， request对象调用getSession()方法就会调用wrapperRequest对象的getSession()方法。

• 网上相关资料：https://blog.csdn.net/m0_46539364/article/details/110533408

1.7.10 页面效果完善

1）、完善社交登录的页面效果

product包下面：index.html

进行简单的判断，如果登录了，就显示昵称；如果没有登录，就显示免费注册。

2）完善账号密码登录

页面登录除了进行扫码登录之外，还有一种方法是通过账号密码登录，这种登录方式的用户我们也需要进行保存到session中。

• 公共服务包

• 会员服务包 — MemberController

以前账号密码登录成功之后，直接是return R.ok.没有做任何操作，现在我们加入一段代码，使之保存到session中。

• 认证服务包 ---- LoginController

3）、设置默认的昵称

• 会员服务包下 ------ MemberServiceImpl

4）、完善登录逻辑

我们如果已经登录了，那么我们在浏览器中重新访问登录页面的话就直接跳转到首页，而不是再次跳转到登录页面了。所以这一块我们需要自定义。

• 认证服务 ------ GulimallWebConfig

这个是以前我们对于只有登录跳转页面这个controller的抽取。使用springmvc抽取的，现在我们需要自定义。

• 自己编写接口实现逻辑

  • 认证服务下 LoginController

  • //如果登录成功了之后，访问auth.gulimall.login.html这个页面会自动跳转到首页
        @GetMapping("/login.html")
            public String loginPage(HttpSession session){
                Object attribute = session.getAttribute(AuthServerConstant.LOGIN_USER);
                if(attribute == null){
                    //没登录
                    return "login";
                }else{
                    return "redirect:http://gulimall.com";
                }
            }
    

5)、商品详情页面登录完善

• 详情页显示昵称

• 点击详情页面左上角京东图标返回谷粒商城首页

6）、搜索页面用户昵称显示

注意这个是在检索服务包下。

1. 导入依赖

因为我们都是将session这些存在redis中，都是对redis的操作。所以需要引入redis相关依赖。

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <!--spring整合session-->
        <dependency>
            <groupId>org.springframework.session</groupId>
            <artifactId>spring-session-data-redis</artifactId>
        </dependency>

2. 配置

• 检索服务包下的application.properties中配置redis的相关配置

3. 开启session共享

4. 因为都是使用同一个session。所以我们可以将认证服务中的GulimallSessionConfig复制到检索服务中。

@Configuration
public class GulimallSessionConfig {

    //子域共享问题解决
    @Bean
    public CookieSerializer cookieSerializer(){
        DefaultCookieSerializer cookieSerializer = new DefaultCookieSerializer();
        //将session作用域设置为不仅仅只限于子域名，而是整个父域名。这样所有子域名都可以获得一样的cookie
        cookieSerializer.setDomainName("gulimall.com");
        cookieSerializer.setCookieName("GULISESSION");
        return cookieSerializer;
    }

    // 默认使用jdk进行序列化机制，这里我们使用json序列化方式来序列化对象数据到redis中
    @Bean
    public RedisSerializer<Object> springSessionDefaultRedisSerializer() {
        return new GenericJackson2JsonRedisSerializer();
    }
}

5. item.html页面完善

总结

1.7.11 单点登录

1）、介绍

2）、前置概念

3）、xxl单点登录demo

这里以码云上的[许雪里](https://gitee.com/xuxueli0323) / [xxl-sso](https://gitee.com/xuxueli0323/xxl-sso)单点登录为演示。

1. 修改配置

• 配置本机域名

• 修改服务器redis地址

• 修改客户端配置
  • xxl-sso-master\xxl-sso-master\xxl-sso-samples\xxl-sso-web-sample-springboot\src\main\resources

• 打包

mvn clean package -Dmaven.skip.test=true

• 启动服务器端和客户端

同样启动一个8081。

• 当访问客户端1，会自动重定向到服务器认证中心，认证中心登录后，客户端2刷新之后就登录上了。

认证中心访问路径：http://ssoserver.com:8080/xxl-sso-server
客户端1访问路径：http://client1.com:8081/xxl-sso-web-sample-springboot 
客户端2访问路径：http://client2.com:8082/xxl-sso-web-sample-springboot

实现一处登录，处处登录。一处退出，处处退出。

4）、单点登录代码实现

① 总流程梳理

下图是一个总的流程。单点登录就是单独起一个认证服务，其他服务登录先请求认证服务，认证服务判断自己域名下是否有cookie保存登录信息，如果有直接返回，如果没有就登录并保存cookie重定向到申请地址。

② 环境准备

1. 本机配置域名

根据此我们要在idea中创建相应的模块，服务端和客户端。

2. 创建模块

• 使用Spring Initializr创建 gulimall-test-sso-server (服务器端)和 gulimall-test-sso-client（客户端）

• 引入的依赖
  • spring web
  • thymeleaf
  • lombok

接下来我们将单点登录流程的全部分为三个部分进行理解和编排。

③单点登录流程1：

客户端：

• 创建一个HelloController

package com.atguigu.gulimall.ssoclient.controller;


@Controller
public class HelloController {
     
    @Value("${sso.server.url}")   #取出配置文件中的值
    String ssoServerUrl;
    
     /**
    * 无需登录即可访问 
    * @return
    */
   @ResponseBody
   @GetMapping("/hello") 
   public String hello(){
       return "hello"; 
    }
    
    /**
    需要登录才可以访问的
    */
   @GetMapping("/employees")
   public String employees(Model model, HttpSession session){ 
       //先从session中获取，看是否有登录用户
       Object loginUser = session.getAttribute("loginUser"); 
       //进行判断  没有登录
       if (loginUser == null){
           //如果没登录，让其跳转重定向到登录服务器进行登录，并且在跳转时带上前一个页面，即我们在sso登录之后需要跳回的页面。
           //redirect:http://client1.com:8081/employees
           return "redirect:"+ssoServerUrl+"? 
      redirect_url=http://client1.com:8081/employees"; 
       }else{
           
           //登录了，保存。这个地方我们都是写死了，两个用户的。开发中不可能是这样
           List<String> emps = new ArrayList<>(); 
           emps.add("张三");
           emps.add("李四");
          // model 就是个 key-value 集合。Model 对象负责在控制器和展现数据的视图之间传递数据。
           model.addAttribute("emps",emps); 
           return "list";
     } 
  }

}

• 创建一个list.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
   <head>
       <meta charset="UTF-8">
       <title>员工列表</title>
   </head>
   <body>
     <h1>欢迎：[]</h1>
     <ul>
       <li th:each="emp:${emps}">姓名：[[${emp}]]</li>
     </ul>
   </body>
</html>

• application.properties

server.port=8081
sso.server.url=http://sso.com:8080/login.html

服务器端：

• LoginController

@Controller
public class LoginController { 
    
   @GetMapping("/login.html")
   public String loginPage(@RequestParam("redirect_url")String url){ 
       return "login";
 }
   @PostMapping("/doLogin")
   public String doLogin(){
       //登录成功跳转，跳回到之前的页面 
       return "";
 } 
}

• login.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org"> 
   <head>
       <meta charset="UTF-8">
    <title>登录页</title> 
   </head>
   <body>
       <!--表单提交-->
     <form action="/doLogin" method="post"> 
      用户名：<input name="username"/><br/>
       密码：<input name="password" type="password"/><br/> 
       <input type="submit" value="登录"/>
     </form> 
   </body> 
</html>

• application.properties

server.port=8080

• 演示：访问客户端直接重定向到 服务端。

④单点登录流程2：

服务器端：

• 加入依赖：（将cookie这些存入到redis中）

<dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-data-redis</artifactId> 
       </dependency>

• 配置：

spring.redis.host=192.168.56.10

• login页面带一个隐藏输入框：用于存储调回的url

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
   <head>
       <meta charset="UTF-8">
       <title>登录页</title>
   </head>
   <body>
     <form action="/doLogin" method="post"> 
      用户名：<input name="username"/><br/>
       密码：<input name="password" type="password"/><br/> 
       <input type="hidden" name="url" th:value="${url}"/> 
       <input type="submit" value="登录"/>
     </form> 
   </body> 
</html>

• LoginController
  • 登录成功保存用户信息并传递token

@Controller
public class LoginController {
   @Autowired
   private  StringRedisTemplate redisTemplate; 
    
   @GetMapping("/login.html")
   public String loginPage(@RequestParam("redirect_url")String url, Model model){ 
       model.addAttribute("url",url);
       return "login"; 
 }
    
   @PostMapping("/doLogin")
   public String doLogin(@RequestParam("username") String username,
                         @RequestParam("password") String password,
                         @RequestParam("url") String url){
       if (!StringUtils.isEmpty(username) && !StringUtils.isEmpty(password)){ 
           //登录成功，跳回之前页面
   
           
           String uuid = UUID.randomUUID().toString().replace("-","");
            //把登录成功的用户保存起来
           //登录成功保存用户信息并传递token
           redisTemplate.opsForValue().set(uuid,username);
           
           return "redirect:"+url+"?token="+uuid; 
     }
       //登录失败，展示登录页 
       return "login"; 
 }

客户端：

• 拿到令牌需要去认证中心查询用户的信息，这里只是简单保存了以下并没有模拟

/**
    * 能够感知这次是在    ssoserver登录成功跳回来的。 
    * @param model
    * @param session
    * @param token  只要去ssoserver登录成功跳回来就会带上 
    * @return
    */
   @GetMapping("/employees")
   public String employees(Model model, HttpSession session,
                           @RequestParam(value = "token",required = false) String token){ 
       if (!StringUtils.isEmpty(token)){
           //去ssoserver登录成功跳回来就会带上
           //TODO 1、去ssoserver获取当前token真正对应的用户信息 
           session.setAttribute("loginUser","zhangsan"); 
     }
       
       
       //先从session中获取，看是否有登录用户
       Object loginUser = session.getAttribute("loginUser"); 
       //进行判断  没有登录
       if (loginUser == null){
           //如果没登录，让其跳转重定向到登录服务器进行登录，并且在跳转时带上前一个页面，即我们在sso登录之后需要跳回的页面。
           //redirect:http://client1.com:8081/employees
           return "redirect:"+ssoServerUrl+"? 
      redirect_url=http://client1.com:8081/employees"; 
       } 
       else{
           List<String> emps = new ArrayList<>(); 
           emps.add("张三");
           emps.add("李四");
           model.addAttribute("emps",emps); 
           return "list";
     } 
 }

• 测试：客户端1加上了token

⑤单点登录流程3：

• 将客户端复制一份，改为客户端2，修改一些配置

• 添加进项目

• 服务器端：

@Controller
public class LoginController {
   @Autowired
   private  StringRedisTemplate redisTemplate; 
    
   //登录之后保存用户token
   @ResponseBody
   @GetMapping("/userInfo")
   public String userInfo(@RequestParam("token") String token){ 
       String s = redisTemplate.opsForValue().get(token);
       return s; 
   }
    
    @GetMapping("/login.html")   
    public String loginPage(@RequestParam("redirect_url")String url, Model model,
                           @CookieValue(value = "sso_token",required = false) String sso_token){
       if (!StringUtils.isEmpty(sso_token)){ 
           //说明之前有人登录过，浏览器留下了痕迹
           return "redirect:"+url+"?token="+sso_token; 
     }
       model.addAttribute("url",url); 
       return "login";
 }
   
    @PostMapping("/doLogin")
    public String doLogin(@RequestParam("username") String username, 
                         @RequestParam("password") String password, 
                         @RequestParam("url") String url,
                         HttpServletResponse response){
       if (!StringUtils.isEmpty(username) && !StringUtils.isEmpty(password)){ 
           //登录成功，跳回之前页面
           //把登录成功的用户保存起来
           // 登录成功保存用户信息并传递token 
           //UUID  01E4DC67-6F61-4272-07E1-28417A4A4707
           String uuid = UUID.randomUUID().toString().replace("-",""); 
           redisTemplate.opsForValue().set(uuid,username);
           Cookie sso_token = new Cookie("sso_token", uuid); 
           response.addCookie(sso_token);
           return "redirect:"+url+"?token="+uuid; 
     }
       //登录失败，展示登录页 
       return "login"; 
 }
}

• 客户端：

@Controller
public class HelloController {
   @Value("${sso.server.url}") 
   String ssoServerUrl;
   /**
    * 无需登录即可访问 
    * @return
    */
   @ResponseBody
   @GetMapping("/hello") 
   public String hello(){
       return "hello"; 
 }   /**
    * 能够感知这次是在    ssoserver登录成功跳回来的。 
    * @param model
    * @param session
    * @param token  只要去ssoserver登录成功跳回来就会带上 
    * @return
    */
   @GetMapping("/employees")
   public String employees(Model model, HttpSession session,
                           @RequestParam(value = "token",required = false) String token){ 
       if (!StringUtils.isEmpty(token)){
           //去ssoserver登录成功跳回来就会带上
           //TODO 1、去ssoserver获取当前token真正对应的用户信息 
           RestTemplate restTemplate = new RestTemplate(); 
           ResponseEntity<String> forEntity =
restTemplate.getForEntity("http://sso.com:8080/userInfo?token=" + token, String.class); 
           String body = forEntity.getBody();
           session.setAttribute("loginUser",body); 
     }
       Object loginUser = session.getAttribute("loginUser"); 
       if (loginUser == null){
           //没登录，跳转到登录服务器进行登录
           //跳转过去以后，使用url上的查询参数标识我们自己是那个页面 
           //redirect:http://client1.com:8081/employees
           return "redirect:"+ssoServerUrl+"? 
				redirect_url=http://client1.com:8081/employees"; 
       }else{
           List<String> emps = new ArrayList<>(); 
           emps.add("张三");
           emps.add("李四");
           model.addAttribute("emps",emps); 
           return "list";
     } 
 }
}

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
   <head>
       <meta charset="UTF-8">
       <title>员工列表</title>
   </head>
   <body>
     <h1>欢迎：[[${session.loginUser}]]</h1>
     <ul>
       <li th:each="emp:${emps}">姓名：[[${emp}]]</li>
     </ul>
   </body>
</html>

• 测试：

1.8 购物车服务

1.8.1 环境搭建

1)、配置域名：cart.gulimall.com

2）、创建微服务

• gulimall-cart

• 加入的依赖：lombok springweb springbootdevTools thymeleaf openfeign

• 导入公共服务的依赖

       <dependency>
           <groupId>com.atguigu.gulimall</groupId> 
           <artifactId>gulimall-common</artifactId> 
           <version>0.0.1-SNAPSHOT</version>
       </dependency>

• application.properties配置

server.port= 15000

spring.application.name=gulimall-cart
spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848

• 主启动类上加入nacos服务注册发现功能，而且由于后面还需要远程调用，所以我们还需要加上相应注解（特别提醒：我们导入了common包，但是没有用到数据库服务，所以我们还需要暂时排除数据库自动配置，否则启动会报错）

@EnableFeignClients
@EnableDiscoveryClient
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)

3）、动静分离

• 将课件中的静态资源放到nginx中

  • 在nginx中，/mydata/nginx/html/static下创建一个cart文件夹。将静态资源放入起重

• 将动态页面放入项目中

• 由于更换了路径，所以一些文件路径和图片路径会发生变化，所以我们需要修改。

  • 

4)、网关配置

       - id: gulimall_cart_route 
        uri: lb://gulimall-cart 
        predicates:
          - Host=cart.gulimall.com

5）、前端页面调试

在不编写任何代码的情况下，我们进行测试访问。为了方便，将success.html页面改名为Index.html

• 测试中发现的问题

  • 页面中存在th:这个thymeleaf预先写好的代码，导致找不到，进而报错。我们可以先将其替换为空 。
    • 
    • 

• 前端页面点击图标可以返回首页

• 

1.8.2 数据模型分析

1）、购物车需求

2）、数据结构

因此每一个购物项信息，都是一个对象，基本字段包括：

1.8.3 vo编写

1)、购物项的Vo编写：

package com.atguigu.gulimall.cart.vo;


public class CartItem {
    private Long skuId;
    private Boolean check = true;//是否被选中
    private String title;//标题
    private String image;//图片
    private List<String> skuAttr;//销售属性组合描述
    private BigDecimal price;//商品单价
    private Integer count;//商品数量
    private BigDecimal totalPrice;//总价，总价需要计算

    public Long getSkuId() {
        return skuId;
    }

    public void setSkuId(Long skuId) {
        this.skuId = skuId;
    }

    public Boolean getCheck() {
        return check;
    }

    public void setCheck(Boolean check) {
        this.check = check;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getImage() {
        return image;
    }

    public void setImage(String image) {

        this.image = image;
    }

    public List<String> getSkuAttr() {
        return skuAttr;
    }

    public void setSkuAttr(List<String> skuAttr) {
        this.skuAttr = skuAttr;
    }

    public BigDecimal getPrice() {
        return price;
    }

    public void setPrice(BigDecimal price) {
        this.price = price;
    }

    public Integer getCount() {
        return count;
    }

    public void setCount(Integer count) {
        this.count = count;
    }

    /**
     * 计算当前项的总价
     *
     * @return
     */
    public BigDecimal getTotalPrice() {
        return this.price.multiply(new BigDecimal("" + this.count));
    }

    public void setTotalPrice(BigDecimal totalPrice) {
        this.totalPrice = totalPrice;
    }
}

2）、购车Vo

/**
 * 整个购物车
 * 需要计算的属性，必须重写它的get方法，保证每次获取属性都会进行计算,所以不用使用@Data方法
 */
public class Cart {

    //一个购物车有很多个购物项
    List<CartItem> items;
    private Integer countNum;//商品数量
    private Integer countType;//商品类型数量
    private BigDecimal totalAmount;//商品总价
    private BigDecimal reduce = new BigDecimal("0.00");//减免价格

    public List<CartItem> getItems() {
        return items;
    }

    public void setItems(List<CartItem> items) {
        this.items = items;
    }

    public Integer getCountNum() {
        int count = 0;
        if (items != null && items.size() > 0) {
            for (CartItem item : items) {
                count += item.getCount();
            }
        }
        return count;
    }

    public Integer getCountType() {
        int count = 0;
        if (items != null && items.size() > 0) {
            for (CartItem item : items) {
                count += 1;
            }
        }
        return count;
    }

    public BigDecimal getTotalAmount() {
        BigDecimal amount = new BigDecimal("0");
        //1、计算购物项总价
        if (items != null && items.size() > 0) {
            for (CartItem item : items) {
                BigDecimal totalPrice = item.getTotalPrice();
                amount = amount.add(totalPrice);
            }
        }
        //2、减去优惠总价
        BigDecimal subtract = amount.subtract(getReduce());
        return subtract;
    }

    public void setTotalAmount(BigDecimal totalAmount) {
        this.totalAmount = totalAmount;
    }

    public BigDecimal getReduce() {
        return reduce;
    }

    public void setReduce(BigDecimal reduce) {
        this.reduce = reduce;
    }
}

1.8.4 ThreadLocal用户身份鉴别

1)、数据存储-redis

将购物车数据存储至Redis中，因此，需要导入Spring整合Redis的依赖以及Redis的配置。项目上线之后，应该有 一个专门的Redis负责存储购物车的数据不应该使用缓存的Redis

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

• 配置redis地址

spring.redis.host=192.168.56.10

2)、准备cartService和其实现类

这个接口是以后我们编写购物车具体服务的

• 创建CartService这个类
• CartServiceImpl

package com.atguigu.gulimall.cart.service.impl;


@Slf4j 
@Service
public class CartServiceImpl implements CartService { 
   @Autowired
   private StringRedisTemplate stringRedisTemplate; 
}

3）、引入springsession判断用户登录与否

 <dependency>
            <groupId>org.springframework.session</groupId>
            <artifactId>spring-session-data-redis</artifactId>
        </dependency>

我们会将登录的用户保存到session中，然后通过判断session中是否有用户的数据来判断登录与否。

• 配置session

  • 直接将我们认证服务中的编写好的sessionconfig拿过来

  • GulimallSessionConfig

  • 
    package com.atguigu.gulimall.cart.config;
    
    @Configuration
    public class GulimallSessionConfig {
    
        //子域共享问题解决
        @Bean
        public CookieSerializer cookieSerializer(){
            DefaultCookieSerializer cookieSerializer = new DefaultCookieSerializer();
            //将session作用域设置为不仅仅只限于子域名，而是整个父域名。这样所有子域名都可以获得一样的cookie
            cookieSerializer.setDomainName("gulimall.com");
            cookieSerializer.setCookieName("GULISESSION");
            return cookieSerializer;
        }
    
        // 默认使用jdk进行序列化机制，这里我们使用json序列化方式来序列化对象数据到redis中
        @Bean
        public RedisSerializer<Object> springSessionDefaultRedisSerializer() {
            return new GenericJackson2JsonRedisSerializer();
        }
    }
    

4)、cookie中的user-key说明

第一次访问京东，会给你的cookie中设置user-key标识你的身份，有效期为一个月，浏览器会保存你的user-key， 以后访问都会带上

*浏览器有一个cookie；user-key；标识用户身份，一个月后个过期；
    * 如果第一次使用jd的购物车功能，都会给一个临时的用户身份；
    * 浏览器以后保存，每次访问都会带上这个cookie；

    * 登录：session有
    * 没登录：按照cookie里面带来user-key来做。
    * 第一次：如果没有临时用户，帮忙创建一个临时用户。
  *

5)、编写To与常量

• UserInfoTo

package com.atguigu.gulimall.cart.vo;

@ToString
@Data
public class UserInfoTo {

    private Long userId;
    private String userKey;
    private boolean tempUser = false;   //标识临时用户
}

• 公共服务下增加一个有关购物车的常量(设置临时用户的过期时间)

• package com.atguigu.common.constant;
  
  
  public class CartConstant {
  
      public static final String TEMP_USER_COOKIE_NAME = "user-key";
  
      //过期时间为1个月 ,默认单位是秒  临时用户的过期时间（参考京东）
      public static final int TEMP_USER_COOKIE_TIMEOUT= 60*60*24*30;
  
  }
  

6）、编写拦截器（登录前检查）

拦截器逻辑：业务执行之前，判断是否登录，若登录则封装用户信息，将标识位设置为true，postHandler就不再
设置作用域和有效时间，否则为其创建一个user-key
注意细节：整合SpringSession之后，Session获取数据都是从Redis中获取的
使用ThreadLocal，解决线程共享数据问题，方便同一线程共享UserInfoTo

• 编写拦截器 ---- CartInterceptor

  • package com.atguigu.gulimall.cart.interceptor;
    
    
    /**   在执行目标方法之前，判断用户的登录状态，并封装传递给controller目标请求
     * @author hxld
     * @create 2022-12-15 21:36
     */
    public class CartInterceptor implements HandlerInterceptor {
        public static ThreadLocal<UserInfoTo> threadLocal = new ThreadLocal<>();
    
        /**
         * 目标方法执行之前
         * @param request
         * @param response
         * @param handler
         * @return
         * @throws Exception
         */
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
            UserInfoTo userInfoTo = new UserInfoTo();
    
            HttpSession session = request.getSession();
            MemberRespVo member = (MemberRespVo) session.getAttribute(AuthServerConstant.LOGIN_USER);
    
            if(member != null){
                //用户登录
                userInfoTo.setUserId(member.getId());
            }
            Cookie[] cookies = request.getCookies();
            if(cookies!=null && cookies.length>0){
                for (Cookie cookie : cookies) {
                    //user-key
                    String name = cookie.getName();
                    if(name.equals(CartConstant.TEMP_USER_COOKIE_NAME)){
                        userInfoTo.setUserKey(cookie.getValue());
                    }
                }
            }
    
            //如果没有临时用户一定要分配一个临时用户
            if(StringUtils.isEmpty(userInfoTo.getUserKey())){
                String uuid = UUID.randomUUID().toString();
                userInfoTo.setUserKey(uuid);
            }
    
            threadLocal.set(userInfoTo);
    
            return true;
        }
    
        /**
         * 业务执行之后：分配临时用户，让浏览器保存
         * @param request
         * @param response
         * @param handler
         * @param modelAndView
         * @throws Exception
         */
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
            UserInfoTo userInfoTo = threadLocal.get();
    
            //如果没有临时用户一定要保存一个临时用户
            if(!userInfoTo.isTempUser()){
                //持续的延长临时用户的过期时间
                Cookie cookie = new Cookie(CartConstant.TEMP_USER_COOKIE_NAME, userInfoTo.getUserKey());
                cookie.setDomain("gulimall.com");
                cookie.setMaxAge(CartConstant.TEMP_USER_COOKIE_TIMEOUT);
                response.addCookie(cookie);
            }
        }
    }
    

• 配置拦截器拦截所有请求

  • package com.atguigu.gulimall.cart.config;
    
    @Configuration
    public class GulimallWebConfig implements WebMvcConfigurer {
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            //配置catrInterceptor拦截器拦截所有请求
            registry.addInterceptor(new CartInterceptor()).addPathPatterns("/**");
        }
    }