框架扩展 on Macula

Macula Boot Starter Binlog4j

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

概览

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

组件坐标

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

使用配置

spring:
 redis:
 host: 127.0.0.1
 port: 6379
 
binlog4j:
 client-configs:
 master: # clientID
 username: root  # mysql的用户
 password: # mysql的密码
 host: 127.0.0.1 # mysql的host
 port: 3306 # mysql的port
 serverId: 1990 # 本实例的serverId，不同应用不能重复
 persistence: true # 是否将binlog位置持久化，默认false
 inaugural: false # 是否是首次启动，默认false
 mode: cluster  # 启动模式，集群模式一个实例启动连接到mysql，其他standby，默认standalone
 keepAlive: true # 是否保持连接，默认是true
 KeepAliveInterval: 60000L # 保持连接间隔，默认1分钟，单位毫秒
 connectTimeout: 3000L  # 连接超时时间，默认3秒，单位毫秒
 heartbeatInterval: 6000L  # 发送心跳间隔，默认6秒，单位毫秒 
 gtidMode: true # 开启GTID模式，默认为false
 gtidPurged: true # 当GTID SET为“”时，是否获取最近的purged的GTID SET，默认为true
 gtidSetDefault: "xxx" # 设置开始消费的GTID位置

核心功能

订阅binlog事件

@BinlogSubscriber(clientName = "master", database = "macula-system", table ="sys_user")
public class UserEventHandler implements IBinlogEventHandler<User> {

 @Override
 public void onInsert(User target) {
 System.out.println("插入数据：" + JSON.toJSONString(target));
 }

 @Override
 public void onUpdate(User source, User target) {
 System.out.println("修改数据:" + JSON.toJSONString(target));
 }

 @Override
 public void onDelete(User target) {
 System.out.println("删除数据");
 }
}

@Data
@JSONType(naming = PropertyNamingStrategy.SnakeCase)
public class User {
 private Long id;
 private String username;
 private String nickname;
 private String mobile;
 private Integer gender;
 private String avatar;
 private String password;
 private String email;
 private Integer status;
 private Long deptId;
}

注意Entity要使用SnakeCase策略

调用重试

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

概览

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

组件坐标

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

使用配置

通过方法上的重试注解声明重试次数、异常与退避策略，具体用法见“核心功能”。

核心功能

@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:
 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注解定义如下：

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Lock4j {
 String name() default "";

 Class<? extends LockExecutor> executor() default LockExecutor.class;
		// 锁的KEY
 String[] keys() default {""};
		// 锁过期时间
 long expire() default 0L;
		// 获取锁的超时时间，也就是等待时间
 long acquireTimeout() default 0L;
}

配置全局默认的获取锁超时时间和锁过期时间

lock4j:
 acquire-timeout: 3000 #默认值3s，可不设置
 expire: 30000 #默认值30s，可不设置
 primary-executor: com.baomidou.lock.executor.RedisTemplateLockExecutor #默认redisson>redisTemplate>zookeeper，可不设置
 lock-key-prefix: lock4j #锁key前缀, 默认值lock4j，可不设置

acquire-timeout：可以理解为排队时长，超过这个时才就退出排队，抛出获取锁超时异常。为什么必须要有这个参数？现实你会一直排队等下去吗？所有人都一直排队有没有问题？
expire：锁过期时间。主要是防止死锁。建议估计好你锁方法运行时常，正常没有复杂业务的增删改查最多几秒，留有一定冗余，10秒足够。我们默认30秒是为了兼容绝大部分场景。

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>

使用配置

配置redis

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

spring:
 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个重复请求；
异常处理策略：当配置了 deleteOnException = true 或 deleteForExceptions 时，在发生异常的情况下会删除幂等key，允许用户重新请求。如果未配置异常处理策略，发生异常时幂等key仍然会被保留直到过期时间结束。

接口设置注解

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;

 /**
 * 是否在发生任意异常时删除幂等key，默认false
 *
 * @return boolean
 */
 boolean deleteOnException() default false;

 /**
 * 指定异常类型，在捕获这些异常时删除幂等key，默认空
 *
 * @return Class[]
 */
 Class<? extends Throwable>[] deleteForExceptions() default {};
}

异常处理策略

新增异常处理相关的属性，用于控制在发生异常时是否删除幂等key：

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>

使用配置

配置redis

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

spring:
 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

RocketMQ的配置可以参考 macula-boot-starter-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>

使用配置

提示

注意官网默认配置是以dromara.x-file-storage，由于macula oss没有使用官网的starter，所以这里是以macula.oss开头，其他保持不变。

# 配置存储平台 ，第一位 test-minio 为默认存储平台
macula:
 oss: #文件存储配置
 default-platform: local-1 #默认使用的存储平台
 thumbnail-suffix: ".min.jpg" #缩略图后缀，例如【.min.jpg】【.png】
 local: # 本地存储（不推荐使用），不使用的情况下可以不写
 - platform: local-1 # 存储平台标识
 enable-storage: true #启用存储
 enable-access: true #启用访问（线上请使用 Nginx 配置，效率更高）
 domain: "" # 访问域名，例如：“http://127.0.0.1:8030/test/file/”，注意后面要和 path-patterns 保持一致，“/”结尾，本地存储建议使用相对路径，方便后期更换域名
 base-path: D:/Temp/test/ # 存储地址
 path-patterns: /test/file/** # 访问路径，开启 enable-access 后，通过此路径可以访问到上传的文件
 local-plus: # 本地存储升级版，不使用的情况下可以不写
 - platform: local-plus-1 # 存储平台标识
 enable-storage: true #启用存储
 enable-access: true #启用访问（线上请使用 Nginx 配置，效率更高）
 domain: "" # 访问域名，例如：“http://127.0.0.1:8030/”，注意后面要和 path-patterns 保持一致，“/”结尾，本地存储建议使用相对路径，方便后期更换域名
 base-path: local-plus/ # 基础路径
 path-patterns: /** # 访问路径
 storage-path: D:/Temp/ # 存储路径
 huawei-obs: # 华为云 OBS ，不使用的情况下可以不写
 - platform: huawei-obs-1 # 存储平台标识
 enable-storage: false # 启用存储
 access-key: ??
 secret-key: ??
 end-point: ??
 bucket-name: ??
 domain: ?? # 访问域名，注意“/”结尾，例如：http://abc.obs.com/
 base-path: hy/ # 基础路径
 aliyun-oss: # 阿里云 OSS ，不使用的情况下可以不写
 - platform: aliyun-oss-1 # 存储平台标识
 enable-storage: false # 启用存储
 access-key: ??
 secret-key: ??
 end-point: ??
 bucket-name: ??
 domain: ?? # 访问域名，注意“/”结尾，例如：https://abc.oss-cn-shanghai.aliyuncs.com/
 base-path: hy/ # 基础路径
 qiniu-kodo: # 七牛云 kodo ，不使用的情况下可以不写
 - platform: qiniu-kodo-1 # 存储平台标识
 enable-storage: false # 启用存储
 access-key: ??
 secret-key: ??
 bucket-name: ??
 domain: ?? # 访问域名，注意“/”结尾，例如：http://abc.hn-bkt.clouddn.com/
 base-path: base/ # 基础路径
 tencent-cos: # 腾讯云 COS
 - platform: tencent-cos-1 # 存储平台标识
 enable-storage: true # 启用存储
 secret-id: ??
 secret-key: ??
 region: ?? #存仓库所在地域
 bucket-name: ??
 domain: ?? # 访问域名，注意“/”结尾，例如：https://abc.cos.ap-nanjing.myqcloud.com/
 base-path: hy/ # 基础路径
 minio: # MinIO，由于 MinIO SDK 支持 AWS S3，其它兼容 AWS S3 协议的存储平台也都可配置在这里
 - platform: minio-1 # 存储平台标识
 enable-storage: true # 启用存储
 access-key: ??
 secret-key: ??
 end-point: ??
 bucket-name: ??
 domain: ?? # 访问域名，注意“/”结尾，例如：http://minio.abc.com/abc/
 base-path: hy/ # 基础路径
 aws-s3: # AWS S3，其它兼容 AWS S3 协议的存储平台也都可配置在这里
 - platform: aws-s3-1 # 存储平台标识
 enable-storage: true # 启用存储
 access-key: ??
 secret-key: ??
 region: ?? # 与 end-point 参数至少填一个
 end-point: ?? # 与 region 参数至少填一个
 bucket-name: ??
 domain: ?? # 访问域名，注意“/”结尾，例如：https://abc.hn-bkt.clouddn.com/
 base-path: s3/ # 基础路径
 ftp: # FTP
 - platform: ftp-1 # 存储平台标识
 enable-storage: true # 启用存储
 host: ?? # 主机，例如：192.168.1.105
 port: 21 # 端口，默认21
 user: anonymous # 用户名，默认 anonymous（匿名）
 password: "" # 密码，默认空
 domain: ?? # 访问域名，注意“/”结尾，例如：ftp://192.168.1.105/
 base-path: ftp/ # 基础路径
 storage-path: /www/wwwroot/file.abc.com/ # 存储路径，可以配合 Nginx 实现访问，注意“/”结尾，默认“/”
 sftp: # SFTP
 - platform: sftp-1 # 存储平台标识
 enable-storage: true # 启用存储
 host: ?? # 主机，例如：192.168.1.105
 port: 22 # 端口，默认22
 user: root # 用户名
 password: ?? # 密码或私钥密码
 private-key-path: ?? # 私钥路径，兼容Spring的ClassPath路径、文件路径、HTTP路径等，例如：classpath:id_rsa_2048
 domain: ?? # 访问域名，注意“/”结尾，例如：https://file.abc.com/
 base-path: sftp/ # 基础路径
 storage-path: /www/wwwroot/file.abc.com/ # 存储路径，可以配合 Nginx 实现访问，注意“/”结尾，默认“/”
 webdav: # WebDAV
 - platform: webdav-1 # 存储平台标识
 enable-storage: true # 启用存储
 server: ?? # 服务器地址，例如：http://192.168.1.105:8405/
 user: ?? # 用户名
 password: ?? # 密码
 domain: ?? # 访问域名，注意“/”结尾，例如：https://file.abc.com/
 base-path: webdav/ # 基础路径
 storage-path: / # 存储路径，可以配合 Nginx 实现访问，注意“/”结尾，默认“/”
 google-cloud: # 谷歌云存储
 - platform: google-1 # 存储平台标识
 enable-storage: true # 启用存储
 project-id: ?? # 项目 id
 bucket-name: ??
 credentials-path: file:/deploy/example-key.json # 授权 key json 路径，兼容Spring的ClassPath路径、文件路径、HTTP路径等
 domain: ?? # 访问域名，注意“/”结尾，例如：https://storage.googleapis.com/test-bucket/
 base-path: hy/ # 基础路径
 fastdfs:
 - platform: fastdfs-1 # 存储平台标识
 enable-storage: true # 启用存储
 run-mod: COVER #运行模式，默认 COVER（覆盖模式），强制用 FastDFS 返回的路径及文件名覆盖 FileInfo 中的 path 及 filename。
 tracker-server: # Tracker Server 配置
 server-addr: ?? # Tracker Server 地址（IP:PORT），多个用英文逗号隔开
 domain: ?? # 访问域名，注意“/”结尾，例如：https://file.abc.com/
 base-path: "" # 基础路径，强烈建议留空，详情查看兼容性说明章节

注意配置每个平台前面都有个-号，通过以下方式可以配置多个：

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.ruleSource路径。

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状态机介绍

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：状态机

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>

<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:
 security:
 ignore-urls: /, /index.html, /hello2/**				# 演示项目忽略权限认证，正式环境要走授权逻辑
	websocket:
 enabled: true																		# 是否开启websocket自动配置，默认true
 permit-test: true 														# 是否允许测试白名单，/xxx/test/xxx的websocket路径默认开白，默认true
		endpoint: websocket 													# websocket端点，默认是websocket
 		broker-destination-prefixes: /topic, /queue		# 转发订阅的前缀，默认是/topic,/queue
		app-destination-prefixes: /app								# SimpAnnotationMethodMessageHandler的处理前缀，默认/app
		user-destination-prefix: /user								# UserDestinationMessageHandler的处理前缀，默认/user
 heartbeat: 10000, 10000												# 默认是10000,10000，前面是服务端心跳，后面是客户端心跳间隔

网关需要配置路由

spring:
	gateway:
		routes:
			- id: macula-example-consumer-ws
 uri: lb:ws://macula-example-consumer			# 要加ws
 predicates:
 - Path=/websocket/**
 filters:
 - StripPrefix=1
macula:
 gateway:
 security:
 ignore-urls: /consumer/hello2/**						# 测试地址，正式环境建议使用授权
 only-auth-urls: /api/**, /websocket/**  # /websocket前缀在握手时会请求，这里要设置为仅认证