)这个错误通常意味着你正在尝试将一个非 JSON 格式的数据转换成 JSON 格式。为了修复这个问题，你需要找到导致错误的代码行并检查它的输入数据是否符合 JSON 格式标准。这个错误通常是因为你的 TypeScript 版本不支持 Node.js ..._uncaught syntaxerror: "undefined" is not valid json at js">
devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：我家小花儿 | 2024-07-26 06:02:18

赞

踩

uncaught syntaxerror: "undefined" is not valid json at json.parse (

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）中包含了以下配置：

    1. {
    2.   "compilerOptions": {
    3.     "target": "es6",
    4.     "module": "commonjs",
    5.     "esModuleInterop": true,
    6.     "types": ["node"]
    7.   }
    8. }

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

    tsc

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

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

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

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

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

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

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

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

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

应该改为：

  1. const language = navigator.language;
  2. 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 实例作为默认模块。

6a6625d2bed8955b38bea17486406381.png
image.png 
  1. package com.xx.app.utils.constants;
  2.  
  3. public class Constants {
  4.     public static final String SUCCESS_CODE = "200";
  5.     public static final String SUCCESS_MSG = "操作成功";
  6. }
  1. package com.xx.app.utils.constants;
  2.  
  3. public enum ErrorEnum {
  4.     E_400("400", "请求处理异常，请稍后再试"),
  5.     E_500("500", "请求方式有误,请检查 GET/POST"),
  6.     E_501("501", "请求路径不存在"),
  7.     E_502("502", "权限不足"),
  8.     E_10008("10008", "角色删除失败,尚有用户属于此角色"),
  9.     E_10009("10009", "账户已存在"),
  10.     E_10010("10010", "账号/密码错误"),
  11.     E_20011("20011", "登录已过期,请重新登录"),
  12.     E_90003("90003", "缺少必填参数");
  13.     private final String errorCode;
  14.     private final String errorMsg;
  15.  
  16.     ErrorEnum(String errorCode, String errorMsg) {
  17.         this.errorCode = errorCode;
  18.         this.errorMsg = errorMsg;
  19.     }
  20.  
  21.     public String getErrorCode() {
  22.         return errorCode;
  23.     }
  24.  
  25.     public String getErrorMsg() {
  26.         return errorMsg;
  27.     }
  28. }
  1. package com.xxx.app.utils.model;
  2.  
  3. import com.alibaba.fastjson.JSONObject;
  4.  
  5. import java.util.List;
  6. import java.util.Set;
  7.  
  8. /**
  9.  * MyBatis的一对多JSON返回对象
  10.  * 处理嵌套查询结果时，MyBatis会根据bean定义的属性类型来初始化嵌套的成员变量，主要看其是不是Collection
  11.  * 如果这里不定义，那么嵌套返回结果里就只能返回一对一的结果，而不是一对多的
  12.  * 参见MyBatis  DefaultResultSetHandler.instantiateCollectionPropertyIfAppropriate()
  13.  */
  14. public class One2Many extends JSONObject {
  15.     private Set<String> roleList;
  16.     private Set<String> menuList;
  17.     private Set<String> permissionList;
  18.     private Set<Integer> permissionIds;
  19.     private List<JSONObject> picList;
  20.     private List<JSONObject> menus;
  21.     private List<JSONObject> users;
  22.     private List<JSONObject> permissions;
  23.     private List<JSONObject> roles;
  24. }
  1. package com.xxx.app.utils;
  2.  
  3. import com.xxx.app.utils.constants.Constants;
  4. import com.xxx.app.utils.constants.ErrorEnum;
  5. import com.alibaba.fastjson.JSONObject;
  6.  
  7. import javax.servlet.http.HttpServletRequest;
  8. import java.util.Enumeration;
  9. import java.util.List;
  10.  
  11. /**
  12.  * 后台接口系统常用的json工具类
  13.  */
  14. public class CommonUtil {
  15.     /**
  16.      * 返回一个info为空对象的成功消息的json
  17.      */
  18.     public static JSONObject successJson() {
  19.         return successJson(new JSONObject());
  20.     }
  21.     public static JSONObject successJson(Object info) {
  22.         JSONObject resultJson = new JSONObject();
  23.         resultJson.put("code", Constants.SUCCESS_CODE);
  24.         resultJson.put("msg", Constants.SUCCESS_MSG);
  25.         resultJson.put("info", info);
  26.         return resultJson;
  27.     }
  28.     /**
  29.      * 返回错误信息JSON
  30.      */
  31.     public static JSONObject errorJson(ErrorEnum errorEnum) {
  32.         JSONObject resultJson = new JSONObject();
  33.         resultJson.put("code", errorEnum.getErrorCode());
  34.         resultJson.put("msg", errorEnum.getErrorMsg());
  35.         resultJson.put("info", new JSONObject());
  36.         return resultJson;
  37.     }
  38.     /**
  39.      * 查询分页结果后的封装工具方法
  40.      * @param requestJson 请求参数json,此json在之前调用fillPageParam 方法时,已经将pageRow放入
  41.      * @param list        查询分页对象list
  42.      * @param totalCount  查询出记录的总条数
  43.      */
  44.     public static JSONObject successPage(final JSONObject requestJson, List<JSONObject> list, int totalCount) {
  45.         int pageRow = requestJson.getIntValue("pageRow");
  46.         int totalPage = getPageCounts(pageRow, totalCount);
  47.         JSONObject result = successJson();
  48.         JSONObject info = new JSONObject();
  49.         info.put("list", list);
  50.         info.put("totalCount", totalCount);
  51.         info.put("totalPage", totalPage);
  52.         result.put("info", info);
  53.         return result;
  54.     }
  55.     /**
  56.      * 获取总页数
  57.      *
  58.      * @param pageRow   每页行数
  59.      * @param itemCount 结果的总条数
  60.      */
  61.     private static int getPageCounts(int pageRow, int itemCount) {
  62.         if (itemCount == 0) {
  63.             return 1;
  64.         }
  65.         return itemCount % pageRow == 0? itemCount / pageRow : itemCount / pageRow + 1;
  66.         //return (itemCount + pageRow - 1) / pageRow;
  67.     }
  68.     /**
  69.      * 查询分页结果后的封装工具方法
  70.      *
  71.      * @param list 查询分页对象list
  72.      */public static JSONObject successPage(List<JSONObject> list) {
  73.         JSONObject result = successJson();
  74.         JSONObject info = new JSONObject();
  75.         info.put("list", list);
  76.         result.put("info", info);
  77.         return result;
  78.     }
  79.  
  80.     /**
  81.      * 将request参数值转为json
  82.      */
  83.     public static JSONObject request2Json(HttpServletRequest request) {
  84.         JSONObject requestJson = new JSONObject();
  85.         Enumeration<String> paramNames = request.getParameterNames();
  86.         while (paramNames.hasMoreElements()) {
  87.             String paramName = (String) paramNames.nextElement();
  88.             String[] pv = request.getParameterValues(paramName);
  89.             StringBuilder sb = new StringBuilder();
  90.             for (int i = 0; i < pv.length; i++) {
  91.                 if (pv[i].length() > 0) {
  92.                     if (i > 0) {
  93.                         sb.append(",");
  94.                     }
  95.                     sb.append(pv[i]);
  96.                 }
  97.             }
  98.             requestJson.put(paramName, sb.toString());
  99.         }
  100.         return requestJson;
  101.     }
  102.     /**
  103.      * 将request转JSON
  104.      * 并且验证非空字段
  105.      */
  106.     public static JSONObject convert2JsonAndCheckRequiredColumns(HttpServletRequest request, String requiredColumns) {
  107.         JSONObject jsonObject = request2Json(request);
  108.         hasAllRequired(jsonObject, requiredColumns);
  109.         return jsonObject;
  110.     }
  111.     /**
  112.      * 验证是否含有全部必填字段
  113.      *
  114.      * @param requiredColumns 必填的参数字段名称 逗号隔开 比如"userId,name,telephone"
  115.      */
  116.     public static void hasAllRequired(final JSONObject jsonObject, String requiredColumns) {
  117.         if (!StringTools.isNullOrEmpty(requiredColumns)) {
  118.             //验证字段非空
  119.             String[] columns = requiredColumns.split(",");
  120.             String missCol = "";
  121.             for (String column : columns) {
  122.                 Object val = jsonObject.get(column.trim());
  123.                 if (StringTools.isNullOrEmpty(val)) {
  124.                     missCol += column + "  ";
  125.                 }
  126.             }
  127.             if (!StringTools.isNullOrEmpty(missCol)) {
  128.                 jsonObject.clear();
  129.                 jsonObject.put("code", ErrorEnum.E_90003.getErrorCode());
  130.                 jsonObject.put("msg", "缺少必填参数:" + missCol.trim());
  131.                 jsonObject.put("info", new JSONObject());
  132.                 throw null;
  133.             }
  134.         }
  135.     }
  136.     /**
  137.      * 在分页查询之前,为查询条件里加上分页参数
  138.      *
  139.      * @param paramObject    查询条件json
  140.      * @param defaultPageRow 默认的每页条数,即前端不传pageRow参数时的每页条数
  141.      */
  142.     private static void fillPageParam(final JSONObject paramObject, int defaultPageRow) {
  143.         int pageNum = paramObject.getIntValue("pageNum");
  144.         pageNum = pageNum == 0 ? 1 : pageNum;
  145.         int pageRow = paramObject.getIntValue("pageRow");
  146.         pageRow = pageRow == 0 ? defaultPageRow : pageRow;
  147.         paramObject.put("offSet", (pageNum - 1) * pageRow);
  148.         paramObject.put("pageRow", pageRow);
  149.         paramObject.put("pageNum", pageNum);
  150.         //删除此参数,防止前端传了这个参数,pageHelper分页插件检测到之后,拦截导致SQL错误
  151.         paramObject.remove("pageSize");
  152.     }
  153.     /**
  154.      * 分页查询之前的处理参数
  155.      * 没有传pageRow参数时,默认每页10条.
  156.      */
  157.     public static void fillPageParam(final JSONObject paramObject) {
  158.         fillPageParam(paramObject, 10);
  159.     }
  160. }
  1. package com.xxx.app.utils;
  2.  
  3. public class StringTools {
  4.  
  5.     public static boolean isNullOrEmpty(String str) {
  6.         return null == str || "".equals(str) || "null".equals(str);
  7.     }
  8.  
  9.     public static boolean isNullOrEmpty(Object obj) {
  10.         return null == obj || "".equals(obj);
  11.     }
  12. }
  1. package com.xxxx.app.utils;
  2.  
  3. import com.auth0.jwt.JWT;
  4. import com.auth0.jwt.JWTVerifier;
  5. import com.auth0.jwt.algorithms.Algorithm;
  6. import com.auth0.jwt.exceptions.JWTDecodeException;
  7. import com.auth0.jwt.interfaces.DecodedJWT;
  8.  
  9. import java.io.UnsupportedEncodingException;
  10. import java.util.Date;
  11.  
  12. public class JWTUtils {
  13.     public static final String AUTH_HEADER_KEY = "Authorization";
  14.  
  15.     public static final String TOKEN_PREFIX = "Bearer ";
  16.  
  17.     //过期时间一周
  18.     private static final long EXPIRE_TIME = 7 * 24 * 60 * 60 * 1000;
  19.  
  20.     private static final String secret = "";
  21.  
  22.     /**
  23.      * 验证 JWT token 是否合法
  24.      *
  25.      * @param token 待验证的 JWT token
  26.      * @return 如果 token 合法，则返回 true；否则返回 false。
  27.      */
  28.     public static boolean verify(String token) {
  29.         try {
  30.             Algorithm algorithm = Algorithm.HMAC256(secret);
  31.             // 创建一个 JWT 验证器
  32.             JWTVerifier verifier = JWT.require(algorithm).build();
  33.             // 使用验证器对 token 进行验证
  34.             DecodedJWT jwt = verifier.verify(token);
  35.             return true;
  36.         } catch (Exception exception) {
  37.             return false;
  38.         }
  39.     }
  40.  
  41.     /**
  42.      * 获取token中信息无需secret解密也能获得
  43.      * @param token
  44.      * @return token中包含的id
  45.      */
  46.     public static Long getUserId(String token) {
  47.         try {
  48.             DecodedJWT jwt = JWT.decode(token);
  49.             return jwt.getClaim("id").asLong();
  50.         } catch (JWTDecodeException e) {
  51.             return null;
  52.         }
  53.     }
  54.  
  55.     /**
  56.      * 签发token
  57.      * @param id
  58.      * @return 加密的token
  59.      */
  60.     public static String sign(Long id) {
  61.         try {
  62.             Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
  63.             Algorithm algorithm = Algorithm.HMAC256(secret);
  64.             // 附带username信息
  65.             return JWT.create()
  66.                     .withClaim("id", id)
  67.                     .withExpiresAt(date)
  68.                     .sign(algorithm);
  69.         } catch (UnsupportedEncodingException e) {
  70.             return null;
  71.         }
  72.     }
  73. }
  1. package com.xxx.app.service;
  2.  
  3. import cn.hutool.http.HttpUtil;
  4. import com.alibaba.fastjson.JSON;
  5. import com.xxx.app.common.RedisKey;
  6. import com.xxx.app.handler.UserThreadLocal;
  7. import com.xxx.app.model.WXAuth;
  8. import com.xxx.app.pojo.User;
  9. import com.xxx.app.pojo.dto.UserDto;
  10. import com.xxx.app.utils.JWTUtils;
  11. import lombok.extern.slf4j.Slf4j;
  12. import org.springframework.beans.BeanUtils;
  13. import org.springframework.beans.factory.annotation.Autowired;
  14. import org.springframework.beans.factory.annotation.Value;
  15. import org.springframework.data.redis.core.StringRedisTemplate;
  16. import org.springframework.stereotype.Service;
  17.  
  18. import java.util.HashMap;
  19. import java.util.Map;
  20. import java.util.UUID;
  21. import java.util.concurrent.TimeUnit;
  22.  
  23. @Slf4j
  24. @Service
  25. public class UserService {
  26.  
  27.     @Value("${wxmini.appid}")
  28.     private String appid;
  29.  
  30.     @Value("${wxmini.secret}")
  31.     private String secret;
  32.  
  33.     @Autowired
  34.     private StringRedisTemplate redisTemplate;
  35.  
  36. //    public Result getSessionId(String code) {
  37. //        /**
  38. //         * 1. 拼接一个url，微信登录凭证校验接口
  39. //         * 2. 发起一个http的调用，获取微信的返回结果
  40. //         * 3. 存到redis
  41. //         * 4. 生成一个sessionId，返回给前端，作为当前需要登录用户的标识
  42. //         * 5. 生成一个sessionId，用户在点击微信登录的时候，我们可以标识是谁点击微信登录
  43. //         */
  44. //        String url = "https://api.weixin.qq.com/sns/jscode2session?appid={0}&secret={1}&js_code={2}&grant_type=authorization_code";
  45. //        String replaceUrl = url.replace("{0}", appid).replace("{1}", secret).replace("{2}", code);
  46. //        String res = HttpUtil.get(replaceUrl);
  47. //        String uuid = UUID.randomUUID().toString();
  48. //        redisTemplate.opsForValue().set(RedisKey.WX_SESSION_ID + uuid, res, 30, TimeUnit.MINUTES);
  49. //        Map<String, String> map = new HashMap<>();
  50. //        map.put("sessionId", uuid);
  51. //        return Result.SUCCESS(map);
  52. //    }
  53.  
  54.     @Autowired
  55.     private WxService wxService;
  56.  
  57. //    @Resource
  58. //    private UserMapper userMapper;
  59.  
  60. //    public Result authLogin(WXAuth wxAuth) {
  61. //        /**
  62. //         * 1. 通过wxAuth中的值，要对它进行解密
  63. //         * 2. 解密完成之后，会获取到微信用户信息 其中包含 openId，性别，昵称，头像等信息
  64. //         * 3. openId 是唯一的，需要去user表中查询openId是否存在，存在，已此用户的身份登录成功
  65. //         * 4. 不存在，新用户，注册流程，登录成功
  66. //         * 5. 使用jwt技术，生成一个token，提供给前端 token 令牌，用户在下次访问的时候，携带token来访问
  67. //         * 6. 后端通过对token的验证，找到此用户是否处于登录状态，以及是哪个用户登录的
  68. //         */
  69.         try {
  70.             log.info("获取请求参数："+wxAuth);
  71.             String wxRes = wxService.wxDecrypt(wxAuth.getEncryptedData(), wxAuth.getSessionId(), wxAuth.getIv());
  72.             log.info("信息："+wxRes);
  73.             WxUserInfo wxUserInfo = JSON.parseObject(wxRes, WxUserInfo.class);
  74.             String openId = wxUserInfo.getOpenId();
  75.             User user = userMapper.selectOne(Wrappers.<User>lambdaQuery().eq(User::getOpenId, openId).last("limit 1"));
  76.             UserDto userDto = new UserDto();
  77.             userDto.from(wxUserInfo);
  78.             if (user == null) {
  79.                 // 注册
  80.                 return this.register(userDto);
  81.             } else {
  82.                 userDto.setId(user.getId());
  83.                 // 登录
  84.                 return this.login(userDto);
  85.             }
  86.         } catch (Exception e) {
  87.             e.printStackTrace();
  88.         }
  89.         return Result.FAIL();
  90. //        return null;
  91. //    }
  92. //
  93. //    private Result login(UserDto userDto) {
  94. //        String token = JWTUtils.sign(userDto.getId());
  95. //        userDto.setToken(token);
  96. //        userDto.setOpenId(null);
  97. //        userDto.setUnionId(null);
  98. //        //需要把token 存入redis，value存为 userDto，下次用户访问需要登录资源的时候，可以根据token拿到用户的详细信息
  99. //        //缓存
  100. //        redisTemplate.opsForValue().set(RedisKey.TOKEN+token, JSON.toJSONString(userDto), 7, TimeUnit.DAYS);
  101. //        return Result.SUCCESS(userDto);
  102. //    }
  103. //
  104. //    private Result register(UserDto userDto) {
  105. //        // 注册之前 判断 用户是否存在
  106. //        User user = new User();
  107. //        BeanUtils.copyProperties(userDto, user);
  108.         this.userMapper.insert(user);
  109. //        // return Result.SUCCESS(userDto);
  110. //        userDto.setId(user.getId());
  111. //        return this.login(userDto);
  112. //    }
  113. //
  114. //    // 参数 String token
  115. //    public Result userinfo(Boolean refresh) {
  116. //        /**
  117. //         * 1. 根据token 来验证此token 是否有效
  118. //         * 2. refresh 如果为true 代表刷新 重新生成token和redis里面重新储存 续期
  119. //         * 3. false直接返回用户信息 redis中 查询出来 直接返回
  120. //         */
  121. //        /**
  122. //         token = token.replace("Bearer ", "");
  123. //         boolean verify = JWTUtils.verify(token);
  124. //         if (!verify) {
  125. //         return Result.FAIL("未登录");
  126. //         }
  127. //         String userJson = redisTemplate.opsForValue().get(RedisKey.TOKEN + token);
  128. //         if (StringUtils.isBlank(userJson)) {
  129. //         return Result.FAIL("未登录");
  130. //         }
  131. //         */
  132. //        UserDto userDto = UserThreadLocal.get();
  133. //        if (refresh) {
  134. //            String token = JWTUtils.sign(userDto.getId());
  135. //            userDto.setToken(token);
  136. //            redisTemplate.opsForValue().set(RedisKey.TOKEN+token, JSON.toJSONString(userDto), 7, TimeUnit.DAYS);
  137. //        }
  138. //        return Result.SUCCESS(userDto);
  139. //    }
  140. }
  1. package com.xxx.app.common;
  2.  
  3. public enum ResultCode {
  4.  
  5.     /* 成功状态码 */
  6.     SUCCESS(0, "操作成功！"),
  7.  
  8.     /* 错误状态码 */
  9.     FAIL(-1, "操作失败！"),
  10.  
  11.     /* 参数错误：10001-19999 */
  12.     PARAM_IS_INVALID(10001, "参数无效"),
  13.     PARAM_IS_BLANK(10002, "参数为空"),
  14.     PARAM_TYPE_BIND_ERROR(10003, "参数格式错误"),
  15.     PARAM_NOT_COMPLETE(10004, "参数缺失"),
  16.  
  17.     /* 用户错误：20001-29999*/
  18.     USER_NOT_LOGGED_IN(20001, "用户未登录，请先登录"),
  19.     USER_LOGIN_ERROR(20002, "账号不存在或密码错误"),
  20.     USER_ACCOUNT_FORBIDDEN(20003, "账号已被禁用"),
  21.     USER_NOT_EXIST(20004, "用户不存在"),
  22.     USER_HAS_EXISTED(20005, "用户已存在"),
  23.  
  24.     /* 业务错误：30001-39999 */
  25.     BUSINESS_GROUP_NO_ALLOWED_DEL(30001, "应用分组已经被应用使用，不能删除"),
  26.     BUSINESS_THEME_NO_ALLOWED_DEL(30002, "主题已经被用户使用，不能删除"),
  27.     BUSINESS_THEME_NO_ALLOWED_DISABLE(30003, "主题已经被用户使用，不能停用"),
  28.     BUSINESS_THEME_DEFAULT_NO_ALLOWED_DEL(30004, "默认主题，不能删除"),
  29.     BUSINESS_THEME_NO_ALLOWED_UPDATE(30005, "主题已经被用户使用，不能修改图片信息"),
  30.     BUSINESS_IS_TOP(30040, "已经到最顶部"),
  31.     BUSINESS_IS_BOTTOM(30041, "已经到最底部"),
  32.     BUSINESS_NAME_EXISTED(30051, "名称已存在"),
  33.  
  34.     /* 系统错误：40001-49999 */
  35.     SYSTEM_INNER_ERROR(40001, "系统繁忙，请稍后重试"),
  36.     UPLOAD_ERROR(40002, "系统异常，上传文件失败"),
  37.     FILE_MAX_SIZE_OVERFLOW(40003, "上传尺寸过大"),
  38.     FILE_ACCEPT_NOT_SUPPORT(40004, "上传文件格式不支持"),
  39.     SET_UP_AT_LEAST_ONE_ADMIN(40005, "至少指定一个管理员"),
  40.     URL_INVALID(40006, "地址不合法"),
  41.     LINK_AND_LOGOUT_NO_MATCH(40006, "主页地址和注销地址IP不一致"),
  42.     IP_AND_PORT_EXISTED(40007, "当前IP和端口已经被占中"),
  43.     LINK_IS_REQUIRED(40008, "生成第三方token认证信息： 主页地址不能为空,请完善信息"),
  44.     ONLY_ROOT_DEPARTMENT(40009, "组织机构只能存在一个根机构"),
  45.     DEPART_CODE_EXISTED(40010, "组织机构编码已存在"),
  46.     DEPART_CONTAINS_USERS(40011, "该机构下是存在用户，不允许删除"),
  47.     DEPART_CONTAINS_SON(40012, "该机构下是存在子级机构，不允许删除"),
  48.     DEPART_PARENT_IS_SELF(40013, "选择的父机构不能为本身"),
  49.     DICT_EXIST_DEPEND(40014, "该字典数据存在详情依赖，不允许删除"),
  50.     DICT_DETAIL_LOCK(40015, "该字典数据被锁定，不允许修改或删除"),
  51.     DEPART_CODE_EXISTED_WITH_ARGS(40016, "组织机构编码【{0}】系统已存在"),
  52.  
  53.     /* 数据错误：50001-599999 */
  54.     RESULT_DATA_NONE(50001, "数据未找到"),
  55.     DATA_IS_WRONG(50002, "数据有误"),
  56.     DATA_ALREADY_EXISTED(50003, "数据已存在"),
  57.     AUTH_CODE_ERROR(50004, "验证码错误"),
  58.  
  59.     /* 接口错误：60001-69999 */
  60.     INTERFACE_INNER_INVOKE_ERROR(60001, "内部系统接口调用异常"),
  61.  
  62.     INTERFACE_OUTTER_INVOKE_ERROR(60002, "外部系统接口调用异常"),
  63.  
  64.     INTERFACE_FORBID_VISIT(60003, "该接口禁止访问"),
  65.  
  66.     INTERFACE_ADDRESS_INVALID(60004, "接口地址无效"),
  67.  
  68.     INTERFACE_REQUEST_TIMEOUT(60005, "接口请求超时"),
  69.  
  70.     INTERFACE_EXCEED_LOAD(60006, "接口负载过高"),
  71.  
  72.  
  73.     /* 权限错误：70001-79999 */
  74.     PERMISSION_UNAUTHENTICATED(70001, "此操作需要登陆系统！"),
  75.  
  76.     PERMISSION_UNAUTHORISE(70002, "权限不足，无权操作！"),
  77.  
  78.     PERMISSION_EXPIRE(70003, "登录状态过期！"),
  79.  
  80.     PERMISSION_TOKEN_EXPIRED(70004, "token已过期"),
  81.  
  82.     PERMISSION_LIMIT(70005, "访问次数受限制"),
  83.  
  84.     PERMISSION_TOKEN_INVALID(70006, "无效token"),
  85.  
  86.     PERMISSION_SIGNATURE_ERROR(70007, "签名失败"),
  87.  
  88.     PERMISSION_VIP(70000, "权限不足,此影片需要大会员,请开通大会员");
  89.  
  90.     //操作代码
  91.     int code;
  92.     //提示信息
  93.     String message;
  94.  
  95.     ResultCode(int code, String message) {
  96.         this.code = code;
  97.         this.message = message;
  98.     }
  99.  
  100.     public int code() {
  101.         return code;
  102.     }
  103.  
  104.     public String message() {
  105.         return message;
  106.     }
  107.  
  108.     public void setCode(int code) {
  109.         this.code = code;
  110.     }
  111.  
  112.     public void setMessage(String message) {
  113.         this.message = message;
  114.     }
  115. }
  1. package com.xxx.app.handler;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.xxx.app.common.RedisKey;
  5. import com.xxx.app.pojo.dto.UserDto;
  6. import com.xxx.app.utils.JWTUtils;
  7. import org.apache.commons.lang3.StringUtils;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.data.redis.core.StringRedisTemplate;
  10. import org.springframework.stereotype.Component;
  11. import org.springframework.web.method.HandlerMethod;
  12. import org.springframework.web.servlet.HandlerInterceptor;
  13.  
  14. import javax.servlet.http.HttpServletRequest;
  15. import javax.servlet.http.HttpServletResponse;
  16.  
  17. // 拦截器的使用 要放入 mvc配置当中
  18. // 用于拦截请求并进行身份认证和授权的操作。
  19. @Component
  20. public class LoginHandler implements HandlerInterceptor {
  21.     @Autowired
  22.     private StringRedisTemplate redisTemplate;
  23.  
  24.     /**
  25.      *
  26.      * @param request HTTP 请求对象
  27.      * @param response HTTP 响应对象
  28.      * @param handler 表示待处理的目标对象
  29.      * @return
  30.      * @throws Exception
  31.      */
  32.     @Override
  33.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  34.         //return HandlerInterceptor.super.preHandle(request, response, handler);
  35.         //方法执行之前 进行拦截
  36.         /**
  37.          * 1.判断请求是否是请求 controller 方法
  38.          * 2.有些接口是不需要登录拦截，需要开放自定义的注解 @NoAuth 此注解标识的 不需要登录
  39.          * 3.拿到token
  40.          * 4.token认证 -> user信息
  41.          * 5.如果 redis 认证通过 就放行 认证不通过 返回未登录
  42.          * 6.得到了用户信息，放入 ThreadLocal 当中
  43.          */
  44.         // 判断 handler 是否为 HandlerMethod 的实例。如果不是，则直接返回 true，表示放行。
  45.         if (!(handler instanceof HandlerMethod)) {
  46.             return true;
  47.         }
  48.         // 将 handler 强制转换为 HandlerMethod 对象，以便后面能够获取处理该请求的 Controller 方法及其注解信息。
  49.         HandlerMethod handlerMethod = (HandlerMethod) handler;
  50.         // 判断该 Controller 方法是否被 @NoAuth 注解标记，如果有，则直接返回 true，表示放行。
  51.         if (handlerMethod.hasMethodAnnotation(NoAuth.class)) {
  52.             return true;
  53.         }
  54.         String token = request.getHeader("Authorization");
  55.         token = token.replace("Bearer ", "");
  56.         // 从 HTTP 请求头中获取认证 Token，由于 Token 一般以 Bearer  开头，所以需要将其去掉。
  57.  
  58.         boolean verify = JWTUtils.verify(token);
  59.         // 使用 JWT 进行 Token 认证，如果认证失败，则返回错误信息并直接返回 false，表示拦截该请求。
  60.         if (!verify) {
  61.             response.setContentType("application/json;charset=utf-8");
  62.             //response.getWriter().write(JSON.toJSONString(Result.FAIL("未登录")));
  63.             response.getWriter().write(JSON.toJSONString("未登录"));
  64.             return false;
  65.         }
  66.  
  67.         String userJson = redisTemplate.opsForValue().get(RedisKey.TOKEN + token);
  68.         if (StringUtils.isBlank(userJson)) {
  69.             response.setContentType("application/json;charset=utf-8");
  70.             //response.getWriter().write(JSON.toJSONString(Result.FAIL("未登录")));
  71.             response.getWriter().write(JSON.toJSONString("未登录"));
  72.             return false;
  73.         }
  74.         UserDto userDto = JSON.parseObject(userJson, UserDto.class);
  75.         UserThreadLocal.put(userDto); // 得到了用户信息，放入ThreadLocal当中
  76.         return true;
  77.     }
  78. }
  1. package com.xxx.app.config;
  2.  
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  6. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  7.  
  8. @Configuration
  9. public class WebMvcConfig implements WebMvcConfigurer {
  10.     @Autowired
  11.     private LoginHandler loginHandler;
  12.  
  13.     @Override
  14.     public void addInterceptors(InterceptorRegistry registry) {
  15.         registry.addInterceptor(loginHandler);
  16.         //WebMvcConfigurer.super.addInterceptors(registry);
  17.     }
  18. }

//发送手机验证码

auth/send-sms-code

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

auth/sms-login

//刷新令牌

auth/refresh-token

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

/auth/weixin-mini-app-login

  1. package com.xxx.app.service;
  2.  
  3. import cn.hutool.core.codec.Base64;
  4. import com.alibaba.fastjson.JSON;
  5. import com.alibaba.fastjson.JSONObject;
  6. import com.xxx.app.common.RedisKey;
  7. import lombok.extern.slf4j.Slf4j;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.data.redis.core.StringRedisTemplate;
  10. import org.springframework.stereotype.Component;
  11.  
  12. import javax.crypto.Cipher;
  13. import javax.crypto.spec.IvParameterSpec;
  14. import javax.crypto.spec.SecretKeySpec;
  15. import java.security.spec.AlgorithmParameterSpec;
  16.  
  17. @Slf4j
  18. @Component
  19. public class WxService {
  20.     @Autowired
  21.     private StringRedisTemplate redisTemplate;
  22.  
  23.     public String wxDecrypt(String encryptedData, String sessionId, String vi) throws Exception {
  24.         // 开始解密
  25.         String json =  redisTemplate.opsForValue().get(RedisKey.WX_SESSION_ID + sessionId);
  26.         log.info("信息wxDecrypt："+json);
  27.         JSONObject jsonObject = JSON.parseObject(json);
  28.         String sessionKey = (String) jsonObject.get("session_key");
  29.         log.info("sessionKey 信息"+sessionKey);
  30.  
  31.         byte[] encData = cn.hutool.core.codec.Base64.decode(encryptedData);
  32.         byte[] iv = cn.hutool.core.codec.Base64.decode(vi);
  33.         byte[] key = Base64.decode(sessionKey);
  34.         log.info("key 信息"+key);
  35.         AlgorithmParameterSpec ivSpec = new IvParameterSpec(iv);
  36.  
  37.         Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
  38.         SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
  39.         cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);
  40.  
  41.         return new String(cipher.doFinal(encData), "UTF-8");
  42.     }
  43. }
  1. package com.xxx.app.common;
  2.  
  3. public class RedisKey {
  4.     public static final String WX_SESSION_ID = "wx_session_id";
  5.     public static final String TOKEN = "token_";
  6. }
  1. package com.xxx.app.entity;
  2.  
  3. import java.util.Date;
  4.  
  5. public class Login {
  6.     private int id;
  7.     private String phone;
  8.     private String code;
  9.     private byte role;
  10.     private Date ctime;
  11.  
  12.     public int getId() {
  13.         return id;
  14.     }
  15.  
  16.     public void setId(int id) {
  17.         this.id = id;
  18.     }
  19.  
  20.     public String getPhone() {
  21.         return phone;
  22.     }
  23.  
  24.     public void setPhone(String phone) {
  25.         this.phone = phone;
  26.     }
  27.  
  28.     public String getCode() {
  29.         return code;
  30.     }
  31.  
  32.     public void setCode(String code) {
  33.         this.code = code;
  34.     }
  35.  
  36.     public byte getRole() {
  37.         return role;
  38.     }
  39.  
  40.     public void setRole(byte role) {
  41.         this.role = role;
  42.     }
  43.  
  44.     public Date getCtime() {
  45.         return ctime;
  46.     }
  47.  
  48.     public void setCtime(Date ctime) {
  49.         this.ctime = ctime;
  50.     }
  51.  
  52.     @Override
  53.     public String toString() {
  54.         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() + "]";
  55.     }
  56. }
  1. package com.xxx.app.entity;
  2.  
  3. public class Sms {
  4.     private String phoneNumber;
  5.     private String code;
  6.     public String getPhoneNumber() {
  7.         return phoneNumber;
  8.     }
  9.     public  void setPhoneNumber(String phoneNumber) {
  10.         this.phoneNumber = phoneNumber;
  11.     }
  12.     public String getCode() {
  13.         return code;
  14.     }
  15.     public void setCode(String code) {
  16.         this.code = code;
  17.     }
  18. }
  1. package com.xxx.app.handler;
  2.  
  3. import java.lang.annotation.*;
  4.  
  5. @Target(ElementType.METHOD)
  6. @Retention(RetentionPolicy.RUNTIME)
  7. @Documented
  8. public @interface NoAuth {
  9. }
  1. package com.xxx.app.handler;
  2.  
  3. import com.xxx.app.pojo.dto.UserDto;
  4.  
  5. public class UserThreadLocal {
  6.     private static final ThreadLocal<UserDto> LOCAL = new ThreadLocal<>();
  7.  
  8.     public static void put(UserDto userDto) {
  9.         LOCAL.set(userDto);
  10.     }
  11.     public static UserDto get() {
  12.         return LOCAL.get();
  13.     }
  14.     public static void remove() {
  15.         LOCAL.remove();
  16.     }
  17. }
  1. package com.xxx.app.model;
  2.  
  3. import lombok.Data;
  4.  
  5. @Data
  6. public class WXAuth {
  7.     private String encryptedData;
  8.     private String iv;
  9.     private String sessionId;
  10. }
  1. package com.xxx.app.model;
  2.  
  3. import lombok.Data;
  4.  
  5. @Data
  6. public class WxUserInfo {
  7.  
  8.     private String openId;
  9.  
  10.     private String nickName;
  11.  
  12.     private String gender;
  13.  
  14.     private String city;
  15.  
  16.     private String province;
  17.  
  18.     private String country;
  19.  
  20.     private String avatarUrl;
  21.  
  22.     private String unionId;
  23.  
  24. }
  1. package com.xxx.app.pojo.dto;
  2.  
  3. import com.xxx.app.model.WxUserInfo;
  4. import lombok.AllArgsConstructor;
  5. import lombok.Data;
  6. import lombok.NoArgsConstructor;
  7.  
  8. import java.io.Serializable;
  9. import java.util.List;
  10.  
  11. @Data
  12. @NoArgsConstructor
  13. @AllArgsConstructor
  14. public class UserDto implements Serializable {
  15.     private Long id;
  16.     private String nickname;
  17.     private String username;
  18.     private String password;
  19.     private String gender;
  20.     private String phoneNumber;
  21.     private String background;
  22.     private String avatar_url;
  23.     private String openId;
  24.     private String unionId;
  25.  
  26.     //dto拓展属性
  27.     private String token;
  28.     List<String> permissions;
  29.     List<String> roles;
  30.     // 验证码
  31.     private String code;
  32.  
  33.     public void from(WxUserInfo wxUserInfo) {
  34.         this.nickname = wxUserInfo.getNickName();
  35.         this.avatar_url = wxUserInfo.getAvatarUrl();
  36.         this.username = "";
  37.         this.password = "";
  38.         this.phoneNumber = "";
  39.         this.gender = wxUserInfo.getGender();
  40.         this.openId = wxUserInfo.getOpenId();
  41.         this.unionId = wxUserInfo.getUnionId();
  42.     }
  43. }
  1. package com.xxx.app.pojo;
  2.  
  3. //import com.baomidou.mybatisplus.annotation.IdType;
  4. //import com.baomidou.mybatisplus.annotation.TableId;
  5. //import com.baomidou.mybatisplus.annotation.TableName;
  6. import lombok.Data;
  7.  
  8. import java.io.Serializable;
  9. import java.time.LocalDateTime;
  10.  
  11. @Data
  12. //@TableName("tbl_weixin")
  13. public class User implements Serializable {
  14.  
  15. //    @TableId(value = "id", type = IdType.AUTO)
  16.     private Long id;
  17.  
  18.     //用户唯一标识
  19.     private String openId;
  20.  
  21.     //昵称
  22.     private String nickName;
  23.  
  24.     private String password;
  25.  
  26.     //性别
  27.     private String gender;
  28.  
  29.     //城市
  30.     private String city;
  31.  
  32.     //省份
  33.     private String province;
  34.  
  35.     //国家
  36.     private String country;
  37.  
  38.     //头像
  39.     private String avatarUrl;
  40.  
  41.     //用户在开放平台的唯一标识
  42.     private String unionId;
  43.  
  44.     //是否授权
  45.     private Integer isAuth;
  46.  
  47.     //创建时间
  48.     private LocalDateTime createTime;
  49.  
  50.     //修改时间
  51.     private LocalDateTime updateTime;
  52. }
UserController
  1. package com.xxx.app.controller;
  2.  
  3. import com.xxx.app.handler.NoAuth;
  4. import com.xxx.app.model.WXAuth;
  5. import com.xxx.app.service.UserService;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.web.bind.annotation.*;
  9. @Slf4j
  10. @RestController
  11. public class UserController {
  12.  
  13. //    @Autowired
  14. //    private UserService userService;
  15.  
  16.     //getSessionId
  17. //    @GetMapping("/getSessionId")
  18. //    @NoAuth
  19. //    public Result getSessionId(String code) {
  20. //        return userService.getSessionId(code);
  21. //    }
  22. //
  23. //    @PostMapping("/authLogin")
  24. //    @NoAuth
  25. //    public Result authLogin(@RequestBody WXAuth wxAuth) {
  26. //        Result result = userService.authLogin(wxAuth);
  27. //        log.info("{}", result);
  28. //        return result;
  29. //    }
  30. //
  31. //    @GetMapping("userinfo")
  32. //    public Result userinfo(Boolean refresh) {
  33. //        return userService.userinfo(refresh);
  34. //    }
  35. }
  1. package com.xxx.app.controller;
  2.  
  3. import cn.hutool.json.JSONException;
  4. import com.xxx.app.entity.Sms;
  5. import com.xxx.app.handler.NoAuth;
  6. import com.github.qcloudsms.SmsSingleSender;
  7. import com.github.qcloudsms.SmsSingleSenderResult;
  8. import com.github.qcloudsms.httpclient.HTTPException;
  9. import lombok.extern.slf4j.Slf4j;
  10. import org.apache.commons.lang3.RandomStringUtils;
  11. import org.springframework.web.bind.annotation.RequestBody;
  12. import org.springframework.web.bind.annotation.RequestMapping;
  13. import org.springframework.web.bind.annotation.RequestMethod;
  14. import org.springframework.web.bind.annotation.RestController;
  15.  
  16. import java.io.IOException;
  17.  
  18. @RestController
  19. //@RequestMapping(value = "/sms") //sendCode
  20. @Slf4j
  21. public class SmsController {
  22.     @NoAuth
  23.     @RequestMapping(value = "/sendSms", method = RequestMethod.POST)
  24.     public void sendCode(@RequestBody Sms sms) {
  25.         // String 返回
  26.         // String code = generateCode();
  27.         // redisService.set(mobile, code, 300L); // 有效时间5分钟
  28.         // boolean result = smsService.sendSms(mobile, code);
  29.         // 生产6位数的随机验证码
  30.         // String code = String.valueOf((int) ((Math.random() * 9 + 1) * 100000));
  31.         try{
  32. //            String[] params = {sms.getCode()}; //短信中的参数
  33.             String[] params = {"1" + RandomStringUtils.randomNumeric(5)};
  34.             System.out.println("params = " + params);
  35.  
  36.             //String[] params = ["2344"];
  37.             SmsSingleSender ssender = new SmsSingleSender(appid,appkey);
  38.             SmsSingleSenderResult result = ssender.sendWithParam(
  39.                     "86",
  40.                     sms.getPhoneNumber(),
  41.                     templateId,
  42.                     params,
  43.                     smsSign,
  44.                     "","");
  45.             System.out.println(result);
  46.         }catch (HTTPException e){
  47.             e.printStackTrace();
  48.         }catch (JSONException e){
  49.             e.printStackTrace();
  50.         }catch (IOException e){
  51.             e.printStackTrace();
  52.         }
  53.     }
  54. }
  1. package com.xxx.app.controller;
  2.  
  3. import java.util.List;
  4. import java.util.Set;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.web.bind.annotation.GetMapping;
  7. import org.springframework.web.bind.annotation.PostMapping;
  8. import org.springframework.web.bind.annotation.RequestBody;
  9. import org.springframework.web.bind.annotation.RestController;
  10. import com.xxx.common.constant.Constants;
  11. import com.xxx.common.core.domain.AjaxResult;
  12. import com.xxx.common.core.domain.entity.SysMenu;
  13. import com.xxx.common.core.domain.entity.SysUser;
  14. import com.xxx.common.core.domain.model.LoginBody;
  15. import com.xxx.common.utils.SecurityUtils;
  16. import com.xxx.framework.web.service.SysLoginService;
  17. import com.xxx.framework.web.service.SysPermissionService;
  18. import com.xxx.system.service.ISysMenuService;
  19.  
  20. /**
  21.  * 登录验证
  22.  *
  23.  */
  24. @RestController
  25. public class SysLoginController
  26. {
  27.     @Autowired
  28.     private SysLoginService loginService;
  29.  
  30.     @Autowired
  31.     private ISysMenuService menuService;
  32.  
  33.     @Autowired
  34.     private SysPermissionService permissionService;
  35.  
  36.     /**
  37.      * 登录方法
  38.      *
  39.      * @param loginBody 登录信息
  40.      * @return 结果
  41.      */
  42.     @PostMapping("/login")
  43.     public AjaxResult login(@RequestBody LoginBody loginBody)
  44.     {
  45.         AjaxResult ajax = AjaxResult.success();
  46.         // 生成令牌
  47. //        String token = loginService.login(loginBody.getUsername(), loginBody.getPassword(), loginBody.getCode(),
  48. //                loginBody.getUuid());
  49. //        ajax.put(Constants.TOKEN, token);
  50.         return ajax;
  51.     }
  52.  
  53.     /**
  54.      * 获取用户信息
  55.      *
  56.      * @return 用户信息
  57.      */
  58.     @GetMapping("getInfo")
  59.     public AjaxResult getInfo()
  60.     {
  61.         SysUser user = SecurityUtils.getLoginUser().getUser();
  62.         // 角色集合
  63.         Set<String> roles = permissionService.getRolePermission(user);
  64.         // 权限集合
  65.         Set<String> permissions = permissionService.getMenuPermission(user);
  66.         AjaxResult ajax = AjaxResult.success();
  67.         ajax.put("user", user);
  68.         ajax.put("roles", roles);
  69.         ajax.put("permissions", permissions);
  70.         return ajax;
  71.     }
  72.  
  73.     /**
  74.      * 获取路由信息
  75.      *
  76.      * @return 路由信息
  77.      */
  78.     @GetMapping("getRouters")
  79.     public AjaxResult getRouters()
  80.     {
  81.         Long userId = SecurityUtils.getUserId();
  82.         List<SysMenu> menus = menuService.selectMenuTreeByUserId(userId);
  83.         return AjaxResult.success(menuService.buildMenus(menus));
  84.     }
  85. }

加群联系作者vx：xiaoda0423

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/883846
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。