定时器

## 定时器
### 用途描述
timer组件用于任务调度，可以按照设定的时间规则（如Cron表达式、固定时间或一次性执行）触发数据流任务。业务系统创建定时任务，这些任务可以在指定的时间点或周期性地自动执行，从而实现自动化处理业务逻辑的需求。
### 组件名称
timer
### 组件参数

| 参数名 | 参数类型 |是否必须| 参数描述 |
| --- | --- | --- | --- |
| jobName | String |是 | 任务名称，不能为空且不能超过64个字符 |
| jobGroup | String |否| 任务组名，为空时默认为DEFAULT |
| sceneCode | String |是 |任务对应的业务场景编码，不能为空 |
| reqBody | String |否 |任务执行时需要传递的请求体内容，此参数为空时，执行任务默认从“定时任务队列”中获取数据 |
| jobType | String | 是|调度类型：cron（cron表达式）、fixed（固定时间）、once（一次性），不能为空 |
| cronExpression | String |否| Cron表达式，定义任务触发时间规则，当jobType为cron时必须提供 |
| fixedJobTime | LocalTime| 否| 固定任务时间，格式为HH:mm:ss，当jobType为fixed时必须提供 |
| onceJobTime | LocalDateTime| 否| 一次性任务时间，格式为yyyy-MM-dd HH:mm:ss，当jobType为once时必须提供 |
| concurrent | Integer| 否| 是否允许并发执行，0表示允许，1表示禁止，为空时默认为1 |
| misfirePolicy | String |是| 任务补偿触发策略，可选值为0到3之间的数字（0默认触发一次补偿任务 1执行所有错过的触发点 2只执行一次错过的触发点 3不执行任何错过的触发点）| |
| remark | String |否| 任务描述信息，不能超过500个字符 |

#### 参数实体：
```java
@Data
@Schema(description = "定时任务创建请求参数")
public class JobCreateDTO {

@NotBlank(message = "任务名称不能为空")
    @Size(max = 64, message = "任务名称不能超过64个字符")
    @Schema(description = "任务名称", example = "定时同步任务", requiredMode = Schema.RequiredMode.REQUIRED)
    private String jobName;

@Size(max = 50, message = "任务名称不能超过50个字符")
    @Schema(description = "任务组名", example = "DEFAULT")
    private String jobGroup;

@NotBlank(message = "场景编码不能为空")
    @Pattern(regexp = "^[a-zA-Z0-9_-]+$", message = "sceneCode 只能包含字母、数字、- 或 _")
    @Schema(description = "任务对应的业务场景编码", example = "test123", requiredMode = Schema.RequiredMode.REQUIRED)
    private String sceneCode;

@Size(max = 500, message = "请求体不能超过500个字符")
    @Schema(description = "任务执行时需要传递的请求体内容，此参数为空时，执行任务默认从“定时任务队列”中获取数据", example = "{\"mode\":\"2\",\"ad\":\"123\",\"aa\":1}")
    private String reqBody;

@NotBlank(message = "任务类型不能为空")
    @Pattern(regexp = "cron|fixed|once", message = "jobType 必须是 cron、fixed 或 once")
    @Schema(description = "调度类型：cron（cron表达式）/fixed（固定时间）/once（一次性）", example = "cron", requiredMode = Schema.RequiredMode.REQUIRED)
    private String jobType;

@Schema(description = "Cron表达式，定义任务触发时间规则", example = "0/5 * * * * ?", requiredMode = Schema.RequiredMode.REQUIRED)
    private String cronExpression;

@JsonFormat(pattern = "HH:mm:ss")
    @Schema(description = "固定任务时间，任务触发时间，格式为HH:mm:ss", example = "09:00:00")
    private LocalTime fixedJobTime;

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    @Schema(description = "一次性任务时间，任务触发时间，格式为yyyy-MM-dd HH:mm:ss", example = "2025-01-01 09:00:00")
    private LocalDateTime onceJobTime;

@Min(value = 0, message = "并发策略必须是0或1")
    @Max(value = 1, message = "并发策略必须是0或1")
    @Schema(description = "是否允许并发执行", example = "0", allowableValues = {"0", "1"})
    private Integer concurrent; // 0 允许，1 禁止

@Pattern(regexp = "^[0-3]$", message = "计划执行策略必须是0到3之间的数字")
    @Schema(description = "任务补偿触发策略（0默认触发一次补偿任务 1执行所有错过的触发点 2只执行一次错过的触发点 3不执行任何错过的触发点）", example = "0", allowableValues = "0,1,2,3")
    private String misfirePolicy; // 默认策略

@Size(max = 500, message = "任务描述不能超过500个字符")
    @Schema(description = "任务描述信息", example = "该任务用于......")
    private String remark;
}
```
在创建定时任务时不指定请求参数，后续可通过push接口将定时任务所需参数添加至定时任务队列：
```java
/**
 * @author gzs
 * @description: 添加任务数据到定时队列客户端
 */
public class PushDataClient {

public static void main(String[] args) {
        String url = "localhost:5541/job/push";
        String authorization = ClientConstants.AUTHORIZATION;
        JSONObject jsonObject = new JSONObject();
        
        //  场景编码
        jsonObject.set("chainId", "xxx");

//  添加到定时任务队列的参数
        String testStr = "{\"mode\":\"xxx\",\"ad\":\"12\"}";
        jsonObject.set("jobData", testStr);

String jsonStr = JSONUtil.toJsonStr(jsonObject);

HttpResponse response = HttpRequest.post(url).header("Authorization", authorization)
                .body(jsonStr)
                .execute();

System.out.println("Status Code: " + response.getStatus());
        System.out.println("Response Body: " + response.body());
    }
}
```
### 使用示例
规则链执行上下文如下：
```java
public class SceneContext {

/**
	 * 请求源数据
	 */
	@Getter
	private final Object requestData;

/**
	 * 执行结果
	 */
	@Getter
	@Setter
	private Object result;

private final Map<String, Object> data = new ConcurrentHashMap<>();

public SceneContext(Object requestData) {
		this.requestData = requestData;
	}

public void put(String key, Object value) {
		data.put(key, value);
	}

public Object get(String key) {
		return data.get(key);
	}

}
```
规则（EL表达式）如下：
```
THEN(a, b, c, timer)
```
在timer之前的组件中，将参数添加至上下文（SceneContext）：
```java
public class A extends NodeComponent {

private final Logger log = LoggerFactory.getLogger(A.class);

@Override
    public void process() throws Exception {
        String s = HttpUtil.get("http://baidu.com");
        log.info(s);

JobCreateDTO dto = new JobCreateDTO();
        dto.setJobName("测试任务");
		// dto.setXX...  省略其他set方法

SceneContext sceneContext = getContextBean(SceneContext.class);
        sceneContext.put("jobCreateDTO",dto);
    }
}
```