Блог

Я работаю над клиентом, который использует стандартизированный веб-сервис, однако один из поставщиков ведет себя несколько иначе, так что мы должны учитывать это поведение. Для этого мы использовали перечисление:

 public enum ServiceProviderType {
    FOO, BAR;

    public ServiceProviderType checkService(String url) {
        if (url.equals("http://www.example.com")) {
            return ServiceProviderType.FOO;
        } else {
            return ServiceProviderType.BAR;
        }
    }
}
  

Разница в этом поведении также зависит от того, что мы запрашиваем у службы, например, мы можем запросить слой и хотим, чтобы этот слой был окрашен в красный цвет, но знаем, что службы BAR и FOO представляют значения RGB по-разному. Для этого мы создали другое перечисление, в котором хранятся свойства, которые мы хотим для каждого уровня в сервисе.

 public enum LayerServiceProviderType {
    FOO("#ff0000"),
    BAR("#ff5555");

    private String colour;

    public ServiceProviderType(String colour) {
        this.colour = colour;
    }

    public String getColour() {
        return colour;
    }

    public ServiceProviderType checkService(String url) {
        if (url.equals("http://www.example.com")) {
            return ServiceProviderType.FOO
        } else {
            return ServiceProviderType.BAR;
        }
    }
}
  

Это работает нормально, за исключением случаев, когда мы хотим обрабатывать несколько слоев и рассматривать их как производные от одного и того же базового перечисления. По сути, мы хотим обрабатывать Layer1ServiceProviderType .BAR как эквивалент Layer2ServiceProviderType.BAR . Но мы не можем подклассировать перечисления, и даже попытка сделать это, похоже, нарушает все виды принципов звукового дизайна.

Моей первой мыслью было иметь интерфейс, содержащий перечисление:

 interface ServiceProvider {
    ServiceProviderType {FOO, BAR};

    ServiceProviderType getServiceProviderType();

    ServiceProvider checkService(String url);
}

public enum LayerServiceProvider implements ServiceProvider {
    FOO (ServiceProviderType.FOO, "#ff0000"),
    BAR (ServiceProviderType.BAR, "#ff0000");

    public LayerServiceProvider(ServiceProviderType serviceProviderType, String colour) {
        this.serviceProviderType = serviceProviderType;
        this.colour = colour;
    }

    @Override
    public ServiceProviderType getServiceProviderType() {
        return this.serviceProviderType;
    }

    @Override
    public ServiceProvider checkService(String url) {
        if (url.equals("http://www.example.com")) {
            return LayerServiceProviderType.FOO
        } else {
            return LayerServiceProviderType.BAR;
        }
    }
}
  

Но мне кажется чрезмерным иметь перечисление с перечислением, каждое из которых содержит один и тот же диапазон значений. Есть ли лучший способ сделать это?

Возможно, шаблон посетителя — это то, что вы ищете.

Используемый с перечислением, он в основном позволяет добавлять логику, зависящую от перечисления, без использования switch операторов.

Пример:

 public enum ServiceProviderType {
    FOO {
        @Override public <T> T apply(Action<T> action) { return action.doFoo(); }
    },
    BAR {
        @Override public <T> T apply(Action<T> action) { return action.doBar(); }
    };

    public interface Action<T> {
        T doFoo();
        T doBar();
    }

    public abstract <T> T apply(Action<T> action);

    public static ServiceProviderType checkService(String url) {
        if (url.equals("http://www.example.com"))
            return FOO;
        return BAR;
    }
}

public class LayerServiceProviderType implements ServiceProviderType.Action<String> {
    @Override
    public String doFoo() {
        return "#ff0000";
    }
    @Override
    public String doBar() {
        return "#ff0000";
    }
}

public class Main {
    public static void main(String[] args) {
        ServiceProviderType type = ServiceProviderType.checkService("");

        String colour = type.apply(new LayerServiceProviderType());
    }
}