这是工厂模式还是策略模式？

Question

public interface ResultProvider {
    public Type getType(Type type);

    public List<DTO> search(SearchOption searchOption);
}

@Component
public class Test1ResultProvider {
    public Type getType() {
        return Enum.type;
    }

    public List<DTO> search(SearchOption searchOption) {
        repository.find(searchOption);
    }
}

@Component
public class Test2ResultProvider {
    public Type getType() {
        return Enum.type2;
    }

    public List<DTO> search(SearchOption searchOption) {
        repository.find(searchOption);
    }
}

@Service
public class ResultService {

    private final List<ResultProvider> resultProviders;

    public List<DTO> find(SearchOption searchOption) {
        return resultProviders.stream()
                .filter(provider -> provider.getType() == searchOption.getType())
                .findFirst()
                .map(provider -> provider.search(searchOption.getType()))
                .orElseThrow(() -> new IllegalArgumentException());
    }
}

是否应该将其视为一种策略模式，因为对象的行为会根据条件而变化？或者我应该将其视为工厂模式，因为我根据条件返回不同的对象？或者也许两者兼而有之？如果您知道这个答案，请回复。

我认为这是一种策略模式，但我想知道这是否是一种策略模式。

Answer 1

你没有看错，这是一种策略模式。

Strategy：ResultProvider接口 具体策略：Test1ResultProvider 和 Test2ResultProvider 上下文：结果服务 Client：与ResultService交互的代码。

这是抽象工厂模式的版本（不是工厂方法，因为我们需要创建一个对象家族）。

public interface ResultProvider {
    Type getType();

    List<DTO> search(SearchOption searchOption);
}

public class Test1ResultProvider implements ResultProvider {
    @Override
    public Type getType() {
        return Enum.type;
    }

    @Override
    public List<DTO> search(SearchOption searchOption) {
        // Implementation
    }
}

public class Test2ResultProvider implements ResultProvider {
    @Override
    public Type getType() {
        return Enum.type2;
    }

    @Override
    public List<DTO> search(SearchOption searchOption) {
        // Implementation
    }
}

public interface ResultProviderFactory {
    ResultProvider create();
}

@Component("type")
public class Test1ResultProviderFactory implements ResultProviderFactory {
    @Override
    public ResultProvider create() {
        return new Test1ResultProvider();
    }
}

@Component("type2")
public class Test2ResultProviderFactory implements ResultProviderFactory {
    @Override
    public ResultProvider create() {
        return new Test2ResultProvider();
    }
}

@Service
public class ResultService {

    private final Map<String, ResultProviderFactory> factoryMap;

    public ResultService(Map<String, ResultProviderFactory> factories) {
        factoryMap = factories;
    }

    public List<DTO> find(SearchOption searchOption) {
        ResultProviderFactory factory = factoryMap.get(searchOption.getType().name());
        if (factory != null) {
            ResultProvider provider = factory.create();
            return provider.search(searchOption);
        } else {
            throw new IllegalArgumentException("Unsupported type: " + searchOption.getType());
        }
    }
}