策略模式中避免服务定位器：基于依赖注入的优雅实现

// 策略接口
interface StrategyInterface {
    // ...
}

// 具体策略实现，可能包含依赖
class A implements StrategyInterface {
    private Dependency dep;
    constructor(Dependency dep) {
        this.dep = dep;
    }
}

class B implements StrategyInterface { /* ... */ }
class C implements StrategyInterface { /* ... */ }

// 策略解析器，使用服务定位器
class StrategyResolver {
    private ServiceLocator locator;

    constructor(ServiceLocator locator) {
        this.locator = locator;
    }

    public StrategyInterface resolve(String data) {
        if (data.equals("xxx")) {
            return locator.get(A.class); // 通过服务定位器获取实例
        } else if (data.equals("yyy")) {
            return locator.get(B.class);
        }
        return locator.get(C.class);
    }
}

import java.util.List;
import java.util.ArrayList;
import java.util.Optional;
import javax.inject.Named; // 或 Spring 的 @Component, @Service 等

// 策略接口：推荐简化接口命名，去除 'Interface' 后缀
interface Strategy {
    /**
     * 判断当前策略是否适用于给定的数据。
     * @param data 用于判断的数据
     * @return 如果适用则返回 true，否则返回 false
     */
    boolean appliesTo(String data);

    /**
     * 执行策略的业务逻辑。
     * @param data 策略执行所需的数据
     */
    void execute(String data);
}

// 具体策略实现 A
@Named // 标记为可被DI容器管理的组件，例如Spring的@Component
class ConcreteStrategyA implements Strategy {
    private Dependency dep; // 策略本身的依赖通过DI注入

    public ConcreteStrategyA(Dependency dep) { // 假设Dependency也是一个DI管理的组件
        this.dep = dep;
    }

    @Override
    public boolean appliesTo(String data) {
        return "typeA".equals(data);
    }

    @Override
    public void execute(String data) {
        System.out.println("Executing Strategy A for: " + data);
        // dep.doSomething(); // 使用注入的依赖
    }
}

// 具体策略实现 B
@Named
class ConcreteStrategyB implements Strategy {
    @Override
    public boolean appliesTo(String data) {
        return "typeB".equals(data);
    }

    @Override
    public void execute(String data) {
        System.out.println("Executing Strategy B for: " + data);
    }
}

// 策略解析器
class StrategyResolver {
    private final List<Strategy> strategies;

    // 构造函数注入所有 Strategy 接口的实现
    public StrategyResolver(List<Strategy> strategies) {
        this.strategies = strategies;
    }

    // ... 解析逻辑将在下一节详述
}

// StrategyResolver 的 resolve 方法
class StrategyResolver {
    private final List<Strategy> strategies;

    public StrategyResolver(List<Strategy> strategies) {
        this.strategies = strategies;
    }

    /**
     * 根据输入数据解析并返回适用的策略。
     * @param data 用于判断策略的数据
     * @return 适用的策略实例
     * @throws IllegalArgumentException 如果没有找到适用的策略
     */
    public Strategy resolve(String data) {
        for (Strategy strategy : strategies) {
            if (strategy.appliesTo(data)) {
                return strategy;
            }
        }
        throw new IllegalArgumentException("No strategy applies to: " + data);
    }

    // 使用 Java 8 Stream API 的更简洁实现
    public Strategy resolveWithStream(String data) {
        return strategies.stream()
                         .filter(s -> s.appliesTo(data))
                         .findFirst() // 或 findAny()，取决于是否需要保证顺序
                         .orElseThrow(() -> new IllegalArgumentException("No strategy applies to: " + data));
    }
}

@Named
class DefaultStrategy implements Strategy {
    @Override
    public boolean appliesTo(String data) {
        return true; // 默认策略总是适用
    }

    @Override
    public void execute(String data) {
        System.out.println("Executing Default Strategy for: " + data);
        // 可以记录日志或执行默认行为，例如返回一个默认结果
    }
}

class StrategyResolverWithDefault {
    private final List<Strategy> strategies;

    public StrategyResolverWithDefault(List<Strategy> strategies, DefaultStrategy defaultStrategy) {
        // 创建一个可修改的列表，并将默认策略添加到末尾
        List<Strategy> allStrategies = new ArrayList<>(strategies);
        allStrategies.add(defaultStrategy); // 确保默认策略在最后被检查
        this.strategies = allStrategies;
    }

    public Strategy resolve(String data) {
        // 这里的解析逻辑与之前相同，因为默认策略总能匹配，所以不会抛出异常
        return strategies.stream()
                         .filter(s -> s.appliesTo(data))
                         .findFirst()
                         .orElseThrow(() -> new IllegalStateException("Default strategy should always apply, this indicates a configuration error.")); // 理论上不会发生
    }
}