Java – Design Pattern: avoid switching to decide which service to call

For the project, we have a controller / service / Dao architecture We have implemented calls to different provider APIs, so we have obtained some such template code in each controller class:

enum {
    PARTNER_A,PARTNER_B,PARTNER_C
}

public class MyController {
    @Resource PartnerASearchService partnerASearchService;
    @Resource PartnerBSearchService partnerBSearchService;
    @Resource PartnerCSearchService partnerCSearchService;

    public search(InputForm form) {
        switch(form.getPartnerName()) {
           case PARTNER_A: partnerASearchService.search();
                            break;
           case PARTNER_B: partnerBSearchService.search();
                            break;
           case PARTNER_C: partnerCSearchService.search();
                            break;
        }
    }

    public otherMethod(InputForm form) {
        switch(form.getProvider()) {
           case PARTNER_A: partnerAOtherService.otherMethod();
                           break;
           case PARTNER_B: partnerBOtherService.otherMethod();
                           break;
           case PARTNER_C: partnerCOtherService.otherMethod();
                           break;
        }
    }
}

Which design pattern can I use to get rid of this switch in each controller? I want the code to be similar to the following code:

public class MyController {
    @Resource ServiceStrategy serviceStrategy;

    public search(InputForm form){
        serviceStrategy.search(form.getPartnerName())
        // or
        serviceStrategy.invoke(SEARCH,form.getPartnerName())
    }

    public otherMethod(InputForm form){
        serviceStrategy.other(form.getPartnerName())
        // or
        serviceStrategy.invoke(OTHER,form.getPartnerName())
    }
}

Let the servicestrategy decide which service implementation to call, so as to put the partner's switch in one place

I've used the word "strategy" because I've been told that this design pattern can be implemented, but I'm not sure the best way to use it or whether there is a better way to solve this problem

Editor: I have updated the question because the term provider is misleading What I put in the input form is the name of the partner we are executing the request I want a pattern that determines which correct implementation to use (which of several services) based on the partner name in the form

Solution

Often, the form does not need to know that the "provider" will process its content Instead, providers should be able to explain what kind of input they can handle

I suggest using a form of chain of responsibility (replacing refactoring conditions with polymorphism), which looks like this (groovy for simplicity):

interface ProviderService {
    boolean accepts(InputForm form)
    void invoke(String foo,InputForm form)
    void other(InputForm form)
}

Each implementation of the providerservice implementation accepts to indicate whether it can process a specific form, and your controller stores the list < providerservice > service instead of a personal reference Then, when you need to process the form, you can use:

ProviderService service = services.find { it.accepts(form) }
// error handling if no service found
service.other(form)

For a comprehensive example of this pattern used in the main framework, see the spring conversion service