框架扩展 on Macula

Macula Boot Starter Binlog4j

Mon, 01 Jan 0001 00:00:00 +0000

概览

该模块演示 macula-boot-starter-binlog4j 的 MySQL binlog 订阅。UserEventHandler 监听 macula-system.sys_user 表的新增、修改和删除事件，并将解析后的数据输出到控制台。

binlog4j是一个读取MySQL binlog的组件，以slave的方式接入mysql，将binlog转为事件。

组件坐标


<dependency>
 <groupId>dev.macula.boot</groupId>
 <artifactId>macula-boot-starter-binlog4j</artifactId>
 <version>${macula.version}</version>
</dependency>

使用配置

前置条件

MySQL 127.0.0.1:33306，开启 binlog，建议使用 ROW 格式。
订阅账号具有 replication 权限。
Redis 127.0.0.1:36379，用于集群模式的状态协调。
数据库 macula-system 中存在 sys_user 表。

配置与启动

配置前缀 binlog4j.client-configs.master 定义 MySQL 连接，默认用户 root、密码为空，必须按实际环境覆盖。

属性	示例值	说明
`binlog4j.client-configs.master.host` / `port`	`127.0.0.1` / `33306`	MySQL 地址，端口可用 `MYSQL_PORT` 覆盖
`binlog4j.client-configs.master.username` / `password`	环境提供	复制账号及密码
`binlog4j.client-configs.master.server-id`	`1991`	复制客户端 ID，避免冲突
`binlog4j.client-configs.master.mode`	`cluster`	本示例使用 Redis 协调主备
`binlog4j.client-configs.master.persistence` / `gtid-mode`	`true` / `true`	持久化位点 / 使用 GTID，MySQL 需启用 GTID
`spring.data.redis.host` / `port` / `password`	按环境配置	Boot 4 Redis 连接属性

注意：当前示例文件仍写为旧的 spring.redis.*，运行前需在本地配置中改用 spring.data.redis.* 或通过启动参数覆盖。连接 Examples Compose 的 Redis 时使用端口 36379 和对应密码。完整配置见 Binlog4j Starter。

调用重试

Mon, 01 Jan 0001 00:00:00 +0000

概览

Spring Retry用于解决分布式系统中的网络抖动、连接超时、服务端不可用等网络问题，通过重试机制来保证服务的可用性。在macula中，我们使用了Spring Retry来实现重试机制，通过配置retry策略来达到重试的目的。

组件坐标

<dependency>
 <groupId>dev.macula.boot</groupId>
 <artifactId>macula-boot-starter-springretry</artifactId>
 <version>${macula.version}</version>
</dependency>

使用配置

Starter 已通过 @EnableRetry 开启 Spring Retry，无独立的 macula.* 配置项。使用 org.springframework.retry.annotation 下的注解，通过 Spring Bean 代理调用重试方法；同类内直接调用不会触发代理重试。涉及写操作时，业务需自行保证幂等。

核心功能

@Retryable注解

需要在重试的代码中加入重试注解@Retryable

@Service 
@Slf4j 
public class RetryRequestService { 
 @Autowired 
 private OtherSystemSpi otherSystemSpi; 
 
 @Retryable(value = RuntimeException.class, maxAttempts = 5, backoff = @Backoff(delay = 100)) 
 public String request(String param) { 
 double random = Math.random(); 
 log.info("请求进来了，随机值为：" + random); 
 if (random > 0.1) { 
 throw new RuntimeException("超时"); 
 } 
 return otherSystemSpi.request(param); 
 } 
}

当然，我们这里写了个调皮的逻辑来模拟超时。如果随机值大于0.1则抛出一个RuntimeException异常。每次请求进来时都会输出日志。

Macula Boot Starter Lock4j

Mon, 01 Jan 0001 00:00:00 +0000

概览

lock4j是一个基于redisson的分布式锁组件，其提供了多种不同的支持以满足不同性能和环境的需求。致力于打造一个简单但富有内涵的分布式锁组件。

组件坐标


<dependency>
 <groupId>dev.macula.boot</groupId>
 <artifactId>macula-boot-starter-lock4j</artifactId>
 <version>${macula.version}</version>
</dependency>

使用配置

理论是支持 macula-boot-starter-redis全部配置

spring:
 data:
 redis:
 host: 127.0.0.1
 port: 6379

核心功能

在需要分布式的地方使用Lock4j注解

@Service
public class DemoService {

 //默认获取锁超时3秒，30秒锁过期
 @Lock4j
 public void simple() {
 //do something
 }

 //完全配置，支持spel
 @Lock4j(keys = {"#user.id", "#user.name"}, expire = 60000, acquireTimeout = 1000)
 public User customMethod(User user) {
 return user;
 }
}

@Lock4j注解定义如下：

Macula Boot Starter Idempotent

Mon, 01 Jan 0001 00:00:00 +0000

概览

该模块对原有 idempotent 的代码进行了重构和功能增强。非常感谢idempotent 作者的分享。

组件坐标


<dependency>
 <groupId>dev.macula.boot</groupId>
 <artifactId>macula-boot-starter-idempotent</artifactId>
 <version>${macula.version}</version>
</dependency>

使用配置

无独立 YAML 开关，使用 Redis 配置及方法上的 @Idempotent。还支持 deleteOnException=false（默认异常时保留键）和 deleteForExceptions={}（指定异常类型时删除键）；业务失败后是否允许重试需显式选择。

配置redis

理论是支持 macula-boot-starter-redis全部配置

spring:
 data:
 redis:
 host: 127.0.0.1
 port: 6379

核心功能

原理

请求开始前，根据key查询查到结果：报错。未查到结果：存入key-value-expireTime key=ip+url+args；
请求结束后，直接删除key，不管key是否存在，直接删除。是否删除，可配置；
expireTime过期时间，防止一个请求卡死，会一直阻塞，超过过期时间，自动删除。过期时间要大于业务执行时间，需要大概评估下;
此方案直接切的是接口请求层面；
过期时间需要大于业务执行时间，否则业务请求1进来还在执行中，前端未做遮罩，或者用户跳转页面后再回来做重复请求2，在业务层面上看，结果依旧是不符合预期的。
建议delKey = false。即使业务执行完，也不删除key，强制锁expireTime的时间。预防5的情况发生；
实现思路：同一个请求ip和接口，相同参数的请求，在expireTime内多次请求，只允许成功一次；
页面做遮罩，数据库层面的唯一索引，先查询再添加，等处理方式应该都处理下；
此注解只用于幂等，不用于锁，100个并发这种压测，会出现问题，在这种场景下也没有意义，实际中用户也不会出现1s或者3s内手动发送了50个或者100个重复请求,或者弱网下有100个重复请求；

接口设置注解

public class DemoController {
 @Idempotent(key = "#demo.username", expireTime = 3, info = "请勿重复查询")
 @GetMapping("/test")
 public String test(Demo demo) {
 return "success";
 }
}

@idempotent 配置详细说明


@Inherited
@Target(ElementType.METHOD)
@Retention(value = RetentionPolicy.RUNTIME)
public @interface Idempotent {

 /**
 * <p>
 * 如果是实体类的话,默认拦截不会生效. objects.toString()会返回不同地址.
 * </p>
 * 幂等操作的唯一标识，使用spring el表达式 用#来引用方法参数
 *
 * @return Spring-EL expression
 */
 String key() default "";

 /**
 * 有效期 默认：1 有效期要大于程序执行时间，否则请求还是可能会进来
 *
 * @return expireTime
 */
 int expireTime() default 1;

 /**
 * 时间单位 默认：s
 *
 * @return TimeUnit
 */
 TimeUnit timeUnit() default TimeUnit.SECONDS;

 /**
 * 提示信息，可自定义
 *
 * @return String
 */
 String info() default "重复请求，请稍后重试";

 /**
 * 是否在业务完成后删除key true:删除 false:不删除
 *
 * @return boolean
 */
 boolean delKey() default false;
}

依赖引入


<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-aspectj</artifactId>
 </dependency>
 <dependency>
 <groupId>dev.macula.boot</groupId>
 <artifactId>macula-boot-starter-redis</artifactId>
 </dependency>
</dependencies>

版权说明

原始代码1：https://github.com/it4alla/idempotent/blob/dev/LICENSE
原始代码2：https://github.com/pig-mesh/idempotent-spring-boot-starter/blob/master/LICENSE

Macula Boot Starter LeaderElection

Mon, 01 Jan 0001 00:00:00 +0000

概览

通过redis的lock做领导选举。

组件坐标

<dependency>
 <groupId>dev.macula.boot</groupId>
 <artifactId>macula-boot-starter-leaderelection</artifactId>
 <version>${macula.version}</version>
</dependency>

使用配置

必须配置 spring.application.name，本模块以 leader-lock-<应用名> 为锁键。同一选举组的实例应共用 Redis 和应用名，不同业务组使用不同名称；无独立 macula.leaderelection.* 属性。

配置redis

理论是支持 macula-boot-starter-redis全部配置

spring:
 data:
 redis:
 host: 127.0.0.1
 port: 6379

核心功能

可以在应用中实现如下接口，当被选中时，onElected方法被触发，可以做一些标识或者leader应该做的事情。

/**
 * {@code ElectionListener} 选中为领导触发该监听器
 *
 * @author rain
 * @since 2022/12/2 19:07
 */
public interface ElectionListener {

 /**
 * 被选中为领导时触发
 */
 void onElected();
}


@SpringBootApplication
public class Application {
 public static void main(String[] args) {
 SpringApplication.run(Application.class, args);
 }

 @Component
 public class Service {
 public Service(LeaderElection leaderElection) {
 leaderElection.addElectionListener(() -> System.out.println("master selected"));
 }
 }
}

依赖引入


<dependencies>
 <dependency>
 <groupId>dev.macula.boot</groupId>
 <artifactId>macula-boot-starter-redis</artifactId>
 </dependency>
</dependencies>

版权说明

redisson：https://github.com/redisson/redisson/blob/master/LICENSE.txt

Macula Boot Starter Sender

Mon, 01 Jan 0001 00:00:00 +0000

概览

该模块实现了通过本地表发送事务消息到RocketMQ的功能。

组件坐标

<dependency>
 <groupId>dev.macula.boot</groupId>
 <artifactId>macula-boot-starter-sender</artifactId>
 <version>${macula.version}</version>
</dependency>

使用配置

macula:
 sender:
 message-table: 你的表名 # 默认是MACULA_MSG

唯一的自有属性 macula.sender.message-table 默认为 MACULA_MSG。应用需配置业务 DataSource、事务管理器及 RocketMQ 生产者，并自行建表、安排补偿任务；Starter 不会自动建表或启动定时补偿。RocketMQ 配置参考 RocketMQ 模块。

核心功能

事件消息首先和业务事务一起存储到本地数据库表，然后再发送给 RocketMQ。

业务事务提交后发送消息；发送失败由补偿任务重试。消费端仍需幂等处理，不能将该机制视为消息只投递一次。

使用前，需要在你的业务库中创建如下表（建议定期归档）：

create table MACULA_MSG
(
 id bigint auto_increment primary key,
 orderly tinyint not null comment '是否为顺序消息',
 topic varchar(64) not null comment 'MQ topic',
 sharding_key varchar(128) not null comment 'ShardingKey，用于选择不同的 partition',
 tag varchar(128) not null comment 'Message Tag 信息',
 msg_id varchar(64) not null comment 'Msg ID 只有发送成功后才有数据',
 msg_key varchar(64) not null comment 'MSG Key，用于查询数据',
 msg longtext not null comment '要发送的消息',
 retry_time tinyint not null comment '重试次数',
 status tinyint not null comment '发送状态:0-初始化，1-发送成功，2-发送失败',
 create_time datetime not null,
 update_time datetime not null,
 index idx_update_time_status(update_time, status)
)

可以使用相关API进行消息处理：

Macula Boot Starter OSS

Mon, 01 Jan 0001 00:00:00 +0000

概览

在 SpringBoot 中通过简单的方式将文件存储到本地、FTP、SFTP、WebDAV、FastDFS、Minio、谷歌云存储、阿里云OSS、华为云OBS、七牛云Kodo、腾讯云COS、MinIO、 AWS S3及其它兼容 S3 协议的平台。详情可以参考x-file-storage官网

组件坐标


<dependency>
 <groupId>dev.macula.boot</groupId>
 <artifactId>macula-boot-starter-oss</artifactId>
 <version>${macula.version}</version>
</dependency>

使用配置

自有配置前缀为 macula.oss；默认平台必须指向一个已启用的平台标识，并不会自动创建名为 local 的存储实例。

属性	默认值	说明
`default-platform`	`local`	默认存储平台标识
`thumbnail-suffix`	`.min.jpg`	缩略图后缀
`upload-not-support-metadata-throw-exception` / `upload-not-support-acl-throw-exception`	`true`	上传时不支持元数据 / ACL 是否报错
`copy-not-support-metadata-throw-exception` / `copy-not-support-acl-throw-exception`	`true`	复制时不支持元数据 / ACL 是否报错
`move-not-support-metadata-throw-exception` / `move-not-support-acl-throw-exception`	`true`	移动时不支持元数据 / ACL 是否报错
`enable-byte-file-wrapper`	`true`	byte[] 输入适配器
`enable-uri-file-wrapper`	`true`	URI、URL、String 输入适配器
`enable-input-stream-file-wrapper`	`true`	InputStream 输入适配器
`enable-local-file-wrapper`	`true`	本地文件输入适配器
`enable-http-servlet-request-file-wrapper`	`true`	Servlet 请求文件适配器，需 Servlet 环境
`enable-multipart-file-wrapper`	`true`	MultipartFile 输入适配器，需对应 Web 类
`<平台类型>[].enable-storage`	`false`	启用该存储实例，未启用的条目不参与构建
`local-plus[].enable-access`	`false`	启用本地文件 HTTP 访问，需注意访问控制
`local-plus[].path-patterns`	空数组	本地 HTTP 路径映射

平台列表默认均为空，支持 local-plus、huawei-obs、aliyun-oss、qiniu-kodo、tencent-cos、baidu-bos、upyun-uss、minio、amazon-s3、ftp、sftp、webdav、google-cloud-storage、fastdfs、azure-blob。旧 local 已废弃，同样支持 enable-access 和 path-patterns。平台内部账号、桶、路径等字段参见下面示例及上游文档，只保留实际使用的平台配置。

Macula Boot Starter LiteFlow

Mon, 01 Jan 0001 00:00:00 +0000

概览

该模块基于LiteFlow，是一个轻量，快速，稳定可编排的组件式规则引擎。

组件坐标


<dependency>
 <groupId>dev.macula.boot</groupId>
 <artifactId>macula-boot-starter-liteflow</artifactId>
 <version>${macula.version}</version>
</dependency>

使用配置

基本配置

liteflow:
 #规则文件路径
 rule-source: config/flow.el.xml
 #-----------------以下非必须-----------------
 #liteflow是否开启，默认为true
 enable: true
 #liteflow的banner打印是否开启，默认为true
 print-banner: true
 #zkNode的节点，只有使用zk作为配置源的时候才起作用，默认为/lite-flow/flow
 zk-node: /lite-flow/flow
 #上下文的最大数量槽，默认值为1024
 slot-size: 1024
 #FlowExecutor的execute2Future的线程数，默认为64
 main-executor-works: 64
 #FlowExecutor的execute2Future的自定义线程池Builder，LiteFlow提供了默认的Builder
 main-executor-class: com.yomahub.liteflow.thread.LiteFlowDefaultMainExecutorBuilder
 #自定义请求ID的生成类，LiteFlow提供了默认的生成类
 request-id-generator-class: com.yomahub.liteflow.flow.id.DefaultRequestIdGenerator
 #并行节点的线程池Builder，LiteFlow提供了默认的Builder
 thread-executor-class: com.yomahub.liteflow.thread.LiteFlowDefaultWhenExecutorBuilder
 #异步线程最长的等待时间秒(只用于when)，默认值为15
 when-max-wait-seconds: 15
 #when节点全局异步线程池最大线程数，默认为16
 when-max-workers: 16
 #when节点全局异步线程池等待队列数，默认为512
 when-queue-limit: 512
 #是否在启动的时候就解析规则，默认为true
 parse-on-start: true
 #全局重试次数，默认为0
 retry-count: 0
 #是否支持不同类型的加载方式混用，默认为false
 support-multiple-type: false
 #全局默认节点执行器
 node-executor-class: com.yomahub.liteflow.flow.executor.DefaultNodeExecutor
 #是否打印执行中过程中的日志，默认为true
 print-execution-log: true
 #简易监控配置选项
 monitor:
 #监控是否开启，默认不开启
 enable-log: false
 #监控队列存储大小，默认值为200
 queue-limit: 200
 #监控一开始延迟多少执行，默认值为300000毫秒，也就是5分钟
 delay: 300000
 #监控日志打印每过多少时间执行一次，默认值为300000毫秒，也就是5分钟
 period: 300000

Nacos规则源配置

liteflow-rule-nacos 为 optional 依赖，使用 Nacos 规则源时应用需显式引入，并提供连接地址和认证信息；仅使用本地规则文件则无需引入。

Macula Boot Starter for StateMachine

Mon, 01 Jan 0001 00:00:00 +0000

概览

基于alibab cola statemachine 的状态机模块，cola statemachine是简单、轻量、性能极高的状态机DSL实现，解决业务中的状态流转问题。

组件坐标


<dependency>
 <groupId>dev.macula.boot</groupId>
 <artifactId>macula-boot-starter-statemachine</artifactId>
 <version>${macula.version}</version>
</dependency>

使用配置

状态流转通过 Java DSL 定义，无独立 YAML 配置项。业务负责状态持久化、事务与并发控制，规则定义见“核心功能”。

核心功能

本模块仅封装 COLA 状态机依赖，无 YAML 属性或自动持久化能力。规则通过 Java DSL 定义；业务状态的保存、事务和并发控制由应用负责。

COLA状态机介绍

COLA状态机是在Github开源的，作者也写了介绍文章：https://blog.csdn.net/significantfrank/article/details/104996419。

首先，状态机的实现应该可以非常的轻量，最简单的状态机用一个Enum就能实现，基本是零成本。其次，使用状态机的DSL来表达状态的流转，语义会更加清晰，会增强代码的可读性和可维护性。

开源状态机太复杂：就我们的项目而言（其实大部分项目都是如此）。我实在不需要那么多状态机的高级玩法：比如状态的嵌套（substate），状态的并行（parallel，fork，join）、子状态机等等。

开源状态机性能差：这些开源的状态机都是有状态的（Stateful）的，因为有状态，状态机的实例就不是线程安全的，而我们的应用服务器是分布式多线程的，所以在每一次状态机在接受请求的时候，都不得不重新build一个新的状态机实例。

所以COLA状态机设计的目标很明确，有两个核心理念：简洁的仅支持状态流转的状态机，不需要支持嵌套、并行等高级玩法。状态机本身需要是Stateless（无状态）的，这样一个Singleton Instance就能服务所有的状态流转请求了。

COLA 状态机的核心概念包括：

State：状态
Event：事件，状态由事件触发，引起变化
Transition：流转，表示从一个状态到另一个状态
- External Transition：外部流转，两个不同状态之间的流转
- Internal Transition：内部流转，同一个状态之间的流转
Condition：条件，表示是否允许到达某个状态
Action：动作，到达某个状态之后，可以做什么
StateMachine：状态机

事件触发转换，经 Condition 判断后执行 Action，得到目标 State。

COLA状态机实战

首先配置状态机：

/**
 * 状态机初始化
 */
@Configuration
public class LeaveStateMachineConfig {
 private static final Logger logger = LoggerFactory.getLogger(StateMachineRegist.class);
 private final String STATE_MACHINE_ID = "leaveStateMachineId";

 /**
 * 构建状态机实例
 */
 @Bean(name = STATE_MACHINE_ID)
 public StateMachine<ApplyStatusEnum, Event, LeaveContext> stateMachine() {
 StateMachineBuilder<ApplyStatusEnum, Event, LeaveContext> stateMachineBuilder =
 StateMachineBuilderFactory.create();
 // 员工请假触发事件
 // 因为没有源状态，初始化时只是同一个状态流转;所以用内部流转
 stateMachineBuilder.internalTransition().within(ApplyStatusEnum.LEAVE_SUBMIT).on(Event.EMPLOYEE_SUBMIT)
 .perform(doAction());

 // 部门主管审批触发事件（依赖上一个状态：LEAVE_SUBMIT）
 stateMachineBuilder.externalTransition().from(ApplyStatusEnum.LEAVE_SUBMIT).to(ApplyStatusEnum.LEADE_AUDIT_PASS)
 .on(Event.DIRECTLEADER_AUDIT).when(checkIfPass()).perform(doAction());
 stateMachineBuilder.externalTransition().from(ApplyStatusEnum.LEAVE_SUBMIT)
 .to(ApplyStatusEnum.LEADE_AUDIT_REFUSE).on(Event.DIRECTLEADER_AUDIT).when(checkIfNotPass())
 .perform(doAction());

 // hr事件触发(依赖上一个状态:LEADE_AUDIT_PASS)
 stateMachineBuilder.externalTransition().from(ApplyStatusEnum.LEADE_AUDIT_PASS).to(ApplyStatusEnum.HR_PASS)
 .on(Event.HR_AUDIT).when(checkIfPass()).perform(doAction());
 stateMachineBuilder.externalTransition().from(ApplyStatusEnum.LEADE_AUDIT_PASS).to(ApplyStatusEnum.HR_REFUSE)
 .on(Event.HR_AUDIT).when(checkIfNotPass()).perform(doAction());

 return stateMachineBuilder.build(STATE_MACHINE_ID);
 }

 private Condition<LeaveContext> checkIfPass() {
 return (ctx) -> ctx.getIdea().equals(0);
 }

 private Condition<LeaveContext> checkIfNotPass() {
 return (ctx) -> ctx.getIdea().equals(1);
 }

 /**
 * 事件触发后，匹配成功对应的条件后，就会执行具体动作<br>
 * 可以自定义完成具体业务逻辑...
 * @return
 */
 private Action<ApplyStatusEnum, Event, LeaveContext> doAction() {
 return (from, to, event, ctx) -> {
 logger.info("from:" + from + " to:" + to + " on:" + event + " condition:" + ctx);
 };
 }
}

然后在需要更改状态的地方，获取状态机实例，触发事件，获取更改后的状态：

Macula Boot Starter for Wechat

Mon, 01 Jan 0001 00:00:00 +0000

概览

微信Java开发工具包，支持包括微信支付、开放平台、公众号、企业微信、视频号、小程序等微信功能模块的后端开发。

组件坐标

<dependency>
 <groupId>dev.macula.boot</groupId>
 <artifactId>macula-boot-starter-wechat</artifactId>
 <version>${macula.version}</version>
</dependency>

使用配置

配置使用下文各 SDK 的 wx.* 前缀，无统一 macula.wechat.* 开关。应用需显式引入所用能力的 Starter；Secret、Token、AES Key 和支付证书应由环境注入。集群部署需选择共享配置存储，不应沿用单机内存存储。

开放平台

引入依赖

<dependency>
 <groupId>com.github.binarywang</groupId>
 <artifactId>wx-java-open-spring-boot-starter</artifactId>
</dependency>

添加配置

wx:
 open:
 # 公众号配置(必填)
 appId: '@appId'
 secret: '@secret'
 token: '@token'
 aesKey: '@aesKey'
 config-storage:
 # 存储配置redis(可选)
 # 优先注入容器的(JedisPool, RedissonClient), 当配置了wx.open.config-storage.redis.host, 不会使用容器注入redis连接配置
 type: 'redistemplate' # 配置类型: memory(默认), redis(jedis), jedis, redisson,redistemplate'
 key-prefix: 'wx:open' # 相关redis前缀配置: wx:open(默认)'
 http-client-type: 'httpclient' # http客户端类型: httpclient(默认)'
 http-proxy-host: '' # http客户端配置
 http-proxy-password: ''
 http-proxy-port: ''
 http-proxy-username: ''
 max-retry-times: 5 # 最大重试次数，默认：5 次，如果小于 0，则为 0
 retry-sleep-millis: 1000 # 重试时间间隔步进，默认：1000 毫秒，如果小于 0，则为 1000

支持自动注入的类型

WxOpenService
WxOpenMessageRouter
WxOpenComponentService

公众号

引入依赖

<dependency>
 <groupId>com.github.binarywang</groupId>
 <artifactId>wx-java-mp-spring-boot-starter</artifactId>
</dependency>

添加配置

wx:
 mp:
 appId: appId
 secret: '@secret'
 token: '@token'
 aesKey: '@aesKey'
 config-storage:
 type: 'RedisTemplate' # 配置类型: Memory(默认), Jedis,RedisTemplate,Redisson
 key-prefix: 'wx' # 相关redis前缀配置: wx(默认)
 http-client-type: 'httpclient' # http客户端类型: HttpClient(默认), OkHttp, JoddHttp，用其他的要引入对应jar包
 http-proxy-host: ''
 http-proxy-password: ''
 http-proxy-port: ''
 http-proxy-username: ''

自动注入的类型

WxMpService
WxMpConfigStorage

企业微信

引入依赖

<dependency>
 <groupId>com.github.binarywang</groupId>
 <artifactId>wx-java-cp-spring-boot-starter</artifactId>
</dependency>

添加配置

wx:
 cp:
 # 企业微信号配置(必填)
 corp-id: '@corp-id'
 corp-secret: '@corp-secret'
 # 选填
 agent-id: '@agent-id'
 token: '@token'
 aes-key: '@aes-key'
 msg-audit-lib-path: '@msg-audit-lib-path'
 msg-audit-priKey: '@msg-audit-priKey'
 config-storage:
 type: 'redistemplate' # 配置类型: memory(默认), jedis, redisson, redistemplate
 key-prefix: 'wx:cp' # 相关redis前缀配置: wx:cp(默认)
 http-proxy-host: ''
 http-proxy-password: ''
 http-proxy-port: ''
 http-proxy-username: ''
 max-retry-times: 5
 retry-sleep-millis: 1000

支持自动注入的类型

WxCpService
WxCpConfigStorage

覆盖自动配置: 自定义注入的bean会覆盖自动注入的

WxCpService
WxCpConfigStorage

企业微信多账号

企业微信多账号配置

Macula Boot Starter for WebSocket

Mon, 01 Jan 0001 00:00:00 +0000

概览

该模块基于Spring Boot Websocket搭建，支持基于STOMP协议的Websocket通讯，通过Redis Pub/Sub实现Websocket跨实例通讯。支持微服务调用统一登录上下文获取。

组件坐标

<dependency>
 <groupId>dev.macula.boot</groupId>
 <artifactId>macula-boot-starter-websocket</artifactId>
 <version>${macula.version}</version>
</dependency>

使用配置

websocket服务模块配置

配置前缀为 macula.websocket。

属性	默认值	说明
`enabled`	`true`	启用 WebSocket 自动配置
`permit-test`	`true`	放行内置测试消息路径；生产环境应设为 `false`
`endpoint`	`[/websocket]`	STOMP 握手端点列表
`broker-destination-prefixes`	`[/topic, /queue]`	消息代理处理的目标前缀
`app-destination-prefixes`	`[/app]`	应用消息处理前缀
`user-destination-prefix`	`/user`	用户定向消息前缀
`heartbeat`	`[10000, 10000]`	服务端发送 / 期望客户端发送的心跳间隔，单位毫秒

macula:
 websocket:
 enabled: true
 permit-test: false
 endpoint: [/websocket]
 broker-destination-prefixes: [/topic, /queue]
 app-destination-prefixes: [/app]
 user-destination-prefix: /user
 heartbeat: [10000, 10000]

网关需要配置路由

spring:
 cloud:
 gateway:
 server:
 webflux:
 routes:
 - id: macula-example-consumer-ws
 uri: lb:ws://macula-example-alibaba-consumer
 predicates:
 - Path=/websocket/**
 filters:
 - StripPrefix=1
macula:
 gateway:
 security:
 only-auth-urls: [/websocket/**]

核心功能

Spring Websocket核心流程

客户端完成 WebSocket/STOMP 连接后，发送到 /app 的消息由应用处理，发往 /topic、/queue 的消息由代理路由给订阅者；/user 用于用户定向消息。