前端系列17集-和公司架构师在学习vue3-springboot

SyntaxError: "undefined" is not valid JSON at JSON.parse (<anonymous>)

这个错误通常意味着你正在尝试将一个非 JSON 格式的数据转换成 JSON 格式。为了修复这个问题，你需要找到导致错误的代码行并检查它的输入数据是否符合 JSON 格式标准。

这个错误通常是因为你的 TypeScript 版本不支持 Node.js 的类型定义文件。你可以尝试升级 TypeScript 到最新版本，或者使用 @types/node 包来获取 Node.js 的类型定义文件。

具体的步骤如下：

1. 在命令行中进入项目根目录，执行以下命令安装 @types/node 包：

   npm install --save-dev @types/node

2. 确认你的 TypeScript 配置文件（一般为 tsconfig.json）中包含了以下配置：

   {
     "compilerOptions": {
       "target": "es6",
       "module": "commonjs",
       "esModuleInterop": true,
       "types": ["node"]
     }
   }

3. 重新编译你的代码，如果使用的是 TypeScript 编译器，执行以下命令：

   tsc

   如果使用的是 Webpack 等构建工具进行编译，按照相应的配置进行操作即可。

这样就解决了 Cannot find namespace 'NodeJS' 的问题。

需求：实现一个拖拽指令，可在父元素区域任意拖拽元素。

思路：
	1、设置需要拖拽的元素为absolute，其父元素为relative。
	2、鼠标按下(onmousedown)时记录目标元素当前的 left 和 top 值。
	3、鼠标移动(onmousemove)时计算每次移动的横向距离和纵向距离的变化值，并改变元素的 left 和 top 值
	4、鼠标松开(onmouseup)时完成一次拖拽

使用：在 Dom 上加上 v-draggable 即可

Property 'browserLanguage' does not exist on type 'Navigator'.ts

这个错误通常发生在 TypeScript 中，因为 Navigator 类型没有 browserLanguage 属性。相反，应该使用 navigator.language 属性来获取浏览器当前所用的语言。

要解决这个问题，你需要将代码中所有引用 browserLanguage 的地方替换为 language。

例如，如果你的代码是这样的：

const language = navigator.browserLanguage;
console.log(`The browser's language is ${language}`);

应该改为：

const language = navigator.language;
console.log(`The browser's language is ${language}`);

这样就不会再出现类型错误了。

Vue.js 应用程序的国际化配置。它依赖于 vue-i18n 包，并且包含以下步骤：

1. 导入 createI18n 方法和 getBrowserLang 函数，它们分别来自于 vue-i18n 和自定义的 utils 模块。

2. 导入了两个语言模块：zh 和 en，它们分别存储了中文和英文版本的翻译。

3. 使用 createI18n 方法创建 i18n 实例，配置了以下属性：

• allowComposition：设置为 true，表示使用 Composition API。

• legacy：设置为 false，表示不使用旧版 Vue.js 的选项 API。

• locale：根据用户浏览器的语言设置，选择合适的语言作为默认语言。

• messages：将导入的语言模块对象作为消息传入，供 i18n 实例使用。

1. 导出 i18n 实例作为默认模块。

image.png

package com.xx.app.utils.constants;

public class Constants {
    public static final String SUCCESS_CODE = "200";
    public static final String SUCCESS_MSG = "操作成功";
}

package com.xx.app.utils.constants;

public enum ErrorEnum {
    E_400("400", "请求处理异常，请稍后再试"),
    E_500("500", "请求方式有误,请检查 GET/POST"),
    E_501("501", "请求路径不存在"),
    E_502("502", "权限不足"),
    E_10008("10008", "角色删除失败,尚有用户属于此角色"),
    E_10009("10009", "账户已存在"),
    E_10010("10010", "账号/密码错误"),
    E_20011("20011", "登录已过期,请重新登录"),
    E_90003("90003", "缺少必填参数");
    private final String errorCode;
    private final String errorMsg;

    ErrorEnum(String errorCode, String errorMsg) {
        this.errorCode = errorCode;
        this.errorMsg = errorMsg;
    }

    public String getErrorCode() {
        return errorCode;
    }

    public String getErrorMsg() {
        return errorMsg;
    }
}

package com.xxx.app.utils.model;

import com.alibaba.fastjson.JSONObject;

import java.util.List;
import java.util.Set;

/**
 * MyBatis的一对多JSON返回对象
 * 处理嵌套查询结果时，MyBatis会根据bean定义的属性类型来初始化嵌套的成员变量，主要看其是不是Collection
 * 如果这里不定义，那么嵌套返回结果里就只能返回一对一的结果，而不是一对多的
 * 参见MyBatis  DefaultResultSetHandler.instantiateCollectionPropertyIfAppropriate()
 */
public class One2Many extends JSONObject {
    private Set<String> roleList;
    private Set<String> menuList;
    private Set<String> permissionList;
    private Set<Integer> permissionIds;
    private List<JSONObject> picList;
    private List<JSONObject> menus;
    private List<JSONObject> users;
    private List<JSONObject> permissions;
    private List<JSONObject> roles;
}

package com.xxx.app.utils;

import com.xxx.app.utils.constants.Constants;
import com.xxx.app.utils.constants.ErrorEnum;
import com.alibaba.fastjson.JSONObject;

import javax.servlet.http.HttpServletRequest;
import java.util.Enumeration;
import java.util.List;

/**
 * 后台接口系统常用的json工具类
 */
public class CommonUtil {
    /**
     * 返回一个info为空对象的成功消息的json
     */
    public static JSONObject successJson() {
        return successJson(new JSONObject());
    }
    public static JSONObject successJson(Object info) {
        JSONObject resultJson = new JSONObject();
        resultJson.put("code", Constants.SUCCESS_CODE);
        resultJson.put("msg", Constants.SUCCESS_MSG);
        resultJson.put("info", info);
        return resultJson;
    }
    /**
     * 返回错误信息JSON
     */
    public static JSONObject errorJson(ErrorEnum errorEnum) {
        JSONObject resultJson = new JSONObject();
        resultJson.put("code", errorEnum.getErrorCode());
        resultJson.put("msg", errorEnum.getErrorMsg());
        resultJson.put("info", new JSONObject());
        return resultJson;
    }
    /**
     * 查询分页结果后的封装工具方法
     * @param requestJson 请求参数json,此json在之前调用fillPageParam 方法时,已经将pageRow放入
     * @param list        查询分页对象list
     * @param totalCount  查询出记录的总条数
     */
    public static JSONObject successPage(final JSONObject requestJson, List<JSONObject> list, int totalCount) {
        int pageRow = requestJson.getIntValue("pageRow");
        int totalPage = getPageCounts(pageRow, totalCount);
        JSONObject result = successJson();
        JSONObject info = new JSONObject();
        info.put("list", list);
        info.put("totalCount", totalCount);
        info.put("totalPage", totalPage);
        result.put("info", info);
        return result;
    }
    /**
     * 获取总页数
     *
     * @param pageRow   每页行数
     * @param itemCount 结果的总条数
     */
    private static int getPageCounts(int pageRow, int itemCount) {
        if (itemCount == 0) {
            return 1;
        }
        return itemCount % pageRow == 0? itemCount / pageRow : itemCount / pageRow + 1;
        //return (itemCount + pageRow - 1) / pageRow;
    }
    /**
     * 查询分页结果后的封装工具方法
     *
     * @param list 查询分页对象list
     */public static JSONObject successPage(List<JSONObject> list) {
        JSONObject result = successJson();
        JSONObject info = new JSONObject();
        info.put("list", list);
        result.put("info", info);
        return result;
    }

    /**
     * 将request参数值转为json
     */
    public static JSONObject request2Json(HttpServletRequest request) {
        JSONObject requestJson = new JSONObject();
        Enumeration<String> paramNames = request.getParameterNames();
        while (paramNames.hasMoreElements()) {
            String paramName = (String) paramNames.nextElement();
            String[] pv = request.getParameterValues(paramName);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < pv.length; i++) {
                if (pv[i].length() > 0) {
                    if (i > 0) {
                        sb.append(",");
                    }
                    sb.append(pv[i]);
                }
            }
            requestJson.put(paramName, sb.toString());
        }
        return requestJson;
    }
    /**
     * 将request转JSON
     * 并且验证非空字段
     */
    public static JSONObject convert2JsonAndCheckRequiredColumns(HttpServletRequest request, String requiredColumns) {
        JSONObject jsonObject = request2Json(request);
        hasAllRequired(jsonObject, requiredColumns);
        return jsonObject;
    }
    /**
     * 验证是否含有全部必填字段
     *
     * @param requiredColumns 必填的参数字段名称 逗号隔开 比如"userId,name,telephone"
     */
    public static void hasAllRequired(final JSONObject jsonObject, String requiredColumns) {
        if (!StringTools.isNullOrEmpty(requiredColumns)) {
            //验证字段非空
            String[] columns = requiredColumns.split(",");
            String missCol = "";
            for (String column : columns) {
                Object val = jsonObject.get(column.trim());
                if (StringTools.isNullOrEmpty(val)) {
                    missCol += column + "  ";
                }
            }
            if (!StringTools.isNullOrEmpty(missCol)) {
                jsonObject.clear();
                jsonObject.put("code", ErrorEnum.E_90003.getErrorCode());
                jsonObject.put("msg", "缺少必填参数:" + missCol.trim());
                jsonObject.put("info", new JSONObject());
                throw null;
            }
        }
    }
    /**
     * 在分页查询之前,为查询条件里加上分页参数
     *
     * @param paramObject    查询条件json
     * @param defaultPageRow 默认的每页条数,即前端不传pageRow参数时的每页条数
     */
    private static void fillPageParam(final JSONObject paramObject, int defaultPageRow) {
        int pageNum = paramObject.getIntValue("pageNum");
        pageNum = pageNum == 0 ? 1 : pageNum;
        int pageRow = paramObject.getIntValue("pageRow");
        pageRow = pageRow == 0 ? defaultPageRow : pageRow;
        paramObject.put("offSet", (pageNum - 1) * pageRow);
        paramObject.put("pageRow", pageRow);
        paramObject.put("pageNum", pageNum);
        //删除此参数,防止前端传了这个参数,pageHelper分页插件检测到之后,拦截导致SQL错误
        paramObject.remove("pageSize");
    }
    /**
     * 分页查询之前的处理参数
     * 没有传pageRow参数时,默认每页10条.
     */
    public static void fillPageParam(final JSONObject paramObject) {
        fillPageParam(paramObject, 10);
    }
}

package com.xxx.app.utils;

public class StringTools {

    public static boolean isNullOrEmpty(String str) {
        return null == str || "".equals(str) || "null".equals(str);
    }

    public static boolean isNullOrEmpty(Object obj) {
        return null == obj || "".equals(obj);
    }
}

package com.xxxx.app.utils;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.interfaces.DecodedJWT;

import java.io.UnsupportedEncodingException;
import java.util.Date;

public class JWTUtils {
    public static final String AUTH_HEADER_KEY = "Authorization";

    public static final String TOKEN_PREFIX = "Bearer ";

    //过期时间一周
    private static final long EXPIRE_TIME = 7 * 24 * 60 * 60 * 1000;

    private static final String secret = "";

    /**
     * 验证 JWT token 是否合法
     *
     * @param token 待验证的 JWT token
     * @return 如果 token 合法，则返回 true；否则返回 false。
     */
    public static boolean verify(String token) {
        try {
            Algorithm algorithm = Algorithm.HMAC256(secret);
            // 创建一个 JWT 验证器
            JWTVerifier verifier = JWT.require(algorithm).build();
            // 使用验证器对 token 进行验证
            DecodedJWT jwt = verifier.verify(token);
            return true;
        } catch (Exception exception) {
            return false;
        }
    }

    /**
     * 获取token中信息无需secret解密也能获得
     * @param token
     * @return token中包含的id
     */
    public static Long getUserId(String token) {
        try {
            DecodedJWT jwt = JWT.decode(token);
            return jwt.getClaim("id").asLong();
        } catch (JWTDecodeException e) {
            return null;
        }
    }

    /**
     * 签发token
     * @param id
     * @return 加密的token
     */
    public static String sign(Long id) {
        try {
            Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
            Algorithm algorithm = Algorithm.HMAC256(secret);
            // 附带username信息
            return JWT.create()
                    .withClaim("id", id)
                    .withExpiresAt(date)
                    .sign(algorithm);
        } catch (UnsupportedEncodingException e) {
            return null;
        }
    }
}

package com.xxx.app.service;

import cn.hutool.http.HttpUtil;
import com.alibaba.fastjson.JSON;
import com.xxx.app.common.RedisKey;
import com.xxx.app.handler.UserThreadLocal;
import com.xxx.app.model.WXAuth;
import com.xxx.app.pojo.User;
import com.xxx.app.pojo.dto.UserDto;
import com.xxx.app.utils.JWTUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
public class UserService {

    @Value("${wxmini.appid}")
    private String appid;

    @Value("${wxmini.secret}")
    private String secret;

    @Autowired
    private StringRedisTemplate redisTemplate;

//    public Result getSessionId(String code) {
//        /**
//         * 1. 拼接一个url，微信登录凭证校验接口
//         * 2. 发起一个http的调用，获取微信的返回结果
//         * 3. 存到redis
//         * 4. 生成一个sessionId，返回给前端，作为当前需要登录用户的标识
//         * 5. 生成一个sessionId，用户在点击微信登录的时候，我们可以标识是谁点击微信登录
//         */
//        String url = "https://api.weixin.qq.com/sns/jscode2session?appid={0}&secret={1}&js_code={2}&grant_type=authorization_code";
//        String replaceUrl = url.replace("{0}", appid).replace("{1}", secret).replace("{2}", code);
//        String res = HttpUtil.get(replaceUrl);
//        String uuid = UUID.randomUUID().toString();
//        redisTemplate.opsForValue().set(RedisKey.WX_SESSION_ID + uuid, res, 30, TimeUnit.MINUTES);
//        Map<String, String> map = new HashMap<>();
//        map.put("sessionId", uuid);
//        return Result.SUCCESS(map);
//    }

    @Autowired
    private WxService wxService;

//    @Resource
//    private UserMapper userMapper;

//    public Result authLogin(WXAuth wxAuth) {
//        /**
//         * 1. 通过wxAuth中的值，要对它进行解密
//         * 2. 解密完成之后，会获取到微信用户信息 其中包含 openId，性别，昵称，头像等信息
//         * 3. openId 是唯一的，需要去user表中查询openId是否存在，存在，已此用户的身份登录成功
//         * 4. 不存在，新用户，注册流程，登录成功
//         * 5. 使用jwt技术，生成一个token，提供给前端 token 令牌，用户在下次访问的时候，携带token来访问
//         * 6. 后端通过对token的验证，找到此用户是否处于登录状态，以及是哪个用户登录的
//         */
        try {
            log.info("获取请求参数："+wxAuth);
            String wxRes = wxService.wxDecrypt(wxAuth.getEncryptedData(), wxAuth.getSessionId(), wxAuth.getIv());
            log.info("信息："+wxRes);
            WxUserInfo wxUserInfo = JSON.parseObject(wxRes, WxUserInfo.class);
            String openId = wxUserInfo.getOpenId();
            User user = userMapper.selectOne(Wrappers.<User>lambdaQuery().eq(User::getOpenId, openId).last("limit 1"));
            UserDto userDto = new UserDto();
            userDto.from(wxUserInfo);
            if (user == null) {
                // 注册
                return this.register(userDto);
            } else {
                userDto.setId(user.getId());
                // 登录
                return this.login(userDto);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.FAIL();
//        return null;
//    }
//
//    private Result login(UserDto userDto) {
//        String token = JWTUtils.sign(userDto.getId());
//        userDto.setToken(token);
//        userDto.setOpenId(null);
//        userDto.setUnionId(null);
//        //需要把token 存入redis，value存为 userDto，下次用户访问需要登录资源的时候，可以根据token拿到用户的详细信息
//        //缓存
//        redisTemplate.opsForValue().set(RedisKey.TOKEN+token, JSON.toJSONString(userDto), 7, TimeUnit.DAYS);
//        return Result.SUCCESS(userDto);
//    }
//
//    private Result register(UserDto userDto) {
//        // 注册之前 判断 用户是否存在
//        User user = new User();
//        BeanUtils.copyProperties(userDto, user);
        this.userMapper.insert(user);
//        // return Result.SUCCESS(userDto);
//        userDto.setId(user.getId());
//        return this.login(userDto);
//    }
//
//    // 参数 String token
//    public Result userinfo(Boolean refresh) {
//        /**
//         * 1. 根据token 来验证此token 是否有效
//         * 2. refresh 如果为true 代表刷新 重新生成token和redis里面重新储存 续期
//         * 3. false直接返回用户信息 redis中 查询出来 直接返回
//         */
//        /**
//         token = token.replace("Bearer ", "");
//         boolean verify = JWTUtils.verify(token);
//         if (!verify) {
//         return Result.FAIL("未登录");
//         }
//         String userJson = redisTemplate.opsForValue().get(RedisKey.TOKEN + token);
//         if (StringUtils.isBlank(userJson)) {
//         return Result.FAIL("未登录");
//         }
//         */
//        UserDto userDto = UserThreadLocal.get();
//        if (refresh) {
//            String token = JWTUtils.sign(userDto.getId());
//            userDto.setToken(token);
//            redisTemplate.opsForValue().set(RedisKey.TOKEN+token, JSON.toJSONString(userDto), 7, TimeUnit.DAYS);
//        }
//        return Result.SUCCESS(userDto);
//    }
}

package com.xxx.app.common;

public enum ResultCode {

    /* 成功状态码 */
    SUCCESS(0, "操作成功！"),

    /* 错误状态码 */
    FAIL(-1, "操作失败！"),

    /* 参数错误：10001-19999 */
    PARAM_IS_INVALID(10001, "参数无效"),
    PARAM_IS_BLANK(10002, "参数为空"),
    PARAM_TYPE_BIND_ERROR(10003, "参数格式错误"),
    PARAM_NOT_COMPLETE(10004, "参数缺失"),

    /* 用户错误：20001-29999*/
    USER_NOT_LOGGED_IN(20001, "用户未登录，请先登录"),
    USER_LOGIN_ERROR(20002, "账号不存在或密码错误"),
    USER_ACCOUNT_FORBIDDEN(20003, "账号已被禁用"),
    USER_NOT_EXIST(20004, "用户不存在"),
    USER_HAS_EXISTED(20005, "用户已存在"),

    /* 业务错误：30001-39999 */
    BUSINESS_GROUP_NO_ALLOWED_DEL(30001, "应用分组已经被应用使用，不能删除"),
    BUSINESS_THEME_NO_ALLOWED_DEL(30002, "主题已经被用户使用，不能删除"),
    BUSINESS_THEME_NO_ALLOWED_DISABLE(30003, "主题已经被用户使用，不能停用"),
    BUSINESS_THEME_DEFAULT_NO_ALLOWED_DEL(30004, "默认主题，不能删除"),
    BUSINESS_THEME_NO_ALLOWED_UPDATE(30005, "主题已经被用户使用，不能修改图片信息"),
    BUSINESS_IS_TOP(30040, "已经到最顶部"),
    BUSINESS_IS_BOTTOM(30041, "已经到最底部"),
    BUSINESS_NAME_EXISTED(30051, "名称已存在"),

    /* 系统错误：40001-49999 */
    SYSTEM_INNER_ERROR(40001, "系统繁忙，请稍后重试"),
    UPLOAD_ERROR(40002, "系统异常，上传文件失败"),
    FILE_MAX_SIZE_OVERFLOW(40003, "上传尺寸过大"),
    FILE_ACCEPT_NOT_SUPPORT(40004, "上传文件格式不支持"),
    SET_UP_AT_LEAST_ONE_ADMIN(40005, "至少指定一个管理员"),
    URL_INVALID(40006, "地址不合法"),
    LINK_AND_LOGOUT_NO_MATCH(40006, "主页地址和注销地址IP不一致"),
    IP_AND_PORT_EXISTED(40007, "当前IP和端口已经被占中"),
    LINK_IS_REQUIRED(40008, "生成第三方token认证信息： 主页地址不能为空,请完善信息"),
    ONLY_ROOT_DEPARTMENT(40009, "组织机构只能存在一个根机构"),
    DEPART_CODE_EXISTED(40010, "组织机构编码已存在"),
    DEPART_CONTAINS_USERS(40011, "该机构下是存在用户，不允许删除"),
    DEPART_CONTAINS_SON(40012, "该机构下是存在子级机构，不允许删除"),
    DEPART_PARENT_IS_SELF(40013, "选择的父机构不能为本身"),
    DICT_EXIST_DEPEND(40014, "该字典数据存在详情依赖，不允许删除"),
    DICT_DETAIL_LOCK(40015, "该字典数据被锁定，不允许修改或删除"),
    DEPART_CODE_EXISTED_WITH_ARGS(40016, "组织机构编码【{0}】系统已存在"),

    /* 数据错误：50001-599999 */
    RESULT_DATA_NONE(50001, "数据未找到"),
    DATA_IS_WRONG(50002, "数据有误"),
    DATA_ALREADY_EXISTED(50003, "数据已存在"),
    AUTH_CODE_ERROR(50004, "验证码错误"),

    /* 接口错误：60001-69999 */
    INTERFACE_INNER_INVOKE_ERROR(60001, "内部系统接口调用异常"),

    INTERFACE_OUTTER_INVOKE_ERROR(60002, "外部系统接口调用异常"),

    INTERFACE_FORBID_VISIT(60003, "该接口禁止访问"),

    INTERFACE_ADDRESS_INVALID(60004, "接口地址无效"),

    INTERFACE_REQUEST_TIMEOUT(60005, "接口请求超时"),

    INTERFACE_EXCEED_LOAD(60006, "接口负载过高"),


    /* 权限错误：70001-79999 */
    PERMISSION_UNAUTHENTICATED(70001, "此操作需要登陆系统！"),

    PERMISSION_UNAUTHORISE(70002, "权限不足，无权操作！"),

    PERMISSION_EXPIRE(70003, "登录状态过期！"),

    PERMISSION_TOKEN_EXPIRED(70004, "token已过期"),

    PERMISSION_LIMIT(70005, "访问次数受限制"),

    PERMISSION_TOKEN_INVALID(70006, "无效token"),

    PERMISSION_SIGNATURE_ERROR(70007, "签名失败"),

    PERMISSION_VIP(70000, "权限不足,此影片需要大会员,请开通大会员");

    //操作代码
    int code;
    //提示信息
    String message;

    ResultCode(int code, String message) {
        this.code = code;
        this.message = message;
    }

    public int code() {
        return code;
    }

    public String message() {
        return message;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

package com.xxx.app.handler;

import com.alibaba.fastjson.JSON;
import com.xxx.app.common.RedisKey;
import com.xxx.app.pojo.dto.UserDto;
import com.xxx.app.utils.JWTUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

// 拦截器的使用 要放入 mvc配置当中
// 用于拦截请求并进行身份认证和授权的操作。
@Component
public class LoginHandler implements HandlerInterceptor {
    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     *
     * @param request HTTP 请求对象
     * @param response HTTP 响应对象
     * @param handler 表示待处理的目标对象
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //return HandlerInterceptor.super.preHandle(request, response, handler);
        //方法执行之前 进行拦截
        /**
         * 1.判断请求是否是请求 controller 方法
         * 2.有些接口是不需要登录拦截，需要开放自定义的注解 @NoAuth 此注解标识的 不需要登录
         * 3.拿到token
         * 4.token认证 -> user信息
         * 5.如果 redis 认证通过 就放行 认证不通过 返回未登录
         * 6.得到了用户信息，放入 ThreadLocal 当中
         */
        // 判断 handler 是否为 HandlerMethod 的实例。如果不是，则直接返回 true，表示放行。
        if (!(handler instanceof HandlerMethod)) {
            return true;
        }
        // 将 handler 强制转换为 HandlerMethod 对象，以便后面能够获取处理该请求的 Controller 方法及其注解信息。
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        // 判断该 Controller 方法是否被 @NoAuth 注解标记，如果有，则直接返回 true，表示放行。
        if (handlerMethod.hasMethodAnnotation(NoAuth.class)) {
            return true;
        }
        String token = request.getHeader("Authorization");
        token = token.replace("Bearer ", "");
        // 从 HTTP 请求头中获取认证 Token，由于 Token 一般以 Bearer  开头，所以需要将其去掉。

        boolean verify = JWTUtils.verify(token);
        // 使用 JWT 进行 Token 认证，如果认证失败，则返回错误信息并直接返回 false，表示拦截该请求。
        if (!verify) {
            response.setContentType("application/json;charset=utf-8");
            //response.getWriter().write(JSON.toJSONString(Result.FAIL("未登录")));
            response.getWriter().write(JSON.toJSONString("未登录"));
            return false;
        }

        String userJson = redisTemplate.opsForValue().get(RedisKey.TOKEN + token);
        if (StringUtils.isBlank(userJson)) {
            response.setContentType("application/json;charset=utf-8");
            //response.getWriter().write(JSON.toJSONString(Result.FAIL("未登录")));
            response.getWriter().write(JSON.toJSONString("未登录"));
            return false;
        }
        UserDto userDto = JSON.parseObject(userJson, UserDto.class);
        UserThreadLocal.put(userDto); // 得到了用户信息，放入ThreadLocal当中
        return true;
    }
}

package com.xxx.app.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Autowired
    private LoginHandler loginHandler;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginHandler);
        //WebMvcConfigurer.super.addInterceptors(registry);
    }
}

//发送手机验证码

auth/send-sms-code

//使用手机 + 验证码登录

auth/sms-login

//刷新令牌

auth/refresh-token

//微信小程序的一键登录

/auth/weixin-mini-app-login

package com.xxx.app.service;

import cn.hutool.core.codec.Base64;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.xxx.app.common.RedisKey;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.spec.AlgorithmParameterSpec;

@Slf4j
@Component
public class WxService {
    @Autowired
    private StringRedisTemplate redisTemplate;

    public String wxDecrypt(String encryptedData, String sessionId, String vi) throws Exception {
        // 开始解密
        String json =  redisTemplate.opsForValue().get(RedisKey.WX_SESSION_ID + sessionId);
        log.info("信息wxDecrypt："+json);
        JSONObject jsonObject = JSON.parseObject(json);
        String sessionKey = (String) jsonObject.get("session_key");
        log.info("sessionKey 信息"+sessionKey);

        byte[] encData = cn.hutool.core.codec.Base64.decode(encryptedData);
        byte[] iv = cn.hutool.core.codec.Base64.decode(vi);
        byte[] key = Base64.decode(sessionKey);
        log.info("key 信息"+key);
        AlgorithmParameterSpec ivSpec = new IvParameterSpec(iv);

        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
        cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);

        return new String(cipher.doFinal(encData), "UTF-8");
    }
}

package com.xxx.app.common;

public class RedisKey {
    public static final String WX_SESSION_ID = "wx_session_id";
    public static final String TOKEN = "token_";
}

package com.xxx.app.entity;

import java.util.Date;

public class Login {
    private int id;
    private String phone;
    private String code;
    private byte role;
    private Date ctime;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public byte getRole() {
        return role;
    }

    public void setRole(byte role) {
        this.role = role;
    }

    public Date getCtime() {
        return ctime;
    }

    public void setCtime(Date ctime) {
        this.ctime = ctime;
    }

    @Override
    public String toString() {
        return "Login [id=" + id + ", phone=" + phone + ", code=" + code + ", ctime=" + ctime + ", getId()=" + getId() + ", getPhone()=" + getPhone() + ", getCode()=" + getCode() + ", getCtime()=" + getCtime() + ", getClass()=" + getClass() + ", hashCode()=" + hashCode() + ", toString()=" + super.toString() + "]";
    }
}

package com.xxx.app.entity;

public class Sms {
    private String phoneNumber;
    private String code;
    public String getPhoneNumber() {
        return phoneNumber;
    }
    public  void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
}

package com.xxx.app.handler;

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface NoAuth {
}

package com.xxx.app.handler;

import com.xxx.app.pojo.dto.UserDto;

public class UserThreadLocal {
    private static final ThreadLocal<UserDto> LOCAL = new ThreadLocal<>();

    public static void put(UserDto userDto) {
        LOCAL.set(userDto);
    }
    public static UserDto get() {
        return LOCAL.get();
    }
    public static void remove() {
        LOCAL.remove();
    }
}

package com.xxx.app.model;

import lombok.Data;

@Data
public class WXAuth {
    private String encryptedData;
    private String iv;
    private String sessionId;
}

package com.xxx.app.model;

import lombok.Data;

@Data
public class WxUserInfo {

    private String openId;

    private String nickName;

    private String gender;

    private String city;

    private String province;

    private String country;

    private String avatarUrl;

    private String unionId;

}

package com.xxx.app.pojo.dto;

import com.xxx.app.model.WxUserInfo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.util.List;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserDto implements Serializable {
    private Long id;
    private String nickname;
    private String username;
    private String password;
    private String gender;
    private String phoneNumber;
    private String background;
    private String avatar_url;
    private String openId;
    private String unionId;

    //dto拓展属性
    private String token;
    List<String> permissions;
    List<String> roles;
    // 验证码
    private String code;

    public void from(WxUserInfo wxUserInfo) {
        this.nickname = wxUserInfo.getNickName();
        this.avatar_url = wxUserInfo.getAvatarUrl();
        this.username = "";
        this.password = "";
        this.phoneNumber = "";
        this.gender = wxUserInfo.getGender();
        this.openId = wxUserInfo.getOpenId();
        this.unionId = wxUserInfo.getUnionId();
    }
}

package com.xxx.app.pojo;

//import com.baomidou.mybatisplus.annotation.IdType;
//import com.baomidou.mybatisplus.annotation.TableId;
//import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.io.Serializable;
import java.time.LocalDateTime;

@Data
//@TableName("tbl_weixin")
public class User implements Serializable {

//    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    //用户唯一标识
    private String openId;

    //昵称
    private String nickName;

    private String password;

    //性别
    private String gender;

    //城市
    private String city;

    //省份
    private String province;

    //国家
    private String country;

    //头像
    private String avatarUrl;

    //用户在开放平台的唯一标识
    private String unionId;

    //是否授权
    private Integer isAuth;

    //创建时间
    private LocalDateTime createTime;

    //修改时间
    private LocalDateTime updateTime;
}

UserController

package com.xxx.app.controller;

import com.xxx.app.handler.NoAuth;
import com.xxx.app.model.WXAuth;
import com.xxx.app.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@Slf4j
@RestController
public class UserController {

//    @Autowired
//    private UserService userService;

    //getSessionId
//    @GetMapping("/getSessionId")
//    @NoAuth
//    public Result getSessionId(String code) {
//        return userService.getSessionId(code);
//    }
//
//    @PostMapping("/authLogin")
//    @NoAuth
//    public Result authLogin(@RequestBody WXAuth wxAuth) {
//        Result result = userService.authLogin(wxAuth);
//        log.info("{}", result);
//        return result;
//    }
//
//    @GetMapping("userinfo")
//    public Result userinfo(Boolean refresh) {
//        return userService.userinfo(refresh);
//    }
}

package com.xxx.app.controller;

import cn.hutool.json.JSONException;
import com.xxx.app.entity.Sms;
import com.xxx.app.handler.NoAuth;
import com.github.qcloudsms.SmsSingleSender;
import com.github.qcloudsms.SmsSingleSenderResult;
import com.github.qcloudsms.httpclient.HTTPException;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomStringUtils;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;

@RestController
//@RequestMapping(value = "/sms") //sendCode
@Slf4j
public class SmsController {
    @NoAuth
    @RequestMapping(value = "/sendSms", method = RequestMethod.POST)
    public void sendCode(@RequestBody Sms sms) {
        // String 返回
        // String code = generateCode();
        // redisService.set(mobile, code, 300L); // 有效时间5分钟
        // boolean result = smsService.sendSms(mobile, code);
        // 生产6位数的随机验证码
        // String code = String.valueOf((int) ((Math.random() * 9 + 1) * 100000));
        try{
//            String[] params = {sms.getCode()}; //短信中的参数
            String[] params = {"1" + RandomStringUtils.randomNumeric(5)};
            System.out.println("params = " + params);

            //String[] params = ["2344"];
            SmsSingleSender ssender = new SmsSingleSender(appid,appkey);
            SmsSingleSenderResult result = ssender.sendWithParam(
                    "86",
                    sms.getPhoneNumber(),
                    templateId,
                    params,
                    smsSign,
                    "","");
            System.out.println(result);
        }catch (HTTPException e){
            e.printStackTrace();
        }catch (JSONException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

package com.xxx.app.controller;

import java.util.List;
import java.util.Set;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import com.xxx.common.constant.Constants;
import com.xxx.common.core.domain.AjaxResult;
import com.xxx.common.core.domain.entity.SysMenu;
import com.xxx.common.core.domain.entity.SysUser;
import com.xxx.common.core.domain.model.LoginBody;
import com.xxx.common.utils.SecurityUtils;
import com.xxx.framework.web.service.SysLoginService;
import com.xxx.framework.web.service.SysPermissionService;
import com.xxx.system.service.ISysMenuService;

/**
 * 登录验证
 *
 */
@RestController
public class SysLoginController
{
    @Autowired
    private SysLoginService loginService;

    @Autowired
    private ISysMenuService menuService;

    @Autowired
    private SysPermissionService permissionService;

    /**
     * 登录方法
     *
     * @param loginBody 登录信息
     * @return 结果
     */
    @PostMapping("/login")
    public AjaxResult login(@RequestBody LoginBody loginBody)
    {
        AjaxResult ajax = AjaxResult.success();
        // 生成令牌
//        String token = loginService.login(loginBody.getUsername(), loginBody.getPassword(), loginBody.getCode(),
//                loginBody.getUuid());
//        ajax.put(Constants.TOKEN, token);
        return ajax;
    }

    /**
     * 获取用户信息
     *
     * @return 用户信息
     */
    @GetMapping("getInfo")
    public AjaxResult getInfo()
    {
        SysUser user = SecurityUtils.getLoginUser().getUser();
        // 角色集合
        Set<String> roles = permissionService.getRolePermission(user);
        // 权限集合
        Set<String> permissions = permissionService.getMenuPermission(user);
        AjaxResult ajax = AjaxResult.success();
        ajax.put("user", user);
        ajax.put("roles", roles);
        ajax.put("permissions", permissions);
        return ajax;
    }

    /**
     * 获取路由信息
     *
     * @return 路由信息
     */
    @GetMapping("getRouters")
    public AjaxResult getRouters()
    {
        Long userId = SecurityUtils.getUserId();
        List<SysMenu> menus = menuService.selectMenuTreeByUserId(userId);
        return AjaxResult.success(menuService.buildMenus(menus));
    }
}

加群联系作者vx：xiaoda0423

仓库地址：https://github.com/webVueBlog/WebGuideInterview