@Configuration
@Import(EventBusConfiguration.class)
public class MyImport {
}

@Autowired
private EventPublisher eventPublisher;

// AddUserEvent是自定义的事件类型
eventPublisher.publish(new AddUserEvent("张三"));

// 添加用户事件
public class AddUserEvent {
    // 用户id
    private String userId;
    // 用户名
    private String userName;

    public AddUserEvent(String userId, String userName) {
        this.userId = userId;
        this.userName = userName;
    }

    // 在此省略getter、setter
}

// 用户监听器
@BizListener(priority = 1)  // 业务事件监听器注解（这种类型的监听器只能监听你自己发布的事件），属性priority表示优先级（具体执行顺序需要结合@Listen注解的priorityAsc属性共同决定）
public class UserListener {
    @Listen // 监听注解（使用的是org.bekit.event.annotation.Listen）
    public void listenAddUser(AddUserEvent event) {
        // 监听到事件后，执行具体业务
    }
    
    @Listen(priorityAsc = false) // priorityAsc表示是否按照优先级大小升序执行监听器，默认为升序，如果设置为false表示按照优先级大小降序执行。
    public void listenAddUser(DeleteUserEvent event) {
        // 监听到事件后，执行具体业务
    }
}

eventPublisher.publish(new AddUserEvent("123", 张三"));

@Configuration
@Import(FlowEngineConfiguration.class)
public class MyImport {
}

@Autowired
private FlowEngine flowEngine;

Trade trade = new Trade();   // 初始化trade
// tradeFlow是需要执行的流程名称，trade是这个流程需要执行的目标对象（可以是订单、交易等等）
trade = flowEngine.start("tradeFlow", trade);
// 返回的trade是执行结束后的最新的目标对象

@Flow  // 流程注解（流程名称默认就是类名首字母小写，也可以自己在@Flow注解里面自己指定。比如本流程的名称为：tradeFlow）
public class TradeFlow {

    @StartNode      // 开始节点，一个流程必须得有一个开始节点
    public String start() {
        // 返回下一个节点名称。节点名称默认情况下就是对应的方法名，不过也可以在节点注解上指定name属性，自己指定名称
        return "node1";
    }

    @ProcessNode(processor = "node1Processor")      // 处理节点（一种节点类型），属性processor指定这个节点对应的处理器
    public String node1(String processResult) {// 入参processResult是本节点对应的处理器处理后的返回结果，它的类型需要满足能被处理器返回值进行赋值就可以
        // 本方法叫做“节点决策器”，意思是本节点处理器已经执行完了，现在需要决策出下一个节点进行执行，返回参数就是下一个节点名称。
        // 一般下一个节点选择是根据处理器返回结果来选择。
        // 比如：处理器返回转账成功了就表示这笔业务成功了，则应该进入成功节点；如果转账失败了就表示这笔业务失败了，则应该进入失败节点；如果转账被挂起了，那么就只能停留在当前节点直到得到明确结果为止，这个时候就可以返回null，中断流程。
        // 这里为简单演示，直接返回下一个节点
        return "node2";
    }

    @StateNode(processor = "node2Processor")        // 状态节点
    public String node2(String processResult) {
        return "node3";
        // return null;  // 当返回null时，流程会正常中断
    }

    @WaitNode(processor = "node3Processor")         // 等待节点（下面会细说处理节点、状态节点、等待节点的区别）
    public String node3(){
        // 也可以没有processResult入参
        return "node4";
    }

    @ProcessNode(processor = "node4Processor")
    public String node4(String processResult) {
        return "end";
    }

    @EndNode        // 结束节点（一个流程必须至少有一个结束节点）
    public void end() {
    }
    
    @TargetMapping      // 目标对象映射
    public String targetMapping(Trade target){ // 入参target是你传给流程引擎的那个目标对象
        // 将目标对象（比如订单）映射到需要执行的节点
        
        // 流程引擎并不知道当前这个目标对象应该从哪个节点开始执行（是从开始节点，还是从node1，还是从node2等等）。
        // 因为流程引擎并不知道这个目标对象是新建的，还是半路从数据库捡起来扔给流程引擎来执行的，
        // 所以需要你来告诉流程引擎现在应该从哪个节点开始执行，一般你要做的就是根据目标对象当前状态判断当前应该执行哪个节点。
        // 返回值就是需要执行的节点名称。
        // 下面的“XXX”表示逻辑判断
        if (XXX){
            return "start";
        }else if (XXX){
            return "node3";
        }else if (XXX){
            return "node4";
        }else {
            return "end";
        }
    }
}

@Processor // 处理器注解（处理器名称默认就是类型名称首字母小写，也可以在@Processor注解里面自己指定。本处理器的名称：node1Processor）
public class Node1Processor {
    
    @ProcessorExecute   // 处理器方法注解
    public String execute(TargetContext<Trade> targetContext) {
        // TODO 执行具体业务
        
        return "success";  //返回值会成为处理器的返回值，然后传给流程节点中的节点决策器
    }
}

@TheFlowListener(flow = "tradeFlow")  // 特定流程监听器注解，属性flow指定被监听的流程名称
public class DenoFlowListener {

    @ListenNodeDecided   // 监听节点选择事件
    public void listenNodeDecided(String node, TargetContext<Transfer> targetContext) { // 入参node表示被选择的节点，targetContext是目标上下文
        // 一般监听节点选择事件的目的是用来更新目标对象的状态，因为当节点选择事件发生时，就表明已经执行完一个节点，即将进入到下一个节点，所以目标对象的状态应该修改为下一个状态
    }

    @ListenFlowException    // 监听流程异常事件，当流程发生任何异常时都会发送这个事件
    public void listenFlowException(Throwable throwable, TargetContext<Transfer> targetContext) {
        // 本监听方法的作用就是在流程发生异常时可以做一些措施。

        // 当一个流程被某些原因中断时，我们可以通过定时任务扫描表将中间状态的交易查询出来，继续执行交易。
        // 这是个好方法，但是存在一个问题，当数据量过大时，定时任务的间隔时间不好确定，
        // 间隔时间短了就怕前面一个定时任务还没执行完第二个定时任务就开始执行了，间隔时间长了中间状态的交易就会长时间得不到执行

        // 一个更好的方式就是将发生异常的交易发送到MQ的延迟队列，同时系统监听MQ消息，当监听到这种数据时就继续执行这笔交易
        // 也就是你可以在本方法里实现将数据发送到MQ
    }
}

@FlowTx(flow = "tradeFlow") // 流程事务注解，属性flow指定本流程事务所对应的流程
public class TradeFlowTx {

    @LockTarget     // 锁目标对象，必选
    public Trade lockTarget(TargetContext<Trade> targetContext) { // 目标上下文中的泛型必须和返回类型一致
        // 在并发情况下需要用锁来控制并发
        // 流程引擎知道什么时候应该锁目标对象，但是流程引擎并不知道怎么锁住目标对象（不知道数据库表等信息）
        // 所以你需要在这里实现具体锁住目标对象的代码
        
        // 锁住目标对象后必须查出目标对象最新内容并返回给流程引擎，流程引擎需要将它更新到目标上下文，
        // 因为在锁住之前目标对象可能被其他线程执行了，并修改了其中的内容
    }

    @InsertTarget   // 插入目标对象，可选
    public Trade insertTarget(TargetContext<Trade> targetContext) {
        // 在这里实现插入目标对象到数据库的具体代码
        // 必须返回插入后的目标对象，流程引擎需要将它更新到目标上下文
    }
}

Trade trade = new Trade();   // 初始化trade
// tradeFlow是需要执行的流程名称，trade是这个流程需要执行的目标对象（可以是订单、交易等等）
trade = flowEngine.start("tradeFlow", trade);
// 返回的trade是执行结束后的最新的目标对象

@Configuration
@Import(ServiceEngineConfiguration.class)
public class MyImport {
}

@Autowired
private ServiceEngine serviceEngine;

// myService是需要执行的服务名称，XXXOrder是这个服务需要的命令对象，result是这个服务的执行结果对象，result是由服务引擎创建的
XXXResult result = serviceEngine.execute("myService", new XXXOrder("001"));

@Service(enableTx = true) // 服务定义注解（注意：此注解和spring的@Service注解名字一样，但是是两个不一样的注解），enableTx属性表示服务是否开启事务，默认不开启
public class MyService {
    @ServiceBefore // 服务前置处理（执行中不会有事务）
    public void check(ServiceContext<XXXOrder, XXXResult> serviceContext) { 
        // ServiceContext是服务上下文，可以通过它获取到传给服务引擎的order，也可以获取由服务引擎创建的result。
        // 进行业务校验（比如校验账户是否合法等等）
    }

    @ServiceExecute // 服务执行注解，即真正开始执行业务（注意：@Service的enableTx属性为true的话，会在进入本方法前开启新事务，如果本方法执行完后没有异常抛出，则提交事务；否则如果有任何异常抛出，则回滚事务）
    public void execute(ServiceContext<XXXOrder, XXXResult> serviceContext) {
        // 真正执行业务
    }
    
    @ServiceAfter // 服务后置处理（执行中不会有事务）
    public void serviceAfter(ServiceContext<XXXOrder, XXXResult> serviceContext) {
        // 可以进行一些后置处理，一般情况下用的不多
    }
}

@ServiceListener(priority = 1)  // 服务监听器注解（专门监听服务引擎发出的事件），priority属性表示监听器优先级（具体使用方式请查看“事件总线”功能模块）
public class MyServiceListener {
    @Listen // 监听注解（具体使用方式请查看“事件总线”功能模块）
    public void listenServiceApplyEvent(ServiceApplyEvent event) {
        // ServiceApplyEvent是服务申请事件，表示即将要执行某个服务
        
        // 监听到这个事件后，可以进行一些初始化，比如：打印日志、初始化result、校验order等等
    }

    @Listen(priorityAsc = false) // priorityAsc属性表示是否优先级升序（具体使用方式请查看“事件总线”功能模块）
    public void listenServiceFinishEvent(ServiceFinishEvent event) {
        // ServiceFinishEvent是服务完成事件，表示服务已经执行完了（注意：不管服务执行中是否有异常往外抛，都会发布这个事件）
        // 你监听这个事件后可以进行一些结尾性操作，比如：打印日志。
    }

    @Listen
    public void listenServiceExceptionEvent(ServiceExceptionEvent event) {
        // ServiceExceptionEvent是服务异常事件，表示服务执行过程中有异常往外抛
        // 你监听这个事件后可以根据你的业务执行相应操作，比如：打印异常日志。
        
        // 关于这个事件如果是我的话，我就会根据异常类型判断是否是我自己定义的异常，如果是的话，我就会根据异常里面的值对result设置。
        // 如果不是我自己抛出的异常（如空指针异常），则会返回给上层系统处理中，因为这个异常发生后我自己也判断不了业务执行结果到底是怎样的。
    }
}

// myService是需要执行的服务名称，XXXOrder是这个服务需要的命令对象，result是这个服务的执行结果对象，result是由服务引擎创建的
XXXResult result = serviceEngine.execute("myService", new XXXOrder("001"));