Treasure

com.dingwen
├── scene[综合场景启动器使用示例]                                               				
│     └── pom.xml[ Maven依赖]                                      									
├── starter[启动器集]                                            				  						
│       └── base-spring-boot-starter[基础场景启动器]                        						
│       └── api-docs-spring-boot-starter[API文档再封装场景启动器]                  		
│       └── screw-spring-boot-starter[数据库文档生成场景启动器]                     		
│       └── webplus-spring-boot-starter[Web再封装场景启动器 ]                  				
│       └── redis-spring-boot-starter[Redis场景启动器]                       				
│       └── caffeine-spring-boot-starter[本地缓存启动器]                  							
│       └── async-spring-boot-starter[异步场景启动器]                     							
│       └── enums-spring-boot-starter[枚举场景启动器]                   								 
│       └── mybatisplus-spring-boot-starter[MybatisPlus场景启动器]       						
│       └── log-spring-boot-starter[日志场景启动器]                          				
│       └── logv-spring-boot-starter[日志查看启动器]                        						
│       └── email-spring-boot-starter[电子邮件场景启动器]                      				
│       └── mongo-spring-boot-starter[MongoDB场景启动器]                     				
│       └── xxl-job-spring-boot-starter[xxljob场景启动器]                    				
│       └── translate-spring-boot-starter[翻译场景启动器]               								
│       └── oss-spring-boot-starter[文件存储场景启动器]                     						
│       └── pipeline-spring-boot-starter[责任链Pipeline场景启动器]               			
│       └── bar-spring-boot-starter[进度条场景启动器]                     						
│       └── dic-spring-boot-starter[字典场景启动器]                     								
│       └── excel-spring-boot-starter[Excel场景启动器]                  							
│       └── config-spring-boot-starter[系统配置场景启动器]                  						 
│       └── quartz-spring-boot-starter[Quartz定时任务场景启动器]                  			 
│       └── file-spring-boot-starter[文件场景启动器]                    								
│       └── change-log-spring-boot-starter[变更记录场景启动器]                   			
│       └── db-backup-spring-boot-starter[数据归档场景启动器]  
│       └── event-spring-boot-starter[事件场景启动器]
│       └── 规划中[数据脱敏场景启动器]                                            			
│       └── jwt-spring-boot-starter[JWT场景启动器]                                   
│       └── security-plus-spring-boot-starter[Security场景启动器]  
│       └── auth-spring-boot-starter[认证场景启动器]  
│       └── dcache-spring-boot-starter[二级缓存启动器]  
│       └── kkFile-docker[文件预览场景启动器]                                         
│       └── 规划中[监控场景启动器]                                            				 
│       └── 规划中[审核场景启动器]                                            					 
│       └── 规划中[Flowable启动器]                                            				 
│       └── 规划中[Camunda启动器]                                            					 
│       └── 规划中[微信公众号开发启动器]                                            		
│       └── 规划中[钉钉开发启动器]                                            					
│       └── 规划中[重要表单变更日志启动器]                                            	
│       └── 规划中[elasticsearch启动器]    
│       └── 规划中[Dingger消息告警二次封装] 
├── pom.xml[Maven依赖]                                            														     

com.dingwen 
├── treasure-canal-client[canal客户端 [80]]            						 
├── treasure-kettle[kettle集成企业级解决方案 [9999]]                   						 
├── treasure-websocket[websocket方案 [8081] [8080]]               					    
├── treasure-sms4j[通用短信解决方案 [8080]]                   						   
├── treasure-poi-tl[word模板渲染解决方案 [8080]]                  						   
├── treasure-jimu-report[开源报表解决方案 [8080]]              					 
├── treasure-dingtalk-ger[钉钉,企业微信预警机器人解决方案 [8080]]			  				     
├── 规划中[认证解决方案 [8080]]								  						  
├── 规划中[单点登录解决方案 [8080]]								 						     
├── 规划中[动态表单解决方案 [8080]]								  						  
├── treasure-gof[大话设计模式]										    
├── pom.xml[Maven依赖]                         						   

com.cdn  
com.dingwen 
├── treasure-auth[认证服务 [20902]]                       														
├── treasure-business[业务服务 [20903]]                   													  
├── treasure-admin[监控服务 [20901]]                     														 
├── treasure-common[通用模块]                    													 
│       └── common-pom[依赖管理模块]                  												  
│       └── common-base[基础模块]                													
│       └── common-beansearcher[对象搜索]         											
│       └── common-config[基础配置]             												 
│       └── common-core[ 核心模块]      													           
│       └── common-jpa[持久层JPA]           													        
│       └── common-jwt[JWT令牌]                 													  
│       └── common-knifej[接口文档]                 											
│       └── common-model[通用MODEL]                    										       
│       └── common-mongodb[MongoDB]                 											 
│       └── common-mybatisplus[持久层Mybatisplus]             											  
│       └── common-rabbitmq[RabbitMQ]                											   
│       └── common-redis[Redis]                    											   
│       └── common-security[安全模块]              												 
│       └── common-sensitive[自定义注解实现数据脱敏]              											 
│       └── common-web[WEB模块]                     											    
│       └── common-tkmybatis[tkmybatis模块]               											 
│       └── common-minio[minio文件存储]                  											  
│       └── common-easyexcel[excel 文件导入导出]              										     
│       └── common-influxdb[时序数据库案例]                 											
│       └── common-open-api[open api 案例]                											   
│               └── open-api-baidu-map[百度地图]         										     
│               └── open-api-sms[阿里云短信]            											 
│               └── open-api-tx[天行数据基础服务]            													 
│               └── open-api-wechat-pub[微信公众号]            									    
│               └── open-api-baidu-map[百度地图]             										  
│               └── open-api-tianxing-rainbow[天行数据彩虹屁]          								  
├── treasure-gateway[网关服务 [20904]]                 													     
├── treasure-log[日志服务 [20905]]                     													       
├── treasure-manage[后台管理 [20906]]                 													     
├── treasure-file-generate[ 文件生成服务 [20907]]               												
├── treasure-task-quartz[定时任务(Quarzt实现) [20908]]                								
├── treasure-file[文件服务 [20909]]                     													      
├── treasure-code-generate[代码生成服务 [20910]]                  											  
├── treasure-slow-sql[慢SQL [20911]]                     													  
├── treasure-xxl-job-admin[xxl-job-admin [20933]]              												
├── logs[日志]                         													         		    
├── sql[sql]                               													         	     
├── img[图片]                                 													            
├── pom.xml[公共依赖]                               													      

<servers>
    <!-- 阿里云私服开始 -->
    <server>
        <id>rdc-releases</id>
        <username>62c3e2f6a908b6a4db54fa26</username>
        <password>5V8N7KJ]rvtt</password>
    </server>
    <server>
        <id>rdc-snapshots</id>
        <username>62c3e2f6a908b6a4db54fa26</username>
        <password>5V8N7KJ]rvtt</password>
    </server>
    <!-- 阿里云私服结束 -->
</servers>

        <!-- 相当于拦截器访问改地址是映射的配置 -->
<mirrors>
<!-- 阿里云制品仓库 -->
<mirror>
    <id>mirror</id>
    <mirrorOf>central,jcenter,!rdc-releases,!rdc-snapshots</mirrorOf>
    <name>mirror</name>
    <url>https://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>

</mirrors>


<profiles>
<!-- 阿里云制品仓库 -->
<profile>
    <id>rdc</id>
    <properties>
        <altReleaseDeploymentRepository>
            rdc-releases::default::https://packages.aliyun.com/maven/repository/2380560-release-WXL1gl/
        </altReleaseDeploymentRepository>
        <altSnapshotDeploymentRepository>
            rdc-snapshots::default::https://packages.aliyun.com/maven/repository/2380560-snapshot-vKCASA/
        </altSnapshotDeploymentRepository>
    </properties>
</profile>
</profiles>

        <!-- 激活配置 -->
<activeProfiles>
<activeProfile>rdc</activeProfile>
</activeProfiles>

        <!--基础场景启动器-->
<dependency>
    <groupId>com.dingwen</groupId>
    <artifactId>base-spring-boot-starter</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

@EnableBase

 Checker<SysUser> checker = Checkers.<SysUser>lambdaCheck()
                    .notNull(SysUser::getName)
                    .ne(SysUser::getAge, 0)
                    .custom(item -> item.getAge() > queryByDb(item.getId()), "年龄异常");
            checker.check(sysUser);

/**
 * 　OptimizeUtilController: 优化工具测试
 * 　@author dingwen
 * 　@since 2022/8/28
 */
@Api(tags = "优化工具API")
@RestController
@Slf4j
@RequestMapping("optimize")
@RequiredArgsConstructor
public class OptimizeUtilController {

    @ApiOperation(value = "API使用测试")
    @GetMapping
    public void test() {
        optimizeApi();
    }

    @SneakyThrows(Throwable.class)
    private void optimizeApi() {
        OptimizeUtil.start("任务1");
        TimeUnit.SECONDS.sleep(1);
        OptimizeUtil.stop("任务1");
        for (int i = 0; i < 100; i++) {
            OptimizeUtil.start("任务2");
            for (int j = 0; j < 1000; j++) {
                OptimizeUtil.start("任务2-1");
                OptimizeUtil.stop("任务2-1");
            }
            OptimizeUtil.stop("任务2");
        }

        OptimizeUtil.print("任务2");
        OptimizeUtil.print();
    }
}

   /**
    * 发布事件，将指定的应用事件发布到Spring事件传播机制中。
    * @param event 应用事件对象，代表一个具体的事件实例，将被Spring应用上下文中的事件监听器处理。
    */
   public static void publishEvent(BaseEvent event){
       // 将事件对象持久化到数据库,方便实现重发
       Map<String, IEvent> events = SpringUtil.getBeansOfType(IEvent.class);
       events.forEach((eName,ev) -> ev.saveEvent(event));
       // 将事件发布到Spring应用上下文中
       SpringUtil.publishEvent(event);
   }

<!--webplus场景-->
<dependency>
    <groupId>com.dingwen</groupId>
    <artifactId>webplus-spring-boot-starter</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

@EnableWebplus

dingwen:
  treasure:
    # webplus
    webplus:
      # 开启Debug
      debug: true
      # 静态资源映射处理
      handlers:
        - handler: "doc.html"
          locations: "classpath:/META-INF/resources/"
        - handler: "swagger-ui.html"
          locations: "classpath:/META-INF/resources/"
        - handler: "/webjars/**"
          locations: "classpath:/META-INF/resources/webjars/"

    @ApiOperation("测试国际化校验消息")
    @ApiImplicitParam(name = "msg", value = "消息", dataTypeClass = String.class)
    @GetMapping("/valid")
    public ResultVO<String> testInternationalization(@RequestParam @Size(min = 1,max = 6,message = "{treasure.webplus.valid.test.msg.size}") String msg) {
        return success(msg);
    }

        <!--api文档生成启动器-->
<dependency>
    <groupId>com.dingwen</groupId>
    <artifactId>api-docs-spring-boot-starter</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

@EnableApiDocs

dingwen:
  treasure:
    # API接口文档生成
    api:
      docs:
        # 标题
        title: "Ding Wen Service Api"
        # 描述
        description: "This is Interface Desc"
        # 服务地址
        url: "http://127.0.0.1"
        # 版本号
        version: "1.0.0"
        # 分组名称
        group: prod
        # 内部API请求头值
        headervalue: "DINGWEN-API-VALUE"
        # 内部APi请求名称
        headername: "DINGWEN-API-NAME"
        # 文档联系人名称
        contactname: "dingwen"
        # 文档联系人站点
        contacturl: "https://treasure.dingwen.top"
        # 文档联系人邮箱
        contactemail: "dingwen0314@163.com"

        <!--异步场景-->
<dependency>
    <groupId>com.dingwen</groupId>
    <artifactId>async-spring-boot-starter</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

@EnableAsync

dingwen:
  treasure:
    # async
    async:
      # 是否开启线程池实时日志打印
      logPrint: true
      pool:
        # 核心线程数
        - core: 8
          # 最大线程数
          max: 16
          # 线程空闲时间
          keepAliveTime: 60
          # 缓冲队列大小
          queueCapacity: 2000
          # 线程池前缀
          poolNamePrefix: treasure-async-
          # 线程池对象名称
          poolBeanName: logvExecutor
          # 线程池拒绝策略
          poolPolicy: CallerRunsPolicy

    // 注解式
    @Resource(name = "fileExecutor")
    @Lazy
    private ThreadPoolTaskExecutor fileExecutor;
    
    
    // 编程式
    ThreadPoolTaskExecutor logVExecutor = SpringUtil.getBean("logvExecutor", ThreadPoolTaskExecutor.class);

        <!--日志场景-->
<dependency>
    <groupId>com.dingwen</groupId>
    <artifactId>log-spring-boot-starter</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

@EnableLog

dingwen:
  treasure:
    # 请求日志
    log:
      request:
        # 是否开启请求日志
        reEnable: true
        #  是否记录请求体内容
        reEnableBody: false
      method:
        global-log-level: debug
        # 全局综合日志代码定位
        global-log-position: unknown
        # 全局综合日志格式化
        global-log-formatter: com.dingwen.treasure.log.method.format.DefaultMeLogFormatter
        # 全局综合日志回调
        global-log-callback: com.dingwen.treasure.log.method.callback.DefaultMeLogCallback
        # 全局参数日志级别
        global-param-log-level: debug
        # 全局参数日志代码定位
        global-param-log-position: unknown
        # 全局参数日志格式化
        global-param-log-formatter: com.dingwen.treasure.log.method.format.DefaultMeParamLogFormatter
        # 全局参数日志回调
        global-param-log-callback: com.dingwen.treasure.log.method.callback.DefaultMeLogCallback
        # 全局结果日志级别
        global-result-log-level: debug
        # 全局结果日志代码定位
        global-result-log-position: unknown
        # 全局结果日志格式化
        global-result-log-formatter: com.dingwen.treasure.log.method.format.DefaultMeResultLogFormatter
        # 全局结果日志回调
        global-result-log-callback: com.dingwen.treasure.log.method.callback.DefaultMeLogCallback
        # 全局异常日志回调
        global-throwing-log-callback: com.dingwen.treasure.log.method.callback.DefaultMeLogCallback

    /**
     * 测试方法日志
     *
     * @param name 名字
     * @return {@link ResultVO}<{@link String}>
     */
    @GetMapping("/method-test")
    @ApiOperation(value = "测试方法日志")
    @ApiImplicitParam(name = "name", value = "名称", dataTypeClass = String.class)
    @MeLog(value = "方法日志测试业务")
    public ResultVO<String> testMeLog(@RequestParam String name) {
        return success();
    }


    /**
     * 测试操作日志
     *
     * @param name 名称
     * @return {@link ResultVO}<{@link String}>
     */
    @GetMapping("/operate-test")
    @ApiOperation(value = "测试操作日志")
    @ApiImplicitParam(name = "name", value = "名称", dataTypeClass = String.class)
    @OperateLogAnnotation(module = "场景", desc = "test")
    public ResultVO<String> testOperateLog(@RequestParam String name) {
        return success();
    }
    

        <!--日志查看场景-->
<dependency>
    <groupId>com.dingwen</groupId>
    <artifactId>logv-spring-boot-starter</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

@EnableLogv

dingwen:
  treasure:
    # webplus
    webplus:
      debug: true
      handlers:
        - handler: "doc.html"
          locations: "classpath:/META-INF/resources/"
        - handler: "swagger-ui.html"
          locations: "classpath:/META-INF/resources/"
        - handler: "/webjars/**"
          locations: "classpath:/META-INF/resources/webjars/"
    # async
    async:
      logPrint: true
      pool:
        - core: 8
          max: 16
          keepAliveTime: 60
          queueCapacity: 2000
          poolNamePrefix: treasure-async-
          poolBeanName: logvExecutor
          poolPolicy: CallerRunsPolicy
# 监控项
management:
  endpoints:
    web:
      exposure:
        include: "*"
  endpoint:
    health:
      show-details: always
    shutdown:
      enabled: true

        <!--枚举场景-->
<dependency>
    <groupId>com.dingwen</groupId>
    <artifactId>enums-spring-boot-starter</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

/**
 * 　逻辑删除
 * 　@author dingwen
 * 　@since 2022/6/14
 */
@Getter
@AllArgsConstructor
public enum LogicDelete implements IBaseEnum<Integer> {
    /**
     * 已删除
     */
    DELETED(0, "删除"),
    /**
     *存在
     */
    EXISTED(1, "存在");
    /**
     * 状态值
     */
    @EnumValue
    private final Integer code;

    /**
     * 状态描述
     */
    private final String desc;

}

dingwen:
  treasure:
    # enums
    enums:
      # 枚举类扫描包
      packagepath: "com.dingwen"
      # 枚举类所在类路径
      classpath: "/**/*.class"

package com.dingwen.treasure.scene.enums;

import com.dingwen.treasure.enums.core.IBaseEnum;

/**
 * 配置环境简单枚举
 *
 * @author dingwen
 * @since 2024/1/18 15:22
 */
public enum ProfileSimpleEnum implements IBaseEnum<String> {
    /**
     * 生产环境
     */
    PROD,
    /**
     * 开发环境
     */
    DEV,
    /**
     * 测试环境
     */
    TEST
}

        <!--数据库文档生成场景启动器-->
<dependency>
    <groupId>com.dingwen</groupId>
    <artifactId>screw-spring-boot-starter</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

@EnableScrew

dingwen:
  treasure:
  # 数据库文档生成
  screw:
  # 数据源连接地址
  jdbcUrl: ${spring.datasource.dynamic.datasource.master.url}
  # 数据源用户名
  username: ${spring.datasource.dynamic.datasource.master.username}
  # 数据源连接密码
  password: ${spring.datasource.dynamic.datasource.master.password}
  # 驱动类名称
  driverClassName: ${spring.datasource.dynamic.datasource.master.driver-class-name}
  # 是否读取表注释信息
  tableRemark: true
  # 文档版本号
  docVersion: 1.0.0
  # 文件输出目录
  fileOutputDir: @project.name@/src/main/resources/static

<!--mongo场景启动器-->
<dependency>
    <groupId>com.dingwen</groupId>
    <artifactId>mongo-spring-boot-starter</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

@EnableMongo

/**
 * 请求日志
 *
 * @author dingwen
 * @since 2023/7/24 13:12
 */
@ApiModel(value = "RequestLog", description = "请求日志实体")
@Document("tre_c_request_log")
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@EqualsAndHashCode(callSuper = true)
public class RequestLog extends BaseMongoEntity {

    @ApiModelProperty(value = "请求日志id")
    @Id
    private String reLogId;


    @ApiModelProperty(value = "请求时间")
    @Field("reTime")
    private LocalDateTime reTime;

    @ApiModelProperty(value = "请求IP")
    @Field("reIp")
    @Indexed
    private String reIp;

    @ApiModelProperty(value = "IP属地")
    @Field("reAddress")
    private String reAddress;

    @ApiModelProperty(value = "耗时")
    @Field("consumeTime")
    private Long consumeTime;

    @ApiModelProperty(value = "请求体信息")
    @Field("resBody")
    private String resBody;

    @ApiModelProperty(value = "响应体信息")
    @Field("respBody")
    private String respBody;

    @ApiModelProperty(value = "请求地址")
    @Field("reUrl")
    @Indexed
    private String reUrl;

    @ApiModelProperty(value = "请求头信息")
    @Field("reqHeaders")
    private String reqHeaders;
}

/**
 * 请求日志服务
 *
 * @author dingwen
 * @since 2023/7/24 13:36
 */
public interface IRequestLogService extends MongoService<RequestLog> {
}

/**
 * 请求日志服务
 *
 * @author dingwen
 * @since 2023/7/24 13:38
 */
@Service
public class RequestLogServiceImpl extends MongoServiceImpl<RequestLog> implements IRequestLogService {
}

/**
 * MongoAPI
 *
 * @author dingwen
 * @since 2023/7/24 13:42
 */
@Api(tags = "MongoDB API")
@RestController
@Slf4j
@RequestMapping("common/mongo")
public class MongoController implements BaseViewController {

    @Resource
    private IRequestLogService requestLogService;


    /**
     * 请求日志列表
     *
     */
    @ApiOperation(value = "请求日志列表")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "reIp", value = "请求IP", dataTypeClass = String.class),
            @ApiImplicitParam(name = "reAddress", value = "IP属地", dataTypeClass = String.class),
            @ApiImplicitParam(name = "reUrl", value = "请求地址", dataTypeClass = String.class)
    })
    @GetMapping("request-logs")
    public ResultVO<PageVO<RequestLog>> getRequestLogPage(@RequestParam(required = false) String reIp,
                                                          @RequestParam(required = false) String reAddress,
                                                          @RequestParam(required = false) String reUrl) {
        LambdaQueryWrapper<RequestLog> query = Wrappers.<RequestLog>lambdaQuery()
                                                       .like(StrUtil.isNotBlank(reIp), RequestLog::getReIp, reIp)
                                                       .like(StrUtil.isNotBlank(reAddress), RequestLog::getReAddress, reAddress)
                                                       .like(StrUtil.isNotBlank(reUrl), RequestLog::getReUrl, reUrl)
                                                       .orderByDesc(RequestLog::getCreateTime);

        Page<RequestLog> page = requestLogService.page(query, PageUtils.getPageNum(), PageUtils.getPageSize());
        return page(page.getRecords(), Convert.toInt(page.getTotal()));
    }
}

<!--xxl-job场景启动器-->
<dependency>
    <groupId>com.dingwen</groupId>
    <artifactId>xxl-job-spring-boot-starter</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

@EnableXxlJob

dingwen:
  treasure:
    #xxl-job定时任务场景
    xxljob:
      # 执行器开关
      enabled: true
      adminAddresses: http://127.0.0.1:8003
      #调度中心应用名
      adminAppName: treasure-xxl-job-admin
      # 执行器通讯TOKEN
      accessToken: xxl-job-access-token
      # 执行器配置
      executor:
        appName: scene
        #执行器日志文件保存天数：大于3生效
        logRetentionDays: 10
        # 执行器运行日志文件存储磁盘路径 【注意不要和项目本身log路径冲突】
        logPath: logs/xxljob
        # 执行器端口号
        port: 9999

        <!--caffeine场景-->
        <dependency>
            <groupId>com.dingwen</groupId>
            <artifactId>caffeine-spring-boot-starter</artifactId>
            <version>1.0.0-SNAPSHOT</version>
        </dependency>

@EnableCaffeine

dingwen:
  treasure:
    # caffeine
    caffeine:
      caches:
      	  # 缓存Spring Bean名称
        - name: testCache
          # 有效时间，单位秒
          invalidTime: 60
          # 最大缓存数量
          maximumSize: 100
        - name: fileCache
          invalidTime: 60
          maximumSize: 1000

package com.dingwen.treasure.scene.controller.caffeine;

/**
 * Caffeine
 *
 * @author dingwen
 * @since 2023/5/22 16:20
 */
@Api(tags = "本地缓存API")
@RestController
@Slf4j
@RequestMapping("common/caffeine")
@CacheConfig(cacheManager = "caffeineCacheManager")
public class CaffeineController implements BaseViewController {

    @Resource(name = "testCache")
    @Lazy
    private CaffeineCache testCache;


    /**
     * 缓存测试
     *
     * @return {@link ResultVO}<{@link String}>
     */
    @ApiOperation("本地缓存测试")
    @Cacheable(cacheNames = "testCache")
    @GetMapping("/test")
    public ResultVO<String> cache() {
        testCache.putIfAbsent("test", "test");
        String test = testCache.get("test", String.class);
        log.info("test:{}", test);
        return success(test);
    }

package com.dingwen.treasure.caffeine.util;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import org.springframework.cache.Cache;
import org.springframework.cache.caffeine.CaffeineCache;

import java.lang.reflect.Field;
import java.util.*;
import java.util.function.Function;

/**
 * 缓存工具类
 *
 * @author dingwen
 * @since 2023/5/30 16:01
 */
public class CacheHelper {

    /**
     * 实体初始化
     */
    private static final CacheHelper CACHEHELPER = new CacheHelper();

    /**
     * 构造器私有
     */
    private CacheHelper() {
    }


    /**
     * 获取实例
     *
     * @return {@link CacheHelper}
     */
    public static CacheHelper getInstance() {
        return CACHEHELPER;
    }

    /**
     * 缓存Map
     *
     * @param cache 缓存
     * @return {@link Map}<{@link String}, {@link Object}>
     */
    public <T> Map<String, T> cacheToMap(Cache cache) {
        Object obj = cache.getNativeCache();
        Map<String, Object> map = new HashMap<>(16);
        Field[] fields = obj.getClass().getDeclaredFields();
        try {
            for (Field field : fields) {
                field.setAccessible(true);
                map.put(field.getName(), field.get(obj));
            }
        } catch (Exception e) {
            return null;
        }
        return (Map<String, T>) map.get("cache");
    }


    /**
     * 本地缓存通用逻辑处理
     *
     * @param key           缓存key id
     * @param keyPrefix     缓存key 前缀
     * @param keySuffix     缓存key 后缀
     * @param clazz         缓存值字节码
     * @param func          实际执行函数
     * @param caffeineCache 缓存池
     * @return {@link V}
     */
    public <K, V> V cacheAndGet(K key, String keyPrefix, String keySuffix,
                                Class<V> clazz, Function<K, V> func,
                                CaffeineCache caffeineCache) {
        if (Objects.isNull(key)
                || Objects.isNull(keyPrefix)
                || Objects.isNull(keySuffix)
                || Objects.isNull(clazz)
                || Objects.isNull(caffeineCache)) {
            if (Objects.isNull(func)) {
                return null;
            }
            return func.apply(key);
        }
        String cacheKey = StrUtil.format("{}_{}_{}", keyPrefix, key, keySuffix);
        V vCache = caffeineCache.get(cacheKey, clazz);
        if (Objects.nonNull(vCache)) {
            return vCache;
        }
        V v = func.apply(key);
        caffeineCache.put(cacheKey, v);
        return v;
    }

    /**
     * caches and gets
     *
     * @param keys          缓存keys ids
     * @param keyPrefix     缓存key 前缀
     * @param keySuffix     缓存key 后缀
     * @param clazz         缓存值字节码
     * @param func          实际执行函数
     * @param caffeineCache 缓存池
     * @return {@link V}
     */
    public <K, V> List<V> cachesAndGets(List<K> keys, String keyPrefix, String keySuffix,
                                        Class<V> clazz, Function<List<K>, Map<K, V>> func,
                                        CaffeineCache caffeineCache) {
        if (CollUtil.isEmpty(keys)
                || Objects.isNull(keyPrefix)
                || Objects.isNull(keySuffix)
                || Objects.isNull(clazz)
                || Objects.isNull(caffeineCache)) {
            if (Objects.isNull(func)) {
                return null;
            }
            return new ArrayList<>(func.apply(keys).values());
        }
        // 缓存的结果
        List<V> cacheValues = new ArrayList<>(keys.size());
        // 没有在缓存中的key
        List<K> noCacheKeys = new LinkedList<>();
        for (K key : keys) {
            String cacheKey = buildCacheKey(key, keyPrefix, keySuffix);
            V vCache = caffeineCache.get(cacheKey, clazz);
            if (Objects.nonNull(vCache)) {
                cacheValues.add(vCache);
            } else {
                // 缓存未命中
                noCacheKeys.add(key);
            }
        }
        // 查询参数完全命中，直接返回
        if (CollUtil.isNotEmpty(noCacheKeys)) {
            return cacheValues;
        }
        // 未命中缓存的数据
        Map<K, V> noCacheValues = func.apply(noCacheKeys);
        if (CollUtil.isEmpty(noCacheValues)) {
            return cacheValues;
        }
        // 添加新查询到的数据到缓存中
        noCacheValues.forEach((K key, V value) -> {
            String cacheKey = buildCacheKey(key, keyPrefix, keySuffix);
            caffeineCache.put(cacheKey, value);
            cacheValues.add(value);
        });
        return cacheValues;

    }

    /**
     * 构建缓存key
     *
     * @param key       key
     * @param keyPrefix key prefix
     * @param keySuffix key suffix
     * @return {@link String}
     */
    public <K> String buildCacheKey(K key, String keyPrefix, String keySuffix) {
        return StrUtil.format("{}_{}_{}", keyPrefix, key, keySuffix);
    }
}

        <!--redis场景-->
        <dependency>
            <groupId>com.dingwen</groupId>
            <artifactId>redis-spring-boot-starter</artifactId>
            <version>1.0.0-SNAPSHOT</version>
        </dependency>

@EnableRedis

dingwen:
  treasure:
    # redis
    redis:
      easy:
        # 开启easy cache
        cache: true
      rate:
        # 开启限流
        limiter: true
      re:
        # 开启防重复提交
        submit: true
      # 缓存项配置  
      caches:
        - keyPrefix: "re_submit:"
          remark: "防止重复提交"
        - keyPrefix: "common_lock:"
          remark: "通用锁"

package com.dingwen.treasure.scene.controller.redis;

/**
 * Redis场景API
 *
 * @author dingwen
 * @since 2023/5/22 11:11
 */
@Api(tags = "Redis缓存API")
@RestController
@Slf4j
@RequestMapping("common/redis")
public class RedisController implements BaseViewController {

    /**
     * redis 服务
     */
    @Resource
    private RedisService redisService;

    @Resource
    private RedisProperties redisProperties;


    /**
     * 得到Redis信息
     *
     * @return {@link ResultVO}
     */
    @ApiOperation("获取Redis信息")
    @GetMapping("/info")
    public ResultVO getInfo() {
        return success(redisService.getInfo());
    }

    /**
     * 获取缓存项
     *
     * @return {@link ResultVO}<{@link List}<{@link CacheVO}>>
     */
    @ApiOperation(value = "获取缓存项")
    @GetMapping
    public ResultVO<List<CacheVO>> getCaches() {
        List<CacheBO> caches = redisProperties.getCaches();
        List<CacheVO> cacheVOS = BeanCopyUtils.copyList(caches, CacheVO.class);
        return success(cacheVOS);
    }


    /**
     * 获取指定前缀的所有key
     *
     * @param keyPrefix 关键前缀
     * @return {@link ResultVO}<{@link Collection}<{@link String}>>
     */
    @ApiOperation(value = "获取指定前缀的所有key")
    @ApiImplicitParam(name = "keyPrefix", value = "key前缀", dataTypeClass = String.class)
    @GetMapping("/{keyPrefix}")
    public ResultVO<Collection<String>> getKeys(@PathVariable("keyPrefix") String keyPrefix) {
        return success(redisService.getKeys(keyPrefix + RedisConstant.KEY_ALL));
    }


    /**
     * 获取缓存值
     *
     * @param keyPrefix 关键前缀
     * @param key       关键
     * @return {@link ResultVO}<{@link CacheVO}>
     */
    @ApiOperation(value = "获取指定key的缓存值")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "keyPrefix", value = "key前缀", dataTypeClass = String.class),
            @ApiImplicitParam(name = "key", value = "key", dataTypeClass = String.class)
    })
    @GetMapping("/{keyPrefix}/{key}")
    public ResultVO<CacheVO> getCache(@PathVariable("keyPrefix") String keyPrefix, @PathVariable("key") String key) {
        String cacheValue = redisService.getCacheObject(key);
        CacheVO cacheVO = CacheVO.builder()
                                 .keyPrefix(keyPrefix)
                                 .cacheKey(key)
                                 .cacheValue(cacheValue)
                                 .build();
        return success(cacheVO);
    }


    /**
     * 清除指定key前缀的所有缓存
     *
     * @param keyPrefix 关键前缀
     * @return {@link ResultVO}<{@link String}>
     */
    @ApiOperation(value = "清除指定key前缀的所有缓存")
    @ApiImplicitParam(name = "keyPrefix", value = "key前缀", dataTypeClass = String.class)
    @PutMapping("/{keyPrefix}")
    public ResultVO<String> cleanCaches(@PathVariable("keyPrefix") String keyPrefix) {
        redisService.removeKeys(keyPrefix + RedisConstant.KEY_ALL);
        return success();
    }

    /**
     * 清除指定key的缓存
     *
     * @param key 关键
     * @return {@link ResultVO}<{@link String}>
     */
    @ApiOperation(value = "清除指定key的缓存")
    @ApiImplicitParam(name = "key", value = "key", dataTypeClass = String.class)
    @DeleteMapping("/{key}")
    public ResultVO<String> cleanCache(@PathVariable("key") String key) {
        redisService.deleteObject(key);
        return success();
    }

    /**
     * 清洗所有缓存
     *
     * @return {@link ResultVO}<{@link String}>
     */
    @ApiOperation(value = "清除所有缓存")
    @DeleteMapping
    public ResultVO<String> cleanAllCache() {
        redisService.removeKeys(RedisConstant.KEY_ALL);
        return success();
    }


    /**
     * 轻松缓存
     *
     * @param easyCacheSubmitVO 轻松缓存提交内容
     * @return {@link ResultVO}<{@link String}>
     */
    @PostMapping("/easy-cache")
    @ApiOperation("轻松缓存测试")
    @EasyCache(keyParams = {
            "#easyCacheSubmitVO.getId()",
            "#easyCacheSubmitVO.getName()"},
            time = 100,
            returnType = ResultVO.class)
    public ResultVO<EasyCacheSubmitVO> easyCache(@RequestBody EasyCacheSubmitVO easyCacheSubmitVO) {
        return success(easyCacheSubmitVO);
    }

    /**
     * 速率限制
     *
     * @return {@link ResultVO}<{@link String}>
     */
    @ApiOperation("redis限流测试")
    @GetMapping("/rate-limit")
    @RateLimiter(time = 1, count = 2)
    public ResultVO<String> rateLimit() {
        return success();
    }

    /**
     * 防止重复提交测试
     */
    @ApiOperation("防止重复提交测试")
    @GetMapping("/re-submit")
    @ReSubmit(message = "登录重复提交请求", isDeleteKey = false, time = 90)
    public void resubmit() {
    }

    /**
     * 锁 </br>
     * redisson方案；<a href="https://redisson.org">...</a>
     *
     * @return {@link ResultVO}<{@link String}>
     */
    @ApiOperation("lock测试")
    @GetMapping("/lock")
    public ResultVO<String> lock() {
        boolean ifAbsent = redisService.setIfAbsent(RedisKeyConstant.LOCK_PREFIX.concat("test"), "lock test",
                1L, TimeUnit.MINUTES);
        // 剩余时间
        long expire = redisService.getExpire(RedisKeyConstant.LOCK_PREFIX.concat("test"), TimeUnit.SECONDS);
        if (ObjectUtil.isNotNull(ifAbsent) && ifAbsent) {
            return success();
        }
        String message = StrUtil.format("频繁的操作，请{}秒后重试", expire);
        return failure(message);
    }


}

/**
 * redis 分布式锁组件
 *
 * @author dingwen
 * @since 2023/12/5 14:57
 */
@Component
@Slf4j
public class RedisShareLockComponent {
    @Resource
    private RedisProperties redisProperties;
    @Resource
    private RedisService redisService;

    /**
     * 加锁å
     *
     * @param lockKey   锁key
     * @param requestId 请求id
     * @param time      时间
     * @param timeUnit  时间单位
     * @return boolean
     */
    public boolean lock(String lockKey, String requestId, Long time, TimeUnit timeUnit) {
        // 参数检查
        lockParamsCheck(lockKey, requestId, time, timeUnit);
        // 当前时间
        long currentTime = System.currentTimeMillis();
        // 超时时间
        long outTime = currentTime + redisProperties.getShareLockTimeOut();
        boolean lockResult = false;

        // 加锁
        while (currentTime < outTime) {
            lockResult = redisService.setIfAbsent(lockKey, requestId, time, timeUnit);
            if (lockResult) {
                log.info("[Redis模块]\t[分布式锁]，加锁成功：lockKey:{},requestId:{},time:{},timeUnit:{}",
                        lockKey, requestId, time, timeUnit);
                return true;
            }
            ThreadUtil.sleep(100);
            currentTime = System.currentTimeMillis();
        }
        return lockResult;
    }

    /**
     * 加锁参数检查
     *
     * @param lockKey   lock key
     * @param requestId request id
     * @param time      time
     * @param timeUnit  time unit
     */
    private void lockParamsCheck(String lockKey, String requestId, Long time, TimeUnit timeUnit) {
        if (StrUtil.isBlank(lockKey) || StrUtil.isBlank(requestId) || time <= 0 || Objects.isNull(timeUnit)) {
            log.error("[Redis模块]\t[分布式锁]，加锁参数错误：lockKey:{},requestId:{},time:{},timeUnit:{}",
                    lockKey, requestId, time, timeUnit);
            throw new ShareLockException("加锁参数异常");
        }
    }


    /**
     * 解锁
     *
     * @param lockKey   锁keu
     * @param requestId 请求id
     * @return boolean
     */
    public boolean unLock(String lockKey, String requestId) {
        if (StrUtil.isBlank(lockKey) || StrUtil.isBlank(requestId)) {
            throw new ShareLockException("解锁参数异常");
        }
        try {
            String cacheRequestId = redisService.getCacheObject(lockKey);
            if (requestId.equals(cacheRequestId)) {
                redisService.deleteObject(cacheRequestId);
                return true;
            }
        } catch (Exception e) {
            log.error("[Redis模块]\t[分布式锁]，解锁失败。lockKey:{},requestId:{}", lockKey, requestId, e);
        }
        return false;
    }


    /**
     * 尝试加锁方法
     *
     * @param lockKey   锁key
     * @param requestId 请求id
     * @param time      时间
     * @param timeUnit  时间单位
     * @return boolean
     */
    public boolean tryLock(String lockKey, String requestId, Long time, TimeUnit timeUnit) {
        // 参数检查
        lockParamsCheck(lockKey, requestId, time, timeUnit);
        return redisService.setIfAbsent(lockKey, requestId, time, timeUnit);
    }
}

        <!--邮件场景启动器-->
        <dependency>
            <groupId>com.dingwen</groupId>
            <artifactId>email-spring-boot-starter</artifactId>
            <version>1.0.0-SNAPSHOT</version>
        </dependency>

@EnableEmail

dingwen:
  treasure:
    # 电子邮件
    email:
      enabled: true
      # SMTP服务器域名
      host: smtp.163.com
      port: 465
      # 是否需要用户名密码验证
      auth: true
      # 发送方，遵循RFC-822标准
      from: dingwen0314@163.com
      # 用户名（注意：如果使用foxmail邮箱，此处user为qq号）
      user: dingwen0314@163.com
      # 密码（注意，某些邮箱需要为SMTP服务单独设置密码，详情查看相关帮助）
      pass: TODO
      # 使用 STARTTLS安全连接，STARTTLS是对纯文本通信协议的扩展。
      starttlsEnable: true
      # 使用SSL安全连接
      sslEnable: true
      # SMTP超时时长，单位毫秒，缺省值不超时
      timeout: 0
      # Socket连接超时值，单位毫秒，缺省值不超时
      connectionTimeout: 0

    /**
     * 发送电子邮件
     */
    @Test
    public void sendEmail() {
        String messageId = MailUtils.sendText("1981723769@qq.com", "test", "测试邮件内容");
        System.out.println(messageId);
    }

        <!--进度条场景-->
        <dependency>
            <groupId>com.dingwen</groupId>
            <artifactId>bar-spring-boot-starter</artifactId>
            <version>1.0.0-SNAPSHOT</version>
        </dependency>

@EnableBar

        <!--pipeline场景-->
        <dependency>
            <groupId>com.dingwen</groupId>
            <artifactId>pipeline-spring-boot-starter</artifactId>
            <version>1.0.0-SNAPSHOT</version>
        </dependency>

@EnablePipeline

dingwen:
  treasure:
    # pipeline
    pipeline:
      routes:
       # 管道上下文名称 key
        testContext:
          # 第一个执行的管道
          - onePipeLine
          # 第二个执行的管道
          - twoPipeLine

// 配置管道过滤器
@PipeFilters(filters = {
        @PipeFilter(beanName = "beforeOneFilter",exePoint = PipelineFilterExePoint.ALL),
        @PipeFilter(beanName = "beforeTwoFilter",exePoint = PipelineFilterExePoint.BEFORE),
})

        <!--对象存储场景-->
        <dependency>
            <groupId>com.dingwen</groupId>
            <artifactId>oss-spring-boot-starter</artifactId>
            <version>1.0.0-SNAPSHOT</version>
        </dependency>

@EnableOss

dingwen:
  treasure:
    # oss
    oss:
      # 对象存储服务的URL
      endpoint: http://127.0.0.1:9000
      # key
      access-key: admin
      # 密钥
      secret-key: 1234567890
      # 路径风格
      path-style-access: true
      # 最大线程数
      max-connections: 100
      # 区域
      region: 

<!--mybatisplus场景启动器-->
<dependency>
    <groupId>com.dingwen</groupId>
    <artifactId>mybatisplus-spring-boot-starter</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

@EnableMybatisPlus

@Test
    void testOpForLevel3() {
        List<OpParam> opParams = new ArrayList<>();

        OpParam unitOpParam = OpParam
                .builder()
                .labelField("unit_name")
                .valueField("unit_id")
                .tableName("hom_u_unit")
                .build();

        OpParam deptOpParam = OpParam
                .builder()
                .labelField("t1.dept_name")
                .valueField("t1.dept_id")
                .tableName("sys_dept t1")
                .leftJoinField(", t2.dept_id")
                .leftJoinSql("left join hom_u_unit_lnk_dept t2 on t1.dept_id = t2.dept_id")
                .parentField("t2.unit_id")
                .build();

        OpParam usertOpParam = OpParam
                .builder()
                .labelField("user_name")
                .valueField("user_id")
                .tableName("sys_user")
                .parentField("dept_id")
                .build();
        opParams.add(unitOpParam);
        opParams.add(deptOpParam);
        opParams.add(usertOpParam);
        List<Option> options = OptionHelper.get(opParams);
        log.info(JSONUtil.toJsonPrettyStr(options));
    }

    @Test
    void testOpForLevel2() {
        List<OpParam> opParams = new ArrayList<>();

        OpParam deptOpParam = OpParam
                .builder()
                .labelField("dept_name")
                .valueField("dept_id")
                .tableName("sys_dept")
                .build();

        OpParam usertOpParam = OpParam
                .builder()
                .labelField("user_name")
                .valueField("user_id")
                .tableName("sys_user")
                .parentField("dept_id")
                .build();
        opParams.add(deptOpParam);
        opParams.add(usertOpParam);
        List<Option> options = OptionHelper.get(opParams);
        log.info(JSONUtil.toJsonPrettyStr(options));
    }

    @Test
    void testOpForLevel1() {
        List<OpParam> opParams = new ArrayList<>();


        OpParam deptOpParam = OpParam
                .builder()
                .labelField("dept_name")
                .valueField("dept_id")
                .tableName("sys_dept")
                .build();

        opParams.add(deptOpParam);
        List<Option> options = OptionHelper.get(opParams);
        log.info(JSONUtil.toJsonPrettyStr(options));
    }

package com.dingwen.web.mybatisplus;
/**
 * BaseCrudController MybatisPlus实现 </br>
 * <p> P: 持久化对象</p>
 *
 * @author dingwen
 * @since 2023/3/19 15:55
 */
public abstract class AbstractBaseControllerMybatisPlusImpl<P extends BaseEntity>
        implements BaseCrudController<P>, BaseViewController {

    /**
     * 服务
     */
    @Autowired
    private IService<P> iService;

    /**
     * 根据Id查询，返回单个实体
     *
     * @param id 数据表主键
     * @return {@link ResultVO} 结果
     */
    @ApiOperation("根据唯一键查询,返回单个对象")
    @ApiOperationSupport(author = "dingwen")
    @ApiImplicitParam(value = "唯一键", name = "id", dataTypeClass = Long.class)
    @GetMapping("/default/{id}")
    @Override
    public ResultVO find(@PathVariable Serializable id) {
        return success(iService.getById(id));
    }


    /**
     * 分页查询 </br>
     * 分页参数由分页工具自动从Servlet上下文中获取
     *
     * @param p 查询实体
     * @return {@link ResultVO}<{@link PageVO}
     */
    @ApiOperation("分页查询,返回PageVO")
    @ApiOperationSupport(author = "dingwen")
    @GetMapping("/default/page")
    @Override
    public ResultVO<PageVO<P>> findPage(@ModelAttribute P p) {
        PageUtils.startPage();
        return page(iService.list(new QueryWrapper<>(p)));
    }


    /**
     * 根据唯一键集查询数据对象
     *
     * @param ids 唯一键集
     * @return {@link ResultVO}<{@link List}
     */
    @ApiOperation("根据唯一键集查询，返回对象列表")
    @ApiOperationSupport(author = "dingwen")
    @ApiImplicitParam(value = "唯一键集", name = "ids", dataTypeClass = List.class)
    @GetMapping("/default/{ids}")
    @Override
    public ResultVO<List<P>> find(@PathVariable List<Serializable> ids) {
        return success(iService.listByIds(ids));
    }

    /**
     * 获取数据表总记录条数
     *
     * @return {@link ResultVO}<{@link Long}>
     */
    @ApiOperation("获取数据表总记录条数，返回统计数量")
    @ApiOperationSupport(author = "dingwen")
    @GetMapping("/default/count")
    @Override
    public ResultVO<Long> count() {
        return success(iService.count());
    }

    /**
     * 通过唯一键查询是否存在 </br>
     * <ol>
     *     <li>true: 存在</li>
     *     <li>false: 不存在</li>
     * </ol>
     *
     * @param id 唯一键
     * @return {@link ResultVO}
     */
    @ApiOperation("通过唯一键查询是否存在,返回布尔值")
    @ApiOperationSupport(author = "dingwen")
    @GetMapping("/default/exists/{id}")
    @Override
    public ResultVO<Boolean> exists(@PathVariable Serializable id) {
        return success(ObjectUtil.isEmpty(iService.getById(id)));
    }

    /**
     * 通过对象唯一键进行修改
     *
     * @param p 参数对象
     * @return {@link ResultVO}<{@link Boolean}>
     */
    @ApiOperation("通过对象唯一键进行修改,返回布尔值")
    @ApiOperationSupport(author = "dingwen")
    @PutMapping("/default")
    @Override
    public ResultVO<Boolean> modify(@RequestBody P p) {
        return genResult(iService.updateById(p));
    }


    /**
     * 保存
     *
     * @param p 数据对象
     * @return {@link ResultVO}
     */
    @ApiOperation("保存一个对象到数据库，返回布尔值")
    @ApiOperationSupport(author = "dingwen")
    @PostMapping("/default")
    @Override
    public ResultVO create(@RequestBody P p) {
        return genResult(iService.save(p));
    }

    /**
     * 批量保存
     *
     * @param ps 对象集
     * @return {@link ResultVO}
     */
    @ApiOperation("批量添加，返回布尔值")
    @ApiOperationSupport(author = "dingwen")
    @PostMapping("/default/batch")
    @Override
    public ResultVO<Boolean> create(@RequestBody List<P> ps) {
        return genResult(iService.saveBatch(ps));
    }

    /**
     * 删除单条记录
     *
     * @param id 唯一键
     * @return {@link ResultVO}
     */
    @ApiOperation("删除单条记录，返回布尔值")
    @ApiOperationSupport(author = "dingwen")
    @DeleteMapping("/default/{id}")
    @Override
    public ResultVO<Boolean> remove(@PathVariable Serializable id) {
        return genResult(iService.removeById(id));
    }


    /**
     * 根据唯一键集批量删除
     *
     * @param ids 唯一键集
     * @return {@link ResultVO}<{@link Boolean}>
     */
    @ApiOperation("批量删除记录,返回布尔值")
    @ApiOperationSupport(author = "dingwen")
    @ApiImplicitParam(name = "ids", value = "唯一键集", dataTypeClass = List.class)
    @DeleteMapping("/default/batch/{ids}")
    @Override
    public ResultVO<Boolean> remove(@PathVariable List<Serializable> ids) {
        return genResult(iService.removeByIds(ids));
    }


    /**
     * 保存或更新
     *
     * @param p p
     * @return {@link ResultVO}<{@link Boolean}>
     */
    @ApiOperation("批量删除记录,返回布尔值")
    @ApiOperationSupport(author = "dingwen")
    @PostMapping("/default/sa-mos")
    @Override
    public ResultVO<Boolean> saveOrUpdate(P p) {
        return genResult(iService.saveOrUpdate(p));
    }
}