first commit

play-common/src/main/java/com/starry/common/annotation/DataScope.java

@@ -0,0 +1,29 @@
+package com.starry.common.annotation;
+
+import java.lang.annotation.*;
+
+/**
+ * 数据权限过滤注解
+ *
+ * @author admin
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface DataScope {
+    /**
+     * 部门表的别名
+     */
+    String deptAlias() default "";
+
+    /**
+     * 用户表的别名
+     */
+    String userAlias() default "";
+
+
+    /**
+     * 权限字符（用于多个角色匹配符合要求的权限）默认根据权限注解@ss获取，多个权限用逗号分隔开来
+     */
+    String permission() default "";
+}

play-common/src/main/java/com/starry/common/annotation/Log.java

@@ -0,0 +1,36 @@
+package com.starry.common.annotation;
+
+import com.starry.common.enums.BusinessType;
+
+import java.lang.annotation.*;
+
+/**
+ * @author admin
+ * 自定义操作日志记录注解
+ * @since 2022/7/22
+ */
+@Target({ElementType.PARAMETER, ElementType.METHOD}) // 注解放置的目标位置,PARAMETER: 可用在参数上  METHOD：可用在方法级别上
+@Retention(RetentionPolicy.RUNTIME)    // 指明修饰的注解的生存周期  RUNTIME：运行级别保留
+@Documented
+public @interface Log {
+
+    /**
+     * 模块
+     */
+    String title() default "";
+
+    /**
+     * 功能
+     */
+    BusinessType businessType() default BusinessType.OTHER;
+
+    /**
+     * 是否保存请求的参数
+     */
+    boolean isSaveRequestData() default true;
+
+    /**
+     * 是否保存响应的参数
+     */
+    boolean isSaveResponseData() default true;
+}

play-common/src/main/java/com/starry/common/config/CosConfig.java

@@ -0,0 +1,56 @@
+package com.starry.common.config;
+
+import com.qcloud.cos.COSClient;
+import com.qcloud.cos.ClientConfig;
+import com.qcloud.cos.auth.BasicCOSCredentials;
+import com.qcloud.cos.auth.COSCredentials;
+import com.qcloud.cos.region.Region;
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * @author admin
+ * 腾讯云cos对象存储配置类
+ * @since 2022/10/28
+ */
+@Data
+@Component
+@ConfigurationProperties(prefix = "cos")
+public class CosConfig {
+    /**
+     * 存储桶访问路径
+     **/
+    private String baseUrl;
+    /**
+     * 腾讯云账号秘钥
+     **/
+    private String secretId;
+    /**
+     * 密码秘钥
+     **/
+    private String secretKey;
+    /**
+     * 存储桶地区
+     **/
+    private String regionName;
+    /**
+     * 存储桶名称
+     **/
+    private String bucketName;
+    /**
+     * 上传的根目录
+     **/
+    private String folderPrefix;
+
+    public COSClient getCosClient() {
+        // 初始化用户信息
+        COSCredentials cosCredentials = new BasicCOSCredentials(this.secretId, this.secretKey);
+        // 设置地域
+        Region region = new Region(this.regionName);
+        ClientConfig config = new ClientConfig(region);
+        // 生成COS客户端
+        return new COSClient(cosCredentials, config);
+    }
+
+}

play-common/src/main/java/com/starry/common/config/FastJson2JsonRedisSerializer.java

@@ -0,0 +1,44 @@
+package com.starry.common.config;
+
+import com.alibaba.fastjson2.JSON;
+import com.alibaba.fastjson2.JSONReader;
+import com.alibaba.fastjson2.JSONWriter;
+import org.springframework.data.redis.serializer.RedisSerializer;
+import org.springframework.data.redis.serializer.SerializationException;
+
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Redis使用FastJson序列化
+ *
+ * @author ruoyi
+ */
+public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T> {
+    public static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;
+
+    private final Class<T> clazz;
+
+    public FastJson2JsonRedisSerializer(Class<T> clazz) {
+        super();
+        this.clazz = clazz;
+    }
+
+    @Override
+    public byte[] serialize(T t) throws SerializationException {
+        if (t == null) {
+            return new byte[0];
+        }
+        return JSON.toJSONString(t, JSONWriter.Feature.WriteClassName).getBytes(DEFAULT_CHARSET);
+    }
+
+    @Override
+    public T deserialize(byte[] bytes) throws SerializationException {
+        if (bytes == null || bytes.length <= 0) {
+            return null;
+        }
+        String str = new String(bytes, DEFAULT_CHARSET);
+
+        return JSON.parseObject(str, clazz, JSONReader.Feature.SupportAutoType);
+    }
+}

play-common/src/main/java/com/starry/common/config/RedisConfig.java

@@ -0,0 +1,36 @@
+package com.starry.common.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+/**
+ * @author admin
+ * redis 配置
+ * @since 2022/10/18
+ */
+
+@Configuration
+public class RedisConfig {
+
+    @Bean
+    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
+        RedisTemplate<Object, Object> template = new RedisTemplate<>();
+        template.setConnectionFactory(connectionFactory);
+
+        FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
+
+        // 使用StringRedisSerializer来序列化和反序列化redis的key值
+        template.setKeySerializer(new StringRedisSerializer());
+        template.setValueSerializer(serializer);
+
+        // Hash的key也采用StringRedisSerializer的序列化方式
+        template.setHashKeySerializer(new StringRedisSerializer());
+        template.setHashValueSerializer(serializer);
+
+        template.afterPropertiesSet();
+        return template;
+    }
+}

play-common/src/main/java/com/starry/common/config/Swagger2Config.java

@@ -0,0 +1,53 @@
+package com.starry.common.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import springfox.documentation.builders.ApiInfoBuilder;
+import springfox.documentation.builders.PathSelectors;
+import springfox.documentation.builders.RequestHandlerSelectors;
+import springfox.documentation.service.ApiKey;
+import springfox.documentation.spi.DocumentationType;
+import springfox.documentation.spring.web.plugins.Docket;
+import springfox.documentation.swagger2.annotations.EnableSwagger2WebMvc;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+/**
+ * @author admin
+ * swagger配置
+ * @since 2021/9/1
+ */
+@Configuration
+@EnableSwagger2WebMvc
+public class Swagger2Config {
+
+    @Bean(value = "defaultApi2")
+    public Docket defaultApi2() {
+        Docket docket = new Docket(DocumentationType.SWAGGER_2)
+                .apiInfo(new ApiInfoBuilder()
+                        .title("接口文档")
+                        .description("# 接口文档")
+                        .termsOfServiceUrl("http://www.xx.com/")
+                        .contact("277769738@qq.com")
+                        .version("1.0")
+                        .build())
+                // 分组名称
+                .groupName("2.X版本")
+                .select()
+                // 这里指定Controller扫描包路径
+                .apis(RequestHandlerSelectors.basePackage("com.java.admin"))
+                .paths(PathSelectors.any())
+                .build();
+        return docket;
+    }
+
+    private List<ApiKey> securitySchemes() {
+        // 设置请求头信息
+        List<ApiKey> result = new ArrayList<>();
+        ApiKey apiKey = new ApiKey("Authorization", "Authorization", "header");
+        result.add(apiKey);
+        return result;
+    }
+}

play-common/src/main/java/com/starry/common/config/ThreadPoolConfig.java

@@ -0,0 +1,67 @@
+package com.starry.common.config;
+
+
+import com.starry.common.utils.ThreadsUtils;
+import org.apache.commons.lang3.concurrent.BasicThreadFactory;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.ThreadPoolExecutor;
+
+/**
+ * @author admin
+ * 线程池配置
+ * @since 2022/7/25
+ */
+@Configuration
+public class ThreadPoolConfig {
+
+    /**
+     * 核心线程池大小
+     **/
+    private final int corePoolSize = 50;
+    /**
+     * 最大可创建的线程数
+     **/
+    private final int maxPoolSize = 200;
+    /**
+     * 队列最大长度
+     **/
+    private final int queueCapacity = 1000;
+    /**
+     * 线程池维护线程所允许的空闲时间
+     **/
+    private final int keepAliveSeconds = 300;
+
+    @Bean(name = "threadPoolTaskExecutor")
+    public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
+        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+        executor.setMaxPoolSize(maxPoolSize);
+        executor.setCorePoolSize(corePoolSize);
+        executor.setQueueCapacity(queueCapacity);
+        executor.setKeepAliveSeconds(keepAliveSeconds);
+        // 线程池对拒绝任务(无线程可用)的处理策略
+        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
+        return executor;
+    }
+
+    /**
+     * 执行周期性或定时任务
+     */
+    @Bean(name = "scheduledExecutorService")
+    protected ScheduledExecutorService scheduledExecutorService() {
+        return new ScheduledThreadPoolExecutor(corePoolSize, new BasicThreadFactory.Builder().namingPattern("schedule-pool-%d").daemon(true).build(),
+                new ThreadPoolExecutor.CallerRunsPolicy()) {
+            @Override
+            protected void afterExecute(Runnable r, Throwable t) {
+                super.afterExecute(r, t);
+                ThreadsUtils.printException(r, t);
+            }
+        };
+    }
+
+
+}

play-common/src/main/java/com/starry/common/config/typehandler/ArrayLongTypeHandler.java

@@ -0,0 +1,48 @@
+package com.starry.common.config.typehandler;
+
+import cn.hutool.json.JSONUtil;
+import org.apache.ibatis.type.BaseTypeHandler;
+import org.apache.ibatis.type.JdbcType;
+import org.apache.ibatis.type.MappedJdbcTypes;
+import org.apache.ibatis.type.MappedTypes;
+
+import java.sql.CallableStatement;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * 存储到数据库, 将LONG数组转换成字符串;
+ * 从数据库获取数据, 将字符串转为LONG数组.
+ */
+@MappedTypes({Long[].class})
+@MappedJdbcTypes({JdbcType.VARCHAR})
+public class ArrayLongTypeHandler extends BaseTypeHandler<Long[]> {
+
+    private static final Long[] l = new Long[]{};
+
+    @Override
+    public void setNonNullParameter(PreparedStatement ps, int i,
+                                    Long[] parameter, JdbcType jdbcType) throws SQLException {
+        ps.setString(i, JSONUtil.toJsonStr(parameter));
+    }
+
+    @Override
+    public Long[] getNullableResult(ResultSet rs, String columnName)
+            throws SQLException {
+        return JSONUtil.parseArray(rs.getString(columnName)).toArray(l);
+    }
+
+    @Override
+    public Long[] getNullableResult(ResultSet rs, int columnIndex)
+            throws SQLException {
+        return JSONUtil.parseArray(rs.getString(columnIndex)).toArray(l);
+    }
+
+    @Override
+    public Long[] getNullableResult(CallableStatement cs, int columnIndex)
+            throws SQLException {
+        return JSONUtil.parseArray(cs.getString(columnIndex)).toArray(l);
+    }
+
+}

play-common/src/main/java/com/starry/common/config/typehandler/ArrayStringTypeHandler.java

@@ -0,0 +1,48 @@
+package com.starry.common.config.typehandler;
+
+import cn.hutool.json.JSONUtil;
+import org.apache.ibatis.type.BaseTypeHandler;
+import org.apache.ibatis.type.JdbcType;
+import org.apache.ibatis.type.MappedJdbcTypes;
+import org.apache.ibatis.type.MappedTypes;
+
+import java.sql.CallableStatement;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * 存储到数据库, 将String数组转换成字符串;
+ * 从数据库获取数据, 将字符串转为LONG数组.
+ */
+@MappedTypes({String[].class})
+@MappedJdbcTypes({JdbcType.VARCHAR})
+public class ArrayStringTypeHandler extends BaseTypeHandler<String[]> {
+
+    private static final String[] l = new String[]{};
+
+    @Override
+    public void setNonNullParameter(PreparedStatement ps, int i,
+                                    String[] parameter, JdbcType jdbcType) throws SQLException {
+        ps.setString(i, JSONUtil.toJsonStr(parameter));
+    }
+
+    @Override
+    public String[] getNullableResult(ResultSet rs, String columnName)
+            throws SQLException {
+        return JSONUtil.parseArray(rs.getString(columnName)).toArray(l);
+    }
+
+    @Override
+    public String[] getNullableResult(ResultSet rs, int columnIndex)
+            throws SQLException {
+        return JSONUtil.parseArray(rs.getString(columnIndex)).toArray(l);
+    }
+
+    @Override
+    public String[] getNullableResult(CallableStatement cs, int columnIndex)
+            throws SQLException {
+        return JSONUtil.parseArray(cs.getString(columnIndex)).toArray(l);
+    }
+
+}

play-common/src/main/java/com/starry/common/config/typehandler/JsonTypeHandler.java

@@ -0,0 +1,50 @@
+package com.starry.common.config.typehandler;
+
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
+import org.apache.ibatis.type.BaseTypeHandler;
+import org.apache.ibatis.type.JdbcType;
+import org.apache.ibatis.type.MappedJdbcTypes;
+import org.apache.ibatis.type.MappedTypes;
+
+import java.sql.CallableStatement;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * 存储到数据库, 将JSON对象转换成字符串;
+ * 从数据库获取数据, 将字符串转为JSON对象.
+ */
+@MappedTypes({JSONObject.class})
+@MappedJdbcTypes({JdbcType.VARCHAR})
+public class JsonTypeHandler extends BaseTypeHandler<JSONObject> {
+
+    @Override
+    public void setNonNullParameter(PreparedStatement ps, int i, JSONObject parameter,
+                                    JdbcType jdbcType) throws SQLException {
+
+        ps.setString(i, JSONUtil.toJsonStr(parameter));
+    }
+
+    @Override
+    public JSONObject getNullableResult(ResultSet rs, String columnName)
+            throws SQLException {
+
+        return JSONUtil.parseObj(rs.getString(columnName)).toBean(JSONObject.class);
+    }
+
+    @Override
+    public JSONObject getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
+
+        return JSONUtil.parseObj(rs.getString(columnIndex)).toBean(JSONObject.class);
+    }
+
+    @Override
+    public JSONObject getNullableResult(CallableStatement cs, int columnIndex)
+            throws SQLException {
+
+        return JSONUtil.parseObj(cs.getString(columnIndex)).toBean(JSONObject.class);
+    }
+
+}

play-common/src/main/java/com/starry/common/constant/CacheConstants.java

@@ -0,0 +1,23 @@
+package com.starry.common.constant;
+
+/**
+ * @author 缓存常量
+ * @since 2022/8/26
+ */
+public class CacheConstants {
+
+    /**
+     * 字典管理 cache key
+     */
+    public static final String SYS_DICT_KEY = "sys_dict:";
+
+    /**
+     * 登录用户 redis key
+     */
+    public static final String LOGIN_TOKEN_KEY = "login_tokens:";
+
+    /**
+     * 验证码 redis key
+     */
+    public static final String CAPTCHA_CODE_KEY = "captcha_codes:";
+}

play-common/src/main/java/com/starry/common/constant/Constants.java

@@ -0,0 +1,58 @@
+package com.starry.common.constant;
+
+/**
+ * @author admin
+ * 通用常量信息
+ */
+public class Constants {
+
+    /**
+     * UTF-8 字符集
+     */
+    public static final String UTF8 = "UTF-8";
+
+    /**
+     * GBK 字符集
+     */
+    public static final String GBK = "GBK";
+
+    /**
+     * http请求
+     */
+    public static final String HTTP = "http://";
+
+    /**
+     * https请求
+     */
+    public static final String HTTPS = "https://";
+
+    /**
+     * 通用成功标识
+     */
+    public static final String SUCCESS = "0";
+
+    /**
+     * 通用失败标识
+     */
+    public static final String FAIL = "1";
+
+    /**
+     * 登录成功
+     */
+    public static final String LOGIN_SUCCESS = "Success";
+
+    /**
+     * 注销
+     */
+    public static final String LOGOUT = "Logout";
+
+    /**
+     * 登录失败
+     */
+    public static final String LOGIN_FAIL = "Error";
+
+    /**
+     * 令牌前缀
+     */
+    public static final String LOGIN_USER_KEY = "login_user_key";
+}

play-common/src/main/java/com/starry/common/constant/HttpStatus.java

@@ -0,0 +1,89 @@
+package com.starry.common.constant;
+
+/**
+ * 返回状态码
+ *
+ * @author ruoyi
+ */
+@SuppressWarnings("")
+public class HttpStatus {
+    /**
+     * 操作成功
+     */
+    public static final int SUCCESS = 200;
+
+    /**
+     * 对象创建成功
+     */
+    public static final int CREATED = 201;
+
+    /**
+     * 请求已经被接受
+     */
+    public static final int ACCEPTED = 202;
+
+    /**
+     * 操作已经执行成功，但是没有返回数据
+     */
+    public static final int NO_CONTENT = 204;
+
+    /**
+     * 资源已被移除
+     */
+    public static final int MOVED_PERM = 301;
+
+    /**
+     * 重定向
+     */
+    public static final int SEE_OTHER = 303;
+
+    /**
+     * 资源没有被修改
+     */
+    public static final int NOT_MODIFIED = 304;
+
+    /**
+     * 参数列表错误（缺少，格式不匹配）
+     */
+    public static final int BAD_REQUEST = 400;
+
+    /**
+     * 未授权
+     */
+    public static final int UNAUTHORIZED = 401;
+
+    /**
+     * 访问受限，授权过期
+     */
+    public static final int FORBIDDEN = 403;
+
+    /**
+     * 资源，服务未找到
+     */
+    public static final int NOT_FOUND = 404;
+
+    /**
+     * 不允许的http方法
+     */
+    public static final int BAD_METHOD = 405;
+
+    /**
+     * 资源冲突，或者资源被锁
+     */
+    public static final int CONFLICT = 409;
+
+    /**
+     * 不支持的数据，媒体类型
+     */
+    public static final int UNSUPPORTED_TYPE = 415;
+
+    /**
+     * 系统内部错误
+     */
+    public static final int ERROR = 500;
+
+    /**
+     * 接口未实现
+     */
+    public static final int NOT_IMPLEMENTED = 501;
+}

play-common/src/main/java/com/starry/common/constant/SecurityConstants.java

@@ -0,0 +1,39 @@
+package com.starry.common.constant;
+
+/**
+ * @author admin
+ * 权限相关常量
+ */
+public class SecurityConstants {
+    /**
+     * 租户ID字段
+     */
+    public static final String DETAILS_TENANT_ID = "tenant_id";
+
+    /**
+     * 部门ID字段
+     */
+    public static final String DETAILS_DEPT_ID = "dept_id";
+
+    /**
+     * 用户ID字段
+     */
+    public static final String DETAILS_USER_ID = "user_id";
+
+    /**
+     * 用户名字段
+     */
+    public static final String DETAILS_USERNAME = "username";
+    /**
+     * 用户标识
+     */
+    public static final String USER_KEY = "user_key";
+    /**
+     * 登录用户
+     */
+    public static final String LOGIN_USER = "login_user";
+    /**
+     * 角色权限
+     */
+    public static final String ROLE_PERMISSION = "role_permission";
+}

play-common/src/main/java/com/starry/common/constant/UserConstants.java

@@ -0,0 +1,78 @@
+package com.starry.common.constant;
+
+/**
+ * @author 用户常量信息
+ * @since 2022/7/4
+ */
+public class UserConstants {
+
+    /**
+     * 校验返回结果码 0：唯一  1：不唯一
+     */
+    public final static String UNIQUE = "0";
+    public final static String NOT_UNIQUE = "1";
+
+    /**
+     * 是否菜单外链（否）
+     */
+    public static final String NO_FRAME = "0";
+
+    /**
+     * 是否菜单外链（是）
+     */
+    public static final String YES_FRAME = "1";
+
+    /**
+     * 菜单类型（目录）
+     */
+    public static final String TYPE_DIR = "0";
+
+    /**
+     * 菜单类型（菜单）
+     */
+    public static final String TYPE_MENU = "1";
+
+    /**
+     * 菜单类型（按钮）
+     */
+    public static final String TYPE_BUTTON = "2";
+
+    /**
+     * Layout组件标识
+     */
+    public final static String LAYOUT = "Layout";
+
+    /**
+     * InnerLink组件标识
+     */
+    public final static String INNER_LINK = "InnerLink";
+
+    /**
+     * ParentView组件标识
+     */
+    public final static String PARENT_VIEW = "ParentView";
+
+    /**
+     * 部门正常状态
+     */
+    public static final String DEPT_NORMAL = "0";
+
+    /**
+     * 部门停用状态
+     */
+    public static final String DEPT_DISABLE = "1";
+
+    /**
+     * 用户名长度限制
+     */
+    public static final int USERNAME_MIN_LENGTH = 2;
+
+    public static final int USERNAME_MAX_LENGTH = 20;
+
+    /**
+     * 密码长度限制
+     */
+    public static final int PASSWORD_MIN_LENGTH = 5;
+
+    public static final int PASSWORD_MAX_LENGTH = 20;
+}

play-common/src/main/java/com/starry/common/context/SecurityContextHolder.java

@@ -0,0 +1,77 @@
+package com.starry.common.context;
+
+import cn.hutool.core.convert.Convert;
+import com.alibaba.ttl.TransmittableThreadLocal;
+import com.starry.common.constant.SecurityConstants;
+import com.starry.common.utils.StringUtils;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * @author admin
+ * 获取当前线程变量中的 租户id 部门id 用户id、用户名称、Token等信息
+ * @since 2023/3/6
+ */
+public class SecurityContextHolder {
+
+    private static final TransmittableThreadLocal<Map<String, Object>> THREAD_LOCAL = new TransmittableThreadLocal<>();
+
+    public static void set(String key, Object value) {
+        Map<String, Object> map = getLocalMap();
+        map.put(key, value == null ? StringUtils.EMPTY : value);
+    }
+
+    public static String get(String key) {
+        Map<String, Object> map = getLocalMap();
+        return Convert.toStr(map.getOrDefault(key, StringUtils.EMPTY));
+    }
+
+
+    public static <T> T get(String key, Class<T> clazz) {
+        Map<String, Object> map = getLocalMap();
+        return StringUtils.cast(map.getOrDefault(key, null));
+    }
+
+    public static Map<String, Object> getLocalMap() {
+        Map<String, Object> map = THREAD_LOCAL.get();
+        if (map == null) {
+            map = new ConcurrentHashMap<>();
+            THREAD_LOCAL.set(map);
+        }
+        return map;
+    }
+
+    public static void setLocalMap(Map<String, Object> threadLocalMap) {
+        THREAD_LOCAL.set(threadLocalMap);
+    }
+
+
+    public static Long getTenantId() {
+        return Convert.toLong(get(SecurityConstants.DETAILS_TENANT_ID), 9999L);
+    }
+
+    public static void setTenantId(String tenantId) {
+        set(SecurityConstants.DETAILS_TENANT_ID, tenantId);
+    }
+
+    public static Long getDeptId() {
+        return Convert.toLong(get(SecurityConstants.DETAILS_DEPT_ID));
+    }
+
+    public static void setDeptId(String deptId) {
+        set(SecurityConstants.DETAILS_DEPT_ID, deptId);
+    }
+
+    public static String getPermission() {
+        return get(SecurityConstants.ROLE_PERMISSION);
+    }
+
+    public static void setPermission(String permissions) {
+        set(SecurityConstants.ROLE_PERMISSION, permissions);
+    }
+
+    public static void remove() {
+        THREAD_LOCAL.remove();
+    }
+}

play-common/src/main/java/com/starry/common/controller/CaptchaController.java

@@ -0,0 +1,33 @@
+package com.starry.common.controller;
+
+
+import com.starry.common.domain.Captcha;
+import com.starry.common.redis.CaptchaService;
+import com.starry.common.result.R;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.annotation.Resource;
+
+/**
+ * @author admin
+ * 验证码前端控制器
+ * @since 2022/7/7
+ */
+@RestController
+@RequestMapping("/captcha")
+public class CaptchaController {
+
+    @Resource
+    private CaptchaService captchaService;
+
+    @ApiOperation(value = "生成验证码拼图")
+    @PostMapping("get-captcha")
+    public R getCaptcha(@RequestBody Captcha captcha) {
+        return R.ok(captchaService.getCaptcha(captcha));
+    }
+
+}

play-common/src/main/java/com/starry/common/controller/CosController.java

@@ -0,0 +1,83 @@
+package com.starry.common.controller;
+
+import com.starry.common.result.R;
+import com.starry.common.utils.file.CosClientUtils;
+import com.tencent.cloud.CosStsClient;
+import com.tencent.cloud.Response;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.util.TreeMap;
+
+/**
+ * @author admin
+ * cos存储前端控制器
+ * @since 2022/11/13 17:51
+ */
+@Slf4j
+@RestController
+@RequestMapping("/cos")
+public class CosController {
+
+    @Value("${cos.secretId}")
+    private String secretId;
+    @Value("${cos.secretKey}")
+    private String secretKey;
+    @Value("${cos.regionName}")
+    private String regionName;
+    @Value("${cos.bucketName}")
+    private String bucketName;
+
+    @ApiOperation(value = "照片上传")
+    @PostMapping("/upload/image")
+    public R uploadImage(MultipartFile file) throws Exception {
+        if (!file.isEmpty()) {
+            String avatar = CosClientUtils.upload(file, "house");
+            return R.ok(avatar);
+        }
+        return R.error("上传照片异常，请联系管理员");
+    }
+
+    @ApiOperation(value = "获取cos临时密钥")
+    @GetMapping("/temp-key")
+    public R getTempKey() {
+        TreeMap<String, Object> config = new TreeMap<>();
+        try {
+            // 替换为您的云 api 密钥 SecretId
+            config.put("secretId", secretId);
+            // 替换为您的云 api 密钥 SecretKey
+            config.put("secretKey", secretKey);
+            // 临时密钥有效时长，单位是秒，默认 1800 秒，目前主账号最长 2 小时（即 7200 秒），子账号最长 36 小时（即 129600）秒
+            config.put("durationSeconds", 1800);
+            // 换成您的 bucket
+            config.put("bucket", bucketName);
+            // 换成 bucket 所在地区
+            config.put("region", regionName);
+
+            // 只允许用户访问 upload/house 目录下的资源
+            config.put("allowPrefixes", new String[]{"upload/house/*"});
+
+            // 密钥的权限列表。必须在这里指定本次临时密钥所需要的权限。
+            String[] allowActions = new String[]{
+                    // 简单上传
+                    "name/cos:PutObject",
+                    // 表单上传、小程序上传
+                    "name/cos:PostObject",
+                    // 分块上传
+                    "name/cos:InitiateMultipartUpload", "name/cos:ListMultipartUploads", "name/cos:ListParts", "name/cos:UploadPart", "name/cos:CompleteMultipartUpload"};
+            config.put("allowActions", allowActions);
+
+            Response response = CosStsClient.getCredential(config);
+            return R.ok(response);
+        } catch (Exception e) {
+            log.error("getTempKey error", e);
+            throw new IllegalArgumentException("no valid secret !");
+        }
+    }
+}

play-common/src/main/java/com/starry/common/domain/BaseEntity.java

@@ -0,0 +1,81 @@
+package com.starry.common.domain;
+
+import com.baomidou.mybatisplus.annotation.FieldFill;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.Version;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import javax.persistence.MappedSuperclass;
+import javax.persistence.Transient;
+import java.io.Serializable;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author admin
+ * 基类
+ * @since 2022/7/14
+ */
+@Getter
+@Setter
+@MappedSuperclass
+public class BaseEntity<T> implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @TableField(fill = FieldFill.INSERT)
+    @ApiModelProperty(value = "逻辑删除 1已删除 0未删除")
+    private Boolean deleted;
+
+    @TableField(fill = FieldFill.INSERT)
+    @ApiModelProperty(value = "创建人")
+    private String createdBy;
+
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @TableField(fill = FieldFill.INSERT)
+    @ApiModelProperty(value = "创建时间")
+    private Date createdTime;
+
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty(value = "更新时间")
+    private Date updatedTime;
+
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty(value = "更新人")
+    private String updatedBy;
+
+    @Version
+    @ApiModelProperty(value = "数据版本")
+    private Long version;
+
+
+    /**
+     * 搜索值
+     */
+    @TableField(exist = false)
+    private String searchValue;
+
+    /**
+     * 开始日期
+     */
+    @TableField(exist = false)
+    private String beginTime;
+
+    /**
+     * 结束日期
+     */
+    @TableField(exist = false)
+    private String endTime;
+
+    /**
+     * 请求参数
+     */
+    @Transient
+    @TableField(exist = false)
+    private Map<String, Object> params = new HashMap<>();
+
+}

play-common/src/main/java/com/starry/common/domain/BasePageEntity.java

@@ -0,0 +1,73 @@
+package com.starry.common.domain;
+
+import com.baomidou.mybatisplus.annotation.FieldFill;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.Version;
+import lombok.Data;
+import lombok.experimental.Accessors;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import javax.persistence.Transient;
+import java.io.Serializable;
+import java.util.Date;
+import java.util.Map;
+
+/**
+ * @author admin
+ * 分页基类
+ * @since 2021/9/2
+ */
+@Data
+@Accessors(chain = true)
+public class BasePageEntity implements Serializable {
+
+    private int currentPage = 1;
+
+    private int pageSize = 10;
+
+    private int pageNum = 1;
+
+    @TableField(fill = FieldFill.INSERT)
+    private Boolean deleted = Boolean.FALSE;
+
+    @TableField(fill = FieldFill.INSERT)
+    private Long createdBy;
+
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @TableField(fill = FieldFill.INSERT)
+    private Date createdTime;
+
+    @TableField(fill = FieldFill.UPDATE)
+    private Date updatedTime;
+
+    @TableField(fill = FieldFill.UPDATE)
+    private Long updatedBy;
+
+    @Version
+    private Long version;
+
+    /**
+     * 搜索值
+     */
+    @TableField(exist = false)
+    private String searchValue;
+
+    /**
+     * 开始日期
+     */
+    @TableField(exist = false)
+    private String beginTime;
+
+    /**
+     * 结束日期
+     */
+    @TableField(exist = false)
+    private String endTime;
+
+    /**
+     * 请求参数
+     */
+    @Transient
+    @TableField(exist = false)
+    private Map<String, Object> params;
+}

play-common/src/main/java/com/starry/common/domain/Captcha.java

@@ -0,0 +1,60 @@
+package com.starry.common.domain;
+
+import lombok.Data;
+
+/**
+ * @author admin
+ * 验证码拼图类
+ */
+@Data
+public class Captcha {
+
+    /**
+     * 随机字符串
+     **/
+    private String nonceStr;
+    /**
+     * 验证值
+     **/
+    private String value;
+    /**
+     * 生成的画布的base64
+     **/
+    private String canvasSrc;
+    /**
+     * 画布宽度
+     **/
+    private Integer canvasWidth;
+    /**
+     * 画布高度
+     **/
+    private Integer canvasHeight;
+    /**
+     * 生成的阻塞块的base64
+     **/
+    private String blockSrc;
+    /**
+     * 阻塞块宽度
+     **/
+    private Integer blockWidth;
+    /**
+     * 阻塞块高度
+     **/
+    private Integer blockHeight;
+    /**
+     * 阻塞块凸凹半径
+     **/
+    private Integer blockRadius;
+    /**
+     * 阻塞块的横轴坐标
+     **/
+    private Integer blockX;
+    /**
+     * 阻塞块的纵轴坐标
+     **/
+    private Integer blockY;
+    /**
+     * 图片获取位置
+     **/
+    private Integer place;
+}

play-common/src/main/java/com/starry/common/enums/BusinessType.java

@@ -0,0 +1,53 @@
+package com.starry.common.enums;
+
+/**
+ * @author admin
+ * 业务操作类型
+ * @since 2022/7/22
+ */
+public enum BusinessType {
+    /**
+     * 其它
+     */
+    OTHER,
+
+    /**
+     * 新增
+     */
+    INSERT,
+
+    /**
+     * 修改
+     */
+    UPDATE,
+
+    /**
+     * 删除
+     */
+    DELETE,
+    /**
+     * 导出
+     */
+    EXPORT,
+
+    /**
+     * 导入
+     */
+    IMPORT,
+    /**
+     * 生成代码
+     */
+    GENCODE,
+    /**
+     * 清空数据
+     */
+    CLEAN,
+    /**
+     * 强退
+     */
+    FORCE,
+    /**
+     * 授权
+     */
+    GRANT,
+}

play-common/src/main/java/com/starry/common/filter/RepeatableFilter.java

@@ -0,0 +1,40 @@
+package com.starry.common.filter;
+
+import com.starry.common.utils.StringUtils;
+import org.springframework.http.MediaType;
+
+import javax.servlet.*;
+import javax.servlet.http.HttpServletRequest;
+import java.io.IOException;
+
+/**
+ * Repeatable 过滤器
+ *
+ * @author ruoyi
+ */
+public class RepeatableFilter implements Filter {
+    @Override
+    public void init(FilterConfig filterConfig) throws ServletException {
+
+    }
+
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
+            throws IOException, ServletException {
+        ServletRequest requestWrapper = null;
+        if (request instanceof HttpServletRequest
+                && StringUtils.equalsAnyIgnoreCase(request.getContentType(), MediaType.APPLICATION_JSON_VALUE)) {
+            requestWrapper = new RepeatedlyRequestWrapper((HttpServletRequest) request, response);
+        }
+        if (null == requestWrapper) {
+            chain.doFilter(request, response);
+        } else {
+            chain.doFilter(requestWrapper, response);
+        }
+    }
+
+    @Override
+    public void destroy() {
+
+    }
+}

play-common/src/main/java/com/starry/common/filter/RepeatedlyRequestWrapper.java

@@ -0,0 +1,65 @@
+package com.starry.common.filter;
+
+
+import com.starry.common.utils.http.HttpHelper;
+
+import javax.servlet.ReadListener;
+import javax.servlet.ServletInputStream;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletRequestWrapper;
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+/**
+ * 构建可重复读取inputStream的request
+ *
+ * @author ruoyi
+ */
+public class RepeatedlyRequestWrapper extends HttpServletRequestWrapper {
+    private final byte[] body;
+
+    public RepeatedlyRequestWrapper(HttpServletRequest request, ServletResponse response) throws IOException {
+        super(request);
+        request.setCharacterEncoding("UTF-8");
+        response.setCharacterEncoding("UTF-8");
+
+        body = HttpHelper.getBodyString(request).getBytes("UTF-8");
+    }
+
+    @Override
+    public BufferedReader getReader() throws IOException {
+        return new BufferedReader(new InputStreamReader(getInputStream()));
+    }
+
+    @Override
+    public ServletInputStream getInputStream() throws IOException {
+
+        final ByteArrayInputStream bais = new ByteArrayInputStream(body);
+
+        return new ServletInputStream() {
+
+            @Override
+            public int read() throws IOException {
+                return bais.read();
+            }
+
+            @Override
+            public boolean isFinished() {
+                return false;
+            }
+
+            @Override
+            public boolean isReady() {
+                return false;
+            }
+
+            @Override
+            public void setReadListener(ReadListener readListener) {
+
+            }
+        };
+    }
+}

play-common/src/main/java/com/starry/common/filter/XssFilter.java

@@ -0,0 +1,79 @@
+package com.starry.common.filter;
+
+import com.starry.common.utils.StringUtils;
+
+import javax.servlet.*;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * 防止XSS攻击的过滤器
+ *
+ * @author ruoyi
+ */
+public class XssFilter implements Filter {
+    /**
+     * 排除链接
+     */
+    public List<String> excludes = new ArrayList<>();
+
+    /**
+     * xss过滤开关
+     */
+    public boolean enabled = false;
+
+    @Override
+    public void init(FilterConfig filterConfig) {
+        String tempExcludes = filterConfig.getInitParameter("excludes");
+        String tempEnabled = filterConfig.getInitParameter("enabled");
+        if (StringUtils.isNotEmpty(tempExcludes)) {
+            String[] url = tempExcludes.split(",");
+            excludes.addAll(Arrays.asList(url));
+        }
+        if (StringUtils.isNotEmpty(tempEnabled)) {
+            enabled = Boolean.parseBoolean(tempEnabled);
+        }
+    }
+
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
+            throws IOException, ServletException {
+        HttpServletRequest req = (HttpServletRequest) request;
+        HttpServletResponse resp = (HttpServletResponse) response;
+        if (handleExcludeURL(req, resp)) {
+            chain.doFilter(request, response);
+            return;
+        }
+        XssHttpServletRequestWrapper xssRequest = new XssHttpServletRequestWrapper((HttpServletRequest) request);
+        chain.doFilter(xssRequest, response);
+    }
+
+    private boolean handleExcludeURL(HttpServletRequest request, HttpServletResponse response) {
+        if (!enabled) {
+            return true;
+        }
+        if (excludes == null || excludes.isEmpty()) {
+            return false;
+        }
+        String url = request.getServletPath();
+        for (String pattern : excludes) {
+            Pattern p = Pattern.compile("^" + pattern);
+            Matcher m = p.matcher(url);
+            if (m.find()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void destroy() {
+
+    }
+}

play-common/src/main/java/com/starry/common/filter/XssHttpServletRequestWrapper.java

@@ -0,0 +1,90 @@
+package com.starry.common.filter;
+
+import com.starry.common.utils.StringUtils;
+import com.starry.common.utils.html.EscapeUtil;
+import org.apache.commons.io.IOUtils;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+
+import javax.servlet.ReadListener;
+import javax.servlet.ServletInputStream;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletRequestWrapper;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * XSS过滤处理
+ *
+ * @author ruoyi
+ */
+public class XssHttpServletRequestWrapper extends HttpServletRequestWrapper {
+    /**
+     * @param request
+     */
+    public XssHttpServletRequestWrapper(HttpServletRequest request) {
+        super(request);
+    }
+
+    @Override
+    public String[] getParameterValues(String name) {
+        String[] values = super.getParameterValues(name);
+        if (values != null) {
+            int length = values.length;
+            String[] escapseValues = new String[length];
+            for (int i = 0; i < length; i++) {
+                // 防xss攻击和过滤前后空格
+                escapseValues[i] = EscapeUtil.clean(values[i]).trim();
+            }
+            return escapseValues;
+        }
+        return super.getParameterValues(name);
+    }
+
+    @Override
+    public ServletInputStream getInputStream() throws IOException {
+        // 非json类型，直接返回
+        if (!isJsonRequest()) {
+            return super.getInputStream();
+        }
+
+        // 为空，直接返回
+        String json = IOUtils.toString(super.getInputStream(), StandardCharsets.UTF_8);
+        if (StringUtils.isEmpty(json)) {
+            return super.getInputStream();
+        }
+
+        // xss过滤
+        json = EscapeUtil.clean(json).trim();
+        final ByteArrayInputStream bis = new ByteArrayInputStream(json.getBytes(StandardCharsets.UTF_8));
+        return new ServletInputStream() {
+            @Override
+            public boolean isFinished() {
+                return true;
+            }
+
+            @Override
+            public boolean isReady() {
+                return true;
+            }
+
+            @Override
+            public void setReadListener(ReadListener readListener) {
+            }
+
+            @Override
+            public int read() throws IOException {
+                return bis.read();
+            }
+        };
+    }
+
+    /**
+     * 是否是Json请求
+     */
+    public boolean isJsonRequest() {
+        String header = super.getHeader(HttpHeaders.CONTENT_TYPE);
+        return MediaType.APPLICATION_JSON_VALUE.equalsIgnoreCase(header);
+    }
+}

play-common/src/main/java/com/starry/common/redis/CaptchaService.java

@@ -0,0 +1,97 @@
+package com.starry.common.redis;
+
+import cn.hutool.core.util.StrUtil;
+import com.starry.common.constant.CacheConstants;
+import com.starry.common.domain.Captcha;
+import com.starry.common.utils.CaptchaUtils;
+import org.springframework.data.redis.core.StringRedisTemplate;
+import org.springframework.data.redis.core.ValueOperations;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.awt.image.BufferedImage;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 验证码服务
+ *
+ * @author admin
+ */
+@Service
+public class CaptchaService {
+    /**
+     * 拼图验证码允许偏差
+     **/
+    private static final Integer ALLOW_DEVIATION = 3;
+
+    @Resource
+    private StringRedisTemplate stringRedisTemplate;
+
+    /**
+     * 校验验证码
+     *
+     * @param imageKey
+     * @param imageCode
+     * @return boolean
+     **/
+    public String checkImageCode(String imageKey, String imageCode) {
+        ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
+        String text = ops.get(CacheConstants.CAPTCHA_CODE_KEY + imageKey);
+        if (StrUtil.isBlank(text)) {
+            return "验证码已失效";
+        }
+        // 根据移动距离判断验证是否成功
+        if (Math.abs(Integer.parseInt(text) - Integer.parseInt(imageCode)) > ALLOW_DEVIATION) {
+            return "验证失败，请控制拼图对齐缺口";
+        }
+        return null;
+    }
+
+    /**
+     * 缓存验证码，有效期15分钟
+     *
+     * @param key
+     * @param code
+     **/
+    public void saveImageCode(String key, String code) {
+        ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
+        ops.set(CacheConstants.CAPTCHA_CODE_KEY + key, code, 15, TimeUnit.MINUTES);
+    }
+
+    /**
+     * 获取验证码拼图（生成的抠图和带抠图阴影的大图及抠图坐标）
+     **/
+    public Object getCaptcha(Captcha captcha) {
+        // 参数校验
+        CaptchaUtils.checkCaptcha(captcha);
+        // 获取画布的宽高
+        int canvasWidth = captcha.getCanvasWidth();
+        int canvasHeight = captcha.getCanvasHeight();
+        // 获取阻塞块的宽高/半径
+        int blockWidth = captcha.getBlockWidth();
+        int blockHeight = captcha.getBlockHeight();
+        int blockRadius = captcha.getBlockRadius();
+        // 获取资源图
+        BufferedImage canvasImage = CaptchaUtils.getBufferedImage(captcha.getPlace());
+        // 调整原图到指定大小
+        canvasImage = CaptchaUtils.imageResize(canvasImage, canvasWidth, canvasHeight);
+        // 随机生成阻塞块坐标
+        int blockX = CaptchaUtils.getNonceByRange(blockWidth, canvasWidth - blockWidth - 10);
+        int blockY = CaptchaUtils.getNonceByRange(10, canvasHeight - blockHeight + 1);
+        // 阻塞块
+        BufferedImage blockImage = new BufferedImage(blockWidth, blockHeight, BufferedImage.TYPE_4BYTE_ABGR);
+        // 新建的图像根据轮廓图颜色赋值，源图生成遮罩
+        CaptchaUtils.cutByTemplate(canvasImage, blockImage, blockWidth, blockHeight, blockRadius, blockX, blockY);
+        // 移动横坐标
+        String nonceStr = UUID.randomUUID().toString().replaceAll("-", "");
+        // 缓存
+        saveImageCode(nonceStr, String.valueOf(blockX));
+        // 设置返回参数
+        captcha.setNonceStr(nonceStr);
+        captcha.setBlockY(blockY);
+        captcha.setBlockSrc(CaptchaUtils.toBase64(blockImage, "png"));
+        captcha.setCanvasSrc(CaptchaUtils.toBase64(canvasImage, "png"));
+        return captcha;
+    }
+}

play-common/src/main/java/com/starry/common/redis/RedisCache.java

@@ -0,0 +1,82 @@
+package com.starry.common.redis;
+
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.core.ValueOperations;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.Collection;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author rieds 工具类
+ * @since 2022/8/26
+ */
+@Component
+public class RedisCache {
+
+    @Resource
+    public RedisTemplate redisTemplate;
+
+    /**
+     * 获得缓存的基本对象。
+     *
+     * @param key 缓存键值
+     * @return 缓存键值对应的数据
+     */
+    public <T> T getCacheObject(final String key) {
+        ValueOperations<String, T> operations = redisTemplate.opsForValue();
+        return operations.get(key);
+    }
+
+    /**
+     * 缓存基本的对象，Integer、String、实体类等
+     *
+     * @param key   缓存的键值
+     * @param value 缓存的值
+     */
+    public <T> void setCacheObject(final String key, final T value) {
+        redisTemplate.opsForValue().set(key, value);
+    }
+
+    /**
+     * 缓存基本的对象，Integer、String、实体类等
+     *
+     * @param key      缓存的键值
+     * @param value    缓存的值
+     * @param timeout  过期时间
+     * @param timeUnit 时间颗粒度
+     */
+    public <T> void setCacheObject(final String key, final T value, final Long timeout, final TimeUnit timeUnit) {
+        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
+    }
+
+    /**
+     * 删除单个对象
+     *
+     * @param key
+     */
+    public boolean deleteObject(final String key) {
+        return redisTemplate.delete(key);
+    }
+
+    /**
+     * 获得缓存的基本对象列表
+     *
+     * @param pattern 字符串前缀
+     * @return 对象列表
+     */
+    public Collection<String> keys(final String pattern) {
+        return redisTemplate.keys(pattern);
+    }
+
+    /**
+     * 删除集合对象
+     *
+     * @param collection 多个对象
+     * @return
+     */
+    public long deleteObject(final Collection collection) {
+        return redisTemplate.delete(collection);
+    }
+}

play-common/src/main/java/com/starry/common/result/IBaseEnum.java

@@ -0,0 +1,19 @@
+package com.starry.common.result;
+
+/**
+ * @author admin
+ */
+public interface IBaseEnum {
+
+    /**
+     * 获取枚举值
+     *
+     */
+    int getCode();
+
+    /**
+     * 获取枚举描述
+     *
+     */
+    String getMessage();
+}

play-common/src/main/java/com/starry/common/result/R.java

@@ -0,0 +1,133 @@
+package com.starry.common.result;
+
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.beans.ConstructorProperties;
+import java.io.Serializable;
+
+/**
+ * @author admin
+ * @since 2021/9/1
+ */
+@Data
+@ApiModel(value = "全局统一返回结果")
+public class R implements Serializable {
+
+    public final static String OK_MSG = "请求成功";
+    public final static String FAIL_MSG = "请求失败";
+
+    @ApiModelProperty(value = "是否成功")
+    private boolean success;
+
+    @ApiModelProperty(value = "返回码")
+    private Integer code;
+
+    @ApiModelProperty(value = "返回消息")
+    private String message;
+
+    @ApiModelProperty(value = "返回数据")
+    private Object data;
+
+    @ApiModelProperty(value = "总条数")
+    private Long total;
+
+    @ApiModelProperty(value = "分页信息")
+    private PageInfo pageInfo;
+
+    private R() {
+    }
+
+    private R(int code, Boolean success, String msg, Object data) {
+        this.code = code;
+        this.success = success;
+        this.message = msg;
+        if (data instanceof Page<?>) {
+            Page<?> page = (Page<?>) data;
+            this.total = page.getTotal();
+            this.data = page.getRecords();
+            this.pageInfo = new PageInfo((int) page.getCurrent(), (int) page.getSize(), page.getTotal(), page.getPages());
+        } else {
+            this.data = data;
+        }
+    }
+
+    public static R ok() {
+        R r = new R();
+        r.setSuccess(true);
+        r.setCode(ResultCodeEnum.SUCCESS.getCode());
+        r.setMessage(ResultCodeEnum.SUCCESS.getMessage());
+        return r;
+    }
+
+    public static R ok(Object data) {
+        return new R(ResultCodeEnum.SUCCESS.getCode(), true, ResultCodeEnum.SUCCESS.getMessage(), data);
+    }
+
+    public static R ok(String msg, Object data) {
+        return new R(ResultCodeEnum.SUCCESS.getCode(), true, msg, data);
+    }
+
+    public static R error() {
+        R r = new R();
+        r.setSuccess(false);
+        r.setCode(ResultCodeEnum.FAILED.getCode());
+        r.setMessage(ResultCodeEnum.FAILED.getMessage());
+        return r;
+    }
+
+    public static R error(String msg) {
+        return new R(ResultCodeEnum.FAILED.getCode(), false, msg, null);
+    }
+
+    public static R error(int errorCode, String msg) {
+        return new R(errorCode, false, msg, null);
+    }
+
+    public static R unauthorized() {
+        return new R(ResultCodeEnum.UNAUTHORIZED.getCode(), false, ResultCodeEnum.UNAUTHORIZED.getMessage(), null);
+    }
+
+    public R message(String message) {
+        this.setMessage(message);
+        return this;
+    }
+
+    public R code(Integer code) {
+        this.setCode(code);
+        return this;
+    }
+
+    public R data(Object data) {
+        this.setData(data);
+        return this;
+    }
+
+    @Data
+    public static class PageInfo {
+
+        @ApiModelProperty("当前页")
+        protected int currentPage;
+        @ApiModelProperty("页大小")
+        protected int pageSize;
+        @ApiModelProperty("总记录数")
+        protected long totalCount;
+        @ApiModelProperty("总页数")
+        protected long totalPage;
+
+        public PageInfo() {
+        }
+
+        @ConstructorProperties({"currentPage", "pageSize", "totalCount", "totalPage"})
+        public PageInfo(int currentPage, int pageSize, long totalCount, long totalPage) {
+            this.currentPage = currentPage;
+            this.pageSize = pageSize;
+            this.totalCount = totalCount;
+            this.totalPage = totalPage;
+        }
+    }
+
+}

play-common/src/main/java/com/starry/common/result/ResultCodeEnum.java

@@ -0,0 +1,32 @@
+package com.starry.common.result;
+
+/**
+ * @author admin
+ * 返回码枚举
+ */
+public enum ResultCodeEnum implements IBaseEnum {
+
+    SUCCESS(200, "操作成功"),
+    FAILED(500, "操作失败"),
+    VALIDATE_FAILED(404, "参数检验失败"),
+    UNAUTHORIZED(401, "无效的会话，或者会话已过期，请重新登录。"),
+    FORBIDDEN(403, "没有相关权限");
+
+    private final int code;
+    private final String message;
+
+    ResultCodeEnum(int code, String message) {
+        this.code = code;
+        this.message = message;
+    }
+
+    @Override
+    public int getCode() {
+        return code;
+    }
+
+    @Override
+    public String getMessage() {
+        return message;
+    }
+}

play-common/src/main/java/com/starry/common/sensitive/Sensitive.java

@@ -0,0 +1,28 @@
+package com.starry.common.sensitive;
+
+import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 脱敏注解
+ *
+ * @author admin
+ *  
+ **/
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+@JacksonAnnotationsInside
+@JsonSerialize(using = SensitiveSerialize.class)
+public @interface Sensitive {
+
+    /**
+     * 脱敏数据类型
+     */
+    SensitiveTypeEnum type();
+
+}

play-common/src/main/java/com/starry/common/sensitive/SensitiveSerialize.java

@@ -0,0 +1,67 @@
+package com.starry.common.sensitive;
+
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.BeanProperty;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.JsonSerializer;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.ser.ContextualSerializer;
+import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
+
+import java.io.IOException;
+import java.util.Objects;
+
+/**
+ * @author admin
+ *  
+ * 脱敏序列化
+ */
+@NoArgsConstructor
+@AllArgsConstructor
+public class SensitiveSerialize extends JsonSerializer<String> implements ContextualSerializer {
+
+    private SensitiveTypeEnum type;
+
+    @Override
+    public void serialize(final String originStr, final JsonGenerator jsonGenerator,
+                          final SerializerProvider serializerProvider) throws IOException {
+        switch (type) {
+            case CHINESE_NAME:
+                jsonGenerator.writeString(SensitiveUtils.chineseName(originStr));
+                break;
+            case MOBILE_PHONE:
+                jsonGenerator.writeString(SensitiveUtils.mobilePhone(originStr));
+                break;
+            case EMAIL:
+                jsonGenerator.writeString(SensitiveUtils.email(originStr));
+                break;
+            case PASSWORD:
+                jsonGenerator.writeString(SensitiveUtils.password(originStr));
+                break;
+            case KEY:
+                jsonGenerator.writeString(SensitiveUtils.key(originStr));
+                break;
+            default:
+                throw new IllegalArgumentException("未定义的敏感信息枚举类" + type);
+        }
+    }
+
+    @Override
+    public JsonSerializer<?> createContextual(final SerializerProvider serializerProvider, final BeanProperty beanProperty) throws JsonMappingException {
+        if (beanProperty != null) {
+            if (Objects.equals(beanProperty.getType().getRawClass(), String.class)) {
+                Sensitive sensitive = beanProperty.getAnnotation(Sensitive.class);
+                if (sensitive == null) {
+                    sensitive = beanProperty.getContextAnnotation(Sensitive.class);
+                }
+                if (sensitive != null) {
+                    return new SensitiveSerialize(sensitive.type());
+                }
+            }
+            return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
+        }
+        return serializerProvider.findNullValueSerializer(null);
+    }
+
+}

play-common/src/main/java/com/starry/common/sensitive/SensitiveTypeEnum.java

@@ -0,0 +1,31 @@
+package com.starry.common.sensitive;
+
+/**
+ * 敏感信息枚举类
+ *
+ * @author admin
+ **/
+public enum SensitiveTypeEnum {
+
+    /**
+     * 用户名, 李*天, 张*
+     */
+    CHINESE_NAME,
+    /**
+     * 手机号, 185****1653
+     */
+    MOBILE_PHONE,
+    /**
+     * 电子邮件, r*****o@qq.com
+     */
+    EMAIL,
+    /**
+     * 密码, ******
+     */
+    PASSWORD,
+    /**
+     * 密钥, 最后三位其他都是***
+     */
+    KEY
+
+}

play-common/src/main/java/com/starry/common/sensitive/SensitiveUtils.java

@@ -0,0 +1,155 @@
+package com.starry.common.sensitive;
+
+import cn.hutool.core.util.StrUtil;
+
+/**
+ * 数据脱敏工具类
+ *
+ * @author  admin
+ * @since 2021/7/19 16:21
+ */
+public class SensitiveUtils {
+
+    /**
+     * 默认填充字符
+     */
+    public static final String DEFAULT_PAD_STR = "*";
+
+    /**
+     * 数据脱敏
+     */
+    public static String process(String data) {
+        return process(data, 2, 1, DEFAULT_PAD_STR);
+    }
+
+    /**
+     * 数据脱敏
+     */
+    public static String process(String data, Integer leftLen, Integer rightLen) {
+        return process(data, leftLen, rightLen, DEFAULT_PAD_STR);
+    }
+
+    /**
+     * 对字符串进行脱敏操作
+     *
+     * @param originStr       原始字符串
+     * @param prefixNoMaskLen 左侧需要保留几位明文字段
+     * @param suffixNoMaskLen 右侧需要保留几位明文字段
+     * @param maskStr         用于遮罩的字符串, 如'*'
+     * @return 脱敏后结果
+     */
+    public static String process(String originStr, int prefixNoMaskLen, int suffixNoMaskLen, String maskStr) {
+        if (originStr == null) {
+            return null;
+        }
+
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0, n = originStr.length(); i < n; i++) {
+            if (i < prefixNoMaskLen) {
+                sb.append(originStr.charAt(i));
+                continue;
+            }
+            if (i > (n - suffixNoMaskLen - 1)) {
+                sb.append(originStr.charAt(i));
+                continue;
+            }
+            sb.append(maskStr);
+        }
+        return sb.toString();
+    }
+
+    /**
+     * 中文姓名只显示最后一个汉字
+     *
+     * @param fullName 姓名
+     * @return
+     */
+    public static String chineseName(String fullName) {
+        if (fullName == null) {
+            return null;
+        }
+        return process(fullName, 0, 1, DEFAULT_PAD_STR);
+    }
+
+    /**
+     * 手机号码前三位，后四位，如186****2356
+     *
+     * @param num 手机号码
+     * @return
+     */
+    public static String mobilePhone(String num) {
+        return process(num, 0, 4, DEFAULT_PAD_STR);
+    }
+
+    /**
+     * 地址只显示到地区
+     *
+     * @param address 地址
+     * @return
+     */
+    public static String address(String address) {
+        return process(address, 6, 0, DEFAULT_PAD_STR);
+    }
+
+    /**
+     * 电子邮箱 仅显示第一个字母，@后面的地址显示，比如：r**@qq.com
+     *
+     * @param email 电子邮箱
+     * @return
+     */
+    public static String email(String email) {
+        if (email == null) {
+            return null;
+        }
+        int index = StrUtil.indexOf(email, '@');
+        if (index <= 1) {
+            return email;
+        }
+        String preEmail = process(email.substring(0, index), 1, 0, DEFAULT_PAD_STR);
+        return preEmail + email.substring(index);
+
+    }
+
+    /**
+     * 密码的全部字符，如：******
+     *
+     * @param password 密码
+     * @return
+     */
+    public static String password(String password) {
+        if (password == null) {
+            return null;
+        }
+        return "******";
+    }
+
+    /**
+     * 密钥除了最后三位，全部，比如：***klo
+     *
+     * @param key 密钥
+     * @return 结果
+     */
+    public static String key(String key) {
+        if (key == null) {
+            return null;
+        }
+        int viewLength = 6;
+        StringBuilder tmpKey = new StringBuilder(process(key, 0, 3, DEFAULT_PAD_STR));
+        if (tmpKey.length() > viewLength) {
+            return tmpKey.substring(tmpKey.length() - viewLength);
+        } else if (tmpKey.length() < viewLength) {
+            int buffLength = viewLength - tmpKey.length();
+            for (int i = 0; i < buffLength; i++) {
+                tmpKey.insert(0, DEFAULT_PAD_STR);
+            }
+            return tmpKey.toString();
+        } else {
+            return tmpKey.toString();
+        }
+    }
+
+    public static void main(String[] args) {
+        String s = mobilePhone("18653653621");
+        System.out.println(s);
+    }
+}

play-common/src/main/java/com/starry/common/utils/Arith.java

@@ -0,0 +1,113 @@
+package com.starry.common.utils;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+/**
+ * 精确的浮点数运算
+ *
+ * @author ruoyi
+ */
+public class Arith {
+
+    /**
+     * 默认除法运算精度
+     */
+    private static final int DEF_DIV_SCALE = 10;
+
+    /**
+     * 这个类不能实例化
+     */
+    private Arith() {
+    }
+
+    /**
+     * 提供精确的加法运算。
+     *
+     * @param v1 被加数
+     * @param v2 加数
+     * @return 两个参数的和
+     */
+    public static double add(double v1, double v2) {
+        BigDecimal b1 = new BigDecimal(Double.toString(v1));
+        BigDecimal b2 = new BigDecimal(Double.toString(v2));
+        return b1.add(b2).doubleValue();
+    }
+
+    /**
+     * 提供精确的减法运算。
+     *
+     * @param v1 被减数
+     * @param v2 减数
+     * @return 两个参数的差
+     */
+    public static double sub(double v1, double v2) {
+        BigDecimal b1 = new BigDecimal(Double.toString(v1));
+        BigDecimal b2 = new BigDecimal(Double.toString(v2));
+        return b1.subtract(b2).doubleValue();
+    }
+
+    /**
+     * 提供精确的乘法运算。
+     *
+     * @param v1 被乘数
+     * @param v2 乘数
+     * @return 两个参数的积
+     */
+    public static double mul(double v1, double v2) {
+        BigDecimal b1 = new BigDecimal(Double.toString(v1));
+        BigDecimal b2 = new BigDecimal(Double.toString(v2));
+        return b1.multiply(b2).doubleValue();
+    }
+
+    /**
+     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
+     * 小数点以后10位，以后的数字四舍五入。
+     *
+     * @param v1 被除数
+     * @param v2 除数
+     * @return 两个参数的商
+     */
+    public static double div(double v1, double v2) {
+        return div(v1, v2, DEF_DIV_SCALE);
+    }
+
+    /**
+     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
+     * 定精度，以后的数字四舍五入。
+     *
+     * @param v1    被除数
+     * @param v2    除数
+     * @param scale 表示表示需要精确到小数点以后几位。
+     * @return 两个参数的商
+     */
+    public static double div(double v1, double v2, int scale) {
+        if (scale < 0) {
+            throw new IllegalArgumentException(
+                    "The scale must be a positive integer or zero");
+        }
+        BigDecimal b1 = new BigDecimal(Double.toString(v1));
+        BigDecimal b2 = new BigDecimal(Double.toString(v2));
+        if (b1.compareTo(BigDecimal.ZERO) == 0) {
+            return BigDecimal.ZERO.doubleValue();
+        }
+        return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue();
+    }
+
+    /**
+     * 提供精确的小数位四舍五入处理。
+     *
+     * @param v     需要四舍五入的数字
+     * @param scale 小数点后保留几位
+     * @return 四舍五入后的结果
+     */
+    public static double round(double v, int scale) {
+        if (scale < 0) {
+            throw new IllegalArgumentException(
+                    "The scale must be a positive integer or zero");
+        }
+        BigDecimal b = new BigDecimal(Double.toString(v));
+        BigDecimal one = BigDecimal.ONE;
+        return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue();
+    }
+}

play-common/src/main/java/com/starry/common/utils/CaptchaUtils.java

@@ -0,0 +1,234 @@
+package com.starry.common.utils;
+
+
+import com.starry.common.domain.Captcha;
+import org.apache.commons.lang3.RandomUtils;
+
+import javax.imageio.ImageIO;
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.util.Base64;
+import java.util.Objects;
+import java.util.Random;
+
+/**
+ * @author 拼图验证码工具类
+ * @since 2022/9/6
+ */
+public class CaptchaUtils {
+
+    /**
+     * 网络图片地址
+     **/
+    private final static String IMG_URL = "https://loyer.wang/view/ftp/wallpaper/%s.jpg";
+
+    /**
+     * 本地图片地址
+     **/
+    private final static String IMG_PATH = "E:/Temp/wallpaper/%s.jpg";
+
+    /**
+     * 入参校验设置默认值
+     **/
+    public static void checkCaptcha(Captcha captcha) {
+        // 设置画布宽度默认值
+        if (captcha.getCanvasWidth() == null) {
+            captcha.setCanvasWidth(320);
+        }
+        // 设置画布高度默认值
+        if (captcha.getCanvasHeight() == null) {
+            captcha.setCanvasHeight(155);
+        }
+        // 设置阻塞块宽度默认值
+        if (captcha.getBlockWidth() == null) {
+            captcha.setBlockWidth(65);
+        }
+        // 设置阻塞块高度默认值
+        if (captcha.getBlockHeight() == null) {
+            captcha.setBlockHeight(55);
+        }
+        // 设置阻塞块凹凸半径默认值
+        if (captcha.getBlockRadius() == null) {
+            captcha.setBlockRadius(9);
+        }
+        // 设置图片来源默认值
+        if (captcha.getPlace() == null) {
+            captcha.setPlace(0);
+        }
+    }
+
+    /**
+     * 获取指定范围内的随机数
+     **/
+    public static int getNonceByRange(int start, int end) {
+        Random random = new Random();
+        return random.nextInt(end - start + 1) + start;
+    }
+
+    /**
+     * 获取验证码资源图
+     **/
+    public static BufferedImage getBufferedImage(Integer place) {
+        try {
+            // 随机图片
+            int nonce = getNonceByRange(0, 1000);
+            // 获取网络资源图片
+            if (0 == place) {
+                String imgUrl = String.format(IMG_URL, nonce);
+                URL url = new URL(imgUrl);
+                return ImageIO.read(url.openStream());
+            }
+            // 获取本地图片
+            else {
+                String imgPath = String.format(IMG_PATH, nonce);
+                File file = new File(imgPath);
+                return ImageIO.read(file);
+            }
+        } catch (Exception e) {
+            System.out.println("获取拼图资源失败");
+            // 异常处理
+            return null;
+        }
+    }
+
+    /**
+     * 调整图片大小
+     **/
+    public static BufferedImage imageResize(BufferedImage bufferedImage, int width, int height) {
+        Image image = bufferedImage.getScaledInstance(width, height, Image.SCALE_SMOOTH);
+        BufferedImage resultImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
+        Graphics2D graphics2D = resultImage.createGraphics();
+        graphics2D.drawImage(image, 0, 0, null);
+        graphics2D.dispose();
+        return resultImage;
+    }
+
+    /**
+     * 抠图，并生成阻塞块
+     **/
+    public static void cutByTemplate(BufferedImage canvasImage, BufferedImage blockImage, int blockWidth, int blockHeight, int blockRadius, int blockX, int blockY) {
+        BufferedImage waterImage = new BufferedImage(blockWidth, blockHeight, BufferedImage.TYPE_4BYTE_ABGR);
+        // 阻塞块的轮廓图
+        int[][] blockData = getBlockData(blockWidth, blockHeight, blockRadius);
+        // 创建阻塞块具体形状
+        for (int i = 0; i < blockWidth; i++) {
+            for (int j = 0; j < blockHeight; j++) {
+                try {
+                    // 原图中对应位置变色处理
+                    if (blockData[i][j] == 1) {
+                        // 背景设置为黑色
+                        waterImage.setRGB(i, j, Color.BLACK.getRGB());
+                        blockImage.setRGB(i, j, canvasImage.getRGB(blockX + i, blockY + j));
+                        // 轮廓设置为白色，取带像素和无像素的界点，判断该点是不是临界轮廓点
+                        if (blockData[i + 1][j] == 0 || blockData[i][j + 1] == 0 || blockData[i - 1][j] == 0 || blockData[i][j - 1] == 0) {
+                            blockImage.setRGB(i, j, Color.WHITE.getRGB());
+                            waterImage.setRGB(i, j, Color.WHITE.getRGB());
+                        }
+                    }
+                    // 这里把背景设为透明
+                    else {
+                        blockImage.setRGB(i, j, Color.TRANSLUCENT);
+                        waterImage.setRGB(i, j, Color.TRANSLUCENT);
+                    }
+                } catch (ArrayIndexOutOfBoundsException e) {
+                    // 防止数组下标越界异常
+                }
+            }
+        }
+        // 在画布上添加阻塞块水印
+        addBlockWatermark(canvasImage, waterImage, blockX, blockY);
+    }
+
+    /**
+     * 构建拼图轮廓轨迹
+     **/
+    private static int[][] getBlockData(int blockWidth, int blockHeight, int blockRadius) {
+        int[][] data = new int[blockWidth][blockHeight];
+        double po = Math.pow(blockRadius, 2);
+        // 随机生成两个圆的坐标，在4个方向上 随机找到2个方向添加凸/凹
+        // 凸/凹1
+        int face1 = RandomUtils.nextInt(0, 4);
+        // 凸/凹2
+        int face2;
+        // 保证两个凸/凹不在同一位置
+        do {
+            face2 = RandomUtils.nextInt(0, 4);
+        } while (face1 == face2);
+        // 获取凸/凹起位置坐标
+        int[] circle1 = getCircleCoords(face1, blockWidth, blockHeight, blockRadius);
+        int[] circle2 = getCircleCoords(face2, blockWidth, blockHeight, blockRadius);
+        // 随机凸/凹类型
+        int shape = getNonceByRange(0, 1);
+        // 圆的标准方程 (x-a)²+(y-b)²=r²,标识圆心（a,b）,半径为r的圆
+        // 计算需要的小图轮廓，用二维数组来表示，二维数组有两张值，0和1，其中0表示没有颜色，1有颜色
+        for (int i = 0; i < blockWidth; i++) {
+            for (int j = 0; j < blockHeight; j++) {
+                data[i][j] = 0;
+                // 创建中间的方形区域
+                if ((i >= blockRadius && i <= blockWidth - blockRadius && j >= blockRadius && j <= blockHeight - blockRadius)) {
+                    data[i][j] = 1;
+                }
+                double d1 = Math.pow(i - Objects.requireNonNull(circle1)[0], 2) + Math.pow(j - circle1[1], 2);
+                double d2 = Math.pow(i - Objects.requireNonNull(circle2)[0], 2) + Math.pow(j - circle2[1], 2);
+                // 创建两个凸/凹
+                if (d1 <= po || d2 <= po) {
+                    data[i][j] = shape;
+                }
+            }
+        }
+        return data;
+    }
+
+    /**
+     * 根据朝向获取圆心坐标
+     */
+    private static int[] getCircleCoords(int face, int blockWidth, int blockHeight, int blockRadius) {
+        // 上
+        if (0 == face) {
+            return new int[]{blockWidth / 2 - 1, blockRadius};
+        }
+        // 左
+        else if (1 == face) {
+            return new int[]{blockRadius, blockHeight / 2 - 1};
+        }
+        // 下
+        else if (2 == face) {
+            return new int[]{blockWidth / 2 - 1, blockHeight - blockRadius - 1};
+        }
+        // 右
+        else if (3 == face) {
+            return new int[]{blockWidth - blockRadius - 1, blockHeight / 2 - 1};
+        }
+        return null;
+    }
+
+    /**
+     * 在画布上添加阻塞块水印
+     */
+    private static void addBlockWatermark(BufferedImage canvasImage, BufferedImage blockImage, int x, int y) {
+        Graphics2D graphics2D = canvasImage.createGraphics();
+        graphics2D.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, 0.8f));
+        graphics2D.drawImage(blockImage, x, y, null);
+        graphics2D.dispose();
+    }
+
+    /**
+     * BufferedImage转BASE64
+     */
+    public static String toBase64(BufferedImage bufferedImage, String type) {
+        try {
+            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+            ImageIO.write(bufferedImage, type, byteArrayOutputStream);
+            String base64 = Base64.getEncoder().encodeToString(byteArrayOutputStream.toByteArray());
+            return String.format("data:image/%s;base64,%s", type, base64);
+        } catch (IOException e) {
+            System.out.println("图片资源转换BASE64失败");
+            // 异常处理
+            return null;
+        }
+    }
+}

play-common/src/main/java/com/starry/common/utils/ConvertUtil.java

@@ -0,0 +1,50 @@
+package com.starry.common.utils;
+
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeanUtils;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * @author admin
+ */
+@Slf4j
+public class ConvertUtil {
+
+
+    public static <T> T entityToVo(Object source, Class<T> target) {
+        if (source == null) {
+            return null;
+        }
+        T targetObject = null;
+        try {
+            targetObject = target.newInstance();
+            BeanUtils.copyProperties(source, targetObject);
+        } catch (Exception e) {
+            log.error("entityToVo error,source = {},target={}", source, target, e);
+        }
+        return targetObject;
+    }
+
+    public static <T> List<T> entityToVoList(Collection<?> sourceList, Class<T> target) {
+        if (sourceList == null) {
+            return null;
+        }
+        List<T> targetList = new ArrayList<>(sourceList.size());
+
+        try {
+            for (Object source : sourceList) {
+                T targetObject = target.newInstance();
+                BeanUtils.copyProperties(source, targetObject);
+                targetList.add(targetObject);
+            }
+        } catch (Exception e) {
+            log.error("entityToVo error,source = {},target={}", sourceList, target, e);
+        }
+        return targetList;
+    }
+
+}

play-common/src/main/java/com/starry/common/utils/HttpUtils.java

@@ -0,0 +1,208 @@
+package com.starry.common.utils;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.net.ssl.*;
+import java.io.*;
+import java.net.ConnectException;
+import java.net.SocketTimeoutException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.nio.charset.StandardCharsets;
+import java.security.cert.X509Certificate;
+
+/**
+ * 通用http发送方法
+ *
+ * @author ruoyi
+ */
+public class HttpUtils {
+    private static final Logger log = LoggerFactory.getLogger(HttpUtils.class);
+
+    /**
+     * 向指定 URL 发送GET方法的请求
+     *
+     * @param url 发送请求的 URL
+     * @return 所代表远程资源的响应结果
+     */
+    public static String sendGet(String url) {
+        return sendGet(url, StringUtils.EMPTY);
+    }
+
+    /**
+     * 向指定 URL 发送GET方法的请求
+     *
+     * @param url   发送请求的 URL
+     * @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
+     * @return 所代表远程资源的响应结果
+     */
+    public static String sendGet(String url, String param) {
+        return sendGet(url, param, "utf-8");
+    }
+
+    /**
+     * 向指定 URL 发送GET方法的请求
+     *
+     * @param url         发送请求的 URL
+     * @param param       请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
+     * @param contentType 编码类型
+     * @return 所代表远程资源的响应结果
+     */
+    public static String sendGet(String url, String param, String contentType) {
+        StringBuilder result = new StringBuilder();
+        BufferedReader in = null;
+        try {
+            String urlNameString = StringUtils.isNotBlank(param) ? url + "?" + param : url;
+            log.info("sendGet - {}", urlNameString);
+            URL realUrl = new URL(urlNameString);
+            URLConnection connection = realUrl.openConnection();
+            connection.setRequestProperty("accept", "*/*");
+            connection.setRequestProperty("connection", "Keep-Alive");
+            connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
+            connection.connect();
+            in = new BufferedReader(new InputStreamReader(connection.getInputStream(), contentType));
+            String line;
+            while ((line = in.readLine()) != null) {
+                result.append(line);
+            }
+            log.info("recv - {}", result);
+        } catch (ConnectException e) {
+            log.error("调用HttpUtils.sendGet ConnectException, url=" + url + ",param=" + param, e);
+        } catch (SocketTimeoutException e) {
+            log.error("调用HttpUtils.sendGet SocketTimeoutException, url=" + url + ",param=" + param, e);
+        } catch (IOException e) {
+            log.error("调用HttpUtils.sendGet IOException, url=" + url + ",param=" + param, e);
+        } catch (Exception e) {
+            log.error("调用HttpsUtil.sendGet Exception, url=" + url + ",param=" + param, e);
+        } finally {
+            try {
+                if (in != null) {
+                    in.close();
+                }
+            } catch (Exception ex) {
+                log.error("调用in.close Exception, url=" + url + ",param=" + param, ex);
+            }
+        }
+        return result.toString();
+    }
+
+    /**
+     * 向指定 URL 发送POST方法的请求
+     *
+     * @param url   发送请求的 URL
+     * @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
+     * @return 所代表远程资源的响应结果
+     */
+    public static String sendPost(String url, String param) {
+        PrintWriter out = null;
+        BufferedReader in = null;
+        StringBuilder result = new StringBuilder();
+        try {
+            log.info("sendPost - {}", url);
+            URL realUrl = new URL(url);
+            URLConnection conn = realUrl.openConnection();
+            conn.setRequestProperty("accept", "*/*");
+            conn.setRequestProperty("connection", "Keep-Alive");
+            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
+            conn.setRequestProperty("Accept-Charset", "utf-8");
+            conn.setRequestProperty("contentType", "utf-8");
+            conn.setDoOutput(true);
+            conn.setDoInput(true);
+            out = new PrintWriter(conn.getOutputStream());
+            out.print(param);
+            out.flush();
+            in = new BufferedReader(new InputStreamReader(conn.getInputStream(), StandardCharsets.UTF_8));
+            String line;
+            while ((line = in.readLine()) != null) {
+                result.append(line);
+            }
+            log.info("recv - {}", result);
+        } catch (ConnectException e) {
+            log.error("调用HttpUtils.sendPost ConnectException, url=" + url + ",param=" + param, e);
+        } catch (SocketTimeoutException e) {
+            log.error("调用HttpUtils.sendPost SocketTimeoutException, url=" + url + ",param=" + param, e);
+        } catch (IOException e) {
+            log.error("调用HttpUtils.sendPost IOException, url=" + url + ",param=" + param, e);
+        } catch (Exception e) {
+            log.error("调用HttpsUtil.sendPost Exception, url=" + url + ",param=" + param, e);
+        } finally {
+            try {
+                if (out != null) {
+                    out.close();
+                }
+                if (in != null) {
+                    in.close();
+                }
+            } catch (IOException ex) {
+                log.error("调用in.close Exception, url=" + url + ",param=" + param, ex);
+            }
+        }
+        return result.toString();
+    }
+
+    public static String sendSSLPost(String url, String param) {
+        StringBuilder result = new StringBuilder();
+        String urlNameString = url + "?" + param;
+        try {
+            log.info("sendSSLPost - {}", urlNameString);
+            SSLContext sc = SSLContext.getInstance("SSL");
+            sc.init(null, new TrustManager[]{new TrustAnyTrustManager()}, new java.security.SecureRandom());
+            URL console = new URL(urlNameString);
+            HttpsURLConnection conn = (HttpsURLConnection) console.openConnection();
+            conn.setRequestProperty("accept", "*/*");
+            conn.setRequestProperty("connection", "Keep-Alive");
+            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
+            conn.setRequestProperty("Accept-Charset", "utf-8");
+            conn.setRequestProperty("contentType", "utf-8");
+            conn.setDoOutput(true);
+            conn.setDoInput(true);
+
+            conn.setSSLSocketFactory(sc.getSocketFactory());
+            conn.setHostnameVerifier(new TrustAnyHostnameVerifier());
+            conn.connect();
+            InputStream is = conn.getInputStream();
+            BufferedReader br = new BufferedReader(new InputStreamReader(is));
+            String ret = "";
+            while ((ret = br.readLine()) != null) {
+                if (ret != null && !"".equals(ret.trim())) {
+                    result.append(new String(ret.getBytes(StandardCharsets.ISO_8859_1), StandardCharsets.UTF_8));
+                }
+            }
+            log.info("recv - {}", result);
+            conn.disconnect();
+            br.close();
+        } catch (ConnectException e) {
+            log.error("调用HttpUtils.sendSSLPost ConnectException, url=" + url + ",param=" + param, e);
+        } catch (SocketTimeoutException e) {
+            log.error("调用HttpUtils.sendSSLPost SocketTimeoutException, url=" + url + ",param=" + param, e);
+        } catch (IOException e) {
+            log.error("调用HttpUtils.sendSSLPost IOException, url=" + url + ",param=" + param, e);
+        } catch (Exception e) {
+            log.error("调用HttpsUtil.sendSSLPost Exception, url=" + url + ",param=" + param, e);
+        }
+        return result.toString();
+    }
+
+    private static class TrustAnyTrustManager implements X509TrustManager {
+        @Override
+        public void checkClientTrusted(X509Certificate[] chain, String authType) {
+        }
+
+        @Override
+        public void checkServerTrusted(X509Certificate[] chain, String authType) {
+        }
+
+        @Override
+        public X509Certificate[] getAcceptedIssuers() {
+            return new X509Certificate[]{};
+        }
+    }
+
+    private static class TrustAnyHostnameVerifier implements HostnameVerifier {
+        @Override
+        public boolean verify(String hostname, SSLSession session) {
+            return true;
+        }
+    }
+}

play-common/src/main/java/com/starry/common/utils/ServletUtils.java

@@ -0,0 +1,164 @@
+package com.starry.common.utils;
+
+
+import cn.hutool.core.convert.Convert;
+import org.springframework.web.context.request.RequestAttributes;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+
+/**
+ * 客户端工具类
+ *
+ * @author ruoyi
+ */
+public class ServletUtils {
+    /**
+     * 获取String参数
+     */
+    public static String getParameter(String name) {
+        return getRequest().getParameter(name);
+    }
+
+    /**
+     * 获取String参数
+     */
+    public static String getParameter(String name, String defaultValue) {
+        return Convert.toStr(getRequest().getParameter(name), defaultValue);
+    }
+
+    /**
+     * 获取Integer参数
+     */
+    public static Integer getParameterToInt(String name) {
+        return Convert.toInt(getRequest().getParameter(name));
+    }
+
+    /**
+     * 获取Integer参数
+     */
+    public static Integer getParameterToInt(String name, Integer defaultValue) {
+        return Convert.toInt(getRequest().getParameter(name), defaultValue);
+    }
+
+    /**
+     * 获取Boolean参数
+     */
+    public static Boolean getParameterToBool(String name) {
+        return Convert.toBool(getRequest().getParameter(name));
+    }
+
+    /**
+     * 获取Boolean参数
+     */
+    public static Boolean getParameterToBool(String name, Boolean defaultValue) {
+        return Convert.toBool(getRequest().getParameter(name), defaultValue);
+    }
+
+    /**
+     * 获取request
+     */
+    public static HttpServletRequest getRequest() {
+        return getRequestAttributes().getRequest();
+    }
+
+    /**
+     * 获取response
+     */
+    public static HttpServletResponse getResponse() {
+        return getRequestAttributes().getResponse();
+    }
+
+    /**
+     * 获取session
+     */
+    public static HttpSession getSession() {
+        return getRequest().getSession();
+    }
+
+    public static ServletRequestAttributes getRequestAttributes() {
+        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
+        return (ServletRequestAttributes) attributes;
+    }
+
+    /**
+     * 将字符串渲染到客户端
+     *
+     * @param response 渲染对象
+     * @param string   待渲染的字符串
+     */
+    public static void renderString(HttpServletResponse response, String string) {
+        try {
+            response.setStatus(200);
+            response.setContentType("application/json");
+            response.setCharacterEncoding("utf-8");
+            response.getWriter().print(string);
+        } catch (IOException e) {
+            
+        }
+    }
+
+    /**
+     * 是否是Ajax异步请求
+     *
+     * @param request
+     */
+    /*public static boolean isAjaxRequest(HttpServletRequest request)
+    {
+        String accept = request.getHeader("accept");
+        if (accept != null && accept.contains("application/json"))
+        {
+            return true;
+        }
+
+        String xRequestedWith = request.getHeader("X-Requested-With");
+        if (xRequestedWith != null && xRequestedWith.contains("XMLHttpRequest"))
+        {
+            return true;
+        }
+
+        String uri = request.getRequestURI();
+        if (StringUtils.inStringIgnoreCase(uri, ".json", ".xml"))
+        {
+            return true;
+        }
+
+        String ajax = request.getParameter("__ajax");
+        return StringUtils.inStringIgnoreCase(ajax, "json", "xml");
+    }*/
+
+    /**
+     * 内容编码
+     *
+     * @param str 内容
+     * @return 编码后的内容
+     */
+    public static String urlEncode(String str) {
+        try {
+            return URLEncoder.encode(str, "UTF-8");
+        } catch (UnsupportedEncodingException e) {
+            return StringUtils.EMPTY;
+        }
+    }
+
+    /**
+     * 内容解码
+     *
+     * @param str 内容
+     * @return 解码后的内容
+     */
+    public static String urlDecode(String str) {
+        try {
+            return URLDecoder.decode(str, "UTF-8");
+        } catch (UnsupportedEncodingException e) {
+            return StringUtils.EMPTY;
+        }
+    }
+}

play-common/src/main/java/com/starry/common/utils/SpringUtils.java

@@ -0,0 +1,70 @@
+package com.starry.common.utils;
+
+import org.springframework.aop.framework.AopContext;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.stereotype.Component;
+
+/**
+ * @author admin
+ * spring工具类 方便在非spring管理环境中获取bean
+ * @since 2022/7/28
+ */
+@Component
+public class SpringUtils implements BeanFactoryPostProcessor, ApplicationContextAware {
+
+    /**
+     * Spring应用上下文环境
+     */
+    private static ConfigurableListableBeanFactory beanFactory;
+
+    private static ApplicationContext applicationContext;
+
+    /**
+     * 获取类型为requiredType的对象
+     *
+     * @param clz
+     * @return
+     * @throws BeansException
+     */
+    public static <T> T getBean(Class<T> clz) throws BeansException {
+        T result = (T) beanFactory.getBean(clz);
+        return result;
+    }
+
+    /**
+     * 获取对象
+     *
+     * @param name
+     * @return Object 一个以所给名字注册的bean的实例
+     * @throws BeansException
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> T getBean(String name) throws BeansException {
+        return (T) beanFactory.getBean(name);
+    }
+
+    /**
+     * 获取aop代理对象
+     *
+     * @param invoker
+     * @return
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> T getAopProxy(T invoker) {
+        return (T) AopContext.currentProxy();
+    }
+
+    @Override
+    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
+        SpringUtils.beanFactory = beanFactory;
+    }
+
+    @Override
+    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+        SpringUtils.applicationContext = applicationContext;
+    }
+}

play-common/src/main/java/com/starry/common/utils/StringUtils.java

@@ -0,0 +1,232 @@
+package com.starry.common.utils;
+
+import cn.hutool.core.text.StrFormatter;
+
+import java.util.Collection;
+import java.util.Map;
+
+/**
+ * @author admin
+ * 字符串工具类
+ * @since 2022/7/19
+ */
+public class StringUtils extends org.apache.commons.lang3.StringUtils {
+
+    /**
+     * 空字符串
+     */
+    private static final String NULLSTR = "";
+
+    /**
+     * 下划线
+     */
+    private static final char SEPARATOR = '_';
+
+
+    /**
+     * 驼峰转下划线命名
+     */
+    public static String toUnderScoreCase(String str) {
+        if (str == null) {
+            return null;
+        }
+        StringBuilder sb = new StringBuilder();
+        // 前置字符是否大写
+        boolean preCharIsUpperCase = true;
+        // 当前字符是否大写
+        boolean curreCharIsUpperCase = true;
+        // 下一字符是否大写
+        boolean nexteCharIsUpperCase = true;
+        for (int i = 0; i < str.length(); i++) {
+            char c = str.charAt(i);
+            if (i > 0) {
+                preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
+            } else {
+                preCharIsUpperCase = false;
+            }
+
+            curreCharIsUpperCase = Character.isUpperCase(c);
+
+            if (i < (str.length() - 1)) {
+                nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
+            }
+
+            if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase) {
+                sb.append(SEPARATOR);
+            } else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase) {
+                sb.append(SEPARATOR);
+            }
+            sb.append(Character.toLowerCase(c));
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * 判断一个对象是否为空
+     *
+     * @param object Object
+     * @return true：为空 false：非空
+     */
+    public static boolean isNull(Object object) {
+        return object == null;
+    }
+
+    /**
+     * 判断一个对象是否非空
+     *
+     * @param object Object
+     * @return true：非空   false：空
+     */
+    public static boolean isNotNull(Object object) {
+        return !isNull(object);
+    }
+
+    /**
+     * 判断一个对象数组是否为空
+     *
+     * @param objects 要判断的对象数组
+     *                * @return true：为空  false：非空
+     */
+    public static boolean isEmpty(Object[] objects) {
+        return isNull(objects) || (objects.length == 0);
+    }
+
+    /**
+     * 判断一个Map是否为空
+     *
+     * @param map 要判断的Map
+     * @return true：为空 false：非空
+     */
+    public static boolean isEmpty(Map<?, ?> map) {
+        return isNull(map) || map.isEmpty();
+    }
+
+    /**
+     * 判断一个Map是否为空
+     *
+     * @param map 要判断的Map
+     * @return true：非空 false：空
+     */
+    public static boolean isNotEmpty(Map<?, ?> map) {
+        return !isEmpty(map);
+    }
+
+    /**
+     * 判断一个Collection是否非空，包含List，Set，Queue
+     *
+     * @param coll 要判断的Collection
+     * @return true：非空 false：空
+     */
+    public static boolean isNotEmpty(Collection<?> coll) {
+        return !isEmpty(coll);
+    }
+
+    /**
+     * 判断一个Collection是否为空， 包含List，Set，Queue
+     *
+     * @param coll 要判断的Collection
+     * @return true：为空 false：非空
+     */
+    public static boolean isEmpty(Collection<?> coll) {
+        return isNull(coll) || coll.isEmpty();
+    }
+
+    /**
+     * 格式化文本, {} 表示占位符<br>
+     * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
+     * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
+     * 例：<br>
+     * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
+     * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
+     * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
+     *
+     * @param template 文本模板，被替换的部分用 {} 表示
+     * @param params   参数值
+     * @return 格式化后的文本
+     */
+    public static String format(String template, Object... params) {
+        if (isEmpty(params) || isEmpty(template)) {
+            return template;
+        }
+        return StrFormatter.format(template, params);
+    }
+
+    /**
+     * 判断给定的set列表中是否包含数组array 判断给定的数组array中是否包含给定的元素value
+     *
+     * @param collection 给定的集合
+     * @param array      给定的数组
+     * @return boolean 结果
+     */
+    public static boolean containsAny(Collection<String> collection, String... array) {
+        if (isEmpty(collection) || isEmpty(array)) {
+            return false;
+        } else {
+            for (String str : array) {
+                if (collection.contains(str)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+
+    /**
+     * 驼峰式命名法 例如：user_name->userName
+     */
+    public static String toCamelCase(String s) {
+        if (org.apache.commons.lang3.StringUtils.isNotBlank(s)) {
+            // 小写
+            s = s.toLowerCase();
+            StringBuilder sb = new StringBuilder(s.length());
+            // 大写
+            boolean upperCase = false;
+            for (int i = 0; i < s.length(); i++) {
+                char c = s.charAt(i);
+                if (c == '_') {
+                    upperCase = true;
+                } else if (upperCase) {
+                    sb.append(Character.toUpperCase(c));
+                    upperCase = false;
+                } else {
+                    sb.append(c);
+                }
+            }
+            return sb.toString();
+        }
+        return s;
+    }
+
+    /**
+     * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。
+     * 例如：HELLO_WORLD -> HelloWorld
+     *
+     * @param name 转换前的下划线大写方式命名的字符串
+     * @return 转换后的驼峰式命名的字符串
+     */
+    public static String convertToCamelCase(String name) {
+        StringBuilder result = new StringBuilder();
+        if (org.apache.commons.lang3.StringUtils.isBlank(name)) {
+            return "";
+        } else if (!name.contains("_")) {
+            // 不含下划线，仅将首字母大写
+            return name.substring(0, 1).toUpperCase() + name.substring(1);
+        }
+        String[] camels = name.split("_");
+        for (String camel : camels) {
+            // 跳过原始字符串中开头、结尾的下换线或双重下划线
+            if (camel.isEmpty()) {
+                continue;
+            }
+            // 首字母大写
+            result.append(camel.substring(0, 1).toUpperCase());
+            result.append(camel.substring(1).toLowerCase());
+        }
+        return result.toString();
+    }
+
+    public static <T> T cast(Object obj) {
+        return (T) obj;
+    }
+}

play-common/src/main/java/com/starry/common/utils/ThreadsUtils.java

@@ -0,0 +1,62 @@
+package com.starry.common.utils;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.*;
+
+/**
+ * @author admin
+ * 线程相关工具类
+ * @since 2022/7/25
+ */
+public class ThreadsUtils {
+    private static final Logger logger = LoggerFactory.getLogger(ThreadsUtils.class);
+
+    /**
+     * 停止线程池
+     * 先使用shutdown, 停止接收新任务并尝试完成所有已存在任务.
+     * 如果超时, 则调用shutdownNow, 取消在workQueue中Pending的任务,并中断所有阻塞函数.
+     * 如果仍然超時，則強制退出.
+     * 另对在shutdown时线程本身被调用中断做了处理.
+     */
+    public static void shutdownAndAwaitTermination(ExecutorService pool) {
+        if (pool != null && !pool.isShutdown()) {
+            pool.shutdown();
+            try {
+                if (!pool.awaitTermination(120, TimeUnit.SECONDS)) {
+                    pool.shutdownNow();
+                    if (!pool.awaitTermination(120, TimeUnit.SECONDS)) {
+                        logger.info("Pool did not terminate");
+                    }
+                }
+            } catch (InterruptedException ie) {
+                pool.shutdownNow();
+                Thread.currentThread().interrupt();
+            }
+        }
+    }
+
+    /**
+     * 打印线程异常信息
+     */
+    public static void printException(Runnable r, Throwable t) {
+        if (t == null && r instanceof Future<?>) {
+            try {
+                Future<?> future = (Future<?>) r;
+                if (future.isDone()) {
+                    future.get();
+                }
+            } catch (CancellationException ce) {
+                t = ce;
+            } catch (ExecutionException ee) {
+                t = ee.getCause();
+            } catch (InterruptedException ie) {
+                Thread.currentThread().interrupt();
+            }
+        }
+        if (t != null) {
+            logger.error(t.getMessage(), t);
+        }
+    }
+}

play-common/src/main/java/com/starry/common/utils/file/CosClientUtils.java

@@ -0,0 +1,95 @@
+package com.starry.common.utils.file;
+
+
+import com.qcloud.cos.COSClient;
+import com.qcloud.cos.model.PutObjectRequest;
+import com.qcloud.cos.model.UploadResult;
+import com.qcloud.cos.transfer.TransferManager;
+import com.qcloud.cos.transfer.Upload;
+import com.starry.common.config.CosConfig;
+import com.starry.common.utils.SpringUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.io.FilenameUtils;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author admin
+ * 腾讯云COS文件上传工具类
+ * @since 2022/10/31
+ */
+@Slf4j
+public class CosClientUtils {
+
+    /**
+     * 获取配置信息
+     */
+    private static final CosConfig cosConfig = SpringUtils.getBean(CosConfig.class);
+
+    public static String upload(MultipartFile file, String dir) throws Exception {
+        String originalFilename = file.getOriginalFilename();
+        // 文件名
+        String name = FilenameUtils.getBaseName(originalFilename) + "_" + System.currentTimeMillis() + originalFilename.substring(originalFilename.lastIndexOf("."));
+        // 目录
+        String folderName = cosConfig.getFolderPrefix() + "/" + dir + "/";
+        String key = folderName + name;
+        File localFile = null;
+        try {
+            localFile = transferToFile(file);
+            String filePath = uploadFileToCos(localFile, key);
+            log.info("upload COS successful: {}", filePath);
+            return filePath;
+        } catch (Exception e) {
+            throw new Exception("文件上传失败");
+        } finally {
+            localFile.delete();
+        }
+    }
+
+    /**
+     * 用缓冲区来创建临时文件
+     * 使用 MultipartFile.transferTo()
+     *
+     * @param multipartFile
+     * @return
+     */
+    private static File transferToFile(MultipartFile multipartFile) throws IOException {
+        String originalFilename = multipartFile.getOriginalFilename();
+        String prefix = originalFilename.split("\\.")[0];
+        String suffix = originalFilename.substring(originalFilename.lastIndexOf("."));
+        File file = File.createTempFile(prefix, suffix);
+        multipartFile.transferTo(file);
+        return file;
+    }
+
+    /**
+     * 上传文件到COS
+     *
+     * @param localFile
+     * @param key
+     * @return
+     */
+    private static String uploadFileToCos(File localFile, String key) throws InterruptedException {
+        PutObjectRequest putObjectRequest = new PutObjectRequest(cosConfig.getBucketName(), key, localFile);
+        // 获取连接
+        COSClient cosClient = cosConfig.getCosClient();
+        // 创建线程池
+        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(8, 16,
+                4, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10), new ThreadPoolExecutor.AbortPolicy());
+        // 传入一个threadPool, 若不传入线程池, 默认TransferManager中会生成一个单线程的线程池
+        TransferManager transferManager = new TransferManager(cosClient, threadPool);
+        // 返回一个异步结果Upload, 可同步的调用waitForUploadResult等待upload结束, 成功返回UploadResult, 失败抛出异常
+        Upload upload = transferManager.upload(putObjectRequest);
+        UploadResult uploadResult = upload.waitForUploadResult();
+        transferManager.shutdownNow();
+        cosClient.shutdown();
+        String filePath = cosConfig.getBaseUrl() + uploadResult.getKey();
+        return filePath;
+    }
+
+}

play-common/src/main/java/com/starry/common/utils/file/FileUploadUtils.java

@@ -0,0 +1,33 @@
+package com.starry.common.utils.file;
+
+import org.springframework.web.multipart.MultipartFile;
+
+import java.util.Objects;
+
+/**
+ * @author admin
+ * 文件上传工具类
+ * @since 2022/10/28
+ */
+public class FileUploadUtils {
+
+    /**
+     * 默认大小 50M
+     */
+    public static final long DEFAULT_MAX_SIZE = 50 * 1024 * 1024;
+
+    /**
+     * 默认的文件名最大长度 100
+     */
+    public static final int DEFAULT_FILE_NAME_LENGTH = 100;
+
+    public static String upload(String baseDir, MultipartFile file, String[] allowedExtension) {
+        int fileNameLength = Objects.requireNonNull(file.getOriginalFilename()).length();
+        if (fileNameLength > FileUploadUtils.DEFAULT_FILE_NAME_LENGTH) {
+            throw new RuntimeException("文件名超过默认的最大长度");
+        }
+        return null;
+    }
+
+
+}

play-common/src/main/java/com/starry/common/utils/html/EscapeUtil.java

@@ -0,0 +1,131 @@
+package com.starry.common.utils.html;
+
+
+import com.starry.common.utils.StringUtils;
+
+/**
+ * 转义和反转义工具类
+ *
+ * @author ruoyi
+ */
+public class EscapeUtil {
+    public static final String RE_HTML_MARK = "(<[^<]*?>)|(<[\\s]*?/[^<]*?>)|(<[^<]*?/[\\s]*?>)";
+
+    private static final char[][] TEXT = new char[64][];
+
+    static {
+        for (int i = 0; i < 64; i++) {
+            TEXT[i] = new char[]{(char) i};
+        }
+
+        // special HTML characters
+        TEXT['\''] = "&#039;".toCharArray(); // 单引号
+        TEXT['"'] = "&#34;".toCharArray(); // 单引号
+        TEXT['&'] = "&#38;".toCharArray(); // &符
+        TEXT['<'] = "&#60;".toCharArray(); // 小于号
+        TEXT['>'] = "&#62;".toCharArray(); // 大于号
+    }
+
+    /**
+     * 转义文本中的HTML字符为安全的字符
+     *
+     * @param text 被转义的文本
+     * @return 转义后的文本
+     */
+    public static String escape(String text) {
+        return encode(text);
+    }
+
+    /**
+     * 还原被转义的HTML特殊字符
+     *
+     * @param content 包含转义符的HTML内容
+     * @return 转换后的字符串
+     */
+    public static String unescape(String content) {
+        return decode(content);
+    }
+
+    /**
+     * 清除所有HTML标签，但是不删除标签内的内容
+     *
+     * @param content 文本
+     * @return 清除标签后的文本
+     */
+    public static String clean(String content) {
+        return new HTMLFilter().filter(content);
+    }
+
+    /**
+     * Escape编码
+     *
+     * @param text 被编码的文本
+     * @return 编码后的字符
+     */
+    private static String encode(String text) {
+        int len;
+        if ((text == null) || ((len = text.length()) == 0)) {
+            return StringUtils.EMPTY;
+        }
+        StringBuilder buffer = new StringBuilder(len + (len >> 2));
+        char c;
+        for (int i = 0; i < len; i++) {
+            c = text.charAt(i);
+            if (c < 64) {
+                buffer.append(TEXT[c]);
+            } else {
+                buffer.append(c);
+            }
+        }
+        return buffer.toString();
+    }
+
+    /**
+     * Escape解码
+     *
+     * @param content 被转义的内容
+     * @return 解码后的字符串
+     */
+    public static String decode(String content) {
+        if (StringUtils.isEmpty(content)) {
+            return content;
+        }
+
+        StringBuilder tmp = new StringBuilder(content.length());
+        int lastPos = 0, pos = 0;
+        char ch;
+        while (lastPos < content.length()) {
+            pos = content.indexOf("%", lastPos);
+            if (pos == lastPos) {
+                if (content.charAt(pos + 1) == 'u') {
+                    ch = (char) Integer.parseInt(content.substring(pos + 2, pos + 6), 16);
+                    tmp.append(ch);
+                    lastPos = pos + 6;
+                } else {
+                    ch = (char) Integer.parseInt(content.substring(pos + 1, pos + 3), 16);
+                    tmp.append(ch);
+                    lastPos = pos + 3;
+                }
+            } else {
+                if (pos == -1) {
+                    tmp.append(content.substring(lastPos));
+                    lastPos = content.length();
+                } else {
+                    tmp.append(content, lastPos, pos);
+                    lastPos = pos;
+                }
+            }
+        }
+        return tmp.toString();
+    }
+
+    public static void main(String[] args) {
+        String html = "<script>alert(1);</script>";
+        // String html = "<scr<script>ipt>alert(\"XSS\")</scr<script>ipt>";
+        // String html = "<123";
+        // String html = "123>";
+        System.out.println(EscapeUtil.clean(html));
+        System.out.println(EscapeUtil.escape(html));
+        System.out.println(EscapeUtil.unescape(html));
+    }
+}

play-common/src/main/java/com/starry/common/utils/html/HTMLFilter.java

@@ -0,0 +1,497 @@
+package com.starry.common.utils.html;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * HTML过滤器，用于去除XSS漏洞隐患。
+ *
+ * @author ruoyi
+ */
+public final class HTMLFilter {
+    /**
+     * regex flag union representing /si modifiers in php
+     **/
+    private static final int REGEX_FLAGS_SI = Pattern.CASE_INSENSITIVE | Pattern.DOTALL;
+    private static final Pattern P_COMMENTS = Pattern.compile("<!--(.*?)-->", Pattern.DOTALL);
+    private static final Pattern P_COMMENT = Pattern.compile("^!--(.*)--$", REGEX_FLAGS_SI);
+    private static final Pattern P_TAGS = Pattern.compile("<(.*?)>", Pattern.DOTALL);
+    private static final Pattern P_END_TAG = Pattern.compile("^/([a-z0-9]+)", REGEX_FLAGS_SI);
+    private static final Pattern P_START_TAG = Pattern.compile("^([a-z0-9]+)(.*?)(/?)$", REGEX_FLAGS_SI);
+    private static final Pattern P_QUOTED_ATTRIBUTES = Pattern.compile("([a-z0-9]+)=([\"'])(.*?)\\2", REGEX_FLAGS_SI);
+    private static final Pattern P_UNQUOTED_ATTRIBUTES = Pattern.compile("([a-z0-9]+)(=)([^\"\\s']+)", REGEX_FLAGS_SI);
+    private static final Pattern P_PROTOCOL = Pattern.compile("^([^:]+):", REGEX_FLAGS_SI);
+    private static final Pattern P_ENTITY = Pattern.compile("&#(\\d+);?");
+    private static final Pattern P_ENTITY_UNICODE = Pattern.compile("&#x([0-9a-f]+);?");
+    private static final Pattern P_ENCODE = Pattern.compile("%([0-9a-f]{2});?");
+    private static final Pattern P_VALID_ENTITIES = Pattern.compile("&([^&;]*)(?=(;|&|$))");
+    private static final Pattern P_VALID_QUOTES = Pattern.compile("(>|^)([^<]+?)(<|$)", Pattern.DOTALL);
+    private static final Pattern P_END_ARROW = Pattern.compile("^>");
+    private static final Pattern P_BODY_TO_END = Pattern.compile("<([^>]*?)(?=<|$)");
+    private static final Pattern P_XML_CONTENT = Pattern.compile("(^|>)([^<]*?)(?=>)");
+    private static final Pattern P_STRAY_LEFT_ARROW = Pattern.compile("<([^>]*?)(?=<|$)");
+    private static final Pattern P_STRAY_RIGHT_ARROW = Pattern.compile("(^|>)([^<]*?)(?=>)");
+    private static final Pattern P_AMP = Pattern.compile("&");
+    private static final Pattern P_QUOTE = Pattern.compile("\"");
+    private static final Pattern P_LEFT_ARROW = Pattern.compile("<");
+    private static final Pattern P_RIGHT_ARROW = Pattern.compile(">");
+    private static final Pattern P_BOTH_ARROWS = Pattern.compile("<>");
+
+    // @xxx could grow large... maybe use sesat's ReferenceMap
+    private static final ConcurrentMap<String, Pattern> P_REMOVE_PAIR_BLANKS = new ConcurrentHashMap<>();
+    private static final ConcurrentMap<String, Pattern> P_REMOVE_SELF_BLANKS = new ConcurrentHashMap<>();
+
+    /**
+     * set of allowed html elements, along with allowed attributes for each element
+     **/
+    private final Map<String, List<String>> vAllowed;
+    /**
+     * counts of open tags for each (allowable) html element
+     **/
+    private final Map<String, Integer> vTagCounts = new HashMap<>();
+
+    /**
+     * html elements which must always be self-closing (e.g. "<img />")
+     **/
+    private final String[] vSelfClosingTags;
+    /**
+     * html elements which must always have separate opening and closing tags (e.g. "<b></b>")
+     **/
+    private final String[] vNeedClosingTags;
+    /**
+     * set of disallowed html elements
+     **/
+    private final String[] vDisallowed;
+    /**
+     * attributes which should be checked for valid protocols
+     **/
+    private final String[] vProtocolAtts;
+    /**
+     * allowed protocols
+     **/
+    private final String[] vAllowedProtocols;
+    /**
+     * tags which should be removed if they contain no content (e.g. "<b></b>" or "<b />")
+     **/
+    private final String[] vRemoveBlanks;
+    /**
+     * entities allowed within html markup
+     **/
+    private final String[] vAllowedEntities;
+    /**
+     * flag determining whether comments are allowed in input String.
+     */
+    private final boolean stripComment;
+    private final boolean encodeQuotes;
+    /**
+     * flag determining whether to try to make tags when presented with "unbalanced" angle brackets (e.g. "<b text </b>"
+     * becomes "<b> text </b>"). If set to false, unbalanced angle brackets will be html escaped.
+     */
+    private final boolean alwaysMakeTags;
+
+    /**
+     * Default constructor.
+     */
+    public HTMLFilter() {
+        vAllowed = new HashMap<>();
+
+        final ArrayList<String> a_atts = new ArrayList<>();
+        a_atts.add("href");
+        a_atts.add("target");
+        vAllowed.put("a", a_atts);
+
+        final ArrayList<String> img_atts = new ArrayList<>();
+        img_atts.add("src");
+        img_atts.add("width");
+        img_atts.add("height");
+        img_atts.add("alt");
+        vAllowed.put("img", img_atts);
+
+        final ArrayList<String> no_atts = new ArrayList<>();
+        vAllowed.put("b", no_atts);
+        vAllowed.put("strong", no_atts);
+        vAllowed.put("i", no_atts);
+        vAllowed.put("em", no_atts);
+
+        vSelfClosingTags = new String[]{"img"};
+        vNeedClosingTags = new String[]{"a", "b", "strong", "i", "em"};
+        vDisallowed = new String[]{};
+        vAllowedProtocols = new String[]{"http", "mailto", "https"}; // no ftp.
+        vProtocolAtts = new String[]{"src", "href"};
+        vRemoveBlanks = new String[]{"a", "b", "strong", "i", "em"};
+        vAllowedEntities = new String[]{"amp", "gt", "lt", "quot"};
+        stripComment = true;
+        encodeQuotes = true;
+        alwaysMakeTags = false;
+    }
+
+    /**
+     * Map-parameter configurable constructor.
+     *
+     * @param conf map containing configuration. keys match field names.
+     */
+    @SuppressWarnings("unchecked")
+    public HTMLFilter(final Map<String, Object> conf) {
+
+        assert conf.containsKey("vAllowed") : "configuration requires vAllowed";
+        assert conf.containsKey("vSelfClosingTags") : "configuration requires vSelfClosingTags";
+        assert conf.containsKey("vNeedClosingTags") : "configuration requires vNeedClosingTags";
+        assert conf.containsKey("vDisallowed") : "configuration requires vDisallowed";
+        assert conf.containsKey("vAllowedProtocols") : "configuration requires vAllowedProtocols";
+        assert conf.containsKey("vProtocolAtts") : "configuration requires vProtocolAtts";
+        assert conf.containsKey("vRemoveBlanks") : "configuration requires vRemoveBlanks";
+        assert conf.containsKey("vAllowedEntities") : "configuration requires vAllowedEntities";
+
+        vAllowed = Collections.unmodifiableMap((HashMap<String, List<String>>) conf.get("vAllowed"));
+        vSelfClosingTags = (String[]) conf.get("vSelfClosingTags");
+        vNeedClosingTags = (String[]) conf.get("vNeedClosingTags");
+        vDisallowed = (String[]) conf.get("vDisallowed");
+        vAllowedProtocols = (String[]) conf.get("vAllowedProtocols");
+        vProtocolAtts = (String[]) conf.get("vProtocolAtts");
+        vRemoveBlanks = (String[]) conf.get("vRemoveBlanks");
+        vAllowedEntities = (String[]) conf.get("vAllowedEntities");
+        stripComment = conf.containsKey("stripComment") ? (Boolean) conf.get("stripComment") : true;
+        encodeQuotes = conf.containsKey("encodeQuotes") ? (Boolean) conf.get("encodeQuotes") : true;
+        alwaysMakeTags = conf.containsKey("alwaysMakeTags") ? (Boolean) conf.get("alwaysMakeTags") : true;
+    }
+
+    // ---------------------------------------------------------------
+    // my versions of some PHP library functions
+    public static String chr(final int decimal) {
+        return String.valueOf((char) decimal);
+    }
+
+    public static String htmlSpecialChars(final String s) {
+        String result = s;
+        result = regexReplace(P_AMP, "&amp;", result);
+        result = regexReplace(P_QUOTE, "&quot;", result);
+        result = regexReplace(P_LEFT_ARROW, "&lt;", result);
+        result = regexReplace(P_RIGHT_ARROW, "&gt;", result);
+        return result;
+    }
+
+    private static String regexReplace(final Pattern regex_pattern, final String replacement, final String s) {
+        Matcher m = regex_pattern.matcher(s);
+        return m.replaceAll(replacement);
+    }
+
+    // ---------------------------------------------------------------
+
+    private static boolean inArray(final String s, final String[] array) {
+        for (String item : array) {
+            if (item != null && item.equals(s)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private void reset() {
+        vTagCounts.clear();
+    }
+
+    /**
+     * given a user submitted input String, filter out any invalid or restricted html.
+     *
+     * @param input text (i.e. submitted by a user) than may contain html
+     * @return "clean" version of input, with only valid, whitelisted html elements allowed
+     */
+    public String filter(final String input) {
+        reset();
+        String s = input;
+
+        s = escapeComments(s);
+
+        s = balanceHTML(s);
+
+        s = checkTags(s);
+
+        s = processRemoveBlanks(s);
+
+        // s = validateEntities(s);
+
+        return s;
+    }
+
+    public boolean isAlwaysMakeTags() {
+        return alwaysMakeTags;
+    }
+
+    public boolean isStripComments() {
+        return stripComment;
+    }
+
+    private String escapeComments(final String s) {
+        final Matcher m = P_COMMENTS.matcher(s);
+        final StringBuffer buf = new StringBuffer();
+        if (m.find()) {
+            final String match = m.group(1); // (.*?)
+            m.appendReplacement(buf, Matcher.quoteReplacement("<!--" + htmlSpecialChars(match) + "-->"));
+        }
+        m.appendTail(buf);
+
+        return buf.toString();
+    }
+
+    private String balanceHTML(String s) {
+        if (alwaysMakeTags) {
+            //
+            // try and form html
+            //
+            s = regexReplace(P_END_ARROW, "", s);
+            // 不追加结束标签
+            s = regexReplace(P_BODY_TO_END, "<$1>", s);
+            s = regexReplace(P_XML_CONTENT, "$1<$2", s);
+
+        } else {
+            //
+            // escape stray brackets
+            //
+            s = regexReplace(P_STRAY_LEFT_ARROW, "&lt;$1", s);
+            s = regexReplace(P_STRAY_RIGHT_ARROW, "$1$2&gt;<", s);
+
+            //
+            // the last regexp causes '<>' entities to appear
+            // (we need to do a lookahead assertion so that the last bracket can
+            // be used in the next pass of the regexp)
+            //
+            s = regexReplace(P_BOTH_ARROWS, "", s);
+        }
+
+        return s;
+    }
+
+    private String checkTags(String s) {
+        Matcher m = P_TAGS.matcher(s);
+
+        final StringBuffer buf = new StringBuffer();
+        while (m.find()) {
+            String replaceStr = m.group(1);
+            replaceStr = processTag(replaceStr);
+            m.appendReplacement(buf, Matcher.quoteReplacement(replaceStr));
+        }
+        m.appendTail(buf);
+
+        // these get tallied in processTag
+        // (remember to reset before subsequent calls to filter method)
+        final StringBuilder sBuilder = new StringBuilder(buf.toString());
+        for (String key : vTagCounts.keySet()) {
+            for (int ii = 0; ii < vTagCounts.get(key); ii++) {
+                sBuilder.append("</").append(key).append(">");
+            }
+        }
+        s = sBuilder.toString();
+
+        return s;
+    }
+
+    private String processRemoveBlanks(final String s) {
+        String result = s;
+        for (String tag : vRemoveBlanks) {
+            if (!P_REMOVE_PAIR_BLANKS.containsKey(tag)) {
+                P_REMOVE_PAIR_BLANKS.putIfAbsent(tag, Pattern.compile("<" + tag + "(\\s[^>]*)?></" + tag + ">"));
+            }
+            result = regexReplace(P_REMOVE_PAIR_BLANKS.get(tag), "", result);
+            if (!P_REMOVE_SELF_BLANKS.containsKey(tag)) {
+                P_REMOVE_SELF_BLANKS.putIfAbsent(tag, Pattern.compile("<" + tag + "(\\s[^>]*)?/>"));
+            }
+            result = regexReplace(P_REMOVE_SELF_BLANKS.get(tag), "", result);
+        }
+
+        return result;
+    }
+
+    private String processTag(final String s) {
+        // ending tags
+        Matcher m = P_END_TAG.matcher(s);
+        if (m.find()) {
+            final String name = m.group(1).toLowerCase();
+            if (allowed(name)) {
+                if (false == inArray(name, vSelfClosingTags)) {
+                    if (vTagCounts.containsKey(name)) {
+                        vTagCounts.put(name, vTagCounts.get(name) - 1);
+                        return "</" + name + ">";
+                    }
+                }
+            }
+        }
+
+        // starting tags
+        m = P_START_TAG.matcher(s);
+        if (m.find()) {
+            final String name = m.group(1).toLowerCase();
+            final String body = m.group(2);
+            String ending = m.group(3);
+
+            // debug( "in a starting tag, name='" + name + "'; body='" + body + "'; ending='" + ending + "'" );
+            if (allowed(name)) {
+                final StringBuilder params = new StringBuilder();
+
+                final Matcher m2 = P_QUOTED_ATTRIBUTES.matcher(body);
+                final Matcher m3 = P_UNQUOTED_ATTRIBUTES.matcher(body);
+                final List<String> paramNames = new ArrayList<>();
+                final List<String> paramValues = new ArrayList<>();
+                while (m2.find()) {
+                    paramNames.add(m2.group(1)); // ([a-z0-9]+)
+                    paramValues.add(m2.group(3)); // (.*?)
+                }
+                while (m3.find()) {
+                    paramNames.add(m3.group(1)); // ([a-z0-9]+)
+                    paramValues.add(m3.group(3)); // ([^\"\\s']+)
+                }
+
+                String paramName, paramValue;
+                for (int ii = 0; ii < paramNames.size(); ii++) {
+                    paramName = paramNames.get(ii).toLowerCase();
+                    paramValue = paramValues.get(ii);
+
+                    // debug( "paramName='" + paramName + "'" );
+                    // debug( "paramValue='" + paramValue + "'" );
+                    // debug( "allowed? " + vAllowed.get( name ).contains( paramName ) );
+
+                    if (allowedAttribute(name, paramName)) {
+                        if (inArray(paramName, vProtocolAtts)) {
+                            paramValue = processParamProtocol(paramValue);
+                        }
+                        params.append(' ').append(paramName).append("=\"").append(paramValue).append("\"");
+                    }
+                }
+
+                if (inArray(name, vSelfClosingTags)) {
+                    ending = " /";
+                }
+
+                if (inArray(name, vNeedClosingTags)) {
+                    ending = "";
+                }
+
+                if (ending == null || ending.isEmpty()) {
+                    if (vTagCounts.containsKey(name)) {
+                        vTagCounts.put(name, vTagCounts.get(name) + 1);
+                    } else {
+                        vTagCounts.put(name, 1);
+                    }
+                } else {
+                    ending = " /";
+                }
+                return "<" + name + params + ending + ">";
+            } else {
+                return "";
+            }
+        }
+
+        // comments
+        m = P_COMMENT.matcher(s);
+        if (!stripComment && m.find()) {
+            return "<" + m.group() + ">";
+        }
+
+        return "";
+    }
+
+    private String processParamProtocol(String s) {
+        s = decodeEntities(s);
+        final Matcher m = P_PROTOCOL.matcher(s);
+        if (m.find()) {
+            final String protocol = m.group(1);
+            if (!inArray(protocol, vAllowedProtocols)) {
+                // bad protocol, turn into local anchor link instead
+                s = "#" + s.substring(protocol.length() + 1);
+                if (s.startsWith("#//")) {
+                    s = "#" + s.substring(3);
+                }
+            }
+        }
+
+        return s;
+    }
+
+    private String decodeEntities(String s) {
+        StringBuffer buf = new StringBuffer();
+
+        Matcher m = P_ENTITY.matcher(s);
+        while (m.find()) {
+            final String match = m.group(1);
+            final int decimal = Integer.decode(match);
+            m.appendReplacement(buf, Matcher.quoteReplacement(chr(decimal)));
+        }
+        m.appendTail(buf);
+        s = buf.toString();
+
+        buf = new StringBuffer();
+        m = P_ENTITY_UNICODE.matcher(s);
+        while (m.find()) {
+            final String match = m.group(1);
+            final int decimal = Integer.valueOf(match, 16);
+            m.appendReplacement(buf, Matcher.quoteReplacement(chr(decimal)));
+        }
+        m.appendTail(buf);
+        s = buf.toString();
+
+        buf = new StringBuffer();
+        m = P_ENCODE.matcher(s);
+        while (m.find()) {
+            final String match = m.group(1);
+            final int decimal = Integer.valueOf(match, 16);
+            m.appendReplacement(buf, Matcher.quoteReplacement(chr(decimal)));
+        }
+        m.appendTail(buf);
+        s = buf.toString();
+
+        s = validateEntities(s);
+        return s;
+    }
+
+    private String validateEntities(final String s) {
+        StringBuffer buf = new StringBuffer();
+
+        // validate entities throughout the string
+        Matcher m = P_VALID_ENTITIES.matcher(s);
+        while (m.find()) {
+            final String one = m.group(1); // ([^&;]*)
+            final String two = m.group(2); // (?=(;|&|$))
+            m.appendReplacement(buf, Matcher.quoteReplacement(checkEntity(one, two)));
+        }
+        m.appendTail(buf);
+
+        return encodeQuotes(buf.toString());
+    }
+
+    private String encodeQuotes(final String s) {
+        if (encodeQuotes) {
+            StringBuffer buf = new StringBuffer();
+            Matcher m = P_VALID_QUOTES.matcher(s);
+            while (m.find()) {
+                final String one = m.group(1); // (>|^)
+                final String two = m.group(2); // ([^<]+?)
+                final String three = m.group(3); // (<|$)
+                // 不替换双引号为&quot;，防止json格式无效 regexReplace(P_QUOTE, "&quot;", two)
+                m.appendReplacement(buf, Matcher.quoteReplacement(one + two + three));
+            }
+            m.appendTail(buf);
+            return buf.toString();
+        } else {
+            return s;
+        }
+    }
+
+    private String checkEntity(final String preamble, final String term) {
+
+        return ";".equals(term) && isValidEntity(preamble) ? '&' + preamble : "&amp;" + preamble;
+    }
+
+    private boolean isValidEntity(final String entity) {
+        return inArray(entity, vAllowedEntities);
+    }
+
+    private boolean allowed(final String name) {
+        return (vAllowed.isEmpty() || vAllowed.containsKey(name)) && !inArray(name, vDisallowed);
+    }
+
+    private boolean allowedAttribute(final String name, final String paramName) {
+        return allowed(name) && (vAllowed.isEmpty() || vAllowed.get(name).contains(paramName));
+    }
+}

play-common/src/main/java/com/starry/common/utils/http/HttpHelper.java

@@ -0,0 +1,44 @@
+package com.starry.common.utils.http;
+
+import org.apache.commons.lang3.exception.ExceptionUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.servlet.ServletRequest;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * 通用http工具封装
+ *
+ * @author ruoyi
+ */
+public class HttpHelper {
+    private static final Logger LOGGER = LoggerFactory.getLogger(HttpHelper.class);
+
+    public static String getBodyString(ServletRequest request) {
+        StringBuilder sb = new StringBuilder();
+        BufferedReader reader = null;
+        try (InputStream inputStream = request.getInputStream()) {
+            reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
+            String line = "";
+            while ((line = reader.readLine()) != null) {
+                sb.append(line);
+            }
+        } catch (IOException e) {
+            LOGGER.warn("getBodyString出现问题！");
+        } finally {
+            if (reader != null) {
+                try {
+                    reader.close();
+                } catch (IOException e) {
+                    LOGGER.error(ExceptionUtils.getMessage(e));
+                }
+            }
+        }
+        return sb.toString();
+    }
+}

play-common/src/main/java/com/starry/common/utils/http/HttpUtils.java

@@ -0,0 +1,199 @@
+package com.starry.common.utils.http;
+
+import com.starry.common.constant.Constants;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.net.ssl.*;
+import java.io.*;
+import java.net.ConnectException;
+import java.net.SocketTimeoutException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.nio.charset.StandardCharsets;
+import java.security.cert.X509Certificate;
+
+/**
+ * 通用http发送方法
+ *
+ * @author ruoyi
+ */
+public class HttpUtils {
+    private static final Logger log = LoggerFactory.getLogger(HttpUtils.class);
+
+    /**
+     * 向指定 URL 发送GET方法的请求
+     *
+     * @param url   发送请求的 URL
+     * @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
+     * @return 所代表远程资源的响应结果
+     */
+    public static String sendGet(String url, String param) {
+        return sendGet(url, param, Constants.UTF8);
+    }
+
+    /**
+     * 向指定 URL 发送GET方法的请求
+     *
+     * @param url         发送请求的 URL
+     * @param param       请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
+     * @param contentType 编码类型
+     * @return 所代表远程资源的响应结果
+     */
+    public static String sendGet(String url, String param, String contentType) {
+        StringBuilder result = new StringBuilder();
+        BufferedReader in = null;
+        try {
+            String urlNameString = url + "?" + param;
+            log.info("sendGet - {}", urlNameString);
+            URL realUrl = new URL(urlNameString);
+            URLConnection connection = realUrl.openConnection();
+            connection.setRequestProperty("accept", "*/*");
+            connection.setRequestProperty("connection", "Keep-Alive");
+            connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
+            connection.connect();
+            in = new BufferedReader(new InputStreamReader(connection.getInputStream(), contentType));
+            String line;
+            while ((line = in.readLine()) != null) {
+                result.append(line);
+            }
+            log.info("recv - {}", result);
+        } catch (ConnectException e) {
+            log.error("调用HttpUtils.sendGet ConnectException, url=" + url + ",param=" + param, e);
+        } catch (SocketTimeoutException e) {
+            log.error("调用HttpUtils.sendGet SocketTimeoutException, url=" + url + ",param=" + param, e);
+        } catch (IOException e) {
+            log.error("调用HttpUtils.sendGet IOException, url=" + url + ",param=" + param, e);
+        } catch (Exception e) {
+            log.error("调用HttpsUtil.sendGet Exception, url=" + url + ",param=" + param, e);
+        } finally {
+            try {
+                if (in != null) {
+                    in.close();
+                }
+            } catch (Exception ex) {
+                log.error("调用in.close Exception, url=" + url + ",param=" + param, ex);
+            }
+        }
+        return result.toString();
+    }
+
+    /**
+     * 向指定 URL 发送POST方法的请求
+     *
+     * @param url   发送请求的 URL
+     * @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
+     * @return 所代表远程资源的响应结果
+     */
+    public static String sendPost(String url, String param) {
+        PrintWriter out = null;
+        BufferedReader in = null;
+        StringBuilder result = new StringBuilder();
+        try {
+            log.info("sendPost - {}", url);
+            URL realUrl = new URL(url);
+            URLConnection conn = realUrl.openConnection();
+            conn.setRequestProperty("accept", "*/*");
+            conn.setRequestProperty("connection", "Keep-Alive");
+            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
+            conn.setRequestProperty("Accept-Charset", "utf-8");
+            conn.setRequestProperty("contentType", "utf-8");
+            conn.setDoOutput(true);
+            conn.setDoInput(true);
+            out = new PrintWriter(conn.getOutputStream());
+            out.print(param);
+            out.flush();
+            in = new BufferedReader(new InputStreamReader(conn.getInputStream(), StandardCharsets.UTF_8));
+            String line;
+            while ((line = in.readLine()) != null) {
+                result.append(line);
+            }
+            log.info("recv - {}", result);
+        } catch (ConnectException e) {
+            log.error("调用HttpUtils.sendPost ConnectException, url=" + url + ",param=" + param, e);
+        } catch (SocketTimeoutException e) {
+            log.error("调用HttpUtils.sendPost SocketTimeoutException, url=" + url + ",param=" + param, e);
+        } catch (IOException e) {
+            log.error("调用HttpUtils.sendPost IOException, url=" + url + ",param=" + param, e);
+        } catch (Exception e) {
+            log.error("调用HttpsUtil.sendPost Exception, url=" + url + ",param=" + param, e);
+        } finally {
+            try {
+                if (out != null) {
+                    out.close();
+                }
+                if (in != null) {
+                    in.close();
+                }
+            } catch (IOException ex) {
+                log.error("调用in.close Exception, url=" + url + ",param=" + param, ex);
+            }
+        }
+        return result.toString();
+    }
+
+    public static String sendSSLPost(String url, String param) {
+        StringBuilder result = new StringBuilder();
+        String urlNameString = url + "?" + param;
+        try {
+            log.info("sendSSLPost - {}", urlNameString);
+            SSLContext sc = SSLContext.getInstance("SSL");
+            sc.init(null, new TrustManager[]{new TrustAnyTrustManager()}, new java.security.SecureRandom());
+            URL console = new URL(urlNameString);
+            HttpsURLConnection conn = (HttpsURLConnection) console.openConnection();
+            conn.setRequestProperty("accept", "*/*");
+            conn.setRequestProperty("connection", "Keep-Alive");
+            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
+            conn.setRequestProperty("Accept-Charset", "utf-8");
+            conn.setRequestProperty("contentType", "utf-8");
+            conn.setDoOutput(true);
+            conn.setDoInput(true);
+
+            conn.setSSLSocketFactory(sc.getSocketFactory());
+            conn.setHostnameVerifier(new TrustAnyHostnameVerifier());
+            conn.connect();
+            InputStream is = conn.getInputStream();
+            BufferedReader br = new BufferedReader(new InputStreamReader(is));
+            String ret = "";
+            while ((ret = br.readLine()) != null) {
+                if (!ret.trim().isEmpty()) {
+                    result.append(new String(ret.getBytes(StandardCharsets.ISO_8859_1), StandardCharsets.UTF_8));
+                }
+            }
+            log.info("recv - {}", result);
+            conn.disconnect();
+            br.close();
+        } catch (ConnectException e) {
+            log.error("调用HttpUtils.sendSSLPost ConnectException, url=" + url + ",param=" + param, e);
+        } catch (SocketTimeoutException e) {
+            log.error("调用HttpUtils.sendSSLPost SocketTimeoutException, url=" + url + ",param=" + param, e);
+        } catch (IOException e) {
+            log.error("调用HttpUtils.sendSSLPost IOException, url=" + url + ",param=" + param, e);
+        } catch (Exception e) {
+            log.error("调用HttpsUtil.sendSSLPost Exception, url=" + url + ",param=" + param, e);
+        }
+        return result.toString();
+    }
+
+    private static class TrustAnyTrustManager implements X509TrustManager {
+        @Override
+        public void checkClientTrusted(X509Certificate[] chain, String authType) {
+        }
+
+        @Override
+        public void checkServerTrusted(X509Certificate[] chain, String authType) {
+        }
+
+        @Override
+        public X509Certificate[] getAcceptedIssuers() {
+            return new X509Certificate[]{};
+        }
+    }
+
+    private static class TrustAnyHostnameVerifier implements HostnameVerifier {
+        @Override
+        public boolean verify(String hostname, SSLSession session) {
+            return true;
+        }
+    }
+}

play-common/src/main/java/com/starry/common/utils/ip/AddressUtils.java

@@ -0,0 +1,47 @@
+package com.starry.common.utils.ip;
+
+
+import com.alibaba.fastjson2.JSON;
+import com.alibaba.fastjson2.JSONObject;
+import com.starry.common.utils.HttpUtils;
+import com.starry.common.utils.StringUtils;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * @author admin
+ * 获取地址工具类
+ * @since 2022/7/25
+ */
+@Slf4j
+public class AddressUtils {
+
+    /**
+     * IP地址查询
+     **/
+    public static final String IP_URL = "http://whois.pconline.com.cn/ipJson.jsp";
+    /**
+     * 未知地址
+     **/
+    public static final String UNKNOWN = "XX XX";
+
+    public static String getRealAddressByIp(String ip) {
+        if ("127.0.0.1".equals(ip)) {
+            return "内网IP";
+        } else {
+            try {
+                String rspStr = HttpUtils.sendGet(IP_URL, "ip=" + ip + "&json=true", "GBK");
+                if (StringUtils.isEmpty(rspStr)) {
+                    log.error("获取地理位置异常 {}", ip);
+                    return UNKNOWN;
+                }
+                JSONObject obj = JSON.parseObject(rspStr);
+                String region = obj.getString("pro");
+                String city = obj.getString("city");
+                return String.format("%s %s", region, city);
+            } catch (Exception e) {
+                log.error("获取地理位置异常 {}", ip);
+            }
+            return UNKNOWN;
+        }
+    }
+}

play-common/src/main/java/com/starry/common/utils/ip/IpUtils.java

@@ -0,0 +1,225 @@
+package com.starry.common.utils.ip;
+
+
+import com.starry.common.utils.StringUtils;
+
+import javax.servlet.http.HttpServletRequest;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+/**
+ * 获取IP方法
+ *
+ * @author ruoyi
+ */
+public class IpUtils {
+    /**
+     * 获取客户端IP
+     *
+     * @param request 请求对象
+     * @return IP地址
+     */
+    public static String getIpAddr(HttpServletRequest request) {
+        if (request == null) {
+            return "unknown";
+        }
+        String ip = request.getHeader("x-forwarded-for");
+        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
+            ip = request.getHeader("Proxy-Client-IP");
+        }
+        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
+            ip = request.getHeader("X-Forwarded-For");
+        }
+        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
+            ip = request.getHeader("WL-Proxy-Client-IP");
+        }
+        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
+            ip = request.getHeader("X-Real-IP");
+        }
+
+        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
+            ip = request.getRemoteAddr();
+        }
+
+        return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : getMultistageReverseProxyIp(ip);
+    }
+
+    /**
+     * 检查是否为内部IP地址
+     *
+     * @param ip IP地址
+     * @return 结果
+     */
+    public static boolean internalIp(String ip) {
+        byte[] addr = textToNumericFormatV4(ip);
+        return internalIp(addr) || "127.0.0.1".equals(ip);
+    }
+
+    /**
+     * 检查是否为内部IP地址
+     *
+     * @param addr byte地址
+     * @return 结果
+     */
+    private static boolean internalIp(byte[] addr) {
+        if (StringUtils.isNull(addr) || addr.length < 2) {
+            return true;
+        }
+        final byte b0 = addr[0];
+        final byte b1 = addr[1];
+        // 10.x.x.x/8
+        final byte SECTION_1 = 0x0A;
+        // 172.16.x.x/12
+        final byte SECTION_2 = (byte) 0xAC;
+        final byte SECTION_3 = (byte) 0x10;
+        final byte SECTION_4 = (byte) 0x1F;
+        // 192.168.x.x/16
+        final byte SECTION_5 = (byte) 0xC0;
+        final byte SECTION_6 = (byte) 0xA8;
+        switch (b0) {
+            case SECTION_1:
+                return true;
+            case SECTION_2:
+                if (b1 >= SECTION_3 && b1 <= SECTION_4) {
+                    return true;
+                }
+            case SECTION_5:
+                switch (b1) {
+                    case SECTION_6:
+                        return true;
+                }
+            default:
+                return false;
+        }
+    }
+
+    /**
+     * 将IPv4地址转换成字节
+     *
+     * @param text IPv4地址
+     * @return byte 字节
+     */
+    public static byte[] textToNumericFormatV4(String text) {
+        if (text.isEmpty()) {
+            return null;
+        }
+
+        byte[] bytes = new byte[4];
+        String[] elements = text.split("\\.", -1);
+        try {
+            long l;
+            int i;
+            switch (elements.length) {
+                case 1:
+                    l = Long.parseLong(elements[0]);
+                    if ((l < 0L) || (l > 4294967295L)) {
+                        return null;
+                    }
+                    bytes[0] = (byte) (int) (l >> 24 & 0xFF);
+                    bytes[1] = (byte) (int) ((l & 0xFFFFFF) >> 16 & 0xFF);
+                    bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
+                    bytes[3] = (byte) (int) (l & 0xFF);
+                    break;
+                case 2:
+                    l = Integer.parseInt(elements[0]);
+                    if ((l < 0L) || (l > 255L)) {
+                        return null;
+                    }
+                    bytes[0] = (byte) (int) (l & 0xFF);
+                    l = Integer.parseInt(elements[1]);
+                    if ((l < 0L) || (l > 16777215L)) {
+                        return null;
+                    }
+                    bytes[1] = (byte) (int) (l >> 16 & 0xFF);
+                    bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
+                    bytes[3] = (byte) (int) (l & 0xFF);
+                    break;
+                case 3:
+                    for (i = 0; i < 2; ++i) {
+                        l = Integer.parseInt(elements[i]);
+                        if ((l < 0L) || (l > 255L)) {
+                            return null;
+                        }
+                        bytes[i] = (byte) (int) (l & 0xFF);
+                    }
+                    l = Integer.parseInt(elements[2]);
+                    if ((l < 0L) || (l > 65535L)) {
+                        return null;
+                    }
+                    bytes[2] = (byte) (int) (l >> 8 & 0xFF);
+                    bytes[3] = (byte) (int) (l & 0xFF);
+                    break;
+                case 4:
+                    for (i = 0; i < 4; ++i) {
+                        l = Integer.parseInt(elements[i]);
+                        if ((l < 0L) || (l > 255L)) {
+                            return null;
+                        }
+                        bytes[i] = (byte) (int) (l & 0xFF);
+                    }
+                    break;
+                default:
+                    return null;
+            }
+        } catch (NumberFormatException e) {
+            return null;
+        }
+        return bytes;
+    }
+
+    /**
+     * 获取IP地址
+     *
+     * @return 本地IP地址
+     */
+    public static String getHostIp() {
+        try {
+            return InetAddress.getLocalHost().getHostAddress();
+        } catch (UnknownHostException e) {
+        }
+        return "127.0.0.1";
+    }
+
+    /**
+     * 获取主机名
+     *
+     * @return 本地主机名
+     */
+    public static String getHostName() {
+        try {
+            return InetAddress.getLocalHost().getHostName();
+        } catch (UnknownHostException e) {
+        }
+        return "未知";
+    }
+
+    /**
+     * 从多级反向代理中获得第一个非unknown IP地址
+     *
+     * @param ip 获得的IP地址
+     * @return 第一个非unknown IP地址
+     */
+    public static String getMultistageReverseProxyIp(String ip) {
+        // 多级反向代理检测
+        if (ip != null && ip.indexOf(",") > 0) {
+            final String[] ips = ip.trim().split(",");
+            for (String subIp : ips) {
+                if (false == isUnknown(subIp)) {
+                    ip = subIp;
+                    break;
+                }
+            }
+        }
+        return ip;
+    }
+
+    /**
+     * 检测给定字符串是否为未知，多用于检测HTTP请求相关
+     *
+     * @param checkString 被检测的字符串
+     * @return 是否未知
+     */
+    public static boolean isUnknown(String checkString) {
+        return StringUtils.isBlank(checkString) || "unknown".equalsIgnoreCase(checkString);
+    }
+}