春季启动设计与多个供应商的服务（小服务）

Question

我创建一个春天启动应用程序，我需要用我的服务的设计帮助。我会用自行车服务为例。让我们考虑这些端点：

/api/bike/v1/info
/api/bike/v1/find

端点将调用自行车服务，其可以潜在地调用不同的供应商，如BikeProvider1，BikeProvider2等供应商将在应用程序的属性被指定，这允许改变提供商而不需要重新启动该应用程序。

结构示例

+ bike
     + Client
         - BikeRequest.java
         - BikeResponse.java
     + domain
         - Providers.java //providers enums
         - ServiceType.java // service type enums
        + Exceptions
     + Controller
        - BikeController.java
     + Service
        + Providers
            - BikeProviderService.java //interface
            - BikeProbider1ProviderService.java // implements interface
            - BikeProbider2ProviderService.java // implements interface
        - BikeService.java //interface
        - BikeServiceImpl.java

Properties.file
  bike.provider.primary: BikeProvider1
  bike.provider.fallback: BikeProvider2

我也认为，在未来我想有2个供应商之一，如情况下，第一个不响应的回退。但是现在，我只会用一次。

我目前的设计是这样的，我有枚举类我的服务类型和供应商。在BikeServiceImpl.java我动态查找我需要和拨打电话的供应商。

*******************ENUM CLASSES **************************
public enum Provider {
    BIKEPROVIDER1 ("BikeProvider1"),
    BIKEPROVIDER2  ("BikeProbider2"),

    private String name;

    Provider(final String name) {
        this.name = name;
    }
}

public enum ServiceType {
    BIKEINFORMATION ("BikeInformation"),
    FINDBIKE ("FindBike");

    private String type;

    ServiceType(final String name) {
        this.type = name;
    }
}


*****************BikeProviderService interface**************************

// this is the interface that all providers will implement
public interface BikeProviderService {
    Optional<Bike> getBikeInformation(BikeRequest bike);
    Optional<Bike> findBike(BikeRequest bike);
}

*****************BikeServiceImpl**************************

public class BikeServiceImpl implements BikeService {
    // I autowired providers
    @Autowired
    private BikeProvider1 bikeProvider1;
    @Autowired
    private BikeProvider2 bikeProvider2;

    //Get the provider from the properties
    @Value("${bike.provider.primary:}")
    private String primaryProvider;

// This is the call from controller endpoint /api/bike/v1/info 
    @Override
    public Bike findBikeInformation(BikeRequest bike, ServiceType serviceType) throws ServiceProviderException, BikeNotFoundException {
        return executeBikeInformationWithProvider(primaryProvider, bike, serviceType);
    }

    private Bike executeBikeInformationWithProvider(String provider, BikeRequest bike, ServiceType serviceType) throws ServiceProviderException, BikeNotFoundException {
        // find the providers based on the property value
        Optional<BikeProviderService> bikeProviderService = providerImplementation(provider);

        Optional<Bike> bikeResponse;
        if (BikeProviderService.isPresent()) {
            try {
                bikeResponse = bikeProviderService.get().getBikeInformation(bike);
                if (bikeResponse.isPresent()) {
                    LogCacheService.logRequest(bikeResponse, provider, serviceType.getType());
                    return bikeResponse.get();
                }
            } catch (Exception ex) {
                throw new ServiceProviderException("message");
            }
        }

        throw new BikeNotFoundException("Bike Not found");
    }

// This is the call from controller endpoint /api/bike/v1/find 
    @Override
    public Bike findBike(BikeRequest bike, ServiceType serviceType) throws ServiceProviderException, BikeNotFoundException {
        return executeFindBikeWithProvider(primaryProvider, bike, serviceType) ;
    }

    private Bike executeFindBikeWithProvider(String provider, BikeRequest bike, ServiceType serviceType) throws ServiceProviderException, BikeNotFoundException {
       // find the providers based on the property value
        Optional<BikeProviderService> bikeProviderService = providerImplementation(provider);

        Optional<Bike> bikeResponse;
        if (bikeProviderService.isPresent()) {
            try {
                bikeResponse = bikeProviderService.get().findBike(bike);
                if (bikeResponse.isPresent()) {
                    LogCacheService.logRequest(bike, provider, serviceType.getType());
                    return bikeResponse.get();
                }
            } catch (Exception ex) {
                throw new ServiceProviderException("message");
            }
        }

        throw new BikeNotFoundException("Bike Not found");
    }

    private Optional<BikeProviderService> providerImplementation(String bikeProvider) {
        Provider provider = null;

        try {
            provider = Provider.valueOf(bikeProvider.toUpperCase());
        } catch (IllegalArgumentException | NullPointerException ex) {
            log.error("Bike:: invalid Provider {}" , bikeProvider);
        }

        if (provider != null) {
            switch (provider) {
                case BIKEPROVIDER1:
                    return Optional.ofNullable(bikeProvider1);
                case BIKEPROVIDER2:
                    return Optional.ofNullable(bikeProvider2);
                default:
                    return Optional.empty();
            }
        }
        return Optional.empty();
    }

我想真的很难不重复的代码，但我怕我在做这个代码过于复杂和超难以维持。添加新的供应商现在：

1.- add to the enum provider class
2.- add to the switch statement
3.- add the service and @AutoWire the class

我尝试了工厂模式，但我不想每次创建提供的新实例。并且靠近，我有providerImplementation方法。

另外，我创建了执行/辅助方法，因为正如我前面提到的，我愿做一回退或在未来fallback.Provider恢复方法。例如如果findBike失败，我可以调用与回退的executeFindBikeWithProvider。 executeFindBikeWithProvider(**fallbackProvider**, bike, serviceType)

感谢让我知道，如果你需要更多的细节。

Answer 1

这不是一个很好的用例春天@profile？

https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-profiles.html

https://www.baeldung.com/spring-profiles

而不是使用您的属性文件供应商的名单，你可以使用不同的配置文件更改运行时配置。这将有效地让你有你的供应商被忽略或启用根据您的个人资料设置。

这样一来，增加了新的供应商将只需要你实施新的供应商，它与配置文件相关联。