修改鉴权规则

joying-admin/src/main/java/com/fzm/admin/auth/MySaTokenAction.java

-package com.fzm.admin.auth;
-
-import cn.dev33.satoken.action.SaTokenActionDefaultImpl;
-import com.fzm.common.entity.Admin;
-import com.fzm.common.entity.User;
-import com.fzm.common.service.AdminService;
-import com.fzm.common.service.UserService;
-import com.fzm.common.utils.JwtUtil;
-import org.springframework.stereotype.Component;
-
-import javax.annotation.Resource;
-
-/**
- * 继承Sa-Token行为Bean默认实现, 重写部分逻辑
- */
-@Component
-public class MySaTokenAction extends SaTokenActionDefaultImpl {
-
-    @Resource
-    private AdminService adminService;
-
-    /**
-     * 生成自定义token
-     *
-     * @param loginId
-     * @param loginType
-     * @return
-     */
-    @Override
-    public String createToken(Object loginId, String loginType) {
-        Admin loginUser = adminService.getById((Integer) loginId);
-        return JwtUtil.generateToken(loginUser);
-    }
-}

joying-admin/src/main/java/com/fzm/admin/auth/StpServiceImpl.java

-package com.fzm.admin.auth;
-
-import cn.dev33.satoken.stp.StpInterface;
-import org.springframework.stereotype.Component;
-
-import java.util.List;
-
-/**
- * @author tangtuo
- * @date 2021/7/5 15:11
- *
- * <p>
- *     查询当前角色的权限
- * </p>
- */
-@Component
-public class StpServiceImpl implements StpInterface {
-
-
-    @Override
-    public List<String> getPermissionList(Object loginId, String loginType) {
-        return null;
-    }
-
-    @Override
-    public List<String> getRoleList(Object loginId, String loginType) {
-        return null;
-    }
-}

joying-admin/src/main/java/com/fzm/admin/controller/AdminController.java

 package com.fzm.admin.controller;
 
-import com.fzm.common.utils.StpAdminUtil;
+import com.fzm.common.constant.RedisConstant;
+import com.fzm.common.utils.JwtUtil;
+import com.fzm.common.utils.RedisUtil;
 import com.fzm.admin.params.LoginParam;
 import com.fzm.common.constant.TokenConstant;
 import com.fzm.common.entity.Admin;
@@ -14,6 +16,7 @@ import org.springframework.web.bind.annotation.*;
 import javax.annotation.Resource;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.TimeUnit;
 
 /**
  * @author tangtuo
@@ -27,14 +30,18 @@ public class AdminController {
     @Resource
     private AdminService adminService;
 
+    @Resource
+    private RedisUtil redisUtil;
+
     @PostMapping("/login")
     @ApiOperation(value = "登录")
     public ResponseModel<Map<String, Object>> login(@Validated @RequestBody LoginParam loginParam) {
         Admin admin = adminService.login(loginParam.getUsername(), loginParam.getPassword());
-        StpAdminUtil.login(admin.getId());
+        String token = JwtUtil.generateToken(admin);
+        redisUtil.setEx(RedisConstant.ADMIN_USER_TOKEN_PREFIX + admin.getId(), token, 2L, TimeUnit.HOURS);
         HashMap<String, Object> result = new HashMap<>();
         result.put("user", admin);
-        result.put(TokenConstant.TOKEN_HEADER, StpAdminUtil.getTokenValue());
+        result.put(TokenConstant.TOKEN_HEADER, token);
         return ResponseModel.success(result);
     }
 }

joying-admin/src/main/java/com/fzm/admin/controller/CategoryController.java

 package com.fzm.admin.controller;
 
-import cn.dev33.satoken.annotation.SaCheckLogin;
-import com.fzm.common.utils.StpAdminUtil;
+import com.fzm.common.annotation.Authentication;
 import com.fzm.common.entity.Category;
 import com.fzm.common.model.ResponseModel;
 import com.fzm.common.service.CategoryService;
@@ -18,7 +17,7 @@ import java.util.List;
  * @author tangtuo
  * @date 2021/7/1 14:37
  */
-@SaCheckLogin(type = StpAdminUtil.TYPE)
+@Authentication
 @RestController
 @RequestMapping(value = "/category")
 @Api(tags = "类目管理")

joying-admin/src/main/java/com/fzm/admin/controller/LabelController.java

 package com.fzm.admin.controller;
 
-import cn.dev33.satoken.annotation.SaCheckLogin;
-import com.fzm.common.utils.StpAdminUtil;
+import com.fzm.common.annotation.Authentication;
 import com.fzm.common.entity.Label;
 import com.fzm.common.model.ResponseModel;
 import com.fzm.common.service.LabelService;
@@ -18,7 +17,7 @@ import java.util.List;
  * @author tangtuo
  * @date 2021/7/1 14:37
  */
-@SaCheckLogin(type = StpAdminUtil.TYPE)
+@Authentication
 @RestController
 @RequestMapping(value = "/label")
 @Api(tags = "标签管理")

joying-admin/src/main/java/com/fzm/admin/controller/NftController.java

 package com.fzm.admin.controller;
 
-import cn.dev33.satoken.annotation.SaCheckLogin;
-import com.fzm.common.utils.StpAdminUtil;
+import com.fzm.common.annotation.Authentication;
 import com.fzm.common.entity.Nft;
 import com.fzm.common.entity.vo.NftListVo;
 import com.fzm.common.model.ResponseModel;
@@ -18,7 +17,7 @@ import javax.annotation.Resource;
  * @author tangtuo
  * @date 2021/7/5 15:34
  */
-@SaCheckLogin(type = StpAdminUtil.TYPE)
+@Authentication
 @RestController
 @RequestMapping("/nft")
 @Api(tags = "剧本nft管理")

joying-admin/src/main/java/com/fzm/admin/controller/UserController.java

 package com.fzm.admin.controller;
 
-import cn.dev33.satoken.annotation.SaCheckLogin;
-import com.fzm.common.utils.StpAdminUtil;
+import com.fzm.common.annotation.Authentication;
 import com.fzm.common.entity.vo.UserListVo;
 import com.fzm.common.entity.vo.UserStatisticVo;
 import com.fzm.common.model.ResponseModel;
@@ -23,7 +22,7 @@ import java.util.List;
  * @author tangtuo
  * @date 2021/7/5 10:01
  */
-@SaCheckLogin(type = StpAdminUtil.TYPE)
+@Authentication
 @RestController
 @RequestMapping("/admin")
 @Api(tags = "用户管理")

joying-admin/src/main/resources/application-dev.yml

@@ -54,22 +54,6 @@ spring:
     redis:
       # 缓存失效时间
       time-to-live: 86400000
-  # sa-token配置
-  sa-token:
-    # token名称 (同时也是cookie名称)
-    token-name: Authorization
-    # token有效期，单位s, -1代表永不过期
-    timeout: 7200
-    # 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token)
-    is-share: false
-    # token风格
-    #token-style: uuid
-    # 是否输出操作日志
-    is-log: false
-    tokenPrefix: Bearer
-    # 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录)
-    is-concurrent: false
-
 swagger:
   title: 乐映影视后台管理系统
   description: 乐映影视后台管理系统RESTFUL API

joying-admin/src/main/resources/application-local.yml

@@ -54,21 +54,6 @@ spring:
     redis:
       # 缓存失效时间
       time-to-live: 86400000
-  # sa-token配置
-  sa-token:
-    # token名称 (同时也是cookie名称)
-    token-name: Authorization
-    # token有效期，单位s 默认30天, -1代表永不过期
-    timeout: 7200
-    # 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token)
-    is-share: false
-    # token风格
-    #token-style: uuid
-    # 是否输出操作日志
-    is-log: false
-    tokenPrefix: Bearer
-    # 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录)
-    is-concurrent: false
 
 swagger:
   title: 乐映影视乐映影视后台管理系统

joying-admin/src/main/resources/application-test.yml

@@ -54,22 +54,6 @@ spring:
     redis:
       # 缓存失效时间
       time-to-live: 86400000
-  # sa-token配置
-  sa-token:
-    # token名称 (同时也是cookie名称)
-    token-name: Authorization
-    # token有效期，单位s, -1代表永不过期
-    timeout: 7200
-    # 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token)
-    is-share: false
-    # token风格
-    #token-style: uuid
-    # 是否输出操作日志
-    is-log: false
-    tokenPrefix: Bearer
-    # 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录)
-    is-concurrent: false
-
 swagger:
   title: 乐映影视乐映影视后台管理系统
   description: 乐映影视后台管理系统RESTFUL API

joying-common/pom.xml

@@ -53,16 +53,6 @@
             <groupId>org.springframework.security</groupId>
             <artifactId>spring-security-core</artifactId>
         </dependency>
-        <!-- Sa-Token 权限认证, 在线文档：http://sa-token.dev33.cn/ -->
-        <dependency>
-            <groupId>cn.dev33</groupId>
-            <artifactId>sa-token-spring-boot-starter</artifactId>
-        </dependency>
-        <!-- Sa-Token整合redis (使用jackson序列化方式) -->
-        <dependency>
-            <groupId>cn.dev33</groupId>
-            <artifactId>sa-token-dao-redis-jackson</artifactId>
-        </dependency>
         <dependency>
             <groupId>com.aliyun.oss</groupId>
             <artifactId>aliyun-sdk-oss</artifactId>

joying-common/src/main/java/com/fzm/common/annotation/Authentication.java

+package com.fzm.common.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author tangtuo
+ * @date 2021/7/13 14:23
+ */
+@Target(value = {ElementType.METHOD, ElementType.TYPE})
+@Retention(value = RetentionPolicy.RUNTIME)
+public @interface Authentication {
+
+    String[] permissions() default {};
+}

joying-common/src/main/java/com/fzm/common/config/SaTokenConfigure.java → joying-common/src/main/java/com/fzm/common/config/InterceptorConfig.java

 package com.fzm.common.config;
 
-import cn.dev33.satoken.interceptor.SaAnnotationInterceptor;
+import com.fzm.common.interceptor.AuthenticationInterceptor;
+import org.springframework.context.annotation.Bean;
 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 SaTokenConfigure implements WebMvcConfigurer {
-    // 注册Sa-Token的注解拦截器，打开注解式鉴权功能 
+public class InterceptorConfig implements WebMvcConfigurer {
     @Override
     public void addInterceptors(InterceptorRegistry registry) {
-                // 注册注解拦截器，并排除不需要注解鉴权的接口地址 (与登录拦截器无关)
-        registry.addInterceptor(new SaAnnotationInterceptor()).addPathPatterns("/**");
+        registry.addInterceptor(authenticationInterceptor())
+                .addPathPatterns("/**");    // 拦截所有请求，通过判断是否有 @LoginRequired 注解 决定是否需要登录
+    }
+    @Bean
+    public AuthenticationInterceptor authenticationInterceptor() {
+        return new AuthenticationInterceptor();
     }
 }
+

joying-common/src/main/java/com/fzm/common/constant/RedisConstant.java

@@ -11,9 +11,15 @@ public class RedisConstant {
      */
     public static final String COLLECTION_USER_PREFIX = "collection:user:";
 
+    /**
+     * 门户用户token前缀
+     */
+    public static final String PORTAL_USER_TOKEN_PREFIX = "portal:user:token:";
 
-
-
+    /**
+     * 后台管理用户token前缀
+     */
+    public static final String ADMIN_USER_TOKEN_PREFIX = "admin:user:token:";
 
 
 }

joying-common/src/main/java/com/fzm/common/exception/handler/GlobalExceptionHandler.java

 package com.fzm.common.exception.handler;
 
-import cn.dev33.satoken.exception.*;
-import cn.dev33.satoken.stp.StpUtil;
-import cn.hutool.core.date.DateUtil;
-import cn.hutool.http.HttpStatus;
-import com.fzm.common.constant.TokenConstant;
 import com.fzm.common.enums.ResultCode;
 import com.fzm.common.exception.GlobalException;
 import com.fzm.common.model.ResponseModel;
-import com.fzm.common.utils.JwtUtil;
-import com.fzm.common.utils.StpAdminUtil;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.support.DefaultMessageSourceResolvable;
 import org.springframework.validation.ObjectError;
@@ -20,7 +13,6 @@ import org.springframework.web.bind.annotation.RestControllerAdvice;
 import javax.annotation.Resource;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
-import java.util.Date;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -50,37 +42,6 @@ public class GlobalExceptionHandler {
         return ResponseModel.fail(exception);
     }
 
-    @ExceptionHandler(value = SaTokenException.class)
-    public ResponseModel<String> handlerNotLoginException(SaTokenException exception) {
-        log.error(exception.getMessage(), exception);
-        if (exception instanceof NotLoginException) {
-            if (exception.getMessage().contains("token已被顶下线")) {
-                // 获取已过期的token
-                String expireToken = request.getHeader(TokenConstant.TOKEN_HEADER);
-                String appId = JwtUtil.getAppIdFromToken(expireToken);
-                // 从已过期的token中获取用户id
-                Integer userId = JwtUtil.getUserIdFromToken(expireToken);
-                String tokenValue;
-                if (TokenConstant.TOKEN_APP_ID_PORTAL.equals(appId)) {
-                    tokenValue = StpUtil.getTokenValueByLoginId(userId);
-                } else {
-                    tokenValue = StpAdminUtil.getTokenValueByLoginId(userId);
-                }
-                Date createTime = JwtUtil.getCreateTimeFromToken(tokenValue);
-                // 获取最新的token
-                String format = DateUtil.format(createTime, "yyyy-MM-dd HH:mm:ss");
-                return ResponseModel.fail(ResultCode.UNAUTHORIZED,
-                        String.format("您的账号于 %s 登录另外一台设备,如非您本人所为,请立即修改密码", format));
-            } else {
-                return ResponseModel.fail(ResultCode.UNAUTHORIZED, exception.getMessage());
-            }
-        } else if (exception instanceof NotPermissionException || exception instanceof NotRoleException || exception instanceof StopMatchException) {
-            return ResponseModel.fail(ResultCode.FORBIDDEN, ResultCode.FORBIDDEN.getMessage());
-        } else {
-            return ResponseModel.fail(exception);
-        }
-
-    }
 
     @ExceptionHandler(value = {MethodArgumentNotValidException.class})
     public ResponseModel<String> handleMethodArgumentNotValidException(MethodArgumentNotValidException e) {

joying-common/src/main/java/com/fzm/common/interceptor/AuthenticationInterceptor.java

+package com.fzm.common.interceptor;
+
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.ArrayUtil;
+import com.fzm.common.annotation.Authentication;
+import com.fzm.common.constant.RedisConstant;
+import com.fzm.common.constant.TokenConstant;
+import com.fzm.common.entity.AbstractUser;
+import com.fzm.common.enums.ResultCode;
+import com.fzm.common.exception.GlobalException;
+import com.fzm.common.service.AdminService;
+import com.fzm.common.service.UserService;
+import com.fzm.common.utils.JwtUtil;
+import com.fzm.common.utils.RedisUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.web.method.HandlerMethod;
+import org.springframework.web.servlet.HandlerInterceptor;
+import org.springframework.web.servlet.ModelAndView;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.lang.reflect.Method;
+import java.util.Date;
+
+/**
+ * @author tangtuo
+ * @date 2021/7/13 14:30
+ */
+public class AuthenticationInterceptor implements HandlerInterceptor {
+
+    @Resource
+    private RedisUtil redisUtil;
+
+    @Resource
+    private UserService userService;
+
+    @Resource
+    private AdminService adminService;
+
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
+        // 如果不是映射到方法直接通过
+        if (!(handler instanceof HandlerMethod)) {
+            return true;
+        }
+        HandlerMethod handlerMethod = (HandlerMethod) handler;
+        Method method = handlerMethod.getMethod();
+        Class<?> cls = method.getDeclaringClass();
+        // 先判断目标方法所在的类是否加了Authentication注解,再判断目标方法是否加了Authentication注解
+        if (cls.isAnnotationPresent(Authentication.class) || method.isAnnotationPresent(Authentication.class)) {
+            String token = request.getHeader("Authorization");
+            if (StringUtils.isBlank(token)) {
+                throw GlobalException.newException(ResultCode.UNAUTHORIZED, "请先登录");
+            }
+            if (!token.startsWith(TokenConstant.TOKEN_PREFIX)) {
+                throw GlobalException.newException(ResultCode.UNAUTHORIZED, "非法token");
+            }
+            if (JwtUtil.isTokenExpired(token)) {
+                throw GlobalException.newException(ResultCode.UNAUTHORIZED, "登录已过期");
+            }
+            String realToken = token.substring(TokenConstant.TOKEN_PREFIX.length());
+            String appId = JwtUtil.getAppIdFromToken(token);
+            Integer userId = JwtUtil.getUserIdFromToken(token);
+            AbstractUser user;
+            String redisToken;
+            if (TokenConstant.TOKEN_APP_ID_PORTAL.equals(appId)) {
+                // 门户用户
+                user = userService.getById(userId);
+                redisToken = redisUtil.get(RedisConstant.PORTAL_USER_TOKEN_PREFIX + userId);
+            } else {
+                // 后台管理用户
+                user = adminService.getById(userId);
+                redisToken = redisUtil.get(RedisConstant.ADMIN_USER_TOKEN_PREFIX + userId);
+            }
+            if (user == null) {
+                throw GlobalException.newException(ResultCode.UNAUTHORIZED, "非法用户请求");
+            }
+            if (StringUtils.isBlank(redisToken)) {
+                throw GlobalException.newException(ResultCode.UNAUTHORIZED, "登录已过期");
+            }
+            if (!redisToken.equals(realToken)) {
+                Date date = JwtUtil.getCreateTimeFromToken(realToken);
+                String format = DateUtil.format(date, "yyyy-MM-dd HH:mm:ss");
+                throw GlobalException.newException(ResultCode.UNAUTHORIZED,
+                        String.format("您的账号于 %s 登录另外一台设备,如非您本人所为,请立即修改密码", format));
+            }
+            // todo 认证完毕,对后台用户进行鉴权
+            /*if (TokenConstant.TOKEN_APP_ID_ADMIN.equals(appId)) {
+                Authentication annotation = method.getAnnotation(Authentication.class);
+                String[] permissions = annotation.permissions();
+                if (ArrayUtil.isNotEmpty(permissions)) {
+
+                }
+            }*/
+
+        }
+        return true;
+    }
+
+    @Override
+    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
+
+    }
+
+    @Override
+    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
+
+    }
+
+    public static void main(String[] args) {
+        String token = "Bearer token121323433 ";
+        System.out.println(token.substring("Bearer ".length()));
+    }
+}

joying-common/src/main/java/com/fzm/common/service/impl/NftServiceImpl.java

 package com.fzm.common.service.impl;
 
-import cn.dev33.satoken.stp.StpUtil;
 import cn.fzm.chain.simplesdk.client.ParaChainClient;
 import cn.fzm.chain.simplesdk.constant.TxStatusEnum;
 import cn.fzm.chain.simplesdk.model.TxResult;
@@ -13,7 +12,6 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.fzm.common.constant.RedisConstant;
 import com.fzm.common.constant.SystemConstant;
 import com.fzm.common.entity.*;
-import com.fzm.common.entity.TbCollection;
 import com.fzm.common.entity.vo.CollectionNftVo;
 import com.fzm.common.entity.vo.NftListVo;
 import com.fzm.common.enums.ResultCode;
@@ -24,6 +22,7 @@ import com.fzm.common.service.CollectionService;
 import com.fzm.common.service.NftService;
 import com.fzm.common.service.UserService;
 import com.fzm.common.utils.JsonUtil;
+import com.fzm.common.utils.JwtUtil;
 import com.fzm.common.utils.OssUtil;
 import com.fzm.common.utils.RedisUtil;
 import com.github.pagehelper.PageHelper;
@@ -36,6 +35,7 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -69,12 +69,15 @@ public class NftServiceImpl extends ServiceImpl<NftMapper, Nft> implements NftSe
     @Resource
     private OssUtil ossUtil;
 
+    @Resource
+    private HttpServletRequest request;
+
     @Value("${chain.para.contract-name}")
     private String contractName;
 
     @Override
     public NftDto saveNft(Nft nft) {
-        User user = userService.getById(StpUtil.getLoginIdAsInt());
+        User user = userService.getById(JwtUtil.getUserIdFromToken(request.getHeader("Authorization")));
         save(nft);
         NftDto nftDto = new NftDto();
         // 获取用户的钱包地址
@@ -88,7 +91,7 @@ public class NftServiceImpl extends ServiceImpl<NftMapper, Nft> implements NftSe
 
     @Override
     public Boolean publish(NftDto nftDto) {
-        User user = userService.getById(StpUtil.getLoginIdAsInt());
+        User user = userService.getById(JwtUtil.getUserIdFromToken(request.getHeader("Authorization")));
         String wallet = user.getWallet();
         // 获取用户的私钥
         String privkey = paraChainClient.walletDumpPrivkey(wallet);
@@ -154,7 +157,7 @@ public class NftServiceImpl extends ServiceImpl<NftMapper, Nft> implements NftSe
 
     @Override
     public Boolean collection(Integer id) {
-        int userId = StpUtil.getLoginIdAsInt();
+        int userId = JwtUtil.getUserIdFromToken(request.getHeader("Authorization"));
         String key = RedisConstant.COLLECTION_USER_PREFIX + userId;
         // 如果用户收藏的nft已经存在列表里,那么就是取消收藏
         if (redisUtil.sIsMember(key, id.toString())) {
@@ -174,9 +177,9 @@ public class NftServiceImpl extends ServiceImpl<NftMapper, Nft> implements NftSe
 
     @Override
     public List<CollectionNftVo> getCollectionList() {
-        int userId = StpUtil.getLoginIdAsInt();
+        int userId = JwtUtil.getUserIdFromToken(request.getHeader("Authorization"));
         // 从redis里获取当前用户的收藏列表
-        Set<String> set = redisUtil.setMembers(RedisConstant.COLLECTION_USER_PREFIX + StpUtil.getLoginIdAsInt());
+        Set<String> set = redisUtil.setMembers(RedisConstant.COLLECTION_USER_PREFIX + userId);
         List<Integer> list;
         if (CollectionUtil.isEmpty(set)) {
             // redis里为空,再从mysql里查一次

joying-common/src/main/java/com/fzm/common/service/impl/UserServiceImpl.java

 package com.fzm.common.service.impl;
 
-import cn.dev33.satoken.stp.StpUtil;
 import cn.fzm.chain.simplesdk.client.ParaChainClient;
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.date.DateTime;
 import cn.hutool.core.date.DateUtil;
-import cn.hutool.core.lang.UUID;
 import cn.hutool.core.util.IdUtil;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
@@ -23,18 +21,18 @@ import com.fzm.common.params.LoginParam;
 import com.fzm.common.properties.SmsProperties;
 import com.fzm.common.service.AuthPersonService;
 import com.fzm.common.service.UserService;
+import com.fzm.common.utils.JwtUtil;
 import com.fzm.common.utils.RedisUtil;
 import com.fzm.common.utils.SmsUtil;
 import org.apache.commons.lang3.StringUtils;
-import org.springframework.cache.annotation.CacheEvict;
 import org.springframework.cache.annotation.Cacheable;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
 import java.util.List;
-import java.util.stream.Collectors;
 
 /**
  * @author tangtuo
@@ -65,6 +63,9 @@ public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements Us
     @Resource
     private ParaChainClient paraClient;
 
+    @Resource
+    private HttpServletRequest request;
+
     @Override
     public User loadUserByUsername(String username) {
         QueryWrapper<User> wrapper = new QueryWrapper<>();
@@ -121,11 +122,11 @@ public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements Us
 
     @Override
     public User getUserByToken() {
-        String token = StpUtil.getTokenValue();
+        String token = request.getHeader("Authorization");
         if (StringUtils.isBlank(token)) {
             throw GlobalException.newException(ResultCode.UNAUTHORIZED, "您还没有登录,请先登录");
         }
-        Integer userId = StpUtil.getLoginIdAsInt();
+        Integer userId = JwtUtil.getUserIdFromToken(token);
         return getById(userId);
     }
 
@@ -145,7 +146,7 @@ public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements Us
 
     @Override
     public Boolean personAuth(AuthPerson authPerson) {
-        Integer loginId = StpUtil.getLoginIdAsInt();
+        Integer loginId = JwtUtil.getUserIdFromToken(request.getHeader("Authorization"));
         User user = new User().
                 setAuthStatus(AuthStatusEnum.ONGOING.getStatus()).
                 setAuthType(AuthTypeEnum.PERSON.getType()).
@@ -157,7 +158,7 @@ public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements Us
 
     @Override
     public User uploadAvatar(String avatar) {
-        Integer loginId = StpUtil.getLoginIdAsInt();
+        Integer loginId = JwtUtil.getUserIdFromToken(request.getHeader("Authorization"));
         User user = new User().
                 setAvatar(avatar).
                 setId(loginId);

joying-common/src/main/java/com/fzm/common/utils/JwtUtil.java

@@ -2,6 +2,7 @@ package com.fzm.common.utils;
 
 import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.util.StrUtil;
+import com.fzm.common.constant.TokenConstant;
 import com.fzm.common.entity.AbstractUser;
 import com.fzm.common.enums.ResultCode;
 import com.fzm.common.exception.GlobalException;
@@ -26,7 +27,8 @@ public class JwtUtil {
     private static final String CLAIM_KEY_USERID = "userId";
     private static final String CLAIM_KEY_APP_ID = "appId";
     private static final String SECRET = "fzm-ly";
-    private static final Long EXPIRATION = 1000 * 60 * 60 * 24L;
+    private static final Long PORTAL_EXPIRATION = 1000 * 60 * 60 * 24L;
+    private static final Long ADMIN_EXPIRATION = 1000 * 60 * 60 * 2L;
     private static final String TOKEN_PREFIX = "Bearer ";
 
     /**
@@ -35,7 +37,7 @@ public class JwtUtil {
     private static String generateToken(Map<String, Object> claims) {
         return Jwts.builder()
                 .setClaims(claims)
-                .setExpiration(generateExpirationDate())
+                .setExpiration(generateExpirationDate((String) claims.get(CLAIM_KEY_APP_ID)))
                 .signWith(SignatureAlgorithm.HS512, SECRET)
                 .compact();
     }
@@ -60,8 +62,14 @@ public class JwtUtil {
     /**
      * 生成token的过期时间
      */
-    private static Date generateExpirationDate() {
-        return new Date(System.currentTimeMillis() + EXPIRATION * 1000);
+    private static Date generateExpirationDate(String appId) {
+        long expiration;
+        if (TokenConstant.TOKEN_APP_ID_PORTAL.equals(appId)) {
+            expiration = PORTAL_EXPIRATION;
+        } else {
+            expiration = ADMIN_EXPIRATION;
+        }
+        return new Date(System.currentTimeMillis() + expiration);
     }
 
     /**
@@ -114,7 +122,7 @@ public class JwtUtil {
     /**
      * 判断token是否已经失效
      */
-    private static boolean isTokenExpired(String token) {
+    public static boolean isTokenExpired(String token) {
         Date expiredDate = getExpiredDateFromToken(token);
         return expiredDate.before(new Date());
     }
@@ -127,6 +135,7 @@ public class JwtUtil {
         return claims.getExpiration();
     }
 
+
     /**
      * 根据用户信息生成token
      */

joying-common/src/main/java/com/fzm/common/utils/StpAdminUtil.java

-package com.fzm.common.utils;
-
-import cn.dev33.satoken.fun.SaFunction;
-import cn.dev33.satoken.session.SaSession;
-import cn.dev33.satoken.stp.SaLoginModel;
-import cn.dev33.satoken.stp.SaTokenInfo;
-import cn.dev33.satoken.stp.StpLogic;
-import org.springframework.stereotype.Component;
-
-import java.util.List;
-
-/**
- * Sa-Token 权限验证工具类
- *
- * @author kong
- */
-@Component
-public class StpAdminUtil {
-
-    /**
-     * 账号类型标识
-     */
-    public static final String TYPE = "admin";
-
-    /**
-     * 底层的 StpLogic 对象
-     */
-    public static StpLogic stpLogic = new StpLogic(TYPE);
-
-    /**
-     * 获取当前 StpLogic 的账号类型
-     *
-     * @return See Note
-     */
-    public static String getLoginType() {
-        return stpLogic.getLoginType();
-    }
-
-
-    // =================== 获取token 相关 ===================
-
-    /**
-     * 返回token名称
-     *
-     * @return 此StpLogic的token名称
-     */
-    public static String getTokenName() {
-        return stpLogic.getTokenName();
-    }
-
-    /**
-     * 在当前会话写入当前tokenValue
-     *
-     * @param tokenValue    token值
-     * @param cookieTimeout Cookie存活时间(秒)
-     */
-    public static void setTokenValue(String tokenValue, int cookieTimeout) {
-        stpLogic.setTokenValue(tokenValue, cookieTimeout);
-    }
-
-    /**
-     * 获取当前tokenValue
-     *
-     * @return 当前tokenValue
-     */
-    public static String getTokenValue() {
-        return stpLogic.getTokenValue();
-    }
-
-    /**
-     * 获取当前会话的token信息
-     *
-     * @return token信息
-     */
-    public static SaTokenInfo getTokenInfo() {
-        return stpLogic.getTokenInfo();
-    }
-
-
-    // =================== 登录相关操作 ===================
-
-    /**
-     * 会话登录
-     *
-     * @param id 账号id，建议的类型：（long | int | String）
-     */
-    public static void login(Object id) {
-        stpLogic.login(id);
-    }
-
-    /**
-     * 会话登录，并指定登录设备
-     *
-     * @param id     账号id，建议的类型：（long | int | String）
-     * @param device 设备标识
-     */
-    public static void login(Object id, String device) {
-        stpLogic.login(id, device);
-    }
-
-    /**
-     * 会话登录，并指定是否 [记住我]
-     *
-     * @param id              账号id，建议的类型：（long | int | String）
-     * @param isLastingCookie 是否为持久Cookie
-     */
-    public static void login(Object id, boolean isLastingCookie) {
-        stpLogic.login(id, isLastingCookie);
-    }
-
-    /**
-     * 会话登录，并指定所有登录参数Model
-     *
-     * @param id         登录id，建议的类型：（long | int | String）
-     * @param loginModel 此次登录的参数Model
-     */
-    public static void login(Object id, SaLoginModel loginModel) {
-        stpLogic.login(id, loginModel);
-    }
-
-    /**
-     * 当前会话注销登录
-     */
-    public static void logout() {
-        stpLogic.logout();
-    }
-
-    /**
-     * 指定token的会话注销登录
-     *
-     * @param tokenValue 指定token
-     */
-    public static void logoutByTokenValue(String tokenValue) {
-        stpLogic.logoutByTokenValue(tokenValue);
-    }
-
-    /**
-     * 指定账号id的会话注销登录（踢人下线）
-     * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2
-     *
-     * @param loginId 账号id
-     */
-    public static void logoutByLoginId(Object loginId) {
-        stpLogic.logoutByLoginId(loginId);
-    }
-
-    /**
-     * 指定账号id指定设备的会话注销登录（踢人下线）
-     * <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-2
-     *
-     * @param loginId 账号id
-     * @param device  设备标识
-     */
-    public static void logoutByLoginId(Object loginId, String device) {
-        stpLogic.logoutByLoginId(loginId, device);
-    }
-
-    /**
-     * 封禁指定账号
-     * <p> 此方法不会直接将此账号id踢下线，而是在对方再次登录时抛出`DisableLoginException`异常
-     *
-     * @param loginId     指定账号id
-     * @param disableTime 封禁时间, 单位: 秒 （-1=永久封禁）
-     */
-    public static void disable(Object loginId, long disableTime) {
-        stpLogic.disable(loginId, disableTime);
-    }
-
-    /**
-     * 指定账号是否已被封禁 (true=已被封禁, false=未被封禁)
-     *
-     * @param loginId 账号id
-     * @return see note
-     */
-    public static boolean isDisable(Object loginId) {
-        return stpLogic.isDisable(loginId);
-    }
-
-    /**
-     * 获取指定账号剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
-     *
-     * @param loginId 账号id
-     * @return see note
-     */
-    public static long getDisableTime(Object loginId) {
-        return stpLogic.getDisableTime(loginId);
-    }
-
-    /**
-     * 解封指定账号
-     *
-     * @param loginId 账号id
-     */
-    public static void untieDisable(Object loginId) {
-        stpLogic.untieDisable(loginId);
-    }
-
-    // 查询相关
-
-    /**
-     * 获取当前会话是否已经登录
-     *
-     * @return 是否已登录
-     */
-    public static boolean isLogin() {
-        return stpLogic.isLogin();
-    }
-
-    /**
-     * 检验当前会话是否已经登录，如未登录，则抛出异常
-     */
-    public static void checkLogin() {
-        stpLogic.checkLogin();
-    }
-
-    /**
-     * 获取当前会话账号id, 如果未登录，则抛出异常
-     *
-     * @return 账号id
-     */
-    public static Object getLoginId() {
-        return stpLogic.getLoginId();
-    }
-
-    /**
-     * 获取当前会话登录id, 如果未登录，则返回默认值
-     *
-     * @param <T>          返回类型
-     * @param defaultValue 默认值
-     * @return 登录id
-     */
-    public static <T> T getLoginId(T defaultValue) {
-        return stpLogic.getLoginId(defaultValue);
-    }
-
-    /**
-     * 获取当前会话登录id, 如果未登录，则返回null
-     *
-     * @return 账号id
-     */
-    public static Object getLoginIdDefaultNull() {
-        return stpLogic.getLoginIdDefaultNull();
-    }
-
-    /**
-     * 获取当前会话登录id, 并转换为String
-     *
-     * @return 账号id
-     */
-    public static String getLoginIdAsString() {
-        return stpLogic.getLoginIdAsString();
-    }
-
-    /**
-     * 获取当前会话登录id, 并转换为int
-     *
-     * @return 账号id
-     */
-    public static int getLoginIdAsInt() {
-        return stpLogic.getLoginIdAsInt();
-    }
-
-    /**
-     * 获取当前会话登录id, 并转换为long
-     *
-     * @return 账号id
-     */
-    public static long getLoginIdAsLong() {
-        return stpLogic.getLoginIdAsLong();
-    }
-
-    /**
-     * 获取指定token对应的登录id，如果未登录，则返回 null
-     *
-     * @param tokenValue token
-     * @return 登录id
-     */
-    public static Object getLoginIdByToken(String tokenValue) {
-        return stpLogic.getLoginIdByToken(tokenValue);
-    }
-
-
-    // =================== session相关 ===================
-
-    /**
-     * 获取指定loginId的session, 如果session尚未创建，isCreate=是否新建并返回
-     *
-     * @param loginId  账号id
-     * @param isCreate 是否新建
-     * @return SaSession
-     */
-    public static SaSession getSessionByLoginId(Object loginId, boolean isCreate) {
-        return stpLogic.getSessionByLoginId(loginId, isCreate);
-    }
-
-    /**
-     * 获取指定key的session, 如果session尚未创建，则返回null
-     *
-     * @param sessionId sessionId
-     * @return session对象
-     */
-    public static SaSession getSessionBySessionId(String sessionId) {
-        return stpLogic.getSessionBySessionId(sessionId);
-    }
-
-    /**
-     * 获取指定loginId的session，如果session尚未创建，则新建并返回
-     *
-     * @param loginId 账号id
-     * @return session会话
-     */
-    public static SaSession getSessionByLoginId(Object loginId) {
-        return stpLogic.getSessionByLoginId(loginId);
-    }
-
-    /**
-     * 获取当前会话的session, 如果session尚未创建，isCreate=是否新建并返回
-     *
-     * @param isCreate 是否新建
-     * @return 当前会话的session
-     */
-    public static SaSession getSession(boolean isCreate) {
-        return stpLogic.getSession(isCreate);
-    }
-
-    /**
-     * 获取当前会话的session，如果session尚未创建，则新建并返回
-     *
-     * @return 当前会话的session
-     */
-    public static SaSession getSession() {
-        return stpLogic.getSession();
-    }
-
-
-    // =================== token专属session ===================
-
-    /**
-     * 获取指定token的专属session，如果session尚未创建，则新建并返回
-     *
-     * @param tokenValue token值
-     * @return session会话
-     */
-    public static SaSession getTokenSessionByToken(String tokenValue) {
-        return stpLogic.getTokenSessionByToken(tokenValue);
-    }
-
-    /**
-     * 获取当前token的专属-session，如果session尚未创建，则新建并返回
-     *
-     * @return session会话
-     */
-    public static SaSession getTokenSession() {
-        return stpLogic.getTokenSession();
-    }
-
-
-    // =================== [临时过期] 验证相关 ===================
-
-    /**
-     * 检查当前token 是否已经[临时过期]，如果已经过期则抛出异常
-     */
-    public static void checkActivityTimeout() {
-        stpLogic.checkActivityTimeout();
-    }
-
-    /**
-     * 续签当前token：(将 [最后操作时间] 更新为当前时间戳)
-     * <h1>请注意: 即时token已经 [临时过期] 也可续签成功，
-     * 如果此场景下需要提示续签失败，可在此之前调用 checkActivityTimeout() 强制检查是否过期即可 </h1>
-     */
-    public static void updateLastActivityToNow() {
-        stpLogic.updateLastActivityToNow();
-    }
-
-
-    // =================== 过期时间相关 ===================
-
-    /**
-     * 获取当前登录者的token剩余有效时间 (单位: 秒)
-     *
-     * @return token剩余有效时间
-     */
-    public static long getTokenTimeout() {
-        return stpLogic.getTokenTimeout();
-    }
-
-    /**
-     * 获取当前登录者的Session剩余有效时间 (单位: 秒)
-     *
-     * @return token剩余有效时间
-     */
-    public static long getSessionTimeout() {
-        return stpLogic.getSessionTimeout();
-    }
-
-    /**
-     * 获取当前token的专属Session剩余有效时间 (单位: 秒)
-     *
-     * @return token剩余有效时间
-     */
-    public static long getTokenSessionTimeout() {
-        return stpLogic.getTokenSessionTimeout();
-    }
-
-    /**
-     * 获取当前token[临时过期]剩余有效时间 (单位: 秒)
-     *
-     * @return token[临时过期]剩余有效时间
-     */
-    public static long getTokenActivityTimeout() {
-        return stpLogic.getTokenActivityTimeout();
-    }
-
-
-    // =================== 角色验证操作 ===================
-
-    /**
-     * 指定账号id是否含有角色标识, 返回true或false
-     *
-     * @param loginId 账号id
-     * @param role    角色标识
-     * @return 是否含有指定角色标识
-     */
-    public static boolean hasRole(Object loginId, String role) {
-        return stpLogic.hasRole(loginId, role);
-    }
-
-    /**
-     * 当前账号是否含有指定角色标识, 返回true或false
-     *
-     * @param role 角色标识
-     * @return 是否含有指定角色标识
-     */
-    public static boolean hasRole(String role) {
-        return stpLogic.hasRole(role);
-    }
-
-    /**
-     * 当前账号是否含有指定角色标识, 如果验证未通过，则抛出异常: NotRoleException
-     *
-     * @param role 角色标识
-     */
-    public static void checkRole(String role) {
-        stpLogic.checkRole(role);
-    }
-
-    /**
-     * 当前账号是否含有指定角色标识 [指定多个，必须全部验证通过]
-     *
-     * @param roleArray 角色标识数组
-     */
-    public static void checkRoleAnd(String... roleArray) {
-        stpLogic.checkRoleAnd(roleArray);
-    }
-
-    /**
-     * 当前账号是否含有指定角色标识 [指定多个，只要其一验证通过即可]
-     *
-     * @param roleArray 角色标识数组
-     */
-    public static void checkRoleOr(String... roleArray) {
-        stpLogic.checkRoleOr(roleArray);
-    }
-
-
-    // =================== 权限验证操作 ===================
-
-    /**
-     * 指定账号id是否含有指定权限, 返回true或false
-     *
-     * @param loginId    账号id
-     * @param permission 权限码
-     * @return 是否含有指定权限
-     */
-    public static boolean hasPermission(Object loginId, String permission) {
-        return stpLogic.hasPermission(loginId, permission);
-    }
-
-    /**
-     * 当前账号是否含有指定权限, 返回true或false
-     *
-     * @param permission 权限码
-     * @return 是否含有指定权限
-     */
-    public static boolean hasPermission(String permission) {
-        return stpLogic.hasPermission(permission);
-    }
-
-    /**
-     * 当前账号是否含有指定权限, 如果验证未通过，则抛出异常: NotPermissionException
-     *
-     * @param permission 权限码
-     */
-    public static void checkPermission(String permission) {
-        stpLogic.checkPermission(permission);
-    }
-
-    /**
-     * 当前账号是否含有指定权限 [指定多个，必须全部验证通过]
-     *
-     * @param permissionArray 权限码数组
-     */
-    public static void checkPermissionAnd(String... permissionArray) {
-        stpLogic.checkPermissionAnd(permissionArray);
-    }
-
-    /**
-     * 当前账号是否含有指定权限 [指定多个，只要其一验证通过即可]
-     *
-     * @param permissionArray 权限码数组
-     */
-    public static void checkPermissionOr(String... permissionArray) {
-        stpLogic.checkPermissionOr(permissionArray);
-    }
-
-
-    // =================== id 反查token 相关操作 ===================
-
-    /**
-     * 获取指定loginId的tokenValue
-     * <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
-     * 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
-     *
-     * @param loginId 账号id
-     * @return token值
-     */
-    public static String getTokenValueByLoginId(Object loginId) {
-        return stpLogic.getTokenValueByLoginId(loginId);
-    }
-
-    /**
-     * 获取指定loginId指定设备端的tokenValue
-     * <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
-     * 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
-     *
-     * @param loginId 账号id
-     * @param device  设备标识
-     * @return token值
-     */
-    public static String getTokenValueByLoginId(Object loginId, String device) {
-        return stpLogic.getTokenValueByLoginId(loginId, device);
-    }
-
-    /**
-     * 获取指定loginId的tokenValue集合
-     *
-     * @param loginId 账号id
-     * @return 此loginId的所有相关token
-     */
-    public static List<String> getTokenValueListByLoginId(Object loginId) {
-        return stpLogic.getTokenValueListByLoginId(loginId);
-    }
-
-    /**
-     * 获取指定loginId指定设备端的tokenValue集合
-     *
-     * @param loginId 账号id
-     * @param device  设备标识
-     * @return 此loginId的所有相关token
-     */
-    public static List<String> getTokenValueListByLoginId(Object loginId, String device) {
-        return stpLogic.getTokenValueListByLoginId(loginId, device);
-    }
-
-    /**
-     * 返回当前token的登录设备
-     *
-     * @return 当前令牌的登录设备
-     */
-    public static String getLoginDevice() {
-        return stpLogic.getLoginDevice();
-    }
-
-
-    // =================== 会话管理 ===================
-
-    /**
-     * 根据条件查询token
-     *
-     * @param keyword 关键字
-     * @param start   开始处索引 (-1代表查询所有)
-     * @param size    获取数量
-     * @return token集合
-     */
-    public static List<String> searchTokenValue(String keyword, int start, int size) {
-        return stpLogic.searchTokenValue(keyword, start, size);
-    }
-
-    /**
-     * 根据条件查询SessionId
-     *
-     * @param keyword 关键字
-     * @param start   开始处索引 (-1代表查询所有)
-     * @param size    获取数量
-     * @return sessionId集合
-     */
-    public static List<String> searchSessionId(String keyword, int start, int size) {
-        return stpLogic.searchSessionId(keyword, start, size);
-    }
-
-    /**
-     * 根据条件查询token专属Session的Id
-     *
-     * @param keyword 关键字
-     * @param start   开始处索引 (-1代表查询所有)
-     * @param size    获取数量
-     * @return sessionId集合
-     */
-    public static List<String> searchTokenSessionId(String keyword, int start, int size) {
-        return stpLogic.searchTokenSessionId(keyword, start, size);
-    }
-
-
-    // =================== 身份切换 ===================
-
-    /**
-     * 临时切换身份为指定loginId
-     *
-     * @param loginId 指定loginId
-     */
-    public static void switchTo(Object loginId) {
-        stpLogic.switchTo(loginId);
-    }
-
-    /**
-     * 结束临时切换身份
-     */
-    public static void endSwitch() {
-        stpLogic.endSwitch();
-    }
-
-    /**
-     * 当前是否正处于[身份临时切换]中
-     *
-     * @return 是否正处于[身份临时切换]中
-     */
-    public static boolean isSwitch() {
-        return stpLogic.isSwitch();
-    }
-
-    /**
-     * 在一个代码段里方法内，临时切换身份为指定loginId
-     *
-     * @param loginId  指定loginId
-     * @param function 要执行的方法
-     */
-    public static void switchTo(Object loginId, SaFunction function) {
-        stpLogic.switchTo(loginId, function);
-    }
-
-
-    // =================== 历史API，兼容旧版本 ===================
-
-    /**
-     * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.getLoginType() ，使用方式保持不变 </h1>
-     * 获取当前StpLogin的loginKey
-     *
-     * @return 当前StpLogin的loginKey
-     */
-    @Deprecated
-    public static String getLoginKey() {
-        return stpLogic.getLoginType();
-    }
-
-    /**
-     * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
-     * 在当前会话上登录id
-     *
-     * @param loginId 登录id，建议的类型：（long | int | String）
-     */
-    @Deprecated
-    public static void setLoginId(Object loginId) {
-        stpLogic.login(loginId);
-    }
-
-    /**
-     * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
-     * 在当前会话上登录id, 并指定登录设备
-     *
-     * @param loginId 登录id，建议的类型：（long | int | String）
-     * @param device  设备标识
-     */
-    @Deprecated
-    public static void setLoginId(Object loginId, String device) {
-        stpLogic.login(loginId, device);
-    }
-
-    /**
-     * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
-     * 在当前会话上登录id, 并指定登录设备
-     *
-     * @param loginId         登录id，建议的类型：（long | int | String）
-     * @param isLastingCookie 是否为持久Cookie
-     */
-    @Deprecated
-    public static void setLoginId(Object loginId, boolean isLastingCookie) {
-        stpLogic.login(loginId, isLastingCookie);
-    }
-
-    /**
-     * <h1> 本函数设计已过时，未来版本可能移除此函数，请及时更换为 StpUtil.login() ，使用方式保持不变 </h1>
-     * 在当前会话上登录id, 并指定所有登录参数Model
-     *
-     * @param loginId    登录id，建议的类型：（long | int | String）
-     * @param loginModel 此次登录的参数Model
-     */
-    @Deprecated
-    public static void setLoginId(Object loginId, SaLoginModel loginModel) {
-        stpLogic.login(loginId, loginModel);
-    }
-
-}

joying-portal/src/main/java/com/fzm/portal/auth/MySaTokenAction.java

-package com.fzm.portal.auth;
-
-import com.fzm.common.entity.User;
-import com.fzm.common.service.UserService;
-import com.fzm.common.utils.JwtUtil;
-import org.springframework.stereotype.Component;
-import cn.dev33.satoken.action.SaTokenActionDefaultImpl;
-
-import javax.annotation.Resource;
-
-/**
- * 继承Sa-Token行为Bean默认实现, 重写部分逻辑
- */
-@Component
-public class MySaTokenAction extends SaTokenActionDefaultImpl {
-
-    @Resource
-    private UserService userService;
-
-    /**
-     * 生成自定义token
-     *
-     * @param loginId
-     * @param loginType
-     * @return
-     */
-    @Override
-    public String createToken(Object loginId, String loginType) {
-        User loginUser = userService.getById((Integer)loginId);
-        return JwtUtil.generateToken(loginUser);
-    }
-}

joying-portal/src/main/java/com/fzm/portal/auth/StpInterfaceImpl.java

-package com.fzm.portal.auth;
-
-import java.util.ArrayList;
-import java.util.List;
-import org.springframework.stereotype.Component;
-import cn.dev33.satoken.stp.StpInterface;
-
-/**
- * 自定义权限验证接口扩展 
- */
-@Component
-public class StpInterfaceImpl implements StpInterface {
-
-    /**
-     * 返回一个账号所拥有的权限码集合 
-     */
-    @Override
-    public List<String> getPermissionList(Object loginId, String loginType) {
-
-        return null;
-    }
-
-    /**
-     * 返回一个账号所拥有的角色标识集合 (权限与角色可分开校验)
-     */
-    @Override
-    public List<String> getRoleList(Object loginId, String loginType) {
-       return null;
-    }
-
-}

joying-portal/src/main/java/com/fzm/portal/controller/CollectionController.java

 package com.fzm.portal.controller;
 
-import cn.dev33.satoken.annotation.SaCheckLogin;
+import com.fzm.common.annotation.Authentication;
 import com.fzm.common.entity.vo.CollectionNftVo;
 import com.fzm.common.model.ResponseModel;
 import com.fzm.common.service.NftService;
@@ -10,9 +10,7 @@ import io.swagger.annotations.ApiParam;
 import org.springframework.web.bind.annotation.*;
 
 import javax.annotation.Resource;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
 /**
  * @author tangtuo
@@ -26,7 +24,7 @@ public class CollectionController {
     @Resource
     private NftService nftService;
 
-    @SaCheckLogin
+    @Authentication
     @PostMapping("/add")
     @ApiOperation(value = "收藏 | 取消收藏", notes = "用户如果已经收藏了当前作品的话就是取消收藏,反之就是收藏")
     public ResponseModel add(@ApiParam(value = "nft的主键") @RequestParam Integer id) {
@@ -34,10 +32,10 @@ public class CollectionController {
         return ResponseModel.success(result);
     }
 
-    @SaCheckLogin
+    @Authentication
     @GetMapping("/list")
     @ApiOperation(value = "获取用户的收藏列表")
-    private ResponseModel<List<CollectionNftVo>> list() {
+    private ResponseModel<List<CollectionNftVo>> list(@RequestHeader(value = "Authorization") String token) {
         List<CollectionNftVo> list = nftService.getCollectionList();
         return ResponseModel.success(list);
     }

joying-portal/src/main/java/com/fzm/portal/controller/LabelController.java

 package com.fzm.portal.controller;
 
-import com.fzm.common.entity.Category;
 import com.fzm.common.entity.Label;
 import com.fzm.common.model.ResponseModel;
-import com.fzm.common.service.CategoryService;
 import com.fzm.common.service.LabelService;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;

joying-portal/src/main/java/com/fzm/portal/controller/NftController.java

 package com.fzm.portal.controller;
 
-import cn.dev33.satoken.annotation.SaCheckLogin;
-import cn.dev33.satoken.stp.StpUtil;
 import cn.hutool.crypto.SecureUtil;
+import com.fzm.common.annotation.Authentication;
 import com.fzm.common.constant.SystemConstant;
 import com.fzm.common.entity.Nft;
 import com.fzm.common.entity.NftDto;
@@ -16,6 +15,7 @@ import com.fzm.common.model.ResponseModel;
 import com.fzm.common.service.CategoryService;
 import com.fzm.common.service.NftService;
 import com.fzm.common.service.UserService;
+import com.fzm.common.utils.JwtUtil;
 import com.fzm.common.utils.OssUtil;
 import com.fzm.common.utils.QRCodeUtil;
 import io.swagger.annotations.Api;
@@ -27,6 +27,7 @@ import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
 
 import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.List;
@@ -55,6 +56,9 @@ public class NftController {
     @Resource
     private CategoryService categoryService;
 
+    @Resource
+    private HttpServletRequest request;
+
     /**
      * 存证二维码跳转地址
      * todo 修改成动态前端路由
@@ -62,7 +66,7 @@ public class NftController {
     private static final String PATH = "https://chain.33.cn/document/60";
 
 
-    @SaCheckLogin
+    @Authentication
     @PostMapping("/save")
     @ApiOperation(value = "nft基本信息保存(基本信息和加密上链两个步骤)")
     public ResponseModel<NftDto> save(@ApiParam(value = "类目id", required = true) Integer categoryId,
@@ -92,7 +96,7 @@ public class NftController {
             nft.setFileUrl(fileUrl).setIsGrant(isGrant).setFileName(file.getOriginalFilename());
         }
         nft.setCategoryId(categoryId)
-                .setUserId(StpUtil.getLoginIdAsInt())
+                .setUserId(JwtUtil.getUserIdFromToken(request.getHeader("Authorization")))
                 .setName(name)
                 .setAuthor(author)
                 .setTheme(theme)
@@ -103,7 +107,7 @@ public class NftController {
     }
 
 
-    @SaCheckLogin
+    @Authentication
     @PostMapping("/publish")
     @ApiOperation("发行nft")
     public ResponseModel<Boolean> publish(@Validated @RequestBody NftDto nftDto) {
@@ -138,11 +142,11 @@ public class NftController {
         return ResponseModel.success(nftVo);
     }
 
-    @SaCheckLogin
+    @Authentication
     @GetMapping("/list/current")
     @ApiOperation(value = "获取我的nft列表")
     public ResponseModel<Map<String, Object>> listCurrent(@ApiParam(value = "类目id,查询全部的时候传null") @RequestParam(required = false) Integer categoryId) {
-        List<Nft> list = nftService.listCurrent(categoryId, StpUtil.getLoginIdAsInt());
+        List<Nft> list = nftService.listCurrent(categoryId, JwtUtil.getUserIdFromToken(request.getHeader("Authorization")));
         List<CollectionNftVo> nftVoList = list.stream()
                 .map(nft -> new CollectionNftVo(nft, categoryService.getCategoryById(nft.getCategoryId())))
                 .collect(Collectors.toList());
@@ -152,7 +156,7 @@ public class NftController {
         return ResponseModel.success(result);
     }
 
-    @SaCheckLogin
+    @Authentication
     @GetMapping("/generateNftId")
     @ApiOperation(value = "生成nft编号")
     public ResponseModel<String> generateNftId(@ApiParam(value = "类目id", required = true) @RequestParam Integer categoryId) {
@@ -160,7 +164,7 @@ public class NftController {
         return ResponseModel.success(nftId);
     }
 
-    @SaCheckLogin
+    @Authentication
     @PostMapping("/file/md5")
     @ApiOperation(value = "获取文件的md5值")
     public ResponseModel<String> getFileMd5Value(MultipartFile file) throws IOException {
@@ -169,15 +173,15 @@ public class NftController {
     }
 
 
-    @SaCheckLogin
+    @Authentication
     @GetMapping("/certificate/{id}")
     @ApiOperation(value = "nft证书")
-    public ResponseModel<NftCertificateVo> certificate(@PathVariable Integer id) throws Exception {
+    public ResponseModel<NftCertificateVo> certificate(@PathVariable Integer id, @RequestHeader String Authorization) throws Exception {
         Nft nft = nftService.getById(id);
         if (nft == null) {
             throw GlobalException.newException(ResultCode.DATA_ERROR, "没找到此nft的详情");
         }
-        int userId = StpUtil.getLoginIdAsInt();
+        int userId = JwtUtil.getUserIdFromToken(Authorization);
         if (!nft.getUserId().equals(userId)) {
             throw GlobalException.newException(ResultCode.FORBIDDEN, "您无权查看别人的nft证书");
         }

joying-portal/src/main/java/com/fzm/portal/controller/OssController.java

 package com.fzm.portal.controller;
 
-import cn.dev33.satoken.annotation.SaCheckLogin;
+import com.fzm.common.annotation.Authentication;
 import com.fzm.common.model.ResponseModel;
 import com.fzm.common.utils.OssUtil;
 import io.swagger.annotations.Api;
@@ -24,7 +24,7 @@ public class OssController {
     @Resource
     private OssUtil ossUtil;
 
-    @SaCheckLogin
+    @Authentication
     @GetMapping("/policy")
     @ApiOperation("完成oss签名")
     public ResponseModel<Map<String, String>> policy() {

joying-portal/src/main/java/com/fzm/portal/controller/UserController.java

 package com.fzm.portal.controller;
 
-import cn.dev33.satoken.annotation.SaCheckLogin;
-import cn.dev33.satoken.stp.StpUtil;
+import com.fzm.common.annotation.Authentication;
+import com.fzm.common.constant.RedisConstant;
 import com.fzm.common.constant.TokenConstant;
 import com.fzm.common.entity.AuthPerson;
 import com.fzm.common.entity.User;
@@ -10,7 +10,9 @@ import com.fzm.common.exception.GlobalException;
 import com.fzm.common.model.ResponseModel;
 import com.fzm.common.params.LoginParam;
 import com.fzm.common.service.UserService;
+import com.fzm.common.utils.JwtUtil;
 import com.fzm.common.utils.OssUtil;
+import com.fzm.common.utils.RedisUtil;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import org.apache.commons.lang3.StringUtils;
@@ -22,6 +24,7 @@ import javax.annotation.Resource;
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.TimeUnit;
 
 /**
  * @author tangtuo
@@ -38,6 +41,9 @@ public class UserController {
     @Resource
     private OssUtil ossUtil;
 
+    @Resource
+    private RedisUtil redisUtil;
+
     @PostMapping(value = "/login")
     @ApiOperation(value = "登录|注册")
     public ResponseModel<Map<String, Object>> login(@RequestBody @Validated LoginParam param) {
@@ -54,10 +60,11 @@ public class UserController {
             throw GlobalException.newException(ResultCode.VALIDATE_FAILED, "密码和验证码只能一个为空");
         }
         User user = userService.login(param);
-        StpUtil.login(user.getId());
+        String token = JwtUtil.generateToken(user);
+        redisUtil.setEx(RedisConstant.PORTAL_USER_TOKEN_PREFIX + user.getId(), token, 24L, TimeUnit.HOURS);
         HashMap<String, Object> result = new HashMap<>();
         result.put("user", user);
-        result.put(TokenConstant.TOKEN_HEADER, StpUtil.getTokenValue());
+        result.put(TokenConstant.TOKEN_HEADER, token);
         return ResponseModel.success(result);
     }
 
@@ -79,17 +86,17 @@ public class UserController {
         return ResponseModel.success();
     }
 
-    @SaCheckLogin
+    @Authentication
     @ApiOperation(value = "修改昵称 | 修改个性签名", notes = "用户修改哪项信息就传那一个参数就可以了")
     @PostMapping("/update")
-    public ResponseModel<User> update(@Validated @RequestBody User user) {
-        Integer userId = StpUtil.getLoginIdAsInt();
+    public ResponseModel<User> update(@Validated @RequestBody User user, @RequestHeader String Authorization) {
+        Integer userId = JwtUtil.getUserIdFromToken(Authorization);
         user.setId(userId);
         userService.updateById(user);
         return ResponseModel.success(userService.getById(userId));
     }
 
-    @SaCheckLogin
+    @Authentication
     @ApiOperation(value = "上传头像")
     @PostMapping("/upload/avatar")
     public ResponseModel<User> uploadAvatar(MultipartFile file) throws IOException {
@@ -98,7 +105,7 @@ public class UserController {
         return ResponseModel.success(user);
     }
 
-    @SaCheckLogin
+    @Authentication
     @GetMapping("/detail")
     @ApiOperation(value = "获取用户详情")
     public ResponseModel<User> getUserDetail() {
@@ -106,7 +113,7 @@ public class UserController {
     }
 
 
-    @SaCheckLogin
+    @Authentication
     @PostMapping("/auth/person")
     @ApiOperation(value = "个人认证")
     public ResponseModel<Boolean> personAuth(@RequestBody @Validated AuthPerson authPerson) {
@@ -114,7 +121,7 @@ public class UserController {
     }
 
 
-    @SaCheckLogin
+    @Authentication
     @PostMapping("/auth/enterprise")
     @ApiOperation(value = "企业认证")
     public ResponseModel<Boolean> enterpriseAuth() {

joying-portal/src/main/resources/application-dev.yml

@@ -60,21 +60,6 @@ spring:
       simple:
         ####开启手动签收
         acknowledge-mode: manual
-  # sa-token配置
-  sa-token:
-    # token名称 (同时也是cookie名称)
-    token-name: Authorization
-    # token有效期，单位s 默认30天, -1代表永不过期
-    timeout: 86400
-    # 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token)
-    is-share: false
-    # token风格
-    #token-style: uuid
-    # 是否输出操作日志
-    is-log: true
-    tokenPrefix: Bearer
-    # 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录)
-    is-concurrent: false
 
 swagger:
   title: 乐映影视门户系统

joying-portal/src/main/resources/application-local.yml

@@ -60,21 +60,6 @@ spring:
       simple:
         ####开启手动签收
         acknowledge-mode: manual
-  # sa-token配置
-  sa-token:
-    # token名称 (同时也是cookie名称)
-    token-name: Authorization
-    # token临时有效期 (指定时间内无操作就视为token过期) 单位: 秒
-    timeout: 86400
-    # 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token)
-    is-share: false
-    # token风格
-    #token-style: uuid
-    # 是否输出操作日志
-    is-log: true
-    tokenPrefix: Bearer
-    # 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录)
-    is-concurrent: false
 
 swagger:
   title: 乐映影视门户系统

joying-portal/src/main/resources/application-test.yml

@@ -60,21 +60,6 @@ spring:
       simple:
         ####开启手动签收
         acknowledge-mode: manual
-  # sa-token配置
-  sa-token:
-    # token名称 (同时也是cookie名称)
-    token-name: Authorization
-    # token有效期，单位s 默认30天, -1代表永不过期
-    timeout: 86400
-    # 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token)
-    is-share: false
-    # token风格
-    #token-style: uuid
-    # 是否输出操作日志
-    is-log: true
-    tokenPrefix: Bearer
-    # 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录)
-    is-concurrent: false
 
 swagger:
   title: 乐映影视门户系统