第10章-单点登录

学习目标：

能够说出主流的认证方案-JWT/Token
搭建用户微服务模块
完成基于Token+Redis实现认证
完成网关统一鉴权

1、单点登录业务介绍

早期单一服务器，用户认证。

缺点：

单点性能压力，无法扩展

分布式，SSO(single sign on)模式

解决：

用户身份信息独立管理，更好的分布式管理。
可以自己扩展安全策略
跨域不是问题

缺点：

认证服务器访问压力较大。

业务流程图 {用户访问业务时，必须登录的流程}{单点登录的过程}

2、用户模块

2.1 实现思路

1、用接收的用户名密码核对后台数据库

2、核对通过，用uuid生成token

3、将用户id加载到写入redis，redis的key为token，value为用户id。

4、登录成功返回token与用户信息，将token与用户信息记录到cookie里面

5、重定向用户到之前的来源地址。

数据库表：user_info，并添加一条数据！密码应该是加密的！

2.2 搭建认证中心模块service-user

2.2.1 搭建service-user服务

在gmall-service模块下新增子模块：service-user。搭建方式如service-item

2.2.2 启动类

package com.atguigu.gmall;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class UserApp {
   public static void main(String[] args) {
      SpringApplication.run(UserApp.class, args);
   }
}

2.2.3 配置pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>gmall-service</artifactId>
        <groupId>com.atguigu.gmall</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>service-user</artifactId>


    <build>
        <finalName>service-user</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2.2.4 添加配置文件

在resources目录下新增 bootstrap.properties 文件

spring.application.name=service-user
spring.profiles.active=dev
spring.cloud.nacos.discovery.server-addr=192.168.200.128:8848
spring.cloud.nacos.config.server-addr=192.168.200.128:8848
spring.cloud.nacos.config.prefix=${spring.application.name}
spring.cloud.nacos.config.file-extension=yaml
spring.cloud.nacos.config.shared-configs[0].data-id=common.yaml

修改Nacos配置中心:service-user-dev.yaml

2.2.5 生成基础代码

在mybatis-plus-code中执行代码生成器代码，将gmall_user数据库中的 user_info,user_address 生成基础代码。

package com.atguigu.mybatispluscode;

import com.atguigu.gmall.base.model.BaseEntity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;

import java.util.*;

/**
 * 可参考：https://blog.csdn.net/weixin_44541136/article/details/121202871
 */

public class CodeGenerator {


    public static void main(String[] args) {
        // 设置代码生成的位置
        // TODO String projectPath = System.getProperty("user.dir");
        String projectPath = "D:\\code\\workspace2023\\sph\\0825-sph\\gmall-parent\\gmall-service";
        // 设置父模块名称
        String parentModuleName = "com.atguigu.gmall";
        //TODO 设置子模块名称
        String moduleName = "user";
        String subPath = "/service-" + moduleName;
        // 设置数据库连接
        String databaseUrl = "jdbc:mysql://192.168.200.128:3306/gmall_" + moduleName + "?useUnicode=true&useSSL=false&characterEncoding=utf8";
        // 数据库用户名
        String username = "root";
        //TODO 数据库密码
        String password = "123456";
        // 设置表名前缀，例如表为tb_UserInfo，这里设置表前缀为"tb_",生成实体类的时候会自动去除前缀，最终生成UserInfo
        String tablePrefix = "";
        // 代码生成器
        AutoGenerator mpg = new AutoGenerator();
        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        // 最终输出目录
        gc.setOutputDir(projectPath + subPath + "/src/main/java");
        gc.setAuthor("atguigu"); //作者
        gc.setOpen(false); //是否打开输出目录
        gc.setSwagger2(true); //实体属性 Swagger2 注解
        gc.setDateType(DateType.ONLY_DATE); //时间类型为 Date LocalDateTime
        // 设置主键类型  ASSIGN_ID为分布式全局唯一ID  AUTO:数据库自增
        gc.setIdType(IdType.AUTO);
        //gc.setIdType(IdType.ASSIGN_ID);
        // 是否覆盖已有文件
        gc.setFileOverride(false);
        //去掉Service接口的首字母I
        gc.setServiceName("%sService");
        mpg.setGlobalConfig(gc);

        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl(databaseUrl);
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUsername(username);
        dsc.setPassword(password);
        mpg.setDataSource(dsc);

        // 包配置
        PackageConfig pc = new PackageConfig();
//        pc.setModuleName(scanner("模块名"));
        //设置实体类包名
        pc.setEntity("model");
        pc.setParent(parentModuleName);
        pc.setModuleName(moduleName);

        mpg.setPackageInfo(pc);

        // 自定义配置
        InjectionConfig cfg = new InjectionConfig() {
            //自定义属性注入
            //在.ftl(或者是.vm)模板中，通过${cfg.abc}获取属性
            @Override
            public void initMap() {
                Map<String, Object> map = new HashMap<>();
                map.put("parentName", parentModuleName);
                map.put("moduleName", moduleName);
                this.setMap(map);
            }
        };
        mpg.setCfg(cfg);

        // 配置模板
        TemplateConfig templateConfig = new TemplateConfig();
        templateConfig.setEntity("templates/entity2.java");
        //指定自定义模板路径, 位置：/resources/templates/entity2.java.ftl(或者是.vm)
        templateConfig.setMapper("templates/mapper2.java");
        templateConfig.setService("templates/service2.java");
        templateConfig.setServiceImpl("templates/serviceImpl2.java");
        templateConfig.setController("templates/controller2.java");
        mpg.setTemplate(templateConfig);

        //TODO 根据需要来设置！！！例如：禁用模版的方式禁止生成实体类
        templateConfig.disable(TemplateType.ENTITY, TemplateType.CONTROLLER);
        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setSuperEntityClass(BaseEntity.class);
        //写于父类中的公共字段
        strategy.setSuperEntityColumns("id", "create_time", "update_time", "is_deleted");
        strategy.setNaming(NamingStrategy.underline_to_camel);  //数据库表映射到实体的命名策略
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);    //数据库表字段映射到实体的命名策略
        strategy.setEntityLombokModel(true);    //【实体】是否为lombok模型（默认 false）
        strategy.setRestControllerStyle(true);
        strategy.setEntityTableFieldAnnotationEnable(true); //是否生成实体时，生成字段注解


        strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));
        strategy.setControllerMappingHyphenStyle(true);
        strategy.setTablePrefix(tablePrefix);
        mpg.setStrategy(strategy);
        mpg.setTemplateEngine(new FreemarkerTemplateEngine());
        mpg.execute();
    }

    /**
     * <p>
     * 读取控制台内容
     * </p>
     */
    public static String scanner(String tip) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder help = new StringBuilder();
        help.append("请输入" + tip + "：");
        System.out.println(help.toString());
        if (scanner.hasNext()) {
            String ipt = scanner.next();
            if (StringUtils.isNotBlank(ipt)) {
                return ipt;
            }
        }
        throw new MybatisPlusException("请输入正确的" + tip + "！");
    }

}

2.2.4 封装登录接口

YAPI接口地址：

登录 http://192.168.200.128:3000/project/11/interface/api/803

退出 http://192.168.200.128:3000/project/11/interface/api/811

2.2.4.1 控制器

package com.atguigu.gmall.user.controller;

import com.atguigu.gmall.common.result.Result;
import com.atguigu.gmall.user.model.UserInfo;
import com.atguigu.gmall.user.service.UserInfoService;
import lombok.experimental.Tolerate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;

/**
 * @author: atguigu
 * @create: 2023-03-07 11:30
 */
@RestController
@RequestMapping("/api/user")
public class PassportController {

    @Autowired
    private UserInfoService userInfoService;


    /**
     * 用户登录接口:提供给PC端小程序端使用
     * @param loginUser
     * @return
     */
    @PostMapping("/passport/login")
    public Result login(@RequestBody UserInfo loginUser, HttpServletRequest request){
        return userInfoService.login(loginUser, request);
    }

    /**
     * 用户退出系统
     * @param token
     * @return
     */
    @GetMapping("/passport/logout")
    public Result logout(@RequestHeader("token") String token){
        userInfoService.logout(token);
        return Result.ok();
    }
}

2.2.4.2 业务层

业务接口：UserInfoService

package com.atguigu.gmall.user.service;

import com.atguigu.gmall.common.result.Result;
import com.atguigu.gmall.user.model.UserInfo;
import com.baomidou.mybatisplus.extension.service.IService;

import javax.servlet.http.HttpServletRequest;

/**
 * 用户表 业务接口类
 * @author atguigu
 * @since 2023-03-07
 */
public interface UserInfoService extends IService<UserInfo> {

    /**
     * 用户登录
     * @param loginUser
     * @param request
     * @return
     */
    Result login(UserInfo loginUser, HttpServletRequest request);

    /**
     * 退出系统
     * @param token
     */
    void logout(String token);
}

业务实现类：

package com.atguigu.gmall.user.service.impl;

import com.atguigu.gmall.common.constant.RedisConst;
import com.atguigu.gmall.common.result.Result;
import com.atguigu.gmall.common.util.IpUtil;
import com.atguigu.gmall.user.model.UserInfo;
import com.atguigu.gmall.user.mapper.UserInfoMapper;
import com.atguigu.gmall.user.service.UserInfoService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * 用户表 业务实现类
 *
 * @author atguigu
 * @since 2023-03-07
 */
@Service
public class UserInfoServiceImpl extends ServiceImpl<UserInfoMapper, UserInfo> implements UserInfoService {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 处理用户登录业务
     *
     * @param loginUser
     * @param request
     * @return
     */
    @Override
    public Result login(UserInfo loginUser, HttpServletRequest request) {
        //SELECT id,login_name,phone_num FROM user_info  where passwd = '96e79218965eb72c92a549dd5a330112' and (phone_num='11111' or email = 'atguigu.com' or login_name = 'atguigu')
        //1.根据用户认证信息 账号(手机号,邮箱,用户名称)跟密码 查询用户记录-判断用户是否存在
        //1.1 对用户提交密码进行加密
        String userPwd = DigestUtils.md5DigestAsHex(loginUser.getPasswd().getBytes());
        LambdaQueryWrapper<UserInfo> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(UserInfo::getPasswd, userPwd);
        queryWrapper.and(wrapper -> {
            wrapper.or().eq(UserInfo::getPhoneNum, loginUser.getLoginName())
                    .or().eq(UserInfo::getEmail, loginUser.getLoginName())
                    .or().eq(UserInfo::getLoginName, loginUser.getLoginName());
        });
        UserInfo userInfo = this.getOne(queryWrapper);
        if (userInfo == null) {
            return Result.fail().message("用户名或者密码错误!");
        }
        //2.用户存在-生成用户令牌 将令牌信息存入Redis
        //2.1 生成存入Redis用户令牌 uuid
        String uuId = UUID.randomUUID().toString().replaceAll("-", "");
        String userKey = "user:login:" + uuId;

        //2.2 生成存入Redis用户信息 用户ID 用户登录IP/城市
        //2.2.1 得到的登录用户IP
        String ipAddress = IpUtil.getIpAddress(request);

        //2.2.2 根据IP获取用户所在城市 TODO 调用百度API

        HashMap<String, String> userRedis = new HashMap<>();
        userRedis.put("userId", userInfo.getId().toString());
        userRedis.put("ip", ipAddress);
        userRedis.put("city", "北京市");

        redisTemplate.opsForValue().set(userKey, userRedis, RedisConst.USERKEY_TIMEOUT, TimeUnit.SECONDS);

        //3.按照前端要求响应登录结果 token nickName
        HashMap<String, String> loginResult = new HashMap<>();
        loginResult.put("token", uuId);
        loginResult.put("nickName", userInfo.getNickName());
        return Result.ok(loginResult);
    }

    /**
     * 退出系统 只需要将存储在Redis中的token删除即可
     *
     * @param token
     */
    @Override
    public void logout(String token) {
        String redisKey = "user:login:" + token;
        redisTemplate.delete(redisKey);
    }
}

2.2.4.3 持久层

package com.atguigu.gmall.user.mapper;

import com.atguigu.gmall.model.user.UserInfo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface UserInfoMapper extends BaseMapper<UserInfo> {
}

2.3 配置网关路由

在Nacos配置列表中，server-gateway-dev.yaml进行编辑增加动态路由

- id: service-user
  uri: lb://service-user
  predicates:
  - Path=/*/user/**
- id: web-passport
  uri: lb://web-all
  predicates:
  - Host=passport.gmall.com

2.4 在web-all模块添加实现

YAPI接口地址:http://192.168.200.128:3000/project/11/interface/api/803

2.4.1 在web-all 项目中跳转页面

package com.atguigu.gmall.web;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * @author: atguigu
 * @create: 2023-03-07 11:21
 */
@Controller
public class LoginController {


    /**
     * 渲染登录页面
     *
     * @param originUrl
     * @return
     */
    @GetMapping("/login.html")
    public String loginHtml(@RequestParam(value = "originUrl", required = false) String originUrl, Model model) {
        //给页面中用于调整登录前页面进行赋值
        model.addAttribute("originUrl", originUrl);
        return "/login";
    }

}

2.4.2 登录页面

页面资源： \templates\login1.html

login1.html 没有公共头部信息

Html关键代码

<form class="sui-form">
   <div class="input-prepend"><span class="add-on loginname"></span>
      <input id="inputName" type="text" v-model="user.loginName" placeholder="邮箱/用户名/手机号" class="span2 input-xfat">
   </div>
   <div class="input-prepend"><span class="add-on loginpwd"></span>
      <input id="inputPassword" type="password" v-model="user.passwd" placeholder="请输入密码" class="span2 input-xfat">
   </div>
   <div class="setting">
      <label class="checkbox inline">
         <input name="m1" type="checkbox" value="2" checked="">
         自动登录
      </label>
      <span class="forget">忘记密码？</span>
   </div>
   <div class="logined">
      <a class="sui-btn btn-block btn-xlarge btn-danger" href="javascript:" @click="submitLogin()">登&nbsp;&nbsp;录</a>
   </div>
</form>

<script src="/js/api/login.js"></script>
<script th:inline="javascript">
   var item = new Vue({
      el: '#profile',

      data: {
            originUrl: [[${originUrl}]],
            user: {
                loginName: '',
                passwd: ''
            }
      },

      created() {
      },

      methods: {
            submitLogin() {
                login.login(this.user).then(response => {
                    
                    if (response.data.code == 200) {
                        //把token存在cookie中、也可以放在localStorage中
                        auth.setToken(response.data.data.token)
                        auth.setUserInfo(JSON.stringify(response.data.data))

                        console.log("originUrl:"+this.originUrl);
                        if(this.originUrl == ''){
                            window.location.href="http://www.gmall.com/index.html"
                            return ;
                        } else {
                            window.location.href = decodeURIComponent(this.originUrl)
                  }
                    } else {
                  alert(response.data.data.message)
               }

                })
            }
        }
   })
</script>

2.5 头部信息处理

web-all项目：common/header.html，common/head.html

功能：头部信息为公共信息，所有页面都具有相关的头部，所以我们可以单独提取出来，头部页面显示登录状态与关键字搜索等信息

2.5.1 提取头部信息

提取头部信息我们会用到thymeleaf 两个标签：

th:fragment：定义代码块

th:include：将代码块片段包含的内容插入到使用了th:include的HTML标签中

1，定义头部代码块（/common/header.html），关键代码

<div id="nav-bottom" th:fragment="header">
    <!--顶部-->
	<div class="nav-top" id="header">
		...
	</div>
</div>

2，在其他页面引用头部代码块

<div th:include="common/header :: header"></div>

2.5.2 头部登录状态处理

思路：登录成功后我们将用户信息写入了cookie，所以我们判断cookie中是否有用户信息，如果有则显示登录用户信息和退出按钮，我们采取vue的渲染方式

关键代码

Header.html 中

<ul class="fl">
    <li class="f-item">尚品汇欢迎您！</li>
    <li  v-if="userInfo.nickName == ''" class="f-item">请<span><a href="javascript:" @click="login()">登录</a></span>　<span><a href="#">免费注册</a></span></li>
    <li  v-if="userInfo.nickName != ''" class="f-item"><span>{{userInfo.nickName}}</span>　<span><a href="javascript:" @click="logout()">退出</a></span></li>
</ul>

<script type="text/javascript" src="/js/plugins/jquery/jquery.min.js"></script>
<script type="text/javascript" src="/js/plugins/jquery.cookie.js"></script>
<script src="/js/plugins/vue.js"></script>
<script src="/js/plugins/axios.js"></script>
<script src="/js/auth.js"></script>
<script src="/js/request.js"></script>
<script src="/js/api/login.js"></script>
<script th:inline="javascript">
    var item = new Vue({
        el: '#header',

        data: {
            userInfo: {
                nickName: '',
                name: ''
            }
        },

        created() {
            this.showInfo()
        },

        methods: {
            showInfo() {
                // debugger
                if(auth.getUserInfo()) {
                    this.userInfo = auth.getUserInfo()
                    console.log("--------"+this.userInfo.nickName)
                }
            },

            
            logout() {
                //debugger
                login.logout().then(response => {
                    console.log("已退出")
                    auth.removeToken()
                    auth.removeUserInfo()

                    //跳转页面
                    window.location.href = "/"
                })
            }
        }
    })
</script>

2.4.3 头部关键字搜索

<div class="input-append">
    <input id="keyword" type="text" v-model="keyword" class="input-error input-xxlarge" />
    <button class="sui-btn btn-xlarge btn-danger" @click="search()" type="button">搜索</button>
</div>
<script th:inline="javascript">
    var item = new Vue({
        el: '#header',

        data: {
            keyword: [[${searchParam?.keyword}]],
            userInfo: {
                nickName: '',
                name: ''
            }
        },

        created() {
            this.showInfo()
        },

        methods: {
            showInfo() {
                // debugger
                if(auth.getUserInfo()) {
                    this.userInfo = auth.getUserInfo()
                    console.log("--------"+this.userInfo.nickName)
                }
            },

            search() {
                if(this.keyword == null) this.keyword = ''
                window.location.href = 'http://list.gmall.com/search.html?keyword=' + this.keyword
            },

            login() {
                window.location.href = 'http://passport.gmall.com/login.html?originUrl='+window.location.href
            },

            logout() {
                //debugger
                login.logout().then(response => {
                    console.log("已退出")
                    auth.removeToken()
                    auth.removeUserInfo()

                    //跳转页面
                    window.location.href = "/"
                })
            }
        }
    })
</script>

说明：[[${searchParam?.keyword}]]，searchParam为搜索列表的搜索对象，如果存在searchParam对象，显示关键字的值

2.5.4 头部公共js

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>

<div th:fragment="head">
    <script type="text/javascript" src="/js/plugins/jquery/jquery.min.js"></script>
    <script type="text/javascript" src="/js/plugins/jquery.cookie.js"></script>
    <script src="/js/plugins/vue.js"></script>
    <script src="/js/plugins/axios.js"></script>
    <script src="/js/auth.js"></script>
    <script src="/js/request.js"></script>
</div>
</body>
</html>

引用

3、用户认证与服务网关整合

3.1 实现思路

所有请求都会经过服务网关，服务网关对外暴露服务，不管是api异步请求还是web同步请求都走网关，在网关进行统一用户认证
既然要在网关进行用户认证，网关得知道对哪些url进行认证，所以我们得对url制定规则
Web页面同步请求（如：*.html），我采取配置白名单的形式，凡是配置在白名单里面的请求都是需要用户认证的（注：也可以采取域名的形式，方式多多）
Api接口异步请求的，我们采取url规则匹配，如：/api/** 、/auth /**，"/inner/"如凡是满足该规则的都必须用户认证

所以在Nacos配置列表，修改server-gateway-dev.yaml增加需要校验的html访问路径

authUrls:
  url: trade.html,myOrder.html #,list.html, addCart.html # 用户访问该控制器的时候，会被拦截跳转到登录！

3.2 在服务网关添加fillter

在gmall-gateway模块的pom.xml中增加redis的依赖

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

在gmall-gateway模块中配置RedisTemplate采用自定义序列化器

package com.atguigu.gmall.gateway.config;
   
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
   
@Configuration
@EnableCaching
public class RedisConfig {
   
   @Primary
   @Bean
   public RedisTemplate<Object, Object> RedisTemplate(RedisConnectionFactory RedisConnectionFactory) {
       RedisTemplate<Object, Object> RedisTemplate = new RedisTemplate<>();
       RedisTemplate.setConnectionFactory(RedisConnectionFactory);
   
       //使用Jackson2JsonRedisSerialize 替换默认序列化(默认采用的是JDK序列化) 对存储的对象进行JSON序列化
       Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
       ObjectMapper objectMapper = new ObjectMapper();
       objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
       objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
       jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
   
       // 序列化key value
       RedisTemplate.setKeySerializer(new StringRedisSerializer());
       RedisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
       RedisTemplate.setHashKeySerializer(new StringRedisSerializer());
       RedisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
   
       RedisTemplate.afterPropertiesSet();
       return RedisTemplate;
   }
   
}

gmall-gateway 项目中添加一个全局过滤器

package com.atguigu.gmall.gateway.filter;
   
import com.alibaba.fastjson.JSON;
import com.atguigu.gmall.common.result.Result;
import com.atguigu.gmall.common.result.ResultCodeEnum;
import com.atguigu.gmall.common.util.IpUtil;
import com.atguigu.gmall.gateway.utils.BaiduMapUtil;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.HttpCookie;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.CollectionUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
   
import java.util.HashMap;
import java.util.List;
   
/**
* 身份认证过滤器
*
* @author: atguigu
* @create: 2023-03-07 14:28
*/
@Component
public class AuthFilter implements GlobalFilter, Ordered {
   
   private AntPathMatcher antPathMatcher = new AntPathMatcher();
   
   @Value("${authUrls.url}")
   private List<String> authUrlList;
   
   
   @Autowired
   private RedisTemplate redisTemplate;
   
   /**
    * 验证用户请求是否合法
    *
    * @param exchange 封装请求对象,响应对象
    * @param chain    过滤器链
    * @return
    */
   @Override
   public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
       //通过exchange获取到请求对象以及响应对象
       ServerHttpRequest request = exchange.getRequest();
       ServerHttpResponse response = exchange.getResponse();
       //获取用户请求地址
       String path = request.getURI().getPath();
       //1.对于那些静态资源同步请求 img js css 直接放行-无论是否登录
       if (antPathMatcher.match("/*/img/**", path) || antPathMatcher.match("/*/js/**", path) || antPathMatcher.match("/*/css/**", path)) {
           return chain.filter(exchange);
       }
   
       //2.对于微服务间调用Feign接口不允许用户直接来方法 "/inner" --无论是否登录
       if (antPathMatcher.match("/**/inner/**", path)) {
           //响应错误信息
           return outError(response, ResultCodeEnum.ILLEGAL_REQUEST);
       }
   
       String userId = this.getUserId(request, response);
       if (StringUtils.isBlank(userId)) {
           //3.如果用户没有登录-并且还要访问(需要登录)restuful接口 例如:-返回拒绝访问
           if (antPathMatcher.match("/**/auth/**", path)) {
               //响应错误信息
               return outError(response, ResultCodeEnum.PERMISSION);
           }
           //4.如果用户没有登录-并且访问(需要登录)页面请求-引导用户去登录
           if (!CollectionUtils.isEmpty(authUrlList)) {
               for (String auth : authUrlList) {
                   if (antPathMatcher.match("/" + auth + "*", path)) {
                       //引导用户登录
                       //说明用户未登录 访问地址要求登录 设置重定向 需要将http状态码设置为301
                       response.setStatusCode(HttpStatus.SEE_OTHER);
                       //通过Response对象 响应头设置重定向登录地址
                       response.getHeaders().set(HttpHeaders.LOCATION, "http://www.gmall.com/login.html?originUrl=" + request.getURI().toString());
                       //结束
                       return response.setComplete();
                   }
               }
           }
       }
   
       //5.如果用户登录-将用户ID设置到请求头中-将用户ID参数值透传到业务微服务
       if (StringUtils.isNotBlank(userId)) {
           //为了能在其他微服务中获取用户ID 需要将用户ID存入
           request.mutate().header("userId", userId);
       }
       return chain.filter(exchange);
   }
   
   
   /**
    * 尝试从Redis中获取用户ID
    *
    * @param request
    * @param response
    * @return
    */
   private String getUserId(ServerHttpRequest request, ServerHttpResponse response) {
       //1.先从请求头中获取Token
       String token = "";
       token = request.getHeaders().getFirst("token");
       if (StringUtils.isBlank(token)) {
           //2.在尝试从请求对象中Cookie中获取
           HttpCookie httpCookie = request.getCookies().getFirst("token");
           if (httpCookie != null) {
               token = httpCookie.getValue();
           }
       }
   
       //3.根据Token查询Redis中用户信息-判断用户是否为异地登录 todo 是否更换设备
       if (StringUtils.isNotBlank(token)) {
           String redisKey = "user:login:" + token;
           HashMap<String, String> userInfoMap = (HashMap<String, String>) redisTemplate.opsForValue().get(redisKey);
           if (userInfoMap != null) {
               //用户登录时所在城市
               String loginCity = userInfoMap.get("city");
               //获取本地访问所在城市
               String ipAddress = IpUtil.getGatwayIpAddress(request);
               String nowCity = BaiduMapUtil.getAddress("114.240.253.58");
               if (!nowCity.equals(loginCity)) {
                   this.outError(response, ResultCodeEnum.ILLEGAL_REQUEST);
               }
               //4.返回用户ID
               String userId = userInfoMap.get("userId");
               return userId;
           }
       }
       return null;
   }
   
   
   /**
    * 用来给前端响应错误提示信息
    *
    * @param response
    * @param resultCodeEnum
    * @return
    */
   private Mono<Void> outError(ServerHttpResponse response, ResultCodeEnum resultCodeEnum) {
       //1.准备响应结果对象,转为JSON对象
       Result<Object> result = Result.build(null, resultCodeEnum);
       String resultString = JSON.toJSONString(result);
   
       //2.响应结果给客户端
       //2.1 设置http状态码
       response.setStatusCode(HttpStatus.UNAUTHORIZED);
       //2.2 通过响应头设置响应数据格式-json
       response.getHeaders().add("content-type", "application/json;charset=utf-8");
       DataBuffer wrap = response.bufferFactory().wrap(resultString.getBytes());
       //2.3 网关结束响应-不再路由转发
       //return response.setComplete();
       //2.4 网关将响应数据返回给客户端
       return response.writeWith(Mono.just(wrap));
   }
   
   
   
   /**
    * 值越小优先级越高
    *
    * @return
    */
   @Override
   public int getOrder() {
       return 0;
   }
   
   
   public static void main(String[] args) {
       AntPathMatcher antPathMatcher = new AntPathMatcher();
       boolean match = antPathMatcher.match("*/user/**", "d/user/a/b/c");
       System.out.println(match);
   }
}

3.3 在服务网关中判断用户登录状态

在网关中如何获取用户信息：

1、从cookie中获取（如：web同步请求）

2、从header头信息中获取（如：异步请求）

如何判断用户信息合法：

登录时我们返回用户token，在服务网关中获取到token后，我在到redis中去查看用户id，如果用户id存在，则token合法，否则不合法，同时校验ip，防止token被盗用。

3.3.1 取用户信息

/**
 * 尝试从Redis中获取用户ID
 *
 * @param request
 * @param response
 * @return
 */
private String getUserId(ServerHttpRequest request, ServerHttpResponse response) {
    //1.先从请求头中获取Token
    String token = "";
    token = request.getHeaders().getFirst("token");
    if (StringUtils.isBlank(token)) {
        //2.在尝试从请求对象中Cookie中获取
        HttpCookie httpCookie = request.getCookies().getFirst("token");
        if (httpCookie != null) {
            token = httpCookie.getValue();
        }
    }

    //3.根据Token查询Redis中用户信息-判断用户是否为异地登录 todo 是否更换设备
    if (StringUtils.isNotBlank(token)) {
        String redisKey = "user:login:" + token;
        HashMap<String, String> userInfoMap = (HashMap<String, String>) redisTemplate.opsForValue().get(redisKey);
        if (userInfoMap != null) {
            //用户登录时所在城市
            String loginCity = userInfoMap.get("city");
            //获取本地访问所在城市
            String ipAddress = IpUtil.getGatwayIpAddress(request);
            String nowCity = BaiduMapUtil.getAddress("114.240.253.58");
            if (!nowCity.equals(loginCity)) {
                this.outError(response, ResultCodeEnum.ILLEGAL_REQUEST);
            }
            //4.返回用户ID
            String userId = userInfoMap.get("userId");
            return userId;
        }
    }
    return null;
}

3.3.2 输出信息out 方法

/**
 * 用来给前端响应错误提示信息
 *
 * @param response
 * @param resultCodeEnum
 * @return
 */
private Mono<Void> outError(ServerHttpResponse response, ResultCodeEnum resultCodeEnum) {
    //1.准备响应结果对象,转为JSON对象
    Result<Object> result = Result.build(null, resultCodeEnum);
    String resultString = JSON.toJSONString(result);

    //2.响应结果给客户端
    //2.1 设置http状态码
    response.setStatusCode(HttpStatus.UNAUTHORIZED);
    //2.2 通过响应头设置响应数据格式-json
    response.getHeaders().add("content-type", "application/json;charset=utf-8");
    DataBuffer wrap = response.bufferFactory().wrap(resultString.getBytes());
    //2.3 网关结束响应-不再路由转发
    //return response.setComplete();
    //2.4 网关将响应数据返回给客户端
    return response.writeWith(Mono.just(wrap));
}