java - 使用装饰器模式而不添加“不同”行为

为了进一步说明如何使用责任链模式，我整理了一个小例子。我相信您应该能够调整此解决方案以满足您现实世界问题的需求。

问题空间

我们有一组未知的用户请求，其中包含要检索的属性名称。有多个数据源，每个数据源都有不同数量的属性。我们希望搜索所有可能的数据源，直到发现请求中的所有属性。一些数据类型和数据源可能如下所示（注意我使用Lombok为简洁起见）：

@lombok.Data
class FooBarData {
    private final String foo;
    private final String bar;
}

@lombok.Data
class FizzBuzzData {
    private final String fizz;
    private final String buzz;
}

class FooBarService {
    public FooBarData invoke() {
        System.out.println("This is an expensive FooBar call");
        return new FooBarData("FOO", "BAR");
    }
}

class FizzBuzzService {
    public FizzBuzzData invoke() {
        System.out.println("This is an expensive FizzBuzz call");
        return new FizzBuzzData("FIZZ", "BUZZ");
    }
}

我们的最终用户可能需要多种方法来解析数据。以下可能是有效的用户输入和预期响应：

// Input
"foobar", "foo", "fizz"

// Output
{
  "foobar" : {
    "foo" : "FOO",
    "bar" : "BAR"
  },
  "foo" : "FOO",
  "fizz" : "FIZZ"
}

我们的属性解析器的基本接口和简单的具体实现可能如下所示：

interface PropertyResolver {
    Map<String, Object> resolve(List<String> properties);
}

class UnknownResolver implements PropertyResolver {
    @Override
    public Map<String, Object> resolve(List<String> properties) {
        Map<String, Object> result = new HashMap<>();
        for (String property : properties) {
            result.put(property, "Unknown");
        }
        return result;
    }
}

解决方案空间

与其使用普通的“装饰者模式”，更好的解决方案可能是“责任链模式”。此模式类似于装饰器模式，但是，链中的每个链接都可以处理项目、忽略项目或结束执行。这有助于决定是否需要进行调用，或者如果请求的工作已完成，则终止链。与装饰器模式的另一个区别是它resolve不会被每个具体类覆盖；我们的抽象类可以在需要时使用抽象方法调用子类。

回到手头的问题……对于每个解析器，我们需要两个组件。一种从我们的远程服务获取数据的方法，以及一种从检索到的数据中提取所有必需属性的方法。为了获取数据，我们可以提供一个抽象方法。为了从获取的数据中提取属性，我们可以创建一个小接口并维护这些提取器的列表，因为可以从单个数据中提取多个属性：

interface PropertyExtractor<Data> {
    Object extract(Data data);
}

abstract class PropertyResolverChain<Data> implements PropertyResolver {
    private final Map<String, PropertyExtractor<Data>> extractors = new HashMap<>();
    private final PropertyResolver successor;

    protected PropertyResolverChain(PropertyResolver successor) {
        this.successor = successor;
    }

    protected abstract Data getData();

    protected final void setBinding(String property, PropertyExtractor<Data> extractor) {
        extractors.put(property, extractor);
    }

    @Override
    public Map<String, Object> resolve(List<String> properties) {
        ...
    }
}

该resolve方法的基本思想是首先评估该实例properties可以满足哪些要求。PropertyResolver如果有符合条件的属性，那么我们将使用getData. 对于每个符合条件的属性，我们提取属性值并将其添加到结果映射中。每个无法解析的属性，都successor将被请求解析该属性。如果所有属性都已解决，则执行链将结束。

@Override
public Map<String, Object> resolve(List<String> properties) {
    Map<String, Object> result = new HashMap<>();

    List<String> eligibleProperties = new ArrayList<>(properties);
    eligibleProperties.retainAll(extractors.keySet());

    if (!eligibleProperties.isEmpty()) {
        Data data = getData();
        for (String property : eligibleProperties) {
            result.put(property, extractors.get(property).extract(data));
        }
    }

    List<String> remainingProperties = new ArrayList<>(properties);
    remainingProperties.removeAll(eligibleProperties);

    if (!remainingProperties.isEmpty()) {
        result.putAll(successor.resolve(remainingProperties));
    }

    return result;
}

实施解析器

当我们去实现一个具体的类时，PropertyResolverChain我们需要实现getData方法并绑定PropertyExtractor实例。这些绑定可以充当每个服务返回的数据的适配器。此数据可以遵循与服务返回的数据相同的结构，或者具有自定义架构。使用FooBarService前面的 from 作为示例，我们的类可以像下面这样实现（请注意，我们可以有许多绑定，这些绑定会导致返回相同的数据）。

class FooBarResolver extends PropertyResolverChain<FooBarData> {
    private final FooBarService remoteService;

    FooBarResolver(PropertyResolver successor, FooBarService remoteService) {
        super(successor);
        this.remoteService = remoteService;

        // return the whole object
        setBinding("foobar", data -> data);

        // accept different spellings
        setBinding("foo", data -> data.getFoo());
        setBinding("bar", data -> data.getBar());
        setBinding("FOO", data -> data.getFoo());
        setBinding("__bar", data -> data.getBar());

        // create new properties all together!!
        setBinding("barfoo", data -> data.getBar() + data.getFoo());
    }

    @Override
    protected FooBarData getData() {
        return remoteService.invoke();
    }
}

示例用法

把它们放在一起，我们可以调用Resolver链，如下所示。我们可以观察到，只有当属性绑定到解析器时，昂贵的getData方法调用才会执行一次Resolver，并且用户只获得他们需要的确切字段：

PropertyResolver resolver =
    new FizzBuzzResolver(
        new FooBarResolver(
            new UnknownResolver(),
            new FooBarService()),
        new FizzBuzzService());

Map<String, Object> result = resolver.resolve(Arrays.asList(
    "foobar", "foo", "__bar", "barfoo", "invalid", "fizz"));

ObjectMapper mapper = new ObjectMapper();
mapper.enable(SerializationFeature.INDENT_OUTPUT);
System.out.println(mapper
    .writerWithDefaultPrettyPrinter()
    .writeValueAsString(result));

输出

This is an expensive FizzBuzz call
This is an expensive FooBar call

{
  "foobar" : {
    "foo" : "FOO",
    "bar" : "BAR"
  },
  "__bar" : "BAR",
  "barfoo" : "BARFOO",
  "foo" : "FOO",
  "invalid" : "Unknown",
  "fizz" : "FIZZ"
}

java - 使用装饰器模式而不添加“不同”行为

问题描述

解决方案

问题空间

解决方案空间

实施解析器

示例用法

推荐阅读