Java策略模式实现与应用：优化事件处理的实践指南

/**
 * 策略接口：定义事件处理的统一方法
 */
public interface EventStrategy {
    /**
     * 处理事件的方法
     * @param value 待处理的事件数据
     * @return 处理结果
     */
    String handle(String value);
}

/**
 * 具体策略类1：处理事件类型A
 */
public class EventAStrategy implements EventStrategy {
    @Override
    public String handle(String value) {
        System.out.println("Handling Event A with value: " + value);
        // 模拟事件A的复杂处理逻辑
        return "Event A processed successfully for: " + value;
    }
}

/**
 * 具体策略类2：处理事件类型B
 */
public class EventBStrategy implements EventStrategy {
    @Override
    public String handle(String value) {
        System.out.println("Handling Event B with value: " + value);
        // 模拟事件B的复杂处理逻辑
        return "Event B processed successfully for: " + value;
    }
}

// 可以根据需要添加更多具体策略类，如 EventCStrategy, EventDStrategy 等

/**
 * 上下文类：维护对策略接口的引用，并委托其执行操作
 */
public class EventHandlerContext {
    private EventStrategy eventStrategy;

    /**
     * 通过构造函数注入具体策略
     * @param eventStrategy 要使用的事件处理策略
     */
    public EventHandlerContext(EventStrategy eventStrategy) {
        this.eventStrategy = eventStrategy;
    }

    /**
     * 执行当前策略的事件处理方法
     * @param value 待处理的事件数据
     * @return 处理结果
     */
    public String executeStrategy(String value) {
        if (eventStrategy == null) {
            throw new IllegalStateException("No event strategy has been set.");
        }
        return eventStrategy.handle(value);
    }

    /**
     * 也可以提供setter方法动态改变策略
     * @param eventStrategy 新的事件处理策略
     */
    public void setEventStrategy(EventStrategy eventStrategy) {
        this.eventStrategy = eventStrategy;
    }
}

public class StrategyPatternDemo {
    public static void main(String[] args) {
        // 使用EventA策略
        EventHandlerContext contextA = new EventHandlerContext(new EventAStrategy());
        String resultA = contextA.executeStrategy("Data for Event A");
        System.out.println("Result A: " + resultA);

        System.out.println("--------------------");

        // 使用EventB策略
        EventHandlerContext contextB = new EventHandlerContext(new EventBStrategy());
        String resultB = contextB.executeStrategy("Data for Event B");
        System.out.println("Result B: " + resultB);

        System.out.println("--------------------");

        // 动态改变策略
        contextA.setEventStrategy(new EventBStrategy());
        String resultA_changed = contextA.executeStrategy("Data for Event A (now handled by B)");
        System.out.println("Result A (changed strategy): " + resultA_changed);
    }
}

import org.springframework.stereotype.Component;

@Component("eventAHandler") // 使用特定的bean名称作为标识符
public class EventAStrategy implements EventStrategy {
    @Override
    public String handle(String value) {
        System.out.println("Handling Event A with value: " + value);
        return "Event A processed successfully for: " + value;
    }
}

@Component("eventBHandler") // 使用特定的bean名称作为标识符
public class EventBStrategy implements EventStrategy {
    @Override
    public String handle(String value) {
        System.out.println("Handling Event B with value: " + value);
        return "Event B processed successfully for: " + value;
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Map;
import java.util.Optional;

/**
 * 策略解析器：根据标识符动态获取具体的事件处理策略
 */
@Component
public class EventStrategyResolver {

    // Spring会自动注入所有实现了EventStrategy接口的bean，
    // 并以其bean名称（如"eventAHandler"）作为key，bean实例作为value
    private final Map<String, EventStrategy> strategyMap;

    @Autowired
    public EventStrategyResolver(Map<String, EventStrategy> strategyMap) {
        this.strategyMap = strategyMap;
        System.out.println("Loaded event strategies: " + strategyMap.keySet());
    }

    /**
     * 根据事件类型标识符获取对应的策略
     * @param eventType 标识事件类型的字符串
     * @return 对应的EventStrategy实例，如果不存在则返回Optional.empty()
     */
    public Optional<EventStrategy> getStrategy(String eventType) {
        // 假设eventType与bean名称对应
        return Optional.ofNullable(strategyMap.get(eventType));
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class EventProcessorService {

    private final EventStrategyResolver strategyResolver;

    @Autowired
    public EventProcessorService(EventStrategyResolver strategyResolver) {
        this.strategyResolver = strategyResolver;
    }

    /**
     * 根据解析的字符串处理事件
     * @param rawInput 原始输入字符串，包含事件类型和数据
     * @return 处理结果
     */
    public String processEvent(String rawInput) {
        // 模拟解析rawInput，提取事件类型和实际数据
        // 例如：rawInput可能是 "eventTypeA:some_data_payload"
        String[] parts = rawInput.split(":", 2);
        if (parts.length != 2) {
            return "Invalid input format: " + rawInput;
        }
        String eventType = parts[0].trim(); // 例如 "eventAHandler"
        String eventData = parts[1].trim(); // 例如 "some_data_payload"

        return strategyResolver.getStrategy(eventType)
                .map(strategy -> strategy.handle(eventData))
                .orElse("No handler found for event type: " + eventType);
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class StrategyPatternApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(StrategyPatternApplication.class, args);

        EventProcessorService processor = context.getBean(EventProcessorService.class);

        System.out.println("\n--- Testing Event Processing ---");
        System.out.println(processor.processEvent("eventAHandler:Hello World A!"));
        System.out.println(processor.processEvent("eventBHandler:Hello World B!"));
        System.out.println(processor.processEvent("unknownHandler:This should fail."));
        System.out.println(processor.processEvent("eventAHandler:Another message for A."));
    }
}