Question

我正在使用REST API，其中有一个接口，该接口定义了由4个不同的类实现的方法列表，并且有可能在将来添加更多方法。

当我从客户端收到HTTP请求时，URL中包含一些信息，这些信息将确定需要使用哪种实现。

在我的控制器内，我希望端点方法包含一个switch语句，该语句检查URL路径变量，然后使用适当的实现。

我知道我可以定义具体的实现并将其注入到控制器中，然后在switch语句中插入我想在每种特定情况下使用的具体实现，但是由于两个原因，这看起来不太优雅或可扩展：

即使我只需要使用一个服务，我现在也必须实例化所有服务。
代码似乎可以更精简，因为我实际上是使用相同的参数调用在接口中定义的相同方法，虽然在示例中这并不是真正的问题，但是在这种情况下实现的列表越来越多……用例和冗余代码的数量也在增加。

是否有更好的解决方案来解决这种情况？我正在使用SpringBoot 2和JDK 10，理想情况下，我想实现最现代的解决方案。

我当前的方法

@RequestMapping(Requests.MY_BASE_API_URL)
public class MyController {

    //== FIELDS ==
    private final ConcreteServiceImpl1 concreteService1;
    private final ConcreteServiceImpl2 concreteService2;
    private final ConcreteServiceImpl3 concreteService3;

    //== CONSTRUCTORS ==
    @Autowired
    public MyController(ConcreteServiceImpl1 concreteService1, ConcreteServiceImpl2 concreteService2,
                              ConcreteServiceImpl3 concreteService3){
      this.concreteService1 = concreteService1;
      this.concreteService2 = concreteService2;
      this.concreteService3 = concreteService3;
    }


    //== REQUEST MAPPINGS ==
    @GetMapping(Requests.SPECIFIC_REQUEST)
    public ResponseEntity<?> handleSpecificRequest(@PathVariable String source,
                                                       @RequestParam String start,
                                                       @RequestParam String end){

        source = source.toLowerCase();
        if(MyConstants.SOURCES.contains(source)){
            switch(source){
                case("value1"):
                    concreteService1.doSomething(start, end);
                    break;
                case("value2"):
                    concreteService2.doSomething(start, end);
                    break;
                case("value3"):
                    concreteService3.doSomething(start, end);
                    break;
            }
        }else{
            //An invalid source path variable was recieved
        }

        //Return something after additional processing
        return null;
    }
}

Answer 1

在Spring中，您可以通过注入T或List<T>字段来获得接口的所有实现（例如Map<String, T>）。在第二种情况下，bean的名称将成为地图的键。如果有很多可能的实现方式，或者它们经常更改，则可以考虑这一点。多亏了它，您可以在不更改控制器的情况下添加或删除实现。

在这种情况下，同时注入List或Map都有一些优点和缺点。如果注入List，则可能需要添加一些方法来映射名称和实现。像这样：

interface MyInterface() {
    (...)
    String name()
}

通过这种方式，您可以将其转换为Map<String, MyInterface>，例如使用Streams API。虽然这会更明确，但会稍微污染您的界面（为什么要知道有多个实现？）。

使用Map时，您可能应该显式命名bean，甚至引入注释以遵循最小惊讶原则。如果要使用配置类的类名或方法名来命名Bean，则可以通过重命名它们（实际上是更改url）来中断应用程序，这通常是安全的操作。

Spring Boot中一个简单的实现可能看起来像这样：

@SpringBootApplication
public class DynamicDependencyInjectionForMultipleImplementationsApplication {

    public static void main(String[] args) {
        SpringApplication.run(DynamicDependencyInjectionForMultipleImplementationsApplication.class, args);
    }

    interface MyInterface {
        Object getStuff();
    }

    class Implementation1 implements MyInterface {
        @Override public Object getStuff() {
            return "foo";
        }
    }

    class Implementation2 implements MyInterface {
        @Override public Object getStuff() {
            return "bar";
        }
    }

    @Configuration
    class Config {

        @Bean("getFoo")
        Implementation1 implementation1() {
            return new Implementation1();
        }

        @Bean("getBar")
        Implementation2 implementation2() {
            return new Implementation2();
        }
    }



    @RestController
    class Controller {

        private final Map<String, MyInterface> implementations;

        Controller(Map<String, MyInterface> implementations) {
            this.implementations = implementations;
        }

        @GetMapping("/run/{beanName}")
        Object runSelectedImplementation(@PathVariable String beanName) {
            return Optional.ofNullable(implementations.get(beanName))
                           .orElseThrow(UnknownImplementation::new)
                           .getStuff();
        }

        @ResponseStatus(BAD_REQUEST)
        class UnknownImplementation extends RuntimeException {
        }

    }
}

它通过了以下测试：

@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureMockMvc
public class DynamicDependencyInjectionForMultipleImplementationsApplicationTests {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void shouldCallImplementation1() throws Exception {
        mockMvc.perform(get("/run/getFoo"))
                    .andExpect(status().isOk())
                    .andExpect(content().string(containsString("foo")));
    }

    @Test
    public void shouldCallImplementation2() throws Exception {
        mockMvc.perform(get("/run/getBar"))
                    .andExpect(status().isOk())
                    .andExpect(content().string(containsString("bar")));
    }

    @Test
    public void shouldRejectUnknownImplementations() throws Exception {
        mockMvc.perform(get("/run/getSomethingElse"))
               .andExpect(status().isBadRequest());
    }
}

Answer 2

关于您的两个疑问：
1.实例化服务对象应该不是问题，因为这是一项工作，控制器将需要它们来满足所有类型的请求。
2.您可以使用精确的路径映射来摆脱开关情况。例如：

@GetMapping("/specificRequest/value1")
@GetMapping("/specificRequest/value2")
@GetMapping("/specificRequest/value3")

以上所有映射将位于单独的方法上，该方法将处理特定的源值并调用相应的服务方法。希望这将有助于使代码更简洁明了。

还有另一种选择，可以在服务层上将其分开，并且只有一个终结点来服务所有类型的源，但是正如您所说的，每个源值都有不同的实现，然后它说源不过是您的应用程序的资源，并且具有单独的资源URI /单独方法在这里很有意义。我在这里看到的一些优点是：

使编写测试用例变得容易。
在不影响任何其他来源/服务的情况下进行相同的缩放。
您的代码将每个来源视为与其他来源分开的实体。

当源值有限时，上述方法应该很好。如果您无法控制源值，那么我们需要在此处进行进一步的重新设计，方法是使源值与sourceType等类似的一个值再区分开，然后为每个组的源类型分别设置控制器。

使用Spring MVC对同一接口的多个实现进行动态依赖注入

2 个答案: