Wzór awaryjny Java

Question

Próbuję znaleźć dobry sposób na wdrożenie usługi, która opiera się na klasie biblioteki innej firmy. Mam również "domyślną" implementację, która może być użyta jako element zapasowy w przypadku, gdy biblioteka jest niedostępna lub nie może udzielić odpowiedzi.

public interface Service { 

    public Object compute1(); 

    public Object compute2(); 
} 

public class DefaultService implements Service { 

    @Override 
    public Object compute1() { 
     // ... 
    } 

    @Override 
    public Object compute2() { 
     // ... 
    } 
} 

Faktyczna realizacja usługi będzie coś takiego:

public class ServiceImpl implements Service { 
    Service defaultService = new DefaultService(); 
    ThirdPartyService thirdPartyService = new ThirdPartyService(); 

    @Override 
    public Object compute1() { 
     try { 
      Object obj = thirdPartyService.customCompute1(); 
      return obj != null ? obj : defaultService.compute1(); 
     } 
     catch (Exception e) { 
      return defaultService.compute1(); 
     } 
    } 

    @Override 
    public Object compute2() { 
     try { 
      Object obj = thirdPartyService.customCompute2(); 
      return obj != null ? obj : defaultService.compute2(); 
     } 
     catch (Exception e) { 
      return defaultService.compute2(); 
     } 
    } 
} 

Obecna implementacja zdaje się powielać rzeczy trochę w ten sposób, że jedynie rzeczywiste połączenia z usługami są różne, ale try/catch i domyślny mechanizm są prawie takie same. Ponadto, jeśli dodano inną metodę w usłudze, implementacja wyglądałaby prawie identycznie.

Czy istnieje wzór, który może mieć tutaj zastosowanie (proxy, strategy), aby kod wyglądał lepiej i tworzyć dalsze dodatki, pomniejszając kopiowanie i wklejanie?

Answer 1

można wyodrębnić wspólne logiki do osobnej metody pomocą odwołań metody, jak:

public class ServiceImpl implements Service { 
    Service defaultService = new DefaultService(); 
    ThirdPartyService thirdPartyService = new ThirdPartyService(); 

    @Override 
    public Object compute1() { 
     return run(thirdPartyService::customCompute1, defaultService::compute1); 
    } 

    @Override 
    public Object compute2() { 
     return run(thirdPartyService::customCompute2, defaultService::compute2); 
    } 

    private static <T> T run(Supplier<T> action, Supplier<T> fallback) { 
     try { 
      T result = action.get(); 
      return result != null ? result : fallback.get(); 
     } catch(Exception e) { 
      return fallback.get(); 
     } 
    } 
} 

Answer 2

Jedną z najlepszych bibliotek jest Netflix 'Hystrix. Nie jestem pewien, czy potrzebujesz takiego ciężkiego podnoszenia. Da ci pulę wątków, limity czasu, awarie, monitorowanie, zmiany konfiguracji środowiska wykonawczego, zwarcia, itp.

Zasadniczo jest to biblioteka do obrony twojego kodu przed awariami jego zależności.

Answer 3

Prokurent może ci w tym pomóc. Poniższy przykład jest niesprawdzone, ale powinien dać wyobrażenie o tym, co można umieścić w miejscu:

public class FallbackService implements InvocationHandler { 

    private final Service primaryService; 
    private final Service fallbackService; 

    private FallbackService(Service primaryService, Service fallbackService) { 
     this.primaryService = primaryService; 
     this.fallbackService = fallbackService; 
    } 

    @Override 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
     try { 
      Object result = method.invoke(primaryService, args); 
      if (result != null) return result; 
     } catch (Exception ignore) {} 
     return method.invoke(fallbackService, args); 
    } 

    public static Service createFallbackService(Service primaryService, Service fallbackService) { 
     return (Service) Proxy.newProxyInstance(
       Service.class.getClassLoader(), 
       new Class[] { Service.class }, 
       new FallbackService(primaryService, fallbackService) 
     ); 
    } 
}