Использование базового enum как значения по умолчанию для зависимых перечислений

Question

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

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

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

Answer 1

Возможно, Visitor Pattern - это то, что вы ищете.

Используется с перечислением, он в основном позволяет добавлять зависящую от перечислимого числа логику без использования операторов 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()); 
    } 
}