Abstract Document

Abstract Document

1.主要用于处理具有附加非静态 属性的对象，并确保在强类型语言中保持类型安全。该模式允许开发者在不改变对象原有结构的情况下，动态地向对象添加新属性，同时保持系统的高度灵活性和可扩展性。

2.而说到文档,很容易想到NoSql数据库存储,也就是使用键值对（Key-Value）的形式来存储数据,那么用在这里.就是存储对象的属性,当然也可以是其他…

3.总的来说抽象文档模式是一种面向对象的设计模式，它，支持多层嵌套的数据结构，允许在对象不知道的情况下将属性附加到对象。

核心思想

• 属性存储：通过一个集合（如Map）来存储对象的属性，每个属性由一个唯一的键（Key）和对应的值（Value）组成。
• 接口定义：定义一组接口，每个接口负责一类属性的存取操作。这样做可以将不同类的属性分离到不同的接口中，提高代码的模块化和可维护性。
• 抽象类实现：创建一个抽象类，实现接口定义的基本行为，并提供属性存储的具体实现。子类通过继承抽象类并实现相应的接口，来定义具有特定属性的对象。

使用场景

• 类的属性变化频率很大，需要经常添加或修改属性的情况。
• 需要在不改变类的结构上动态地添加类的属性的情况。
• 需要处理具有复杂嵌套结构的数据对象的情况。

优势与不足

优势：

• 提高了系统的灵活性和可扩展性。
• 保持了类型安全，避免了类型转换错误。
• 通过接口和抽象类的设计，提高了代码的模块化和可维护性。

不足：

• 增加了反射错误的风险，因为属性的继承类型并不总是确定的。
• 在处理大量属性时，可能会影响系统的性能。

简单实现示例

1定义文档接口

public interface Document {  
    void put(String key, Object value);  
    Object get(String key);  
    <T> Stream<T> children(String key, Function<Map<String, Object>, T> constructor);  
}

2创建抽象类

public abstract class AbstractDocument implements Document {  
    private final Map<String, Object> properties;  
    protected AbstractDocument(Map<String, Object> properties) {  
        this.properties = properties;  
    }  

    @Override  
    public void put(String key, Object value) {  
        properties.put(key, value);  
    }  

    @Override  
    public Object get(String key) {  
        return properties.get(key);  
    }  

    @Override  
    public <T> Stream<T> children(String key, Function<Map<String, Object>, T> constructor) {  
        // 实现子文档的遍历逻辑  
    }  
}

3定义属性接口

public interface HasModel extends Document {  
    default String getModel() {  
        return (String) get("model");  
    }  
}  

public interface HasPrice extends Document {  
    default double getPrice() {  
        return (double) get("price");  
    }  
}

4实现类

public class Car extends AbstractDocument implements HasModel, HasPrice {  
    public Car(Map<String, Object> properties) {  
        super(properties);  
    }  

    // 可以根据需要添加其他方法  
}

具体实现示例(github上面就有.都是那个Car)

当然也可点这里参考这个18年博主理解学习

Car类里面写一个Car方法，它接受一个Map类型的参数properties，并将其传递给父类的构造函数进行初始化。通过这个方法，可以方便地将一个Map对象中的属性值赋给Car对象的相应属性，实现对象的创建和初始化。

public class Car  {
  public Car(Map<String, Object> properties) {
    super(properties);
  }
}

然后枚举出小汽车的属性(部件,类型,价格,型号…)

public enum Property {
  PARTS, TYPE, PRICE, MODEL
}

文档接口 对应简单实现1 (我是认为Key就是属性,Value就是属性的值,当然也可是其他)

public interface Document {
  Void put(String key, Object value);
  Object get(String key);
  <T> Stream<T> children(String key, Function<Map<String, Object>, T> constructor);
}

Stream children(String key, Function<Map<String, Object>, T> constructor);

这是获取指定键key下子文档的流。通过constructor函数式参数将每个子文档表示为Map<String, Object>类型，并将其转换为自定义的(泛型)T 类型。返回一个包含所有子文档的Stream流。

抽象文档的实现类

public abstract class AbstractDocument implements Document {

  private final Map<String, Object> documentProperties;

  protected AbstractDocument(Map<String, Object> properties) {
    Objects.requireNonNull(properties, "properties map is required");
    this.documentProperties = properties;
  }

  @Override
  public Void put(String key, Object value) {
    documentProperties.put(key, value);
    return null;
  }

  @Override
  public Object get(String key) {
    return documentProperties.get(key);
  }

  @Override
  public <T> Stream<T> children(String key, Function<Map<String, Object>, T> childConstructor) {
    return Stream.ofNullable(get(key))
            .filter(Objects::nonNull)
            .map(el -> (List<Map<String, Object>>) el)
            .findAny()
            .stream()
            .flatMap(Collection::stream)
            .map(childConstructor);
  }
//重写Object类中的toString方法.
  @Override
  public String toString() {
    return buildStringRepresentation();
  }
    
//这里用于构建并返回一个表示当前对象的字符串。字符串中包含了当前对象所属类的名称以及对象的文档属性
  private String buildStringRepresentation() {
    var builder = new StringBuilder();
    builder.append(getClass().getName()).append("[");

    // 解释文档属性映射的变量
    Map<String, Object> documentProperties = this.documentProperties;

    // 解释文档属性映射大小的变量
    int numProperties = documentProperties.size();

    // 用于跟踪当前属性指数的解释变量
    int currentPropertyIndex = 0;

    // 迭代文档属性映射
    for (Map.Entry<String, Object> entry : documentProperties.entrySet()) {
      String key = entry.getKey();
      Object value = entry.getValue();

      // 追加键值对
      builder.append("[").append(key).append(" : ").append(value).append("]");

      // 如果不是最后一个属性，加逗号
      if (++currentPropertyIndex < numProperties) {
            builder.append(", ");
          }
        }
      builder.append("]");
      
    return builder.toString();
  }

}

属性的实现类 继承所写的抽象文档的实现类

public class Part extends AbstractDocument implements HasType, HasModel, HasPrice {

  public Part(Map<String, Object> properties) {
    super(properties);
  }
}

主类

@Slf4j
public class App {
  public static void main(String[] args) {
      
    var wheelProperties = Map.of(
        Property.TYPE.toString(), "wheel",
        Property.MODEL.toString(), "15C",
        Property.PRICE.toString(), 100L);

    var doorProperties = Map.of(
        Property.TYPE.toString(), "door",
        Property.MODEL.toString(), "Lambo",
        Property.PRICE.toString(), 300L);

    var carProperties = Map.of(
        Property.MODEL.toString(), "300SL",
        Property.PRICE.toString(), 10000L,
        Property.PARTS.toString(), List.of(wheelProperties, doorProperties));

    var car = new Car(carProperties);

    LOGGER.info("Here is our car:");
    LOGGER.info("-> model: {}", car.getModel().orElseThrow());
    LOGGER.info("-> price: {}", car.getPrice().orElseThrow());
    LOGGER.info("-> parts: ");
    car.getParts().forEach(p -> LOGGER.info("\t{}/{}/{}",
        p.getType().orElse(null),
        p.getModel().orElse(null),
        p.getPrice().orElse(null))
    );
  }
}