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

// 策略接口
interface StrategyInterface {
    void execute();
}

// 具体策略A, B, C，它们可能有各自的依赖
class A implements StrategyInterface {
    private Dependency dep;

    public A(Dependency dep) {
        this.dep = dep;
    }

    @Override
    public void execute() { /* ... */ }
}

class B implements StrategyInterface {
    private AnotherDependency anotherDep;

    public B(AnotherDependency anotherDep) {
        this.anotherDep = anotherDep;
    }

    @Override
    public void execute() { /* ... */ }
}

// ... 更多策略

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

    public StrategyResolver(ServiceLocator locator) {
        this.locator = locator;
    }

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

// 策略接口
public interface Strategy {
    /**
     * 判断当前策略是否适用于给定的数据
     * @param data 上下文数据
     * @return 如果适用则返回 true，否则返回 false
     */
    boolean appliesTo(String data);

    /**
     * 执行策略的具体逻辑
     */
    void execute();
}

import javax.inject.Named; // 或者 org.springframework.stereotype.Component

@Named // 或者 @Component
public class ConcreteStrategyA implements Strategy {
    private SomeDependency dependencyA;

    public ConcreteStrategyA(SomeDependency dependencyA) {
        this.dependencyA = dependencyA;
    }

    @Override
    public boolean appliesTo(String data) {
        // 示例：如果数据是 "typeA"，则此策略适用
        return "typeA".equals(data);
    }

    @Override
    public void execute() {
        System.out.println("Executing ConcreteStrategyA with dependency: " + dependencyA.getName());
    }
}

@Named // 或者 @Component
public class ConcreteStrategyB implements Strategy {
    private AnotherDependency dependencyB;

    public ConcreteStrategyB(AnotherDependency dependencyB) {
        this.dependencyB = dependencyB;
    }

    @Override
    public boolean appliesTo(String data) {
        // 示例：如果数据是 "typeB"，则此策略适用
        return "typeB".equals(data);
    }

    @Override
    public void execute() {
        System.out.println("Executing ConcreteStrategyB with dependency: " + dependencyB.getDescription());
    }
}

// ... 更多策略

import java.util.List;
import java.util.stream.Collectors;
import javax.inject.Named; // 或者 org.springframework.stereotype.Component

@Named // 或者 @Component
public class StrategyResolver {
    private final List<Strategy> strategies;

    // Spring 会自动注入所有实现了 Strategy 接口的 Bean
    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: " + data);
    }

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

import java.util.ArrayList;
import java.util.List;
import javax.inject.Named; // 或者 org.springframework.stereotype.Component

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

    @Override
    public void execute() {
        System.out.println("Executing DefaultStrategy: No specific strategy found.");
    }
}

@Named // 或者 @Component
public class StrategyResolverWithDefault {
    private final List<Strategy> strategies;

    // 注入所有策略和默认策略
    public StrategyResolverWithDefault(List<Strategy> strategies, DefaultStrategy defaultStrategy) {
        // 创建一个新的列表，将所有具体策略添加进去
        this.strategies = new ArrayList<>(strategies);
        // 将默认策略添加到列表的末尾，确保它在所有其他策略之后被检查
        this.strategies.add(defaultStrategy);
    }

    public Strategy resolve(String data) {
        return strategies.stream()
                         .filter(strategy -> strategy.appliesTo(data))
                         .findFirst()
                         .orElseThrow(() -> new IllegalStateException("This should not happen if DefaultStrategy is present."));
        // 如果DefaultStrategy被正确添加，这里永远不会抛出异常
    }
}