Java后备模式

时间:2015-04-26 10:59:14

标签: java design-patterns strategy-pattern fallback proxy-pattern

我正在努力寻找一种实现依赖于第三方库类的服务的好方法。我还有一个'默认'实现,可以在库不可用或无法提供答案的情况下用作后备。

public interface Service {

    public Object compute1();

    public Object compute2();
}

public class DefaultService implements Service {

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

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

该服务的实际实现类似于:

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

当前的实现似乎重复了一些事情,只有对服务的实际调用是不同的,但try / catch和默认机制几乎相同。此外,如果在服务中添加了另一种方法,则实现看起来几乎相似。

是否有可能适用于此处的设计模式(proxystrategy),以使代码看起来更好,并进一步减少复制粘贴?

3 个答案:

答案 0 :(得分:4)

您可以使用方法引用将公共逻辑提取到单独的方法中,例如:

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

答案 1 :(得分:3)

最好的图书馆之一是Netflix' Hystrix 。我不确定你是否需要这么繁重的工作。它将为您提供线程池,超时,回退,监视,运行时配置更改,短路等。

基本上它是一个保护代码免受其依赖性失败的库。

答案 2 :(得分:3)

代理可以帮到你。下面的示例未经测试,但应该让您了解可以实施的内容:

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