Java策略模式实现详解：构建灵活可扩展的事件处理系统

public interface Event {
    /**
     * 处理给定的值。
     * @param value 需要处理的字符串值。
     * @return 处理后的事件对象（可以根据实际需求返回不同类型）。
     */
    Event handle(String value);
}

/**
 * 具体事件策略1：实现Event接口，处理特定类型的事件逻辑。
 */
public class Event1 implements Event {
    @Override
    public Event handle(String value) {
        System.out.println("Handling Event1 with value: " + value);
        // 执行Event1特有的处理逻辑
        return this; // 返回自身或其他处理结果
    }
}

/**
 * 具体事件策略2：实现Event接口，处理另一种特定类型的事件逻辑。
 */
public class Event2 implements Event {
    @Override
    public Event handle(String value) {
        System.out.println("Handling Event2 with value: " + value);
        // 执行Event2特有的处理逻辑
        return this; // 返回自身或其他处理结果
    }
}

// 可以有更多类似的EventN类，每个处理不同的事件类型

/**
 * 策略模式的客户端或上下文，负责持有并调用具体的策略。
 */
public class StrategyClient {
    private Event event; // 持有策略接口的引用
    private String valueToProcess; // 需要处理的值

    /**
     * 构造函数，通过依赖注入方式传入具体的Event策略。
     * @param event 具体的事件处理策略实例。
     */
    public StrategyClient(Event event) {
        this.event = event;
    }

    /**
     * 执行当前持有的事件策略的handle方法。
     * @return 处理后的事件对象。
     */
    public Event executeStrategy() {
        if (event == null) {
            throw new IllegalStateException("No event strategy has been set.");
        }
        return event.handle(valueToProcess);
    }

    // Getter和Setter方法
    public String getValueToProcess() {
        return valueToProcess;
    }

    public void setValueToProcess(String valueToProcess) {
        this.valueToProcess = valueToProcess;
    }
}

public class Application {
    public static void main(String[] args) {
        // 场景1：处理Event1
        Event event1Strategy = new Event1();
        StrategyClient client1 = new StrategyClient(event1Strategy);
        client1.setValueToProcess("Data for Event1");
        client1.executeStrategy(); // 输出: Handling Event1 with value: Data for Event1

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

        // 场景2：处理Event2
        Event event2Strategy = new Event2();
        StrategyClient client2 = new StrategyClient(event2Strategy);
        client2.setValueToProcess("Data for Event2");
        client2.executeStrategy(); // 输出: Handling Event2 with value: Data for Event2
    }
}

// 示例：Spring管理策略
/*
import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.Map;

@Component("event1Handler")
public class Event1 implements Event {
    @Override
    public Event handle(String value) {
        System.out.println("Spring managed: Handling Event1 with value: " + value);
        return this;
    }
}

@Component("event2Handler")
public class Event2 implements Event {
    @Override
    public Event handle(String value) {
        System.out.println("Spring managed: Handling Event2 with value: " + value);
        return this;
    }
}

@Component
public class StrategyClient {
    // Spring会自动收集所有Event接口的实现并注入到Map中
    // Map的键可以是Bean的名称，值是对应的实例
    private final Map<String, Event> eventHandlers;

    @Autowired
    public StrategyClient(Map<String, Event> eventHandlers) {
        this.eventHandlers = eventHandlers;
    }

    public Event executeStrategy(String eventType, String value) {
        // 假设eventType对应Bean的名称前缀，例如 "event1" -> "event1Handler"
        Event handler = eventHandlers.get(eventType + "Handler");
        if (handler != null) {
            return handler.handle(value);
        }
        throw new IllegalArgumentException("No handler found for event type: " + eventType);
    }
}

// 在服务层调用示例 (假设MyService也是一个Spring组件)
// import org.springframework.stereotype.Service;
//
// @Service
// public class MyService {
//     private final StrategyClient strategyClient;
//
//     @Autowired
//     public MyService(StrategyClient strategyClient) {
//         this.strategyClient = strategyClient;
//     }
//
//     public void processIncomingEvent(String type, String data) {
//         System.out.println("Processing event through MyService...");
//         strategyClient.executeStrategy(type, data);
//     }
// }
//
// // 在Spring Boot应用的主类中调用
// @SpringBootApplication
// public class DemoApplication implements CommandLineRunner {
//     @Autowired
//     private MyService myService;
//
//     public static void main(String[] args) {
//         SpringApplication.run(DemoApplication.class, args);
//     }
//
//     @Override
//     public void run(String... args) throws Exception {
//         myService.processIncomingEvent("event1", "Hello from Spring Event1!");
//         myService.processIncomingEvent("event2", "Greetings from Spring Event2!");
//     }
// }
*/