代码之家 › 专栏 › 技术社区 › larn

这是工厂模式还是战略模式?

design-patterns spring java

0

larn · 技术社区 · 2 年前

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());
    }
}

是否应该将其视为一种战略模式,因为对象的行为会根据条件而变化?或者我应该将其视为工厂模式,因为我根据条件返回不同的对象?或者两者都有?如果你知道这个答案,请回复。

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

2 回复 | 直到 2 年前

1

0

Abned 2 年前

你没有错,这是一种战略模式。

策略 :ResultProvider接口

具体策略 :Test1ResultProvider和Test2ResultProvider

上下文 :ResultService

客户 :与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());
        }
    }
}

2

0

larn 2 年前

那么,如果我按照下面的方式编写代码,那么使用工厂方法模式和策略模式是否正确?

@Component
public class ResultProviderFactory {

    private final Map<Type, ResultProvider> providerMap = new HashMap<>();

    public ResultProviderFactory(List<ResultProvider> resultProviders) {
        pointCalculateServices.forEach(s -> providerMap.put(s.getType(), s));
    }

    public ResultProvider getResultProvider(Type type) {
        ResultProvider resultProvider = providerMap.get(type);
        if(resultProvider == null){
          throw new IllegalArgumentException();
        }
        return resultProvider;
    }
}

@Service
public class ResultService {

  private final ResultProviderFactory ResultProviderFactory;
  
  public List<DTO> find(SearchOption searchOption){
    ResultProvider resultProvider = ResultProviderFactory.get(searchOption.getType());
    
    return resultProvider.search(searchOption);
  }
}