过滤器/组件模式而不是笨拙的继承？

Question

我有一个：

class ServiceObject {

    ServiceClass svcClass;

    void execute(String operation, Map arguments, ...) {
        svcClass.execute(this, operation, arguments, ...);
    }

}

然后我有一个要在同步中添加的子类：

class SynchronizedServiceObject extends ServiceObject {

    void execute(String operation, Map arguments, ...) {
        synchronized(lock) {
            super.execute(operation, arguments, ...);
        }
    }

}

我还有一个子类来添加日志记录上下文

class LogContextServiceObject extends ServiceObject {

    void execute(String operation, Map arguments, ...) {
        MDC.set("context", myCtx);
        super.execute(operation, arguments, ...);
        MDC.remove("context");
    }

}

但是，如果我想使用这两个功能，我需要编写另一个具有这两个功能的子类。您可以想象，如果有更多附加功能（日志记录、请求重写等），我将不得不为我需要的每种组合编写大量类。

相反，我想放弃子类并在创建 ServiceObject 时传递某种过滤器或组件对象。推荐的模式是什么（在 Java 中，或一般情况下）。

Answer 1

就 GoF 的著名书籍：Decorator 而言。

public class LoggingDecorator implements ServiceObject {

    private final ServiceObject decoratee;

    public LoggingDecorator(ServiceObject decoratee) {
        this.decoratee = decoratee;
    }


    @Override
    public void execute(String operation, Map<?, ?> arguments) {
        MDC.set("context", myCtx);
        try {
            decoratee.execute(operation, arguments);
        } finally {
            MDC.remove("context");
        }
    }
}

public class SynchronizedDecorator implements ServiceObject {

    private final ServiceObject decoratee;

    private final Object lock = new Object();

    public SynchronizedDecorator(ServiceObject decoratee) {
        this.decoratee = decoratee;
    }

    @Override
    public void execute(String operation, Map<?, ?> arguments) {
        synchronized (lock) {
            decoratee.execute(operation, arguments);
        }
    }
}

毕竟，您可以根据需要组合它们：

ServiceObject serviceObject =
                    new LoggingDecorator(
                            new SynchronizedDecorator(
                                    new ServiceObjectImpl()
                            )
                    );

Answer 2

最简单的解决方案是创建一个工厂类和枚举器：

enum ServiceObjectType { SynchronizedServiceObject ,LogContextServiceObject ,ServiceObject }
static class ServiceObjectFactory {
    ServiceObject NewService(ServiceObjectType  type) {
        switch(type) {
           case ServiceObjectType.SynchronizedServiceObject: return new SynchronizedServiceObject();
           case ServiceObjectType.LogContextServiceObject : return new LogContextServiceObject ();
           case ServiceObjectType.ServiceObject : return new ServiceObject (); 
        }
    }
}

用法：

ServiceObject blah1 = ServiceObjectFactory.NewService(ServiceObjectType.SynchronizedServiceObject);
ServiceObject blah2 = ServiceObjectFactory.NewService(ServiceObjectType.LogContextServiceObject);

Answer 3

这听起来很像责任链模式。这通常被描述为传播请求直到某些处理程序可以承担责任，但它也用于传播请求直到某些处理程序“消耗”它。在您的情况下，您希望无条件传播到所有处理程序。