策略模式在项目中的应用

一、定义事件类型枚举

package org.example.cfo.handler;

import lombok.Getter;
import org.apache.commons.lang3.StringUtils;

import java.util.stream.Stream;

/**
*事件类型枚举
*/
@Getter

public enum LolEventTypeEnum {
    /**
     * 完成
     */
    FINISHED("完成", "FINISHED"),

/**

 * 开始
   */
   START("开始", "START"),

/**

 * 执行
   */
   EXECUTED("执行", "EXECUTED");

private final String label;
private final String value;

LolEventTypeEnum(String label, String value) {
    this.label = label;
    this.value = value;
}

public static LolEventTypeEnum getByValue(String value) {
    return Stream.of(values()).filter(var -> StringUtils.equalsIgnoreCase(var.getValue(), value))
            .findFirst()
            .orElse(null);

}
}

二、定义事件处理接口、基类、处理器工厂

2.1、接口

package org.example.cfo.handler;

/**

*事件处理器接口
*/
public interface LolEventHandler {

/**

*@param lolMessage 消息
*/
void handle(LolMessage lolMessage);

/**

*获取支持的事件类型枚举
*

*@return 事件类型枚举
*/
LolEventTypeEnum getSupportedEventType();
}

2.2、基类

package org.example.cfo.handler;

import lombok.extern.slf4j.Slf4j;

/**

*抽象类不能被实例化：Spring 无法直接创建抽象类的实例

*依赖注入是通过子类实现的：当子类被 Spring 管理时，它会继承父类的 @Resource 注解的依赖

*Spring 会自动处理继承的依赖注入：子类实例化时，会自动注入父类中声明的依赖
*/
@Slf4j
public abstract class AbstractLolEventHandler implements LolEventHandler {

//@Resource
//protected LolMapper lolMapper;

// protected 子类的共用方法1

// protected 子类的共用方法2


}

2.3、处理器工厂

package org.example.cfo.handler;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**

*事件处理器工厂
*/
@Slf4j
@Component
public class LolEventHandlerFactory {

private final List<LolEventHandler> eventHandlers;

private final Map<String, LolEventHandler> handlerMap = new HashMap<>();

public LolEventHandlerFactory(List<LolEventHandler> eventHandlers) {
    this.eventHandlers = eventHandlers;
}

/**

*初始化处理器映射
*/
@PostConstruct
public void init() {
for (LolEventHandler handler : eventHandlers) {
    LolEventTypeEnum eventTypeEnum = handler.getSupportedEventType();
    String eventTypeValue = eventTypeEnum.getValue();
    handlerMap.put(eventTypeValue, handler);
    log.info("事件处理器 - eventType: {}, label: {}, handler: {}",
            eventTypeValue, eventTypeEnum.getLabel(), handler.getClass().getSimpleName());
}
log.info("事件处理器工厂初始化完成，共注册 {} 个处理器", handlerMap.size());
}

/**

*根据 eventType 获取对应的处理器
*

*@param eventType 事件类型

*@return 对应的处理器，如果不存在则返回 null
*/
public LolEventHandler getHandler(String eventType) {
return handlerMap.get(eventType);
}

/**

*根据 eventType 枚举获取对应的处理器
*

*@param eventTypeEnum 事件类型枚举

*@return 对应的处理器，如果不存在则返回 null
*/
public LolEventHandler getHandler(LolEventTypeEnum eventTypeEnum) {
return handlerMap.get(eventTypeEnum.getValue());
}

/**

*判断是否存在指定 eventType 的处理器
*

*@param eventType 事件类型

*@return 是否存在
*/
public boolean hasHandler(String eventType) {
return handlerMap.containsKey(eventType);
}
}

三、定义数据Body

package org.example.cfo.handler;

import lombok.Data;

import java.io.Serializable;

/**

*执行事件
*/
@Data
public class LolMessage implements Serializable {

private static final long serialVersionUID = 1L;

/**

事件类型
*/
private String eventType;

/**

*消息ID
*/
private Long messageId;

/**

*事件时间（时间戳）
*/
private Long eventTime;

/**

*操作人
*/
private String operator;
}

四、子类定义

package org.example.cfo.handler;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**

*确认执行事件处理器
*/
@Slf4j
@Component
public class StartEventHandler extends AbstractLolEventHandler {

@Override
public void handle(LolMessage lolMessage) {
    log.info("ATA消费消息-确认执行-事件 - processInstanceId: {}", lolMessage.getMessageId());

}

@Override
public LolEventTypeEnum getSupportedEventType() {
    return LolEventTypeEnum.START;
}
}



package org.example.cfo.handler;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**

*执行事件处理器
*/
@Slf4j
@Component
public class ExecutedEventHandler extends AbstractLolEventHandler {

@Override
public void handle(LolMessage lolMessage) {
    log.info("ATA消费消息-退回执行-事件 - processInstanceId: {}", lolMessage.getMessageId());


    }
    
    @Override
    public LolEventTypeEnum getSupportedEventType() {
        return LolEventTypeEnum.EXECUTED;
    }

}


package org.example.cfo.handler;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**

*完成事件处理器
*/
@Slf4j
@Component
public class FinishedEventHandler extends AbstractLolEventHandler {

@Override
public void handle(LolMessage lolMessage) {
   log.info("消费消息-完成事件-处理流程 - processInstanceId: {}", lolMessage.getMessageId());

}

@Override
public LolEventTypeEnum getSupportedEventType() {
   return LolEventTypeEnum.FINISHED;
}
}