使用统一转换服务处理不同数据显示的想法和实现

本文的示例代码:

本文介绍了这种情况:

对于功能场景，来自第三方的数据格式是不相同的，但是需要通过统一的功能接口来调用它们，然后根据不同的源数据格式执行不同的数据表示. 在后端实现中，请尽量不要硬编码，而要通过配置来完成数据处理和表示.

场景中提到了以下几个概念:

示例如下，数据内容如下:

{
    "trade_fullinfo_get_response": {
        "trade": {
            "seller_nick": "我在测试",
            "pic_name": "T1jVXXXePbXXaoPB6a_091917.jpg",
            "receiver_name": "东方不败",
            "buyer_message": "要送的礼物的，不要忘记的哦",
            "receiver_city": "杭州市",
            "receiver_district": "西湖区",
            "orders": {
                "order": [
                    {
                        "title": "苹果",
                        "unit": "个",
                        "oid": 1,
                        "price": 1.1,
                        "sum": 1
                    }
                ]
            },
        }
    }
}

通过转换服务处理，可以将其显示为以下两种不同的数据内容（以HTML呈现为例）

渲染场景1

渲染场景2

本文从数据格式，转换器，转换过程和数据呈现的角度描述了这种想法.

数据格式

一般来讲，对象级别有List和Map两种数据，并且List是Map格式的集合ifly文件格式转换器，因此最终的对象格式是Map. Map的格式为K，V，对于数据，K的数据格式为String，V为可变，但摘要如下:

和相应的收集格式. 通过此信息，定义表示对象的架构和相应的属性信息

对象架构:

class DataSchemaVO {
    /**
     * 当前这一层的惟一名,一般以相应的property name来表示
     * 如果是顶级，则为 ROOT
     */
    var name: String? = null
    /**
     * 中文标题
     * 如果为顶级，则为 ROOT
     */
    var title: String? = null
    /** 子类的分类集  */
    private var schemaSet: MutableSet<DataSchemaVO>? = null
    /** 当前层的属性集(不包括引用类型)  */
    private var propertySet: MutableSet<DataPropertyVO>? = null
}

其中，子属性分为两类，主要是为了方便以后的转换服务. 如果属性是对象类型，则将其视为DataSchema，即递归数据格式. 如果它是本机数据，则表示DataProperty，它可以用作各种操作和处理的基本数据格式.

属性:

class DataPropertyVO : Cloneable, Comparable<DataPropertyVO> {
    /** 当前层的惟一名  */
    var name: String? = null
    /** 当前标题  */
    var title: String? = null
    /** 数据类型  */
    var dataType: DataPropertyDataType? = null
}

The

属性非常简单. 在Java级别，可以理解，除了name以外的所有其他都是可选的. dataType主要用于执行操作和处理时根据格式进行后续转换和格式化，例如+-* /和format.

通过上述定义，对象将由以下xml描述（json也可以，此处仅供参考）:

<schema name="ROOT" title="ROOT">
    <schema name="trade_fullinfo_get_response" title="订单全信息响应">
        <schema name="trade" title="主订单">
            <property name="seller_nick" title="卖家昵称" dataType="STRING"/>
            <property name="pic_name" title="交易截图" dataType="STRING" order="80"/>
            <property name="payment" title="实付金额" dataType="DOUBLE" order="30"/>
<!-- ... 省略 --->
            <schema name="orders" title="子订单">
                <schema name="order" title="子订单信息">
                    <property name="title" title="商品名称" dataType="STRING"/>
                    <property name="unit" title="商品单位" dataType="STRING"/>
                </schema>
            </schema>
        </schema>
    </schema>
</schema>

此XML可以在本文开头描述订单数据格式.

转换器

转换器是转换器，在弹簧系统中随处可见. 对于转换器，它将单个输入转换为单个输出，但是没有描述从何处获取输入以及以后如何处理输出. 因此，本文将整个过程描述为以下三个步骤

获取输入参数，执行转换，输出参数处理

完整描述了整个生命周期. 整个定义称为“变形金刚”.

同时，在转换过程中，转换本身不是按类型区分的，而是由转换场景描述的. 也就是说，需要有相应的上下文来描述在转换过程中具体获得了哪些数据以及该过程中的逻辑如何进行. 这里介绍了上下文的概念. 它的主要功能是告诉转换器从何处获得相应的输入参数，如何处理旧值以及如何处理后续参数. 转换器本身根据某些逻辑和相应的判断逻辑来完成相应的过程.

因此，整个转换器方法定义为以下格式:

fun transform(input: I, inputSchema: DataSchemaVO, context: C, globalContext: GlobalTransformContext): Tuple2<Any, DataSchemaVO>

除了参数之外，在上下文之后还引入了参数对象格式信息和全局上下文，以进行其他一些判断和处理

转换器的实现基于不同的操作，例如参考代码，包括toString，脚本，split，rollup，remove，copy，case和其他操作. 根据实现，您还可以添加格式等处理. 有关详细信息，请参阅Transformer接口的实现.

转换过程

整个过程应理解为一系列转换操作，即，上一步的输出参数是直到最后的下一步的输入参数. 这个典型的链调用，参考示例是servlet系统的过滤器链，spring系统的链. 整个过程通常由执行对象描述，称为调用. 在这里，我们也直接应用此概念，并通过特定方法形成一个链式调用.

调用对象封装了当前的执行过程，步骤以及相应的当前参数和结果. 它本身是执行的起点ifly文件格式转换器，不断地绑定和调用信息，直到步骤结束. 该过程在代码中简单描述如下:

//执行对象
    @Suppress("UNCHECKED_CAST")
    override fun proceed() {
        if(currentStep >= maxStep) {
            return
        }
        val transformerVO = transformerInstanceList!![currentStep++]
        val transformer = transformerVO.createTransformer() as Transformer<TransformContext, Any>
        val context = transformerVO.createContext()
        transformer.transformChained(currentOutput, currentOutputSchema, context, this, this.globalContext)
    }
//转换器的自身处理和链式下一步调用
    fun transformChained(input: I, inputSchema: DataSchemaVO, context: C, invocation: DefaultTransformerInvocation, globalTransformContext: GlobalTransformContext) {
        val tuple2 = transform(input, inputSchema, context, globalTransformContext)
        invocation.bindCurrentOutput(tuple2.t1)
        invocation.bindCurrentOutputSchema(tuple2.t2)
        invocation.proceed()
    }

可以看出，当currentStep完成时，整个过程可以结束.

本文来自电脑杂谈，转载请注明本文网址：
https://www.pc-fly.com/a/bofangqi/article-260136-1.html