软件设计一点通 | 抽象文档模式详解抽象文档模式

83 阅读 0 评论 55 点赞

我是靠谱客的博主灵巧红牛，最近开发中收集的这篇文章主要介绍软件设计一点通 | 抽象文档模式详解抽象文档模式，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

这里写图片描述

抽象文档模式

抽象文档模式是什么

一种面向对象的结构设计模式，用于在松散类型的键值存储中组织对象并使用类型化视图公开数据。该模式的目的是在强类型语言中实现组件之间的高度灵活性，其中可以动态地将新属性添加到对象树，而不会失去对类型安全的支持。该模式利用特征将类的不同属性分成不同的接口

定义

文档是包含许多属性的对象。例如：属性可以是数字或字符串之类的值，也可以是其他文档的列表。使用key引用每个属性。当遍历文档树时，用户指定用于创建下一级别的实现类的构造函数。这些实现通常是扩展Document接口的各种特性的联合，使它们可以自己处理设置和获取属性

使用场景

需要动态添加新属性
你想要一种灵活的方式来组织树状结构中的域
你想要构建更松散耦合的系统

结构

界面“文档”表示可以使用“put”方法编辑属性，使用“get”方法读取，可以使用“children”方法遍历子文档。“children”方法需要对一个方法的功能性引用，该方法可以在给定子项应具有的数据的映射集合的情况下生成子类型的视图。映射集合应该是指向原始映射集合的指针，以便视图中的更改也会影响原始文档。

实现可以从描述不同属性的多个特征接口继承。多个实现甚至可以共享相同的映射集合，模式对实现设计的唯一限制是它必须是无状态的，除了从“BaseDocument”继承的属性。

来自WIKI百科

官方伪代码

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

用法

抽象文档模式允许开发人员在非类型化树结构中存储变量（如配置设置），并使用类型化视图对文档进行操作。可以在不影响内部文档结构的情况下创建视图的新视图或替代实现。这样做的优点是系统更松散耦合，但它也增加了投射错误的风险，因为属性的继承类型并不总是确定的。

官方示例

Document.java

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

BaseDocument.java

public abstract class BaseDocument implements Document {
    private final Map<String, Object> entries;
    protected BaseDocument(Map<String, Object> entries) {
        this.entries = requireNonNull(entries);
    }
    @Override
    public final Object put(String key, Object value) {
        return entries.put(key, value);
    }
    @Override
    public final Object get(String key) {
        return entries.get(key);
    }
    @Override
    public final <T> Stream<T> children(
            String key,
            Function<Map<String, Object>, T> constructor) {
        final List<Map<String, Object>> children = 
            (List<Map<String, Object>>) get(key);
        return children == null
                    ? Stream.empty()
                    : children.stream().map(constructor);
    }
}

Usage.java

Map<String, Object> source = ...;
Car car = new Car(source);
String model = car.getModel();
int price = car.getPrice();
List<Wheel> wheels = car.children("wheel", Wheel::new)
    .collect(Collections.toList());

我的实践

UML图

这里写图片描述

实现思路

对商品的属性特征拆分成价格、重量、品牌、类型几个特征接口，不同类型的商品可以根据需要装配对应的属性特征，本文用的是数码产品，只需要实现特征接口，就可以拥有操作该属性的能力，而且多个不同类型的商品都可以共用一个映射集合，使用key区分开，后期可以动态装配自己的商品属性，可以不断动态添加同一类型的商品(Mp3、耳机、耳塞、音箱等)
示例结构：

数码产品
- 商品分类
  - 电视
  - 平板
  - 手机
  - xxx

代码实现

Category

/**
 * 商品类别
 *
 * @author liangyh
 * @date 2018/8/9
 */
public class Category extends AbstractGoods implements HasType, HasBrand, HasPrice,HasWeight {

    protected Category(Map<String, Object> properties) {
        super(properties);
    }
}

Digital

/**
 * 数码产品
 *
 * @author liangyh
 * @date 2018/8/9
 */
public class Digital extends AbstractGoods implements HasType, HasBrand, HasPrice,HasWeight {

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

HasBrand

/**
 * 包含品牌
 *
 * @author liangyh
 * @date 2018/8/9
 */
public interface HasBrand extends Goods {
    String BrandProperties = "brand";

    default Optional<String> getBrand() {
        return Optional.ofNullable((String) getProperties(BrandProperties));
    }
}

HasCategory

/**
 * 包含类别
 *
 * @author liangyh
 * @date 2018/8/9
 */
public interface HasCategory extends Goods {

    String CategoryProperties = "category";

    default Stream getCategory(){
    return children(CategoryProperties,Category::new);
    }

}

HasPrice

/**
 * 包含价格
 *
 * @author liangyh
 * @date 2018/8/9
 */
public interface HasPrice extends Goods {
    String PriceProperties = "price";
    default Optional<Number> getPrice(){
        return Optional.ofNullable((Number)getProperties(PriceProperties));
    }
}

HasType

/**
 * 类型
 *
 * @author liangyh
 * @date 2018/8/9
 */
public interface HasType extends Goods {

    String TypeProperty = "type";

    default Optional<String> getType(){
        return Optional.ofNullable((String)getProperties(TypeProperty));
    }
}

HasWeight

/**
 * 包含重量
 *
 * @author liangyh
 * @date 2018/8/9
 */
public interface HasWeight extends Goods {
    String WeightProperties = "weight";

    default Optional<Number> getWeight() {
        return Optional.ofNullable((Number) getProperties(WeightProperties));
    }
}

AbstractGoods

/**
 * 抽象商品类
 *
 * @author liangyh
 * @date 2018/8/9
 */
public class AbstractGoods implements Goods {

    private final Map<String, Object> properties;

    protected AbstractGoods(Map<String, Object> properties) {
        Objects.requireNonNull(properties, "属性不能为空");
        this.properties = properties;
    }


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

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

    @Override
    public <T> Stream<T> children(String key, Function<Map<String, Object>, T> constructor) {
        Optional<List<Map<String, Object>>> any = Stream.of(getProperties(key)).filter(el -> el != null).map(el -> (List<Map<String, Object>>) el).findAny();
        return any.isPresent() ? any.get().stream().map(constructor) : Stream.empty();
    }

    @Override
    public String toString() {
        return JSON.toJSONString(this.properties);
    }
}

Goods

/**
 * 商品接口
 *
 * @author liangyh
 * @date 2018/8/9
 */
public interface Goods {


    Object getProperties(String key);

    void putProperties(String key,Object value);

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

APP

/**
 * 抽象文档示例
 *
 */
public class App
{

    public static void main( String[] args )
    {
        //创建电视属性
        Map<String,Object> televisionProperties = new HashMap<>();
        televisionProperties.put(HasType.TypeProperty,"电视");
        televisionProperties.put(HasPrice.PriceProperties,2000);
        televisionProperties.put(HasBrand.BrandProperties,"创维");
        televisionProperties.put(HasWeight.WeightProperties,50);

        //创建手机属性
        Map<String,Object> phoneProperties = new HashMap<>();
        phoneProperties.put(HasType.TypeProperty,"手机");
        phoneProperties.put(HasPrice.PriceProperties,1900);
        phoneProperties.put(HasBrand.BrandProperties,"小米");
        phoneProperties.put(HasWeight.WeightProperties,0.5);

        //创建平板属性
        Map<String,Object> padProperties = new HashMap<>();
        padProperties.put(HasType.TypeProperty,"平板");
        padProperties.put(HasPrice.PriceProperties,5000);
        padProperties.put(HasBrand.BrandProperties,"苹果");
        padProperties.put(HasWeight.WeightProperties,0.5);

        //创建数码产品属性
        Map<String,Object> digitalProperties = new HashMap<>();
        digitalProperties.put(HasCategory.CategoryProperties,Arrays.asList(televisionProperties,phoneProperties,padProperties));
        Digital digital = new Digital(digitalProperties);

        System.out.println(digital.toString());
    }
}

运行结果

{
    "category": [{
        "price": 2000,
        "weight": 50,
        "type": "电视",
        "brand": "创维"
    }, {
        "price": 1900,
        "weight": 0.5,
        "type": "手机",
        "brand": "小米"
    }, {
        "price": 5000,
        "weight": 0.5,
        "type": "平板",
        "brand": "苹果"
    }]
}

参考引用

维基百科

最后

以上就是灵巧红牛为你收集整理的软件设计一点通 | 抽象文档模式详解抽象文档模式的全部内容，希望文章能够帮你解决软件设计一点通 | 抽象文档模式详解抽象文档模式所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：学习心得
浏览次数：83 次浏览
发布日期：2023-07-19 20:35:02
本文链接：https://www.kaopuke.com/article/k-p-k_14_uzo_22_fz_13__23__10_0.html

软件设计一点通 | 抽象文档模式详解抽象文档模式

概述

抽象文档模式

抽象文档模式是什么

定义

使用场景

结构

用法

官方示例

我的实践

UML图

实现思路

代码实现

运行结果

参考引用

最后

评论列表共有 0 条评论

发表评论取消回复

软件设计一点通 | 抽象文档模式详解抽象文档模式

概述

抽象文档模式

抽象文档模式是什么

定义

使用场景

结构

用法

官方示例

我的实践

UML图

实现思路

代码实现

运行结果

参考引用

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

发表评论取消回复