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

// 策略接口及其实现
interface Strategy {
    void execute();
}

class ConcreteStrategyA implements Strategy {
    private Dependency dep;
    constructor(Dependency dep) { this.dep = dep; }
    void execute() { /* ... */ }
}
// ConcreteStrategyB, ConcreteStrategyC 类似

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

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

    public function resolveAndExecute(data): Strategy {
        if (conditionX(data)) {
            return locator->get(ConcreteStrategyA);
        } else if (conditionY(data)) {
            return locator->get(ConcreteStrategyB);
        }
        return locator->get(ConcreteStrategyC);
    }
}

public interface Strategy {
    // 策略的业务方法
    void execute();
    // 用于判断当前策略是否适用
    boolean appliesTo(String data);
}

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

@Component // 或 @Named
public class ConcreteStrategyA implements Strategy {
    private final SomeDependency dep;

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

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

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

@Component // 或 @Named
public class ConcreteStrategyB implements Strategy {
    // ... 类似的依赖注入和实现
    @Override
    public void execute() {
        System.out.println("Executing Strategy B");
    }

    @Override
    public boolean appliesTo(String data) {
        return "typeB".equals(data);
    }
}
// 更多策略实现...

import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Optional;

@Component
public class StrategyResolver {
    private final List<Strategy> strategies;

    // Spring 会自动收集所有实现了 Strategy 接口的 Bean 并注入到此列表中
    public StrategyResolver(List<Strategy> strategies) {
        this.strategies = strategies;
    }

    // ... 策略解析逻辑
}

import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Optional;

@Component
public class StrategyResolver {
    private final List<Strategy> strategies;

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

    public Strategy resolve(String data) {
        // 使用传统循环方式
        for (Strategy strategy : strategies) {
            if (strategy.appliesTo(data)) {
                return strategy;
            }
        }
        // 或者使用 Java 8 Stream API
        return strategies.stream()
                .filter(strategy -> strategy.appliesTo(data))
                .findFirst() // 找到第一个匹配的策略
                .orElseThrow(() -> new IllegalArgumentException("No strategy applies to data: " + data));
    }

    public void executeStrategy(String data) {
        Strategy strategy = resolve(data);
        strategy.execute();
    }
}

// DefaultStrategy 实现
@Component
public class DefaultStrategy implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing Default Strategy (no specific strategy applied).");
    }

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

// StrategyResolver 构造函数中处理默认策略
@Component
public class StrategyResolver {
    private final List<Strategy> strategies;

    public StrategyResolver(List<Strategy> injectedStrategies, DefaultStrategy defaultStrategy) {
        // 创建一个新的列表，将默认策略添加到末尾
        this.strategies = new java.util.ArrayList<>(injectedStrategies);
        this.strategies.add(defaultStrategy);
        // 注意：Spring注入的List默认是不可修改的，需要复制
    }

    public Strategy resolve(String data) {
        // Stream API 同样适用，DefaultStrategy 会作为最后一个被考虑
        return strategies.stream()
                .filter(strategy -> strategy.appliesTo(data))
                .findFirst()
                .get(); // 因为有DefaultStrategy，所以不会抛出 NoSuchElementException
    }
}