Abstract Document Pattern

<h2 id="definition">Definition</h2>
<p>A document is an object that contains a number of properties. A property can for an example be a value like a number or a string, or it can be a list of other documents. Every property is referenced using a key.<a class="footnote-ref" id="fnref:2" href="#fn:2"><sup>2</sup></a> When traversing the document tree, the user specifies a constructor to be used for creating the <a href="/facts/Implementation/IH1KXgP3">implementation</a> class of the next level. The implementations are often a union of various traits that extend the Document interface, making it possible for them to handle setting and getting properties on their own.
</p>
<h2 id="structure">Structure</h2>

<p>The interface "Document" states that properties can be edited using the "put" method, read using the "get" method and sub-documents can be traversed using the "children" method. The "children" method requires a functional reference to a method that can produce a typed view of a child given a map of the data the child should have. The map should be a pointer to the original map so that changes in the view also affect the original document.
</p><p>Implementations can inherit from multiple trait interfaces that describe different properties. Multiple implementations can even share the same map, the only restriction the pattern puts on the design of the implementation is that it must be <a href="/facts/Program_state/4Yu8xXHS">stateless</a> except for the properties inherited from "BaseDocument".
</p>
<h3>Pseudocode</h3>
interface Document
    put(key : String, value : Object) : Object
    get(key : String) : Object
    children(key : String, constructor : Map<String, Object> -> T) : T[]

abstract class BaseDocument : Document
    properties : Map<String, Object>

constructor(properties : Map<String, Object>)
        this->properties := properties

implement put(key : String, value : Object) : Object
        return this->properties->put(key, value)

implement get(key : String) : Object
        return this->properties->get(key)

implement children(key : String, constructor : Map<String, Object> -> T) : T[]
        var result := new T[]

var children := this->properties->get(key) castTo Map<String, Object>[]
        foreach ( child in children )
            result[] := constructor->apply(child)

return result

<h2 id="usage">Usage</h2>
<p>The Abstract Document Pattern allows the developer to store variables like configuration settings in an untyped tree structure and operate on the documents using typed views. New views or alternative implementations of views can be created without affecting the internal document structure. The advantage of this is a more loosely coupled system, but it also increases the risk of casting errors as the inherit type of a property is not always certain.
</p>
<h2 id="example-implementation">Example implementation</h2>
<p>The full implementation of the Abstract Document pattern is available at <a href="https://java-design-patterns.com/patterns/abstract-document/">https://java-design-patterns.com/patterns/abstract-document/</a>. Here are the key classes shortly.
</p><p>Document.java
</p>
public interface Document {
    Object put(String key, Object value);
    Object get(String key);
    <T> Stream<T> children(
            String key, Function<Map<String, Object>, T> constructor);
    );
}

<p>BaseDocument.java
</p>
public abstract class AbstractDocument implements Document {
    private final Map<String, Object> properties;
    protected AbstractDocument(Map<String, Object> properties) {
        Objects.requireNonNull(properties, "properties map is required");
        this.properties = properties;
    }
    @Override
    public Void put(String key, Object value) {
        properties.put(key, value);
        return null;
    }
    @Override
    public Object get(String key) {
        return properties.get(key);
    }    
    @Override
    public <T> Stream<T> children(String key, Function<Map<String, Object>, T> constructor) {
        return Stream.ofNullable(get(key))
                .filter(Objects::nonNull)
                .map(el -> (List<Map<String, Object>>) el)
                .findAny()
                .stream()
                .flatMap(Collection::stream)
                .map(constructor);
  }
}

<p>Usage.java
</p>
var carProperties = ...;
var car = new Car(carProperties);
String model = car.getModel().orElseThrow());
int price = car.getPrice().orElseThrow());
var parts = car.getParts();

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>Forslund, Emil (2016-01-15). "Age of Java: The Best of Both Worlds". Ageofjava.blogspot.com. Archived from the original on 2016-01-18. Retrieved 2016-01-23. <a href="https://web.archive.org/web/20160118213806/http://ageofjava.blogspot.com/2016/01/the-best-of-both-worlds.html" target="_blank">https://web.archive.org/web/20160118213806/http://ageofjava.blogspot.com/2016/01/the-best-of-both-worlds.html</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>Fowler, Martin. "Dealing with Properties" (PDF). Retrieved 2016-01-29. <a href="http://martinfowler.com/apsupp/properties.pdf" target="_blank">http://martinfowler.com/apsupp/properties.pdf</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
</ol>

Abstract Document Pattern open-in-new

Abstract Document Pattern