From b642bd7d84ae5f2eb9a3902fb2c9547bd340aeb1 Mon Sep 17 00:00:00 2001 From: LQS <2506203757@qq.com> Date: Wed, 24 Jul 2024 20:41:37 +0800 Subject: [PATCH] =?UTF-8?q?=E5=88=9D=E5=A7=8B=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .idea/.gitignore | 8 + .idea/compiler.xml | 13 + .idea/encodings.xml | 7 + .idea/jarRepositories.xml | 35 ++ .idea/misc.xml | 18 + .idea/vcs.xml | 6 + pom.xml | 39 +++ .../annotation/EnableCustomConfig.java | 26 ++ .../annotation/EnableMyFeignClients.java | 27 ++ .../common/security/annotation/InnerAuth.java | 18 + .../common/security/annotation/Logical.java | 18 + .../security/annotation/RequiresLogin.java | 16 + .../annotation/RequiresPermissions.java | 25 ++ .../security/annotation/RequiresRoles.java | 25 ++ .../security/aspect/InnerAuthAspect.java | 46 +++ .../security/aspect/PreAuthorizeAspect.java | 89 +++++ .../muyu/common/security/auth/AuthLogic.java | 327 ++++++++++++++++++ .../muyu/common/security/auth/AuthUtil.java | 154 +++++++++ .../security/config/ApplicationConfig.java | 21 ++ .../common/security/config/WebMvcConfig.java | 32 ++ .../feign/FeignAutoConfiguration.java | 18 + .../feign/FeignRequestInterceptor.java | 48 +++ .../handler/GlobalExceptionHandler.java | 147 ++++++++ .../interceptor/HeaderInterceptor.java | 50 +++ .../common/security/service/TokenService.java | 153 ++++++++ .../muyu/common/security/utils/DictUtils.java | 71 ++++ .../common/security/utils/SecurityUtils.java | 109 ++++++ ...ot.autoconfigure.AutoConfiguration.imports | 5 + ...ot.autoconfigure.AutoConfiguration.imports | 5 + .../annotation/EnableCustomConfig.class | Bin 0 -> 913 bytes .../annotation/EnableMyFeignClients.class | Bin 0 -> 827 bytes .../security/annotation/InnerAuth.class | Bin 0 -> 504 bytes .../common/security/annotation/Logical.class | Bin 0 -> 1127 bytes .../security/annotation/RequiresLogin.class | Bin 0 -> 427 bytes .../annotation/RequiresPermissions.class | Bin 0 -> 633 bytes .../security/annotation/RequiresRoles.class | Bin 0 -> 621 bytes .../security/aspect/InnerAuthAspect.class | Bin 0 -> 2122 bytes .../security/aspect/PreAuthorizeAspect.class | Bin 0 -> 2733 bytes .../muyu/common/security/auth/AuthLogic.class | Bin 0 -> 7638 bytes .../muyu/common/security/auth/AuthUtil.class | Bin 0 -> 2401 bytes .../security/config/ApplicationConfig.class | Bin 0 -> 1631 bytes .../common/security/config/WebMvcConfig.class | Bin 0 -> 1684 bytes .../feign/FeignAutoConfiguration.class | Bin 0 -> 691 bytes .../feign/FeignRequestInterceptor.class | Bin 0 -> 2067 bytes .../handler/GlobalExceptionHandler.class | Bin 0 -> 7704 bytes .../interceptor/HeaderInterceptor.class | Bin 0 -> 2356 bytes .../security/service/TokenService.class | Bin 0 -> 5797 bytes .../common/security/utils/DictUtils.class | Bin 0 -> 2819 bytes .../common/security/utils/SecurityUtils.class | Bin 0 -> 2697 bytes target/cloud-common-security-3.6.3.jar | Bin 0 -> 27609 bytes target/maven-archiver/pom.properties | 5 + .../compile/default-compile/createdFiles.lst | 20 ++ .../compile/default-compile/inputFiles.lst | 20 ++ 53 files changed, 1601 insertions(+) create mode 100644 .idea/.gitignore create mode 100644 .idea/compiler.xml create mode 100644 .idea/encodings.xml create mode 100644 .idea/jarRepositories.xml create mode 100644 .idea/misc.xml create mode 100644 .idea/vcs.xml create mode 100644 pom.xml create mode 100644 src/main/java/com/muyu/common/security/annotation/EnableCustomConfig.java create mode 100644 src/main/java/com/muyu/common/security/annotation/EnableMyFeignClients.java create mode 100644 src/main/java/com/muyu/common/security/annotation/InnerAuth.java create mode 100644 src/main/java/com/muyu/common/security/annotation/Logical.java create mode 100644 src/main/java/com/muyu/common/security/annotation/RequiresLogin.java create mode 100644 src/main/java/com/muyu/common/security/annotation/RequiresPermissions.java create mode 100644 src/main/java/com/muyu/common/security/annotation/RequiresRoles.java create mode 100644 src/main/java/com/muyu/common/security/aspect/InnerAuthAspect.java create mode 100644 src/main/java/com/muyu/common/security/aspect/PreAuthorizeAspect.java create mode 100644 src/main/java/com/muyu/common/security/auth/AuthLogic.java create mode 100644 src/main/java/com/muyu/common/security/auth/AuthUtil.java create mode 100644 src/main/java/com/muyu/common/security/config/ApplicationConfig.java create mode 100644 src/main/java/com/muyu/common/security/config/WebMvcConfig.java create mode 100644 src/main/java/com/muyu/common/security/feign/FeignAutoConfiguration.java create mode 100644 src/main/java/com/muyu/common/security/feign/FeignRequestInterceptor.java create mode 100644 src/main/java/com/muyu/common/security/handler/GlobalExceptionHandler.java create mode 100644 src/main/java/com/muyu/common/security/interceptor/HeaderInterceptor.java create mode 100644 src/main/java/com/muyu/common/security/service/TokenService.java create mode 100644 src/main/java/com/muyu/common/security/utils/DictUtils.java create mode 100644 src/main/java/com/muyu/common/security/utils/SecurityUtils.java create mode 100644 src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports create mode 100644 target/classes/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports create mode 100644 target/classes/com/muyu/common/security/annotation/EnableCustomConfig.class create mode 100644 target/classes/com/muyu/common/security/annotation/EnableMyFeignClients.class create mode 100644 target/classes/com/muyu/common/security/annotation/InnerAuth.class create mode 100644 target/classes/com/muyu/common/security/annotation/Logical.class create mode 100644 target/classes/com/muyu/common/security/annotation/RequiresLogin.class create mode 100644 target/classes/com/muyu/common/security/annotation/RequiresPermissions.class create mode 100644 target/classes/com/muyu/common/security/annotation/RequiresRoles.class create mode 100644 target/classes/com/muyu/common/security/aspect/InnerAuthAspect.class create mode 100644 target/classes/com/muyu/common/security/aspect/PreAuthorizeAspect.class create mode 100644 target/classes/com/muyu/common/security/auth/AuthLogic.class create mode 100644 target/classes/com/muyu/common/security/auth/AuthUtil.class create mode 100644 target/classes/com/muyu/common/security/config/ApplicationConfig.class create mode 100644 target/classes/com/muyu/common/security/config/WebMvcConfig.class create mode 100644 target/classes/com/muyu/common/security/feign/FeignAutoConfiguration.class create mode 100644 target/classes/com/muyu/common/security/feign/FeignRequestInterceptor.class create mode 100644 target/classes/com/muyu/common/security/handler/GlobalExceptionHandler.class create mode 100644 target/classes/com/muyu/common/security/interceptor/HeaderInterceptor.class create mode 100644 target/classes/com/muyu/common/security/service/TokenService.class create mode 100644 target/classes/com/muyu/common/security/utils/DictUtils.class create mode 100644 target/classes/com/muyu/common/security/utils/SecurityUtils.class create mode 100644 target/cloud-common-security-3.6.3.jar create mode 100644 target/maven-archiver/pom.properties create mode 100644 target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst create mode 100644 target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..13566b8 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Editor-based HTTP Client requests +/httpRequests/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/.idea/compiler.xml b/.idea/compiler.xml new file mode 100644 index 0000000..7f16c29 --- /dev/null +++ b/.idea/compiler.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/encodings.xml b/.idea/encodings.xml new file mode 100644 index 0000000..aa00ffa --- /dev/null +++ b/.idea/encodings.xml @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml new file mode 100644 index 0000000..e6fa7ca --- /dev/null +++ b/.idea/jarRepositories.xml @@ -0,0 +1,35 @@ + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..9e1cc11 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,18 @@ + + + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..f1a480a --- /dev/null +++ b/pom.xml @@ -0,0 +1,39 @@ + + + + com.muyu + cloud-common + 3.6.3 + + 4.0.0 + + cloud-common-security + + + cloud-common-security安全模块 + + + + + + + org.springframework + spring-webmvc + + + + + com.muyu + cloud-common-redis + + + + + com.muyu + cloud-common-system + + + + + diff --git a/src/main/java/com/muyu/common/security/annotation/EnableCustomConfig.java b/src/main/java/com/muyu/common/security/annotation/EnableCustomConfig.java new file mode 100644 index 0000000..ca7a07a --- /dev/null +++ b/src/main/java/com/muyu/common/security/annotation/EnableCustomConfig.java @@ -0,0 +1,26 @@ +package com.muyu.common.security.annotation; + +import com.muyu.common.security.config.ApplicationConfig; +import com.muyu.common.security.feign.FeignAutoConfiguration; +import org.mybatis.spring.annotation.MapperScan; +import org.springframework.context.annotation.EnableAspectJAutoProxy; +import org.springframework.context.annotation.Import; +import org.springframework.scheduling.annotation.EnableAsync; + +import java.lang.annotation.*; + +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +@Documented +@Inherited +// 表示通过aop框架暴露该代理对象,AopContext能够访问 +@EnableAspectJAutoProxy(exposeProxy = true) +// 指定要扫描的Mapper类的包的路径 +@MapperScan("com.muyu.**.mapper") +// 开启线程异步执行 +@EnableAsync +// 自动加载类 +@Import({ApplicationConfig.class, FeignAutoConfiguration.class}) +public @interface EnableCustomConfig { + +} diff --git a/src/main/java/com/muyu/common/security/annotation/EnableMyFeignClients.java b/src/main/java/com/muyu/common/security/annotation/EnableMyFeignClients.java new file mode 100644 index 0000000..7a59fa4 --- /dev/null +++ b/src/main/java/com/muyu/common/security/annotation/EnableMyFeignClients.java @@ -0,0 +1,27 @@ +package com.muyu.common.security.annotation; + +import org.springframework.cloud.openfeign.EnableFeignClients; + +import java.lang.annotation.*; + +/** + * 自定义feign注解 + * 添加basePackages路径 + * + * @author muyu + */ +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +@Documented +@EnableFeignClients +public @interface EnableMyFeignClients { + String[] value () default {}; + + String[] basePackages () default {"com.muyu"}; + + Class[] basePackageClasses () default {}; + + Class[] defaultConfiguration () default {}; + + Class[] clients () default {}; +} diff --git a/src/main/java/com/muyu/common/security/annotation/InnerAuth.java b/src/main/java/com/muyu/common/security/annotation/InnerAuth.java new file mode 100644 index 0000000..092a573 --- /dev/null +++ b/src/main/java/com/muyu/common/security/annotation/InnerAuth.java @@ -0,0 +1,18 @@ +package com.muyu.common.security.annotation; + +import java.lang.annotation.*; + +/** + * 内部认证注解 + * + * @author muyu + */ +@Target(ElementType.METHOD) +@Retention(RetentionPolicy.RUNTIME) +@Documented +public @interface InnerAuth { + /** + * 是否校验用户信息 + */ + boolean isUser () default false; +} diff --git a/src/main/java/com/muyu/common/security/annotation/Logical.java b/src/main/java/com/muyu/common/security/annotation/Logical.java new file mode 100644 index 0000000..0be306a --- /dev/null +++ b/src/main/java/com/muyu/common/security/annotation/Logical.java @@ -0,0 +1,18 @@ +package com.muyu.common.security.annotation; + +/** + * 权限注解的验证模式 + * + * @author muyu + */ +public enum Logical { + /** + * 必须具有所有的元素 + */ + AND, + + /** + * 只需具有其中一个元素 + */ + OR +} diff --git a/src/main/java/com/muyu/common/security/annotation/RequiresLogin.java b/src/main/java/com/muyu/common/security/annotation/RequiresLogin.java new file mode 100644 index 0000000..4eff911 --- /dev/null +++ b/src/main/java/com/muyu/common/security/annotation/RequiresLogin.java @@ -0,0 +1,16 @@ +package com.muyu.common.security.annotation; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * 登录认证：只有登录之后才能进入该方法 + * + * @author muyu + */ +@Retention(RetentionPolicy.RUNTIME) +@Target({ElementType.METHOD, ElementType.TYPE}) +public @interface RequiresLogin { +} diff --git a/src/main/java/com/muyu/common/security/annotation/RequiresPermissions.java b/src/main/java/com/muyu/common/security/annotation/RequiresPermissions.java new file mode 100644 index 0000000..8d95bb4 --- /dev/null +++ b/src/main/java/com/muyu/common/security/annotation/RequiresPermissions.java @@ -0,0 +1,25 @@ +package com.muyu.common.security.annotation; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * 权限认证：必须具有指定权限才能进入该方法 + * + * @author muyu + */ +@Retention(RetentionPolicy.RUNTIME) +@Target({ElementType.METHOD, ElementType.TYPE}) +public @interface RequiresPermissions { + /** + * 需要校验的权限码 + */ + String[] value () default {}; + + /** + * 验证模式：AND | OR，默认AND + */ + Logical logical () default Logical.AND; +} diff --git a/src/main/java/com/muyu/common/security/annotation/RequiresRoles.java b/src/main/java/com/muyu/common/security/annotation/RequiresRoles.java new file mode 100644 index 0000000..78911cc --- /dev/null +++ b/src/main/java/com/muyu/common/security/annotation/RequiresRoles.java @@ -0,0 +1,25 @@ +package com.muyu.common.security.annotation; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * 角色认证：必须具有指定角色标识才能进入该方法 + * + * @author muyu + */ +@Retention(RetentionPolicy.RUNTIME) +@Target({ElementType.METHOD, ElementType.TYPE}) +public @interface RequiresRoles { + /** + * 需要校验的角色标识 + */ + String[] value () default {}; + + /** + * 验证逻辑：AND | OR，默认AND + */ + Logical logical () default Logical.AND; +} diff --git a/src/main/java/com/muyu/common/security/aspect/InnerAuthAspect.java b/src/main/java/com/muyu/common/security/aspect/InnerAuthAspect.java new file mode 100644 index 0000000..1707742 --- /dev/null +++ b/src/main/java/com/muyu/common/security/aspect/InnerAuthAspect.java @@ -0,0 +1,46 @@ +package com.muyu.common.security.aspect; + +import com.muyu.common.core.constant.SecurityConstants; +import com.muyu.common.core.exception.InnerAuthException; +import com.muyu.common.core.utils.ServletUtils; +import com.muyu.common.core.utils.StringUtils; +import com.muyu.common.security.annotation.InnerAuth; +import org.aspectj.lang.ProceedingJoinPoint; +import org.aspectj.lang.annotation.Around; +import org.aspectj.lang.annotation.Aspect; +import org.springframework.core.Ordered; +import org.springframework.stereotype.Component; + +/** + * 内部服务调用验证处理 + * + * @author muyu + */ +@Aspect +@Component +public class InnerAuthAspect implements Ordered { + @Around("@annotation(innerAuth)") + public Object innerAround (ProceedingJoinPoint point, InnerAuth innerAuth) throws Throwable { + String source = ServletUtils.getRequest().getHeader(SecurityConstants.FROM_SOURCE); + // 内部请求验证 + if (!StringUtils.equals(SecurityConstants.INNER, source)) { + throw new InnerAuthException("没有内部访问权限，不允许访问"); + } + + String userid = ServletUtils.getRequest().getHeader(SecurityConstants.DETAILS_USER_ID); + String username = ServletUtils.getRequest().getHeader(SecurityConstants.DETAILS_USERNAME); + // 用户信息验证 + if (innerAuth.isUser() && (StringUtils.isEmpty(userid) || StringUtils.isEmpty(username))) { + throw new InnerAuthException("没有设置用户信息，不允许访问 "); + } + return point.proceed(); + } + + /** + * 确保在权限认证aop执行前执行 + */ + @Override + public int getOrder () { + return Ordered.HIGHEST_PRECEDENCE + 1; + } +} diff --git a/src/main/java/com/muyu/common/security/aspect/PreAuthorizeAspect.java b/src/main/java/com/muyu/common/security/aspect/PreAuthorizeAspect.java new file mode 100644 index 0000000..4cdd933 --- /dev/null +++ b/src/main/java/com/muyu/common/security/aspect/PreAuthorizeAspect.java @@ -0,0 +1,89 @@ +package com.muyu.common.security.aspect; + +import com.muyu.common.security.annotation.RequiresLogin; +import com.muyu.common.security.annotation.RequiresPermissions; +import com.muyu.common.security.annotation.RequiresRoles; +import com.muyu.common.security.auth.AuthUtil; +import org.aspectj.lang.ProceedingJoinPoint; +import org.aspectj.lang.annotation.Around; +import org.aspectj.lang.annotation.Aspect; +import org.aspectj.lang.annotation.Pointcut; +import org.aspectj.lang.reflect.MethodSignature; +import org.springframework.stereotype.Component; + +import java.lang.reflect.Method; + +/** + * 基于 Spring Aop 的注解鉴权 + * + * @author kong + */ +@Aspect +@Component +public class PreAuthorizeAspect { + /** + * 定义AOP签名 (切入所有使用鉴权注解的方法) + */ + public static final String POINTCUT_SIGN = " @annotation(com.muyu.common.security.annotation.RequiresLogin) || " + + "@annotation(com.muyu.common.security.annotation.RequiresPermissions) || " + + "@annotation(com.muyu.common.security.annotation.RequiresRoles)"; + + /** + * 构建 + */ + public PreAuthorizeAspect () { + } + + /** + * 声明AOP签名 + */ + @Pointcut(POINTCUT_SIGN) + public void pointcut () { + } + + /** + * 环绕切入 + * + * @param joinPoint 切面对象 + * + * @return 底层方法执行后的返回值 + * + * @throws Throwable 底层方法抛出的异常 + */ + @Around("pointcut()") + public Object around (ProceedingJoinPoint joinPoint) throws Throwable { + // 注解鉴权 + MethodSignature signature = (MethodSignature) joinPoint.getSignature(); + checkMethodAnnotation(signature.getMethod()); + try { + // 执行原有逻辑 + Object obj = joinPoint.proceed(); + return obj; + } catch (Throwable e) { + throw e; + } + } + + /** + * 对一个Method对象进行注解检查 + */ + public void checkMethodAnnotation (Method method) { + // 校验 @RequiresLogin 注解 + RequiresLogin requiresLogin = method.getAnnotation(RequiresLogin.class); + if (requiresLogin != null) { + AuthUtil.checkLogin(); + } + + // 校验 @RequiresRoles 注解 + RequiresRoles requiresRoles = method.getAnnotation(RequiresRoles.class); + if (requiresRoles != null) { + AuthUtil.checkRole(requiresRoles); + } + + // 校验 @RequiresPermissions 注解 + RequiresPermissions requiresPermissions = method.getAnnotation(RequiresPermissions.class); + if (requiresPermissions != null) { + AuthUtil.checkPermi(requiresPermissions); + } + } +} diff --git a/src/main/java/com/muyu/common/security/auth/AuthLogic.java b/src/main/java/com/muyu/common/security/auth/AuthLogic.java new file mode 100644 index 0000000..beb3426 --- /dev/null +++ b/src/main/java/com/muyu/common/security/auth/AuthLogic.java @@ -0,0 +1,327 @@ +package com.muyu.common.security.auth; + +import com.muyu.common.core.context.SecurityContextHolder; +import com.muyu.common.core.exception.auth.NotLoginException; +import com.muyu.common.core.exception.auth.NotPermissionException; +import com.muyu.common.core.exception.auth.NotRoleException; +import com.muyu.common.core.utils.SpringUtils; +import com.muyu.common.core.utils.StringUtils; +import com.muyu.common.security.annotation.Logical; +import com.muyu.common.security.annotation.RequiresLogin; +import com.muyu.common.security.annotation.RequiresPermissions; +import com.muyu.common.security.annotation.RequiresRoles; +import com.muyu.common.security.service.TokenService; +import com.muyu.common.security.utils.SecurityUtils; +import com.muyu.common.system.domain.LoginUser; +import org.springframework.util.PatternMatchUtils; + +import java.util.Collection; +import java.util.HashSet; +import java.util.Set; + +/** + * Token 权限验证，逻辑实现类 + * + * @author muyu + */ +public class AuthLogic { + /** + * 所有权限标识 + */ + private static final String ALL_PERMISSION = "*:*:*"; + + /** + * 管理员角色权限标识 + */ + private static final String SUPER_ADMIN = "admin"; + + public TokenService tokenService = SpringUtils.getBean(TokenService.class); + + /** + * 会话注销 + */ + public void logout () { + String token = SecurityUtils.getToken(); + if (token == null) { + return; + } + logoutByToken(token); + } + + /** + * 会话注销，根据指定Token + */ + public void logoutByToken (String token) { + tokenService.delLoginUser(token); + } + + /** + * 检验用户是否已经登录，如未登录，则抛出异常 + */ + public void checkLogin () { + getLoginUser(); + } + + /** + * 获取当前用户缓存信息, 如果未登录，则抛出异常 + * + * @return 用户缓存信息 + */ + public LoginUser getLoginUser () { + String token = SecurityUtils.getToken(); + if (token == null) { + throw new NotLoginException("未提供token"); + } + LoginUser loginUser = SecurityUtils.getLoginUser(); + if (loginUser == null) { + throw new NotLoginException("无效的token"); + } + return loginUser; + } + + /** + * 获取当前用户缓存信息, 如果未登录，则抛出异常 + * + * @param token 前端传递的认证信息 + * + * @return 用户缓存信息 + */ + public LoginUser getLoginUser (String token) { + return tokenService.getLoginUser(token); + } + + /** + * 验证当前用户有效期, 如果相差不足120分钟，自动刷新缓存 + * + * @param loginUser 当前用户信息 + */ + public void verifyLoginUserExpire (LoginUser loginUser) { + tokenService.verifyToken(loginUser); + } + + /** + * 验证用户是否具备某权限 + * + * @param permission 权限字符串 + * + * @return 用户是否具备某权限 + */ + public boolean hasPermi (String permission) { + return hasPermi(getPermiList(), permission); + } + + /** + * 验证用户是否具备某权限, 如果验证未通过，则抛出异常: NotPermissionException + * + * @param permission 权限字符串 + * + * @return 用户是否具备某权限 + */ + public void checkPermi (String permission) { + if (!hasPermi(getPermiList(), permission)) { + throw new NotPermissionException(permission); + } + } + + /** + * 根据注解(@RequiresPermissions)鉴权, 如果验证未通过，则抛出异常: NotPermissionException + * + * @param requiresPermissions 注解对象 + */ + public void checkPermi (RequiresPermissions requiresPermissions) { + SecurityContextHolder.setPermission(StringUtils.join(requiresPermissions.value(), ",")); + if (requiresPermissions.logical() == Logical.AND) { + checkPermiAnd(requiresPermissions.value()); + } else { + checkPermiOr(requiresPermissions.value()); + } + } + + /** + * 验证用户是否含有指定权限，必须全部拥有 + * + * @param permissions 权限列表 + */ + public void checkPermiAnd (String... permissions) { + Set permissionList = getPermiList(); + for (String permission : permissions) { + if (!hasPermi(permissionList, permission)) { + throw new NotPermissionException(permission); + } + } + } + + /** + * 验证用户是否含有指定权限，只需包含其中一个 + * + * @param permissions 权限码数组 + */ + public void checkPermiOr (String... permissions) { + Set permissionList = getPermiList(); + for (String permission : permissions) { + if (hasPermi(permissionList, permission)) { + return; + } + } + if (permissions.length > 0) { + throw new NotPermissionException(permissions); + } + } + + /** + * 判断用户是否拥有某个角色 + * + * @param role 角色标识 + * + * @return 用户是否具备某角色 + */ + public boolean hasRole (String role) { + return hasRole(getRoleList(), role); + } + + /** + * 判断用户是否拥有某个角色, 如果验证未通过，则抛出异常: NotRoleException + * + * @param role 角色标识 + */ + public void checkRole (String role) { + if (!hasRole(role)) { + throw new NotRoleException(role); + } + } + + /** + * 根据注解(@RequiresRoles)鉴权 + * + * @param requiresRoles 注解对象 + */ + public void checkRole (RequiresRoles requiresRoles) { + if (requiresRoles.logical() == Logical.AND) { + checkRoleAnd(requiresRoles.value()); + } else { + checkRoleOr(requiresRoles.value()); + } + } + + /** + * 验证用户是否含有指定角色，必须全部拥有 + * + * @param roles 角色标识数组 + */ + public void checkRoleAnd (String... roles) { + Set roleList = getRoleList(); + for (String role : roles) { + if (!hasRole(roleList, role)) { + throw new NotRoleException(role); + } + } + } + + /** + * 验证用户是否含有指定角色，只需包含其中一个 + * + * @param roles 角色标识数组 + */ + public void checkRoleOr (String... roles) { + Set roleList = getRoleList(); + for (String role : roles) { + if (hasRole(roleList, role)) { + return; + } + } + if (roles.length > 0) { + throw new NotRoleException(roles); + } + } + + /** + * 根据注解(@RequiresLogin)鉴权 + * + * @param at 注解对象 + */ + public void checkByAnnotation (RequiresLogin at) { + this.checkLogin(); + } + + /** + * 根据注解(@RequiresRoles)鉴权 + * + * @param at 注解对象 + */ + public void checkByAnnotation (RequiresRoles at) { + String[] roleArray = at.value(); + if (at.logical() == Logical.AND) { + this.checkRoleAnd(roleArray); + } else { + this.checkRoleOr(roleArray); + } + } + + /** + * 根据注解(@RequiresPermissions)鉴权 + * + * @param at 注解对象 + */ + public void checkByAnnotation (RequiresPermissions at) { + String[] permissionArray = at.value(); + if (at.logical() == Logical.AND) { + this.checkPermiAnd(permissionArray); + } else { + this.checkPermiOr(permissionArray); + } + } + + /** + * 获取当前账号的角色列表 + * + * @return 角色列表 + */ + public Set getRoleList () { + try { + LoginUser loginUser = getLoginUser(); + return loginUser.getRoles(); + } catch (Exception e) { + return new HashSet<>(); + } + } + + /** + * 获取当前账号的权限列表 + * + * @return 权限列表 + */ + public Set getPermiList () { + try { + LoginUser loginUser = getLoginUser(); + return loginUser.getPermissions(); + } catch (Exception e) { + return new HashSet<>(); + } + } + + /** + * 判断是否包含权限 + * + * @param authorities 权限列表 + * @param permission 权限字符串 + * + * @return 用户是否具备某权限 + */ + public boolean hasPermi (Collection authorities, String permission) { + return authorities.stream().filter(StringUtils::hasText) + .anyMatch(x -> ALL_PERMISSION.equals(x) || PatternMatchUtils.simpleMatch(x, permission)); + } + + /** + * 判断是否包含角色 + * + * @param roles 角色列表 + * @param role 角色 + * + * @return 用户是否具备某角色权限 + */ + public boolean hasRole (Collection roles, String role) { + return roles.stream().filter(StringUtils::hasText) + .anyMatch(x -> SUPER_ADMIN.equals(x) || PatternMatchUtils.simpleMatch(x, role)); + } +} diff --git a/src/main/java/com/muyu/common/security/auth/AuthUtil.java b/src/main/java/com/muyu/common/security/auth/AuthUtil.java new file mode 100644 index 0000000..131d150 --- /dev/null +++ b/src/main/java/com/muyu/common/security/auth/AuthUtil.java @@ -0,0 +1,154 @@ +package com.muyu.common.security.auth; + +import com.muyu.common.security.annotation.RequiresPermissions; +import com.muyu.common.security.annotation.RequiresRoles; +import com.muyu.common.system.domain.LoginUser; + +/** + * Token 权限验证工具类 + * + * @author muyu + */ +public class AuthUtil { + /** + * 底层的 AuthLogic 对象 + */ + public static AuthLogic authLogic = new AuthLogic(); + + /** + * 会话注销 + */ + public static void logout () { + authLogic.logout(); + } + + /** + * 会话注销，根据指定Token + * + * @param token 指定token + */ + public static void logoutByToken (String token) { + authLogic.logoutByToken(token); + } + + /** + * 检验当前会话是否已经登录，如未登录，则抛出异常 + */ + public static void checkLogin () { + authLogic.checkLogin(); + } + + /** + * 获取当前登录用户信息 + * + * @param token 指定token + * + * @return 用户信息 + */ + public static LoginUser getLoginUser (String token) { + return authLogic.getLoginUser(token); + } + + /** + * 验证当前用户有效期 + * + * @param loginUser 用户信息 + */ + public static void verifyLoginUserExpire (LoginUser loginUser) { + authLogic.verifyLoginUserExpire(loginUser); + } + + /** + * 当前账号是否含有指定角色标识, 返回true或false + * + * @param role 角色标识 + * + * @return 是否含有指定角色标识 + */ + public static boolean hasRole (String role) { + return authLogic.hasRole(role); + } + + /** + * 当前账号是否含有指定角色标识, 如果验证未通过，则抛出异常: NotRoleException + * + * @param role 角色标识 + */ + public static void checkRole (String role) { + authLogic.checkRole(role); + } + + /** + * 根据注解传入参数鉴权, 如果验证未通过，则抛出异常: NotRoleException + * + * @param requiresRoles 角色权限注解 + */ + public static void checkRole (RequiresRoles requiresRoles) { + authLogic.checkRole(requiresRoles); + } + + /** + * 当前账号是否含有指定角色标识 [指定多个，必须全部验证通过] + * + * @param roles 角色标识数组 + */ + public static void checkRoleAnd (String... roles) { + authLogic.checkRoleAnd(roles); + } + + /** + * 当前账号是否含有指定角色标识 [指定多个，只要其一验证通过即可] + * + * @param roles 角色标识数组 + */ + public static void checkRoleOr (String... roles) { + authLogic.checkRoleOr(roles); + } + + /** + * 当前账号是否含有指定权限, 返回true或false + * + * @param permission 权限码 + * + * @return 是否含有指定权限 + */ + public static boolean hasPermi (String permission) { + return authLogic.hasPermi(permission); + } + + /** + * 当前账号是否含有指定权限, 如果验证未通过，则抛出异常: NotPermissionException + * + * @param permission 权限码 + */ + public static void checkPermi (String permission) { + authLogic.checkPermi(permission); + } + + /** + * 根据注解传入参数鉴权, 如果验证未通过，则抛出异常: NotPermissionException + * + * @param requiresPermissions 权限注解 + */ + public static void checkPermi (RequiresPermissions requiresPermissions) { + authLogic.checkPermi(requiresPermissions); + } + + /** + * 当前账号是否含有指定权限 [指定多个，必须全部验证通过] + * + * @param permissions 权限码数组 + */ + public static void checkPermiAnd (String... permissions) { + authLogic.checkPermiAnd(permissions); + } + + /** + * 当前账号是否含有指定权限 [指定多个，只要其一验证通过即可] + * + * @param permissions 权限码数组 + */ + public static void checkPermiOr (String... permissions) { + authLogic.checkPermiOr(permissions); + } +} diff --git a/src/main/java/com/muyu/common/security/config/ApplicationConfig.java b/src/main/java/com/muyu/common/security/config/ApplicationConfig.java new file mode 100644 index 0000000..b78abbf --- /dev/null +++ b/src/main/java/com/muyu/common/security/config/ApplicationConfig.java @@ -0,0 +1,21 @@ +package com.muyu.common.security.config; + +import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer; +import org.springframework.context.annotation.Bean; + +import java.util.TimeZone; + +/** + * 系统配置 + * + * @author muyu + */ +public class ApplicationConfig { + /** + * 时区配置 + */ + @Bean + public Jackson2ObjectMapperBuilderCustomizer jacksonObjectMapperCustomization () { + return jacksonObjectMapperBuilder -> jacksonObjectMapperBuilder.timeZone(TimeZone.getDefault()); + } +} diff --git a/src/main/java/com/muyu/common/security/config/WebMvcConfig.java b/src/main/java/com/muyu/common/security/config/WebMvcConfig.java new file mode 100644 index 0000000..8acde35 --- /dev/null +++ b/src/main/java/com/muyu/common/security/config/WebMvcConfig.java @@ -0,0 +1,32 @@ +package com.muyu.common.security.config; + +import com.muyu.common.security.interceptor.HeaderInterceptor; +import org.springframework.web.servlet.config.annotation.InterceptorRegistry; +import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; + +/** + * 拦截器配置 + * + * @author muyu + */ +public class WebMvcConfig implements WebMvcConfigurer { + /** + * 不需要拦截地址 + */ + public static final String[] excludeUrls = {"/login", "/logout", "/refresh"}; + + @Override + public void addInterceptors (InterceptorRegistry registry) { + registry.addInterceptor(getHeaderInterceptor()) + .addPathPatterns("/**") + .excludePathPatterns(excludeUrls) + .order(-10); + } + + /** + * 自定义请求头拦截器 + */ + public HeaderInterceptor getHeaderInterceptor () { + return new HeaderInterceptor(); + } +} diff --git a/src/main/java/com/muyu/common/security/feign/FeignAutoConfiguration.java b/src/main/java/com/muyu/common/security/feign/FeignAutoConfiguration.java new file mode 100644 index 0000000..4bfda6d --- /dev/null +++ b/src/main/java/com/muyu/common/security/feign/FeignAutoConfiguration.java @@ -0,0 +1,18 @@ +package com.muyu.common.security.feign; + +import feign.RequestInterceptor; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +/** + * Feign 配置注册 + * + * @author muyu + **/ +@Configuration +public class FeignAutoConfiguration { + @Bean + public RequestInterceptor requestInterceptor () { + return new FeignRequestInterceptor(); + } +} diff --git a/src/main/java/com/muyu/common/security/feign/FeignRequestInterceptor.java b/src/main/java/com/muyu/common/security/feign/FeignRequestInterceptor.java new file mode 100644 index 0000000..8ae21da --- /dev/null +++ b/src/main/java/com/muyu/common/security/feign/FeignRequestInterceptor.java @@ -0,0 +1,48 @@ +package com.muyu.common.security.feign; + +import com.muyu.common.core.constant.SecurityConstants; +import com.muyu.common.core.utils.ServletUtils; +import com.muyu.common.core.utils.StringUtils; +import com.muyu.common.core.utils.ip.IpUtils; +import feign.RequestInterceptor; +import feign.RequestTemplate; +import org.springframework.stereotype.Component; + +import jakarta.servlet.http.HttpServletRequest; +import java.util.Map; + +/** + * feign 请求拦截器 + * + * @author muyu + */ +@Component +public class FeignRequestInterceptor implements RequestInterceptor { + @Override + public void apply (RequestTemplate requestTemplate) { + HttpServletRequest httpServletRequest = ServletUtils.getRequest(); + if (StringUtils.isNotNull(httpServletRequest)) { + Map headers = ServletUtils.getHeaders(httpServletRequest); + // 传递用户信息请求头，防止丢失 + String userId = headers.get(SecurityConstants.DETAILS_USER_ID); + if (StringUtils.isNotEmpty(userId)) { + requestTemplate.header(SecurityConstants.DETAILS_USER_ID, userId); + } + String userKey = headers.get(SecurityConstants.USER_KEY); + if (StringUtils.isNotEmpty(userKey)) { + requestTemplate.header(SecurityConstants.USER_KEY, userKey); + } + String userName = headers.get(SecurityConstants.DETAILS_USERNAME); + if (StringUtils.isNotEmpty(userName)) { + requestTemplate.header(SecurityConstants.DETAILS_USERNAME, userName); + } + String authentication = headers.get(SecurityConstants.AUTHORIZATION_HEADER); + if (StringUtils.isNotEmpty(authentication)) { + requestTemplate.header(SecurityConstants.AUTHORIZATION_HEADER, authentication); + } + + // 配置客户端IP + requestTemplate.header("X-Forwarded-For", IpUtils.getIpAddr()); + } + } +} diff --git a/src/main/java/com/muyu/common/security/handler/GlobalExceptionHandler.java b/src/main/java/com/muyu/common/security/handler/GlobalExceptionHandler.java new file mode 100644 index 0000000..170211c --- /dev/null +++ b/src/main/java/com/muyu/common/security/handler/GlobalExceptionHandler.java @@ -0,0 +1,147 @@ +package com.muyu.common.security.handler; + +import com.muyu.common.core.constant.HttpStatus; +import com.muyu.common.core.exception.DemoModeException; +import com.muyu.common.core.exception.InnerAuthException; +import com.muyu.common.core.exception.ServiceException; +import com.muyu.common.core.exception.auth.NotPermissionException; +import com.muyu.common.core.exception.auth.NotRoleException; +import com.muyu.common.core.utils.StringUtils; +import com.muyu.common.core.domain.Result; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.validation.BindException; +import org.springframework.web.HttpRequestMethodNotSupportedException; +import org.springframework.web.bind.MethodArgumentNotValidException; +import org.springframework.web.bind.MissingPathVariableException; +import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.RestControllerAdvice; +import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException; + +import jakarta.servlet.http.HttpServletRequest; + +/** + * 全局异常处理器 + * + * @author muyu + */ +@RestControllerAdvice +public class GlobalExceptionHandler { + private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class); + + /** + * 权限码异常 + */ + @ExceptionHandler(NotPermissionException.class) + public Result handleNotPermissionException (NotPermissionException e, HttpServletRequest request) { + String requestURI = request.getRequestURI(); + log.error("请求地址'{}',权限码校验失败'{}'", requestURI, e.getMessage()); + return Result.error(HttpStatus.FORBIDDEN, "没有访问权限，请联系管理员授权"); + } + + /** + * 角色权限异常 + */ + @ExceptionHandler(NotRoleException.class) + public Result handleNotRoleException (NotRoleException e, HttpServletRequest request) { + String requestURI = request.getRequestURI(); + log.error("请求地址'{}',角色权限校验失败'{}'", requestURI, e.getMessage()); + return Result.error(HttpStatus.FORBIDDEN, "没有访问权限，请联系管理员授权"); + } + + /** + * 请求方式不支持 + */ + @ExceptionHandler(HttpRequestMethodNotSupportedException.class) + public Result handleHttpRequestMethodNotSupported (HttpRequestMethodNotSupportedException e, HttpServletRequest request) { + String requestURI = request.getRequestURI(); + log.error("请求地址'{}',不支持'{}'请求", requestURI, e.getMethod()); + return Result.error(e.getMessage()); + } + + /** + * 业务异常 + */ + @ExceptionHandler(ServiceException.class) + public Result handleServiceException (ServiceException e, HttpServletRequest request) { + log.error(e.getMessage(), e); + Integer code = e.getCode(); + return StringUtils.isNotNull(code) ? Result.error(code, e.getMessage()) : Result.error(e.getMessage()); + } + + /** + * 请求路径中缺少必需的路径变量 + */ + @ExceptionHandler(MissingPathVariableException.class) + public Result handleMissingPathVariableException (MissingPathVariableException e, HttpServletRequest request) { + String requestURI = request.getRequestURI(); + log.error("请求路径中缺少必需的路径变量'{}',发生系统异常.", requestURI, e); + return Result.error(String.format("请求路径中缺少必需的路径变量[%s]", e.getVariableName())); + } + + /** + * 请求参数类型不匹配 + */ + @ExceptionHandler(MethodArgumentTypeMismatchException.class) + public Result handleMethodArgumentTypeMismatchException (MethodArgumentTypeMismatchException e, HttpServletRequest request) { + String requestURI = request.getRequestURI(); + log.error("请求参数类型不匹配'{}',发生系统异常.", requestURI, e); + return Result.error(String.format("请求参数类型不匹配，参数[%s]要求类型为：'%s'，但输入值为：'%s'", e.getName(), e.getRequiredType().getName(), e.getValue())); + } + + /** + * 拦截未知的运行时异常 + */ + @ExceptionHandler(RuntimeException.class) + public Result handleRuntimeException (RuntimeException e, HttpServletRequest request) { + String requestURI = request.getRequestURI(); + log.error("请求地址'{}',发生未知异常.", requestURI, e); + return Result.error(e.getMessage()); + } + + /** + * 系统异常 + */ + @ExceptionHandler(Exception.class) + public Result handleException (Exception e, HttpServletRequest request) { + String requestURI = request.getRequestURI(); + log.error("请求地址'{}',发生系统异常.", requestURI, e); + return Result.error(e.getMessage()); + } + + /** + * 自定义验证异常 + */ + @ExceptionHandler(BindException.class) + public Result handleBindException (BindException e) { + log.error(e.getMessage(), e); + String message = e.getAllErrors().get(0).getDefaultMessage(); + return Result.error(message); + } + + /** + * 自定义验证异常 + */ + @ExceptionHandler(MethodArgumentNotValidException.class) + public Object handleMethodArgumentNotValidException (MethodArgumentNotValidException e) { + log.error(e.getMessage(), e); + String message = e.getBindingResult().getFieldError().getDefaultMessage(); + return Result.error(message); + } + + /** + * 内部认证异常 + */ + @ExceptionHandler(InnerAuthException.class) + public Result handleInnerAuthException (InnerAuthException e) { + return Result.error(e.getMessage()); + } + + /** + * 演示模式异常 + */ + @ExceptionHandler(DemoModeException.class) + public Result handleDemoModeException (DemoModeException e) { + return Result.error("演示模式，不允许操作"); + } +} diff --git a/src/main/java/com/muyu/common/security/interceptor/HeaderInterceptor.java b/src/main/java/com/muyu/common/security/interceptor/HeaderInterceptor.java new file mode 100644 index 0000000..0b1938d --- /dev/null +++ b/src/main/java/com/muyu/common/security/interceptor/HeaderInterceptor.java @@ -0,0 +1,50 @@ +package com.muyu.common.security.interceptor; + +import com.muyu.common.core.constant.SecurityConstants; +import com.muyu.common.core.context.SecurityContextHolder; +import com.muyu.common.core.utils.ServletUtils; +import com.muyu.common.core.utils.StringUtils; +import com.muyu.common.security.auth.AuthUtil; +import com.muyu.common.security.utils.SecurityUtils; +import com.muyu.common.system.domain.LoginUser; +import org.springframework.web.method.HandlerMethod; +import org.springframework.web.servlet.AsyncHandlerInterceptor; + +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; + +/** + * 自定义请求头拦截器，将Header数据封装到线程变量中方便获取 + * 注意：此拦截器会同时验证当前用户有效期自动刷新有效期 + * + * @author muyu + */ +public class HeaderInterceptor implements AsyncHandlerInterceptor { + + @Override + public boolean preHandle (HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { + if (!(handler instanceof HandlerMethod)) { + return true; + } + + SecurityContextHolder.setUserId(ServletUtils.getHeader(request, SecurityConstants.DETAILS_USER_ID)); + SecurityContextHolder.setUserName(ServletUtils.getHeader(request, SecurityConstants.DETAILS_USERNAME)); + SecurityContextHolder.setUserKey(ServletUtils.getHeader(request, SecurityConstants.USER_KEY)); + + String token = SecurityUtils.getToken(); + if (StringUtils.isNotEmpty(token)) { + LoginUser loginUser = AuthUtil.getLoginUser(token); + if (StringUtils.isNotNull(loginUser)) { + AuthUtil.verifyLoginUserExpire(loginUser); + SecurityContextHolder.set(SecurityConstants.LOGIN_USER, loginUser); + } + } + return true; + } + + @Override + public void afterCompletion (HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) + throws Exception { + SecurityContextHolder.remove(); + } +} diff --git a/src/main/java/com/muyu/common/security/service/TokenService.java b/src/main/java/com/muyu/common/security/service/TokenService.java new file mode 100644 index 0000000..3955ddc --- /dev/null +++ b/src/main/java/com/muyu/common/security/service/TokenService.java @@ -0,0 +1,153 @@ +package com.muyu.common.security.service; + +import com.muyu.common.core.constant.CacheConstants; +import com.muyu.common.core.constant.SecurityConstants; +import com.muyu.common.core.utils.JwtUtils; +import com.muyu.common.core.utils.ServletUtils; +import com.muyu.common.core.utils.StringUtils; +import com.muyu.common.core.utils.ip.IpUtils; +import com.muyu.common.core.utils.uuid.IdUtils; +import com.muyu.common.redis.service.RedisService; +import com.muyu.common.security.utils.SecurityUtils; +import com.muyu.common.system.domain.LoginUser; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +import jakarta.servlet.http.HttpServletRequest; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.TimeUnit; + +/** + * token验证处理 + * + * @author muyu + */ +@Component +public class TokenService { + protected static final long MILLIS_SECOND = 1000; + protected static final long MILLIS_MINUTE = 60 * MILLIS_SECOND; + private final static Long MILLIS_MINUTE_TEN = CacheConstants.REFRESH_TIME * MILLIS_MINUTE; + private static final Logger log = LoggerFactory.getLogger(TokenService.class); + private final static long expireTime = CacheConstants.EXPIRATION; + + private final static String ACCESS_TOKEN = CacheConstants.LOGIN_TOKEN_KEY; + @Autowired + private RedisService redisService; + + /** + * 创建令牌 + */ + public Map createToken (LoginUser loginUser) { + String token = IdUtils.fastUUID(); + Long userId = loginUser.getSysUser().getUserId(); + String userName = loginUser.getSysUser().getUserName(); + loginUser.setToken(token); + loginUser.setUserid(userId); + loginUser.setUsername(userName); + loginUser.setIpaddr(IpUtils.getIpAddr()); + refreshToken(loginUser); + + // Jwt存储信息 + Map claimsMap = new HashMap(); + claimsMap.put(SecurityConstants.USER_KEY, token); + claimsMap.put(SecurityConstants.DETAILS_USER_ID, userId); + claimsMap.put(SecurityConstants.DETAILS_USERNAME, userName); + + // 接口返回信息 + Map rspMap = new HashMap(); + rspMap.put("access_token", JwtUtils.createToken(claimsMap)); + rspMap.put("expires_in", expireTime); + return rspMap; + } + + /** + * 获取用户身份信息 + * + * @return 用户信息 + */ + public LoginUser getLoginUser () { + return getLoginUser(ServletUtils.getRequest()); + } + + /** + * 设置用户身份信息 + */ + public void setLoginUser (LoginUser loginUser) { + if (StringUtils.isNotNull(loginUser) && StringUtils.isNotEmpty(loginUser.getToken())) { + refreshToken(loginUser); + } + } + + /** + * 获取用户身份信息 + * + * @return 用户信息 + */ + public LoginUser getLoginUser (HttpServletRequest request) { + // 获取请求携带的令牌 + String token = SecurityUtils.getToken(request); + return getLoginUser(token); + } + + /** + * 获取用户身份信息 + * + * @return 用户信息 + */ + public LoginUser getLoginUser (String token) { + LoginUser user = null; + try { + if (StringUtils.isNotEmpty(token)) { + String userkey = JwtUtils.getUserKey(token); + user = redisService.getCacheObject(getTokenKey(userkey)); + return user; + } + } catch (Exception e) { + log.error("获取用户信息异常'{}'", e.getMessage()); + } + return user; + } + + /** + * 删除用户缓存信息 + */ + public void delLoginUser (String token) { + if (StringUtils.isNotEmpty(token)) { + String userkey = JwtUtils.getUserKey(token); + redisService.deleteObject(getTokenKey(userkey)); + } + } + + /** + * 验证令牌有效期，相差不足120分钟，自动刷新缓存 + * + * @param loginUser + */ + public void verifyToken (LoginUser loginUser) { + long expireTime = loginUser.getExpireTime(); + long currentTime = System.currentTimeMillis(); + if (expireTime - currentTime <= MILLIS_MINUTE_TEN) { + refreshToken(loginUser); + } + } + + /** + * 刷新令牌有效期 + * + * @param loginUser 登录信息 + */ + public void refreshToken (LoginUser loginUser) { + loginUser.setLoginTime(System.currentTimeMillis()); + loginUser.setExpireTime(loginUser.getLoginTime() + expireTime * MILLIS_MINUTE); + // 根据uuid将loginUser缓存 + String userKey = getTokenKey(loginUser.getToken()); + redisService.setCacheObject(userKey, loginUser, expireTime, TimeUnit.MINUTES); + } + + private String getTokenKey (String token) { + return ACCESS_TOKEN + token; + } +} diff --git a/src/main/java/com/muyu/common/security/utils/DictUtils.java b/src/main/java/com/muyu/common/security/utils/DictUtils.java new file mode 100644 index 0000000..04ee068 --- /dev/null +++ b/src/main/java/com/muyu/common/security/utils/DictUtils.java @@ -0,0 +1,71 @@ +package com.muyu.common.security.utils; + +import com.alibaba.fastjson2.JSONArray; +import com.muyu.common.core.constant.CacheConstants; +import com.muyu.common.core.utils.SpringUtils; +import com.muyu.common.core.utils.StringUtils; +import com.muyu.common.redis.service.RedisService; +import com.muyu.common.system.domain.SysDictData; + +import java.util.Collection; +import java.util.List; + +/** + * 字典工具类 + * + * @author muyu + */ +public class DictUtils { + /** + * 设置字典缓存 + * + * @param key 参数键 + * @param dictDatas 字典数据列表 + */ + public static void setDictCache (String key, List dictDatas) { + SpringUtils.getBean(RedisService.class).setCacheObject(getCacheKey(key), dictDatas); + } + + /** + * 获取字典缓存 + * + * @param key 参数键 + * + * @return dictDatas 字典数据列表 + */ + public static List getDictCache (String key) { + JSONArray arrayCache = SpringUtils.getBean(RedisService.class).getCacheObject(getCacheKey(key)); + if (StringUtils.isNotNull(arrayCache)) { + return arrayCache.toList(SysDictData.class); + } + return null; + } + + /** + * 删除指定字典缓存 + * + * @param key 字典键 + */ + public static void removeDictCache (String key) { + SpringUtils.getBean(RedisService.class).deleteObject(getCacheKey(key)); + } + + /** + * 清空字典缓存 + */ + public static void clearDictCache () { + Collection keys = SpringUtils.getBean(RedisService.class).keys(CacheConstants.SYS_DICT_KEY + "*"); + SpringUtils.getBean(RedisService.class).deleteObject(keys); + } + + /** + * 设置cache key + * + * @param configKey 参数键 + * + * @return 缓存键key + */ + public static String getCacheKey (String configKey) { + return CacheConstants.SYS_DICT_KEY + configKey; + } +} diff --git a/src/main/java/com/muyu/common/security/utils/SecurityUtils.java b/src/main/java/com/muyu/common/security/utils/SecurityUtils.java new file mode 100644 index 0000000..6e3f92b --- /dev/null +++ b/src/main/java/com/muyu/common/security/utils/SecurityUtils.java @@ -0,0 +1,109 @@ +package com.muyu.common.security.utils; + +import com.muyu.common.core.constant.SecurityConstants; +import com.muyu.common.core.constant.TokenConstants; +import com.muyu.common.core.context.SecurityContextHolder; +import com.muyu.common.core.utils.ServletUtils; +import com.muyu.common.core.utils.StringUtils; +import com.muyu.common.system.domain.LoginUser; +import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; + +import jakarta.servlet.http.HttpServletRequest; + +/** + * 权限获取工具类 + * + * @author muyu + */ +public class SecurityUtils { + /** + * 获取用户ID + */ + public static Long getUserId () { + return SecurityContextHolder.getUserId(); + } + + /** + * 获取用户名称 + */ + public static String getUsername () { + return SecurityContextHolder.getUserName(); + } + + /** + * 获取用户key + */ + public static String getUserKey () { + return SecurityContextHolder.getUserKey(); + } + + /** + * 获取登录用户信息 + */ + public static LoginUser getLoginUser () { + return SecurityContextHolder.get(SecurityConstants.LOGIN_USER, LoginUser.class); + } + + /** + * 获取请求token + */ + public static String getToken () { + return getToken(ServletUtils.getRequest()); + } + + /** + * 根据request获取请求token + */ + public static String getToken (HttpServletRequest request) { + // 从header获取token标识 + String token = request.getHeader(TokenConstants.AUTHENTICATION); + return replaceTokenPrefix(token); + } + + /** + * 裁剪token前缀 + */ + public static String replaceTokenPrefix (String token) { + // 如果前端设置了令牌前缀，则裁剪掉前缀 + if (StringUtils.isNotEmpty(token) && token.startsWith(TokenConstants.PREFIX)) { + token = token.replaceFirst(TokenConstants.PREFIX, ""); + } + return token; + } + + /** + * 是否为管理员 + * + * @param userId 用户ID + * + * @return 结果 + */ + public static boolean isAdmin (Long userId) { + return userId != null && 1L == userId; + } + + /** + * 生成BCryptPasswordEncoder密码 + * + * @param password 密码 + * + * @return 加密字符串 + */ + public static String encryptPassword (String password) { + BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder(); + return passwordEncoder.encode(password); + } + + /** + * 判断密码是否相同 + * + * @param rawPassword 真实密码 + * @param encodedPassword 加密后字符 + * + * @return 结果 + */ + public static boolean matchesPassword (String rawPassword, String encodedPassword) { + BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder(); + return passwordEncoder.matches(rawPassword, encodedPassword); + } +} diff --git a/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports b/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports new file mode 100644 index 0000000..f4e76b1 --- /dev/null +++ b/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports @@ -0,0 +1,5 @@ +com.muyu.common.security.config.WebMvcConfig +com.muyu.common.security.service.TokenService +com.muyu.common.security.aspect.PreAuthorizeAspect +com.muyu.common.security.aspect.InnerAuthAspect +com.muyu.common.security.handler.GlobalExceptionHandler diff --git a/target/classes/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports b/target/classes/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports new file mode 100644 index 0000000..f4e76b1 --- /dev/null +++ b/target/classes/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports @@ -0,0 +1,5 @@ +com.muyu.common.security.config.WebMvcConfig +com.muyu.common.security.service.TokenService +com.muyu.common.security.aspect.PreAuthorizeAspect +com.muyu.common.security.aspect.InnerAuthAspect +com.muyu.common.security.handler.GlobalExceptionHandler diff --git a/target/classes/com/muyu/common/security/annotation/EnableCustomConfig.class b/target/classes/com/muyu/common/security/annotation/EnableCustomConfig.class new file mode 100644 index 0000000000000000000000000000000000000000..18ac118d96497749c165f725d93884fc200b33b3 GIT binary patch literal 913 zcmah{%We}f6unMcrnEdtd6e=Hk3|<*#0w<4s1O>JR0^aJr2&bua@?D#%h(?IQ8K^A zf)C)M5O*dOjns))*fX}zIljK<{QmRv7XZA0CkeC|yp~pT9m~k+M_a=^%IH)mxiH2C z5ftrpjTq;+AAPWT-DtHD@`;E7Zgv&7OF<3blc_j6h&A4uk8ci6L1rm69 z^mWi>@Vps2#6VDL10i?*0~y#{$&!G{@bkw}?~qhqG*jML8LJZTgwP9a?wM00D{9Ew zzI7S*g;OS*IHB=}b>GP|QkaITUZuVuKi;P?*nzXts-$(C7S?0ET%rUp2JKo@mt(To zUx?3Z9g3nrcO*si_Du>%r%Fnv-R|i6gu!lOSzeyvNzAF#d9|6*sV|KrIo`-@cu-Fl z)>WRq>MzVH(I}KWEeh&?o!MDTiM6|!H9?gbeo)O-qh^%oYX0610|rYpR;X71ElBEl z6|U3w1FXUtovnWZhHwLJ!mVnBa2qz@4gof4+@-C1$8aAWTp&Gc!9zOOo~>IF9!Yro E7fR|OqyPW_ literal 0 HcmV?d00001 diff --git a/target/classes/com/muyu/common/security/annotation/EnableMyFeignClients.class b/target/classes/com/muyu/common/security/annotation/EnableMyFeignClients.class new file mode 100644 index 0000000000000000000000000000000000000000..264e1d41c1a5b3192fe64cbdc5a48d6f5b1b1051 GIT binary patch literal 827 zcmaiyU279T6o%hPlWtq*O z#kQ`IV@(&u8L8BCv?AkOgr>l~OL;A0ElnDK8edZ4BdiKMU0N$i-Y@bAw63KNB(U@H z)#!Xl4}7jndLpp3gimQIgZ2WOW9g_TlPj5$6IkPZkIKdcwkw{Fmd=&__TQ=JcFw#$ z;1Q$`IalAULEgN6$5eZAQ?+BwRHY%GuR$P6Ze|zQ7}$^}bfz@t*{j>nQ8^a-`oVaW z(HG?u?{GO6x42&!y|SpG%v18*#q)Z9S5w9>Ff3-oP;>aT*A+OZXZz$C$CchQ=5dc1)4B@d~WkJcC+&7rn$`Mo6WD{MB6Zl?TpN{6wMzA zRRwf%C?K%HUyJqFVl_or|eYE*}fhKmidc=hY53q}e<&Ch1M|jM@6W})}Ug0DF literal 0 HcmV?d00001 diff --git a/target/classes/com/muyu/common/security/annotation/InnerAuth.class b/target/classes/com/muyu/common/security/annotation/InnerAuth.class new file mode 100644 index 0000000000000000000000000000000000000000..78c876b5b03240bac251df50ea3b76294a9529a6 GIT binary patch literal 504 zcmaiw%}&BV6ot=Fp^A#&U*f``E{H6&4?tXyfRRMRU~z$~p!))sx7(uI33QHy{Hs~4x^vIIWlKrLPlbhWbsp}6}$8$DeaQ|D`kmW zG@5<(M;V`6YF0D9P?BDr=brQ2b5GB&-`{=$c#bC$G7L@AcQrRUi8T7-`kpqm%qXzK z6V32EKQuy{dINuAn}(AIgQy^jB?h5?@RFf5Sb*N;{G5V3=Vyj*czI2Mf@KD2Yt$dS z+t(S|?-!aWqll7(Wd&ta7_z40dlo~rt`3fjV?%QcZ=wyyN0u3OWmIuP!is{MxW!Po z1nhf}OCpX9C$feg8J^Ws>^;YrPP?gw9tO5I>84NM1LFBL1-G%ru++0XJKSMdNsmgH zuhmfwS()x%%OTI#bp;#PxHhdTZL zh*1~vo1rrBDGMVbu=&hnu;>{s&97W_i6Rqzvgty3-JWgtHH&@-LHr57n8 z_p-N;sGTl@tou=5TCZ$=PbEogn}6cn4jEjf%nQ4#JiGv{6hfd>*mAfYfNNoniG$yq!Mok}jdirQ>moX_aIioJ5EUk-9)R`vdGym_g7F#Tg|1 zs{S0>XeG3MLRea=CeB)R3cV%=Kv4CQJsM EKV2>P(f|Me literal 0 HcmV?d00001 diff --git a/target/classes/com/muyu/common/security/annotation/RequiresLogin.class b/target/classes/com/muyu/common/security/annotation/RequiresLogin.class new file mode 100644 index 0000000000000000000000000000000000000000..a9c15286298372b5c6a87c1845addf66ab6e3e26 GIT binary patch literal 427 zcmaiw%}T>S6ot>kw$b`myK^BH7hM`$iwnVsLTgKmg1DN7OPDg5(PXBOS99S5_)y}F z3#$-tF?a6I`Oby=@%i=+-~z)Cfxua2i>UCmk2oo;i7Lu`sazdNW2}=-aWA1)uS%*W zHdiJ@M_{m&D;a5N@@TeLQszSR1di9;U-adVkwE|6`ZA+yrAc7;$M>{>1r8H$oGR#1 zRcfJW4OarAN$Y}y95G|fxj=U%wP)|~Khn9?Dyta?lZU(Xb{Y#DwIiu4b8@UaX`jcM z3SOVqFT|qWG)`}3R|1{%X&#RS1UC3}`Q$)=@H=i|i~kYVeV%O-cCd@RCVfUg*vFs= F2Vbake4YRR literal 0 HcmV?d00001 diff --git a/target/classes/com/muyu/common/security/annotation/RequiresPermissions.class b/target/classes/com/muyu/common/security/annotation/RequiresPermissions.class new file mode 100644 index 0000000000000000000000000000000000000000..dd2e6a90a626f4c1e53e288a8cf6c2e43916afc9 GIT binary patch literal 633 zcmb7?O-}+b5Qg9K;VOQCisHdYJP%^=9zCc?O*AdEM*`KQ_LeSVNQO8k@L62#7i17<g6+3NkaCXbJGl4oLQt=o2P``l;Fc^tHB0s>hcdHx(3ep?Ic>}{}@9V3100ye(` jdBPU9k-<*NVi!eTt8A4Run2qD$3be2ks*|Em`+EZ#LKw` literal 0 HcmV?d00001 diff --git a/target/classes/com/muyu/common/security/annotation/RequiresRoles.class b/target/classes/com/muyu/common/security/annotation/RequiresRoles.class new file mode 100644 index 0000000000000000000000000000000000000000..f164119e4bf0dadfae97a1f0940459f97580cfca GIT binary patch literal 621 zcmb7?O-sZu5Qg7$U90Q&w;n|CAnQSkXYn9dQP^FjRzda@%UH6ct+t8KzvjUo;Exig zD0YPf^^jy{^33F&ByaC8uKB%(Bj5La40Xbr!2gY5}jk*ZGUy&SwJG+y5uuIO&}Vw5~IoM|7q%OI`fY{Xr#KU?Z@p zQ3>6uLfvbsRTl!=LyZkxLqLW&Creq@?k~tyrd3oj=ms~v@S^JrY>rL|Wge4Za%c3u zuPNbU!}5_B8t?ky`6YKa7T#U?y8;3Y9!>rb4!^343HB!0YxGe)a|=^nfhJ)ZGjK3l dv6#a=uiI=bFyImvv4rKy?870fV6~doJ^;|8v&;Yh literal 0 HcmV?d00001 diff --git a/target/classes/com/muyu/common/security/aspect/InnerAuthAspect.class b/target/classes/com/muyu/common/security/aspect/InnerAuthAspect.class new file mode 100644 index 0000000000000000000000000000000000000000..f9bfb72df964152d302098860acaef9ddd0f06c9 GIT binary patch literal 2122 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 literal 0 HcmV?d00001 diff --git a/target/classes/com/muyu/common/security/auth/AuthUtil.class b/target/classes/com/muyu/common/security/auth/AuthUtil.class new file mode 100644 index 0000000000000000000000000000000000000000..ecfde4eb9204dc7cfa83e1cb4946f616dac67101 GIT binary patch literal 2401 zcmb7E+j10D6kR75=8_%=L4tQcB$-5{1vE+~AOV9Hh6HoN%Zr^(JLxdfjXgb-^PrDf zKIxT$$6D++6-u(MhYjCVn5sV+rMK3~IEX_9j9NG>;wGOGN6pQ!5q4t1 zAF=Qpjw)1=(ADm0c*hGAj#lftwXVdGA2e!H>w-9D;dx0{cDFqDjwlHv{Gx@I@Unu{ z@M0ZYYkQHxB@@ry3cKytYuTG&%kcxd2iFz8YT-CeP|-av^1tr(elC1_*N;4fGu5Z2 zOA2_+!YRD2P}p+X%VCog#$vyaswON@7UfRa)eDes>!J| z+_8O5AVo*|j8vljDJoppd+MGzdMXq$7InlhW=`v_%uhF(TXqumbzkA)Go|f=vOOca z^psGXbDODkl~=+}J3=Hb*@U{Rw?+D-USr?MBxD{0#_O?z6*?V<1qs0P$^)BaUm-b zF#P~yy9pD-aTIW(FKH1U;v=1uo|STBlaA+;PH^KSlhVyn!1-*_7w(g=zshsQgfuO) z=vVThXDPat;rJMzXwmd3vxbwu=QJ#2@Hf(;>0M?Gr}G*XsbOg!j%hPTHP3OI9G_)4 z>bOarKZ(_uIo`-~d_@i?!?8$R!a?&hbJ%$fpB&o;j*=K<%8{Gt`Fua)4E|QyPkO3Z z!#jBm-%-Q&`*6&fIo`{2{6LN$GaR2{S@(k8Yv!osIesR`FBy)Nw4ZcoGsopT$FJo0 m&A?H_YTu=j3k!_=jf0;*#Qa|<2u*UE6Ehg)YK^f0tp5-6PuNoc literal 0 HcmV?d00001 diff --git a/target/classes/com/muyu/common/security/config/ApplicationConfig.class b/target/classes/com/muyu/common/security/config/ApplicationConfig.class new file mode 100644 index 0000000000000000000000000000000000000000..ef426ec00c9a169153e935c7be2ef79f947fa5db GIT binary patch literal 1631 zcmb_cTTc@~6#j-n3uO^33W7I8&=!T^;x$zhsTwpz6Cr5yX}TTC!0ygwcNWE8r7voD z@CO)wlkrSjuu22LxDRvN^PTUTbIzRaKX<fBP+O0LFW>2Ci&wNZ zTqH)jI#^e=B$9knxLdIf__M}5-{4smVJM@;M0r&imG&G*#Vj23WpKhlKL!|bb$y9Z z9$!_ye4_&*&(@@QB-cgak=!9ta?ptU}QDF>%9#87G{cEgyElhAD$85!}-BUCbU zn|%#$^X*vM2j!SN#SG3c%(>d(mtP`^gOZm3WkDGMaS+TTw<92QW@inag4r^A0XyoWXe-1k_+W z5yvvl;3mW5fgrWJZw9v+E*x%3y|NJ;q8g^YYQGei?W{D8(2mp0XzrT&0``d(9T=t2 z{s#JRmPV&xfO9xcJK}_G(H1;QJ8PHTMF#jtt5)=23p(9IU$oYQ83P8g_WrcCo)!pc yJ@rg|Mek>veD$}KR%bo9j0rMMVUorUT)|bEt;{@~agxQ!AxI{}4cx*VjQj#-5!~_s literal 0 HcmV?d00001 diff --git a/target/classes/com/muyu/common/security/config/WebMvcConfig.class b/target/classes/com/muyu/common/security/config/WebMvcConfig.class new file mode 100644 index 0000000000000000000000000000000000000000..0512c7e83e1dcaa4fc8bb05af45d4a15d905aae4 GIT binary patch literal 1684 zcmb_cTT|0O6#lkNNhlFYfg%bBUfY61QBf(E85tFvijGy7jxVO^5`t;MY!k4L{v$6l zWkyGTfIrAb$CI{77{Q{$!=BxaThS_h&DZEqaUHG74PRJZjd*9nGPQMH zdc0#SH5i6|lY7ftFLSZtcw88K+j9lOY&w%aQjxX)Q~N_U7e_aGWF%DdBFS*y6{c3* z7M5df2))90UGZAm*=0Fh(k!8anq`LqQ=mzm&>6ChPUZ_JJrj& zQ??IymdmsiYK7^qcp5l!GWrjsr{D!%Do9acv}`tx(-@L*M#WhSGpw{jdu+oDJrs-aSme)UHpw<`(^$@*kroz5X*t@=T%$?9PexW z4g(I}FR8eUD-1DLQ28;erdLijI~j(V|107+(ugXUq*l{x*R&i3Qw(x&c70F5H3mf! zd_(Z+ri^KZd;gx?a3A_22!OQYmN_LiZ#jI`uavlWu9s}ON#>k*AIz(`jXz&cExYeMI517Gi z;u!AWF3~`klcEUi;}h9BKCIg6kQ#|j4>E@!izT~G?C!JB|##QoRA=scsMsyiWI44OvwJu^H1c)vQ2oCR<4$juRRZNt{GdV7zKK^`^Jw=^Qj| zi=8WVPnnIDUY73DhE(_ci9n(*)r$PWlP#K@%w&rj#-`yaLvOWV`npn%zQiUx7lQK% zoI<~bfh1l-O5nQIjrx zo%Z3!^UjZhhW&{3Wy8s97!vTwILJ!Xwpz-t6p5*NuBo;b!i82G=LIy6Onh$EPGT4r zHN2k08@MFU*JYm~kVmp`SU?A3)bM7Pq~(AhpV84I#&Csk2Q1xbI%;blO>JyIQwCWL z6G=?sDnU=AS-131o>kd&8itZgll6c;f!V#jg;qY><6FmY@lZqgIIaoA12Q({Rvg#E znPoI(9B+{k!&B?FYkp}c)3)MxN1*>fGUT@4%++eHz+jM~otz1M)-WS*bHBA#sHffzXwl~rjwARe=D z@a2_lkEyX}`Wg=(ku=wQW(CqK9!YD;irF%m19O&TtAIfYGf}kNy54g9()YwA&ChIi zQ*SZvq^%gEzF;>U+al|Ej3Cc)FIe{x^ep+DeZZN{Ua*f&`~vYJ*uKry-v$OT$2Qpp zU>*yc34Dk*LXZ}KCR1;> z=R24R7W`-j<1oy zH^|~UauyBx)MK8qqp8qaNq{Q9G1 zB3Kyk6Yk*?3ic`YeHGevS7^7)mFtMU#FU0r4Z|8n{>JFO_8%VL7tg;bLljT+pc1qX L@Q}T)@gv}08)-2D literal 0 HcmV?d00001 diff --git a/target/classes/com/muyu/common/security/handler/GlobalExceptionHandler.class b/target/classes/com/muyu/common/security/handler/GlobalExceptionHandler.class new file mode 100644 index 0000000000000000000000000000000000000000..a19e77776261789acf127ee655aeba87ba7d3075 GIT binary patch literal 7704 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 BmWu!Y literal 0 HcmV?d00001 diff --git a/target/classes/com/muyu/common/security/service/TokenService.class b/target/classes/com/muyu/common/security/service/TokenService.class new file mode 100644 index 0000000000000000000000000000000000000000..a6885760d62ddd0474efb2a2cd0953007ddedb5a GIT binary patch literal 5797 zcmbVQd3+pY8GgQGli6-2X}h#3DOXC*9PMxvC{3xhA=s28#cq-cRKs+4l1#I^v&_t< z4S0cEA_79?P*G74#Dh}!rQwjn>!*0(Pk-KcQb5G}RzRQco5^HzK!f>XXTF*5d*A1M z-gENA%MU&R;0!TWLz%$pw39P(#gU@Ho1Bw3JS$yvZGVI}?y#Mg+RRD^!%Ql_A><*tZL|(P?Pdq zJ3r8pKoUo2SfFDeYG)Aajd;G5Gcr!jwDU%XGhpX?$bdj%!17ZgUa)AO=&6tNrkvQx$IQGIN%+Zi$ZLv6M`B zmalv!uyECMA|%I2EZ4CDE2)p0r9PYbjws!&)CGGRbTmrARpH*eQrL{u8rJAAB$jFB zsgMZ#WEYI~Lg*!FUVC9vCgVyFC+av!3YH++3#NK1uvW(@I8{J*t$x??218q#R~?4= z$Y(7Ly&BdD%vV7mK^R+1Z?MxWBygGx#ufn??UTZOatx=!B#6Q|&V)g{NT&LRtdT0b z4zJg+Nylci3RF)hq7nvjp~$#iS4w9P>@6kk2%nUOYWOIQHUUlPvNLhKAyh1BkE5N$ znCZ0Td40Z2%mmIxhlWlaUDzhDbVj=ZM{M2Whi<4!yO!x&A+t+Epo%FP&{B#iOrJR3 z$W*ZQ7Hqnt&(2q{gz&HI$pm^px_9V!6V4T=nMgbtL9}Do%oeR}{W83^mI@Bz`F!lu z@MaxvLEj8nSrSGmR-i0{HAr`vmD{ZgiGn^d9N-_pzjxqE&K`3g`1g| z0;Y~#NRvnkiK0fJTk%gNAfuW&Xu!iSnjYm)GHdVVF=N+HwVdWQvT?sST9j!qebOF~u1wd(;eMY=jUw#v8*px>@JD%z=w^T#UB{qmTjF@1z|qfLd+^Y8H$A)Wu4k?~`1GTh@K8g9{XD?Y$>KUK0oh2^>q`|8RWd^1CNWVgB;AJTD~ zjA%V$F}JP2L>d1d(eY8)UaN_qO%ZKJEZ=svcXYI;`a0XYdb->Cy4$)a zqy%?Z){?kK$9~yibv8Fu4gzFJ9MEx}#2i&0`9jsxvK!YxT6Ivzm^@m|qZ3xm!Gm~6 z!^1j0k4FTKQNERVDMzmmvms^maGYY{4G^XTjtk(u(pHA;<#u*Y$Sj9r$Q_l*9)e8Y?m7@LZ|vxluZLjz;2PKKc7 zcG!8VtC-tmx!oqktGrK}*ldPWvvPn)RzDboQNqioi**8rzWzw(==APUO~O8?Qlw27%7Z1amwT~ z8>V})ATidL1>-cYV; zx`+w+U{D8Pxl(FPOjkOS>Xw4-e$+~ zJ>NA8ot8i7WW2eRqAVfGMNAVFtWTm+VA(_$we!Oqx{V-3JupE>yHtAqD;m)xA{F41);FV6+p@>#9n@!oi)e;wR7WT=-hJI+z z=Pg$iM$6Mg6)Wa6J7opvWZ{gcqJt;pM@ExwdTeAKh z7R&z1cZ=m{qORXBdB2^{e}ErG=YK>QoY%Pi3HMg=`cq!3c;&wt`1=%B2CstGipGPe zxR*C&_!)oYX5bk7oWFXo0l&a6xf1+_`W1KauxLY!pn)sLP}SKqiut2h)D>KhSs!a^ z9z}iA>QO9fs*8P#%rUUKE=BCv{5HDx~R9Qzth|5mnT5VP_+qK0E<7p(LG8b9XAq z^}*IiauxoJzfe#GX$T0FB6qh}QWM}jK zJCW=aP6Q3lCRHOgN^y@upw4OiC?#6KxK z@JWsWBvaA~8naLu)2WOhX*A}8J0{$cRE7^T{`N4&_M#3KMFjG{e+rm%(&7lt;t)>g zq&h17R}>CcP@F6=OX&O$kK*=CW4PnASbc5GI)J;m-gn!yz^Ek!z@>;Y)~lHjM{xqK zX9mc;XjJHyM7o!R0TL%pS&__nYd;sEpR#WJmGT+!Q4I0X#5@MD~LeGy^Q z5kXxSLS2p{@E?`JW%6S*#MHv8q*ZHr5MKm8PR3OP1@UGjGDr_C5~+pE$MIrRSJx;p zKym@TLQC$$-AOTquil4iBy6FoRFE9?48|qo=_RG><)~KwS8n59973>03r)!IW!)AD Jp^F;S{SVg4K!^YU literal 0 HcmV?d00001 diff --git a/target/classes/com/muyu/common/security/utils/DictUtils.class b/target/classes/com/muyu/common/security/utils/DictUtils.class new file mode 100644 index 0000000000000000000000000000000000000000..0ec7ae8885c3f52007707442765da0e4bec90970 GIT binary patch literal 2819 zcmbtWZByGu5Pl95gdN2Mw;?6(X(3>fMlETZ29q~TXkHv>Fd;3pP0sQG!m`9jXJ-6Q z+JBLLp_$CIlh6H4olf_pGswmy?ev4CyY=4gv%Amk>CeC4`~lz=ybSt~GSF}07zP+l zZu4Dkx!l{dma5yrmJ9>4j_1hR45`Wds)0dpS1lzSWW4;p;g%l9B=cPS~D1%Le2^9F^o@^4=|Nn9)`ty zLK34aW^fY22684oz=sTz-F`x0Hv>nuw6A%`mfF*C@>JsXmUt{$1Tg8XA{C+zcUqKz zfe{m@@exBd)CSrKo9JQVFyj2GGIGYmS)3yyZ4_-I?*pRaHgJLAqKcNgPL)@=wZTKV z9s1t1^{BG6crOTeD}zh8Y~W)PpJ41gMTkPysYyHGqAwSluFG&L8I*ROUo&upA%7^@ ztx$@FRr4F%@vKTKROz1Qk{g)Rwdsv^S@4<&#ufyZ%|K*u9t9IqxJo3He%T3$jf+Vf zF&);+N5|i3v0X|6qL)aOx(cN4E=S{BDNQjLA71Ql!>60eAlI3bbK!YJfi>? z8AkQ7Zk_yEPBpiQ+o~5%H+WqT8k@`Kj@;VEMczw(O)w0V9ZxJa8&wgk@TyCaT-mp| zyUGJc?X|F9ZaE5TlhO|ne z;u1kQ*?pE_q!W2-r;Ywrm+tK0Fpgqv@is-0t~i@sL`#O{9_9L9=2grlO@KtI#(MbB zbMJt?#4D~ET&MT)I~pMx1Qf@KisW|v3E$CGeflr_{MTF!1)|~aibOO$dx?V1+OFV1 zLUAOK#{}yY?IJRCQGGU+M)#GbNK`Cp#SLdOn&_E|-wbTA;3#5em8)m!in*rD5ryV_ zUxqT^J5Pk%@@wJH0Dj8g1zsB9s)4EuV+S;Jyj{O8tk_lDQw!Xden52nIhjeV7#n@S zy_ze+v9j;in>)qBm=ltYgDb?}9_s4}{q`tMh_s0kcioC3MR5?dyHHN14a7r0U zMTXQT5O9XPpN))-#0Ri|Z%7Ud;{hI$gGaQE9Vy9Ul9Wl(hbQE45lggE4x8HHMAG3N zM&IImdFnMT{(|gOZanonCiakj#a_{o7)B2Lv>vAqm@5Qkf>!wioCytwK5y_Xo|5xr z(jEl+3*!b|lrfYFL0Q2w`d2}@Ly%OCI%40$r_T?P7{@+Mv0qOla#%Y{V|Bj@FSW6A z?YMH+_weQ8_O7spn~~i(m@EYa+(Z^Ll-1(C?JP-d;5q%*&Sot6jwEUI?WUoBPHzR> zD7?Wept6*#`u%-_q=N6GLZz@4X|3Z2dQ)cbBmHa$+U4l<1U9gBcN7llXkhdoD-`rH literal 0 HcmV?d00001 diff --git a/target/classes/com/muyu/common/security/utils/SecurityUtils.class b/target/classes/com/muyu/common/security/utils/SecurityUtils.class new file mode 100644 index 0000000000000000000000000000000000000000..5acb8ecfc645d977c8f002da616e1dce49ba7a21 GIT binary patch literal 2697 zcmbtWT~`xF7=9)MHVG?WC@RG&)`}32ZMChoU<*VLB_IM~wN<+$16h*n#@Pv){*K<* zKhT?Av^PlGb9#E!i~gvdzB9WCOGwY*oaSP7XZHPg-sk<8{Qb{we*n0Ry%b{TFc3G< zi7tk|U3<^A%C@^>J=ogidCAZ`$ex@;DRB!!{sBNi+crz^ypab&}GhZcczq!9uvLjW9SY= zSL_OBc;|@lx)e?*o;K01#8aX860aK=U{I*q!tJ#%`~=RDk+QerxG!pi(7+(W z)m9^Z-Iu}*b=xK>U{t8f(VArt5E9#KU=7;cV6VhiC$PO@d&_ot%q2b2>77cp$$ zl8N_mxeWkKa!opApC}f4WujAUg80|?%NqB|`?zMSWD99q1W$=sMJcP+A}yg_C`=x& zV8p;x6QdYom^c=4m`SVQHArmeHbK#DcqQ&K+*To<%x5(4kQ@W!ZJal1DoC1kL>1M@ z*foYzvo%@tg!7#(9nbBCg%1sUWa2t*5PK)Y6V&A*w{?w2p|Onj;wr3J5+ z?L5~2R|Vg8UZ-#ipBebv#1y6(Mp|i&CQ?^(Bae>1;>r0+Rn{2>+Ch1m0Cl7>$8EvI za0)Y+H85u)tNcWoI3SiPgXj{{f9%L&0`m+|DtApR;vRz;B42QXDx6zw97f7E%vD=9 zmXI^BY+?lu7km{((Ll0ATdb?zaP#~~(}nRU z3tyRdf~Ul5#g_RZr;fVzpC;NcLYna`L1O65IWAwRRkpa;u(!%|lFoT~yS!-&NA1JI zxGXy4WHQ%U7|rBWA@sQEHY(?#=KAoJz3{6bjqOJ)5lq$ zc3hWszO-yt!zc~MpDk1znhyO@HubO{BhI?is8yFiU&NaJN<>n+qB&plbqTsXi7t-?37@K|VlfvhXSdNS#WUoja&Zu|frE1iHL^#=zu zf0LNjES(9Ykw<~flSDDcHrYz5DIVI~M2ChjlsUl7HyFsIZ|~#FH!$fXePt literal 0 HcmV?d00001 diff --git a/target/cloud-common-security-3.6.3.jar b/target/cloud-common-security-3.6.3.jar new file mode 100644 index 0000000000000000000000000000000000000000..20752af318f9cb41cb2a118be1c7204e1caf64d5 GIT binary patch literal 27609 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 NtOzkMj7<=K{U0n0b;|$% literal 0 HcmV?d00001 diff --git a/target/maven-archiver/pom.properties b/target/maven-archiver/pom.properties new file mode 100644 index 0000000..e534907 --- /dev/null +++ b/target/maven-archiver/pom.properties @@ -0,0 +1,5 @@ +#Generated by Maven +#Wed Jul 24 20:40:06 CST 2024 +groupId=com.muyu +artifactId=cloud-common-security +version=3.6.3 diff --git a/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst b/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst new file mode 100644 index 0000000..c31af96 --- /dev/null +++ b/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst @@ -0,0 +1,20 @@ +com\muyu\common\security\aspect\PreAuthorizeAspect.class +com\muyu\common\security\interceptor\HeaderInterceptor.class +com\muyu\common\security\feign\FeignAutoConfiguration.class +com\muyu\common\security\annotation\InnerAuth.class +com\muyu\common\security\aspect\InnerAuthAspect.class +com\muyu\common\security\auth\AuthLogic.class +com\muyu\common\security\config\ApplicationConfig.class +com\muyu\common\security\annotation\EnableCustomConfig.class +com\muyu\common\security\annotation\RequiresPermissions.class +com\muyu\common\security\feign\FeignRequestInterceptor.class +com\muyu\common\security\annotation\EnableMyFeignClients.class +com\muyu\common\security\annotation\RequiresLogin.class +com\muyu\common\security\annotation\RequiresRoles.class +com\muyu\common\security\auth\AuthUtil.class +com\muyu\common\security\handler\GlobalExceptionHandler.class +com\muyu\common\security\annotation\Logical.class +com\muyu\common\security\utils\DictUtils.class +com\muyu\common\security\utils\SecurityUtils.class +com\muyu\common\security\config\WebMvcConfig.class +com\muyu\common\security\service\TokenService.class diff --git a/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst b/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst new file mode 100644 index 0000000..a124cbf --- /dev/null +++ b/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst @@ -0,0 +1,20 @@ +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\auth\AuthUtil.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\annotation\InnerAuth.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\interceptor\HeaderInterceptor.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\auth\AuthLogic.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\feign\FeignAutoConfiguration.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\aspect\PreAuthorizeAspect.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\utils\DictUtils.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\annotation\EnableMyFeignClients.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\annotation\RequiresLogin.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\config\WebMvcConfig.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\utils\SecurityUtils.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\annotation\RequiresRoles.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\config\ApplicationConfig.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\annotation\EnableCustomConfig.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\aspect\InnerAuthAspect.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\annotation\RequiresPermissions.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\feign\FeignRequestInterceptor.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\handler\GlobalExceptionHandler.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\service\TokenService.java +D:\workspace-IceCeram-Cloud-master\zglchaifen\cloud-common-security\src\main\java\com\muyu\common\security\annotation\Logical.java