json.converter

最新推荐文章于 2024-08-08 07:22:36 发布
最新推荐文章于 2024-08-08 07:22:36 发布
阅读量522 收藏
点赞数
分类专栏： 【工作流】 文章标签： json java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiamaocheng/article/details/127894064
版权

爬虫组件分析

Survive by day and develop by night.
talk for import biz , show your perfect code,full busy，skip hardness,make a better result,wait for change,challenge Survive.
happy for hardess to solve denpendies.

目录

在这里插入图片描述

概述

ActivityProcessor的是一个非常常见的需求。

需求：

设计思路

实现思路分析

1.ActivityProcessor

public interface ActivityProcessor {

  public void processFlowElements(FlowElementsContainer container, BpmnModel model, ArrayNode shapesArrayNode,
      Map<String, ModelInfo> formKeyMap, Map<String, ModelInfo> decisionTableKeyMap, double subProcessX, double subProcessY);

  public void processJsonElements(JsonNode shapesArrayNode, JsonNode modelNode, BaseElement parentElement,
      Map<String, JsonNode> shapeMap, Map<String, String> formKeyMap, Map<String, String> decisionTableMap, BpmnModel bpmnModel);
}

2.AssociationJsonConverter

@Override
  public void convertToJson(BaseElement baseElement, ActivityProcessor processor, BpmnModel model, FlowElementsContainer container, ArrayNode shapesArrayNode, double subProcessX, double subProcessY) {

    Association association = (Association) baseElement;
    ObjectNode flowNode = BpmnJsonConverterUtil.createChildShape(association.getId(), STENCIL_ASSOCIATION, 172, 212, 128, 212);
    ArrayNode dockersArrayNode = objectMapper.createArrayNode();
    ObjectNode dockNode = objectMapper.createObjectNode();
    dockNode.put(EDITOR_BOUNDS_X, model.getGraphicInfo(association.getSourceRef()).getWidth() / 2.0);
    dockNode.put(EDITOR_BOUNDS_Y, model.getGraphicInfo(association.getSourceRef()).getHeight() / 2.0);
    dockersArrayNode.add(dockNode);

    List<GraphicInfo> graphicInfoList = model.getFlowLocationGraphicInfo(association.getId());
    if (graphicInfoList.size() > 2) {
      for (int i = 1; i < graphicInfoList.size() - 1; i++) {
        GraphicInfo graphicInfo = graphicInfoList.get(i);
        dockNode = objectMapper.createObjectNode();
        dockNode.put(EDITOR_BOUNDS_X, graphicInfo.getX());
        dockNode.put(EDITOR_BOUNDS_Y, graphicInfo.getY());
        dockersArrayNode.add(dockNode);
      }
    }

    GraphicInfo targetGraphicInfo = model.getGraphicInfo(association.getTargetRef());
    GraphicInfo flowGraphicInfo = graphicInfoList.get(graphicInfoList.size() - 1);

    double diffTopY = Math.abs(flowGraphicInfo.getY() - targetGraphicInfo.getY());
    double diffRightX = Math.abs(flowGraphicInfo.getX() - (targetGraphicInfo.getX() + targetGraphicInfo.getWidth()));
    double diffBottomY = Math.abs(flowGraphicInfo.getY() - (targetGraphicInfo.getY() + targetGraphicInfo.getHeight()));

    dockNode = objectMapper.createObjectNode();
    if (diffTopY < 5) {
      dockNode.put(EDITOR_BOUNDS_X, targetGraphicInfo.getWidth() / 2.0);
      dockNode.put(EDITOR_BOUNDS_Y, 0.0);

    } else if (diffRightX < 5) {
      dockNode.put(EDITOR_BOUNDS_X, targetGraphicInfo.getWidth());
      dockNode.put(EDITOR_BOUNDS_Y, targetGraphicInfo.getHeight() / 2.0);

    } else if (diffBottomY < 5) {
      dockNode.put(EDITOR_BOUNDS_X, targetGraphicInfo.getWidth() / 2.0);
      dockNode.put(EDITOR_BOUNDS_Y, targetGraphicInfo.getHeight());

    } else {
      dockNode.put(EDITOR_BOUNDS_X, 0.0);
      dockNode.put(EDITOR_BOUNDS_Y, targetGraphicInfo.getHeight() / 2.0);
    }
    dockersArrayNode.add(dockNode);
    flowNode.set("dockers", dockersArrayNode);
    ArrayNode outgoingArrayNode = objectMapper.createArrayNode();
    outgoingArrayNode.add(BpmnJsonConverterUtil.createResourceNode(association.getTargetRef()));
    flowNode.set("outgoing", outgoingArrayNode);
    flowNode.set("target", BpmnJsonConverterUtil.createResourceNode(association.getTargetRef()));

    ObjectNode propertiesNode = objectMapper.createObjectNode();
    propertiesNode.put(PROPERTY_OVERRIDE_ID, association.getId());

    flowNode.set(EDITOR_SHAPE_PROPERTIES, propertiesNode);

    shapesArrayNode.add(flowNode);
  }

3.BaseBpmnJsonConverter

public abstract class BaseBpmnJsonConverter implements EditorJsonConstants,
                                                       StencilConstants {

    protected static final Logger LOGGER = LoggerFactory.getLogger(BaseBpmnJsonConverter.class);

    public static final String NAMESPACE = "http://activiti.com/modeler";

    protected ObjectMapper objectMapper = new ObjectMapper();
    protected ActivityProcessor processor;
    protected BpmnModel model;
    protected ObjectNode flowElementNode;
    protected double subProcessX;
    protected double subProcessY;
    protected ArrayNode shapesArrayNode;

    public void convertToJson(BaseElement baseElement,
                              ActivityProcessor processor,
                              BpmnModel model,
                              FlowElementsContainer container,
                              ArrayNode shapesArrayNode,
                              double subProcessX,
                              double subProcessY) {

        this.model = model;
        this.processor = processor;
        this.subProcessX = subProcessX;
        this.subProcessY = subProcessY;
        this.shapesArrayNode = shapesArrayNode;
        GraphicInfo graphicInfo = model.getGraphicInfo(baseElement.getId());

        String stencilId = null;
        if (baseElement instanceof ServiceTask) {
            ServiceTask serviceTask = (ServiceTask) baseElement;
            if ("mail".equalsIgnoreCase(serviceTask.getType())) {
                stencilId = STENCIL_TASK_MAIL;
            } else if ("camel".equalsIgnoreCase(serviceTask.getType())) {
                stencilId = STENCIL_TASK_CAMEL;
            } else if ("mule".equalsIgnoreCase(serviceTask.getType())) {
                stencilId = STENCIL_TASK_MULE;
            } else if ("dmn".equalsIgnoreCase(serviceTask.getType())) {
                stencilId = STENCIL_TASK_DECISION;
            } else {
                stencilId = getStencilId(baseElement);
            }
        } else {
            stencilId = getStencilId(baseElement);
        }

        flowElementNode = BpmnJsonConverterUtil.createChildShape(baseElement.getId(),
                                                                 stencilId,
                                                                 graphicInfo.getX() - subProcessX + graphicInfo.getWidth(),
                                                                 graphicInfo.getY() - subProcessY + graphicInfo.getHeight(),
                                                                 graphicInfo.getX() - subProcessX,
                                                                 graphicInfo.getY() - subProcessY);
        shapesArrayNode.add(flowElementNode);
        ObjectNode propertiesNode = objectMapper.createObjectNode();
        propertiesNode.put(PROPERTY_OVERRIDE_ID, baseElement.getId());

        if (baseElement instanceof FlowElement) {
            FlowElement flowElement = (FlowElement) baseElement;
            if (StringUtils.isNotEmpty(flowElement.getName())) {
                propertiesNode.put(PROPERTY_NAME, flowElement.getName());
            }

            if (StringUtils.isNotEmpty(flowElement.getDocumentation())) {
                propertiesNode.put(PROPERTY_DOCUMENTATION, flowElement.getDocumentation());
            }
        }

        convertElementToJson(propertiesNode, baseElement);

        flowElementNode.set(EDITOR_SHAPE_PROPERTIES, propertiesNode);
        ArrayNode outgoingArrayNode = objectMapper.createArrayNode();

        if (baseElement instanceof FlowNode) {
            FlowNode flowNode = (FlowNode) baseElement;
            for (SequenceFlow sequenceFlow : flowNode.getOutgoingFlows()) {
                outgoingArrayNode.add(BpmnJsonConverterUtil.createResourceNode(sequenceFlow.getId()));
            }

            for (MessageFlow messageFlow : model.getMessageFlows().values()) {
                if (messageFlow.getSourceRef().equals(flowNode.getId())) {
                    outgoingArrayNode.add(BpmnJsonConverterUtil.createResourceNode(messageFlow.getId()));
                }
            }
        }

        if (baseElement instanceof Activity) {

            Activity activity = (Activity) baseElement;
            for (BoundaryEvent boundaryEvent : activity.getBoundaryEvents()) {
                outgoingArrayNode.add(BpmnJsonConverterUtil.createResourceNode(boundaryEvent.getId()));
            }

            propertiesNode.put(PROPERTY_ASYNCHRONOUS,
                               activity.isAsynchronous());
            propertiesNode.put(PROPERTY_EXCLUSIVE,
                               !activity.isNotExclusive());

            if (activity.getLoopCharacteristics() != null) {
                MultiInstanceLoopCharacteristics loopDef = activity.getLoopCharacteristics();
                if (StringUtils.isNotEmpty(loopDef.getLoopCardinality()) || StringUtils.isNotEmpty(loopDef.getInputDataItem()) || StringUtils.isNotEmpty(loopDef.getCompletionCondition())) {

                    if (!loopDef.isSequential()) {
                        propertiesNode.put(PROPERTY_MULTIINSTANCE_TYPE,
                                           "Parallel");
                    } else {
                        propertiesNode.put(PROPERTY_MULTIINSTANCE_TYPE,
                                           "Sequential");
                    }

                    if (StringUtils.isNotEmpty(loopDef.getLoopCardinality())) {
                        propertiesNode.put(PROPERTY_MULTIINSTANCE_CARDINALITY,
                                           loopDef.getLoopCardinality());
                    }
                    if (StringUtils.isNotEmpty(loopDef.getInputDataItem())) {
                        propertiesNode.put(PROPERTY_MULTIINSTANCE_COLLECTION,
                                           loopDef.getInputDataItem());
                    }
                    if (StringUtils.isNotEmpty(loopDef.getElementVariable())) {
                        propertiesNode.put(PROPERTY_MULTIINSTANCE_VARIABLE,
                                           loopDef.getElementVariable());
                    }
                    if (StringUtils.isNotEmpty(loopDef.getCompletionCondition())) {
                        propertiesNode.put(PROPERTY_MULTIINSTANCE_CONDITION,
                                           loopDef.getCompletionCondition());
                    }
                }
            }

            if (activity instanceof UserTask) {
                BpmnJsonConverterUtil.convertListenersToJson(((UserTask) activity).getTaskListeners(),
                                                             false,
                                                             propertiesNode);
            }

            if (CollectionUtils.isNotEmpty(activity.getDataInputAssociations())) {
                for (DataAssociation dataAssociation : activity.getDataInputAssociations()) {
                    if (model.getFlowElement(dataAssociation.getSourceRef()) != null) {
                        createDataAssociation(dataAssociation,
                                              true,
                                              activity);
                    }
                }
            }

            if (CollectionUtils.isNotEmpty(activity.getDataOutputAssociations())) {
                for (DataAssociation dataAssociation : activity.getDataOutputAssociations()) {
                    if (model.getFlowElement(dataAssociation.getTargetRef()) != null) {
                        createDataAssociation(dataAssociation,
                                              false,
                                              activity);
                        outgoingArrayNode.add(BpmnJsonConverterUtil.createResourceNode(dataAssociation.getId()));
                    }
                }
            }
        }

        if (baseElement instanceof FlowElement) {
            BpmnJsonConverterUtil.convertListenersToJson(((FlowElement) baseElement).getExecutionListeners(),
                                                         true,
                                                         propertiesNode);
        }

        for (Artifact artifact : container.getArtifacts()) {
            if (artifact instanceof Association) {
                Association association = (Association) artifact;
                if (StringUtils.isNotEmpty(association.getSourceRef()) && association.getSourceRef().equals(baseElement.getId())) {
                    outgoingArrayNode.add(BpmnJsonConverterUtil.createResourceNode(association.getId()));
                }
            }
        }

        if (baseElement instanceof DataStoreReference) {
            for (Process process : model.getProcesses()) {
                processDataStoreReferences(process,
                                           baseElement.getId(),
                                           outgoingArrayNode);
            }
        }

        flowElementNode.set("outgoing",
                            outgoingArrayNode);
    }

    protected void processDataStoreReferences(FlowElementsContainer container,
                                              String dataStoreReferenceId,
                                              ArrayNode outgoingArrayNode) {
        for (FlowElement flowElement : container.getFlowElements()) {
            if (flowElement instanceof Activity) {
                Activity activity = (Activity) flowElement;

                if (CollectionUtils.isNotEmpty(activity.getDataInputAssociations())) {
                    for (DataAssociation dataAssociation : activity.getDataInputAssociations()) {
                        if (dataStoreReferenceId.equals(dataAssociation.getSourceRef())) {
                            outgoingArrayNode.add(BpmnJsonConverterUtil.createResourceNode(dataAssociation.getId()));
                        }
                    }
                }
            } else if (flowElement instanceof SubProcess) {
                processDataStoreReferences((SubProcess) flowElement,
                                           dataStoreReferenceId,
                                           outgoingArrayNode);
            }
        }
    }

    protected void createDataAssociation(DataAssociation dataAssociation,
                                         boolean incoming,
                                         Activity activity) {
        String sourceRef = null;
        String targetRef = null;
        if (incoming) {
            sourceRef = dataAssociation.getSourceRef();
            targetRef = activity.getId();
        } else {
            sourceRef = activity.getId();
            targetRef = dataAssociation.getTargetRef();
        }

        ObjectNode flowNode = BpmnJsonConverterUtil.createChildShape(dataAssociation.getId(),
                                                                     STENCIL_DATA_ASSOCIATION,
                                                                     172,
                                                                     212,
                                                                     128,
                                                                     212);
        ArrayNode dockersArrayNode = objectMapper.createArrayNode();
        ObjectNode dockNode = objectMapper.createObjectNode();

        dockNode.put(EDITOR_BOUNDS_X,
                     model.getGraphicInfo(sourceRef).getWidth() / 2.0);
        dockNode.put(EDITOR_BOUNDS_Y,
                     model.getGraphicInfo(sourceRef).getHeight() / 2.0);
        dockersArrayNode.add(dockNode);

        if (model.getFlowLocationGraphicInfo(dataAssociation.getId()).size() > 2) {
            for (int i = 1; i < model.getFlowLocationGraphicInfo(dataAssociation.getId()).size() - 1; i++) {
                GraphicInfo graphicInfo = model.getFlowLocationGraphicInfo(dataAssociation.getId()).get(i);
                dockNode = objectMapper.createObjectNode();
                dockNode.put(EDITOR_BOUNDS_X,
                             graphicInfo.getX());
                dockNode.put(EDITOR_BOUNDS_Y,
                             graphicInfo.getY());
                dockersArrayNode.add(dockNode);
            }
        }

        dockNode = objectMapper.createObjectNode();
        dockNode.put(EDITOR_BOUNDS_X,
                     model.getGraphicInfo(targetRef).getWidth() / 2.0);
        dockNode.put(EDITOR_BOUNDS_Y,
                     model.getGraphicInfo(targetRef).getHeight() / 2.0);
        dockersArrayNode.add(dockNode);
        flowNode.set("dockers",
                     dockersArrayNode);
        ArrayNode outgoingArrayNode = objectMapper.createArrayNode();
        outgoingArrayNode.add(BpmnJsonConverterUtil.createResourceNode(targetRef));
        flowNode.set("outgoing",
                     outgoingArrayNode);
        flowNode.set("target",
                     BpmnJsonConverterUtil.createResourceNode(targetRef));

        ObjectNode propertiesNode = objectMapper.createObjectNode();
        propertiesNode.put(PROPERTY_OVERRIDE_ID,
                           dataAssociation.getId());

        flowNode.set(EDITOR_SHAPE_PROPERTIES,
                     propertiesNode);
        shapesArrayNode.add(flowNode);
    }

4.BoundaryEventJsonConverter

 public static void fillTypes(Map<String, Class<? extends BaseBpmnJsonConverter>> convertersToBpmnMap,
      Map<Class<? extends BaseElement>, Class<? extends BaseBpmnJsonConverter>> convertersToJsonMap) {

    fillJsonTypes(convertersToBpmnMap);
    fillBpmnTypes(convertersToJsonMap);
  }

  public static void fillJsonTypes(Map<String, Class<? extends BaseBpmnJsonConverter>> convertersToBpmnMap) {
    convertersToBpmnMap.put(STENCIL_EVENT_BOUNDARY_TIMER, BoundaryEventJsonConverter.class);
    convertersToBpmnMap.put(STENCIL_EVENT_BOUNDARY_ERROR, BoundaryEventJsonConverter.class);
    convertersToBpmnMap.put(STENCIL_EVENT_BOUNDARY_SIGNAL, BoundaryEventJsonConverter.class);
    convertersToBpmnMap.put(STENCIL_EVENT_BOUNDARY_MESSAGE, BoundaryEventJsonConverter.class);
    convertersToBpmnMap.put(STENCIL_EVENT_BOUNDARY_CANCEL, BoundaryEventJsonConverter.class);
    convertersToBpmnMap.put(STENCIL_EVENT_BOUNDARY_COMPENSATION, BoundaryEventJsonConverter.class);
  }

  public static void fillBpmnTypes(Map<Class<? extends BaseElement>, Class<? extends BaseBpmnJsonConverter>> convertersToJsonMap) {
    convertersToJsonMap.put(BoundaryEvent.class, BoundaryEventJsonConverter.class);
  }

  protected String getStencilId(BaseElement baseElement) {
    BoundaryEvent boundaryEvent = (BoundaryEvent) baseElement;
    List<EventDefinition> eventDefinitions = boundaryEvent.getEventDefinitions();
    if (eventDefinitions.size() != 1) {
      // return timer event as default;
      return STENCIL_EVENT_BOUNDARY_TIMER;
    }

    EventDefinition eventDefinition = eventDefinitions.get(0);
    if (eventDefinition instanceof ErrorEventDefinition) {
      return STENCIL_EVENT_BOUNDARY_ERROR;
    } else if (eventDefinition instanceof SignalEventDefinition) {
      return STENCIL_EVENT_BOUNDARY_SIGNAL;
    } else if (eventDefinition instanceof MessageEventDefinition) {
      return STENCIL_EVENT_BOUNDARY_MESSAGE;
    } else if (eventDefinition instanceof CancelEventDefinition) {
      return STENCIL_EVENT_BOUNDARY_CANCEL;
    } else if (eventDefinition instanceof CompensateEventDefinition) {
      return STENCIL_EVENT_BOUNDARY_COMPENSATION;
    } else {
      return STENCIL_EVENT_BOUNDARY_TIMER;
    }
  }

5.BpmnJsonConverter

public class BpmnJsonConverter implements EditorJsonConstants,
                                          StencilConstants,
                                          ActivityProcessor {

    protected static final Logger LOGGER = LoggerFactory.getLogger(BpmnJsonConverter.class);

    protected ObjectMapper objectMapper = new ObjectMapper();

    protected static Map<Class<? extends BaseElement>, Class<? extends BaseBpmnJsonConverter>> convertersToJsonMap = new HashMap<Class<? extends BaseElement>, Class<? extends BaseBpmnJsonConverter>>();
    protected static Map<String, Class<? extends BaseBpmnJsonConverter>> convertersToBpmnMap = new HashMap<String, Class<? extends BaseBpmnJsonConverter>>();

    public final static String MODELER_NAMESPACE = "http://activiti.com/modeler";
    protected final static DateFormat defaultFormat = new SimpleDateFormat("yyyyMMddHHmmss");
    protected final static DateFormat entFormat = new SimpleDateFormat("yyyyMMddHHmmssSSS");

    static {

        // start and end events
        StartEventJsonConverter.fillTypes(convertersToBpmnMap,
                                          convertersToJsonMap);
        EndEventJsonConverter.fillTypes(convertersToBpmnMap,
                                        convertersToJsonMap);

        // connectors
        SequenceFlowJsonConverter.fillTypes(convertersToBpmnMap,
                                            convertersToJsonMap);
        MessageFlowJsonConverter.fillTypes(convertersToBpmnMap,
                                           convertersToJsonMap);
        AssociationJsonConverter.fillTypes(convertersToBpmnMap,
                                           convertersToJsonMap);

        // task types
        BusinessRuleTaskJsonConverter.fillTypes(convertersToBpmnMap,
                                                convertersToJsonMap);
        MailTaskJsonConverter.fillTypes(convertersToBpmnMap,
                                        convertersToJsonMap);
        ManualTaskJsonConverter.fillTypes(convertersToBpmnMap,
                                          convertersToJsonMap);
        ReceiveTaskJsonConverter.fillTypes(convertersToBpmnMap,
                                           convertersToJsonMap);
        ScriptTaskJsonConverter.fillTypes(convertersToBpmnMap,
                                          convertersToJsonMap);
        ServiceTaskJsonConverter.fillTypes(convertersToBpmnMap,
                                           convertersToJsonMap);
        UserTaskJsonConverter.fillTypes(convertersToBpmnMap,
                                        convertersToJsonMap);
        CallActivityJsonConverter.fillTypes(convertersToBpmnMap,
                                            convertersToJsonMap);
        CamelTaskJsonConverter.fillTypes(convertersToBpmnMap,
                                         convertersToJsonMap);
        MuleTaskJsonConverter.fillTypes(convertersToBpmnMap,
                                        convertersToJsonMap);
        SendTaskJsonConverter.fillTypes(convertersToBpmnMap,
                                        convertersToJsonMap);
        DecisionTaskJsonConverter.fillTypes(convertersToBpmnMap,
                                            convertersToJsonMap);

        // gateways
        ExclusiveGatewayJsonConverter.fillTypes(convertersToBpmnMap,
                                                convertersToJsonMap);
        InclusiveGatewayJsonConverter.fillTypes(convertersToBpmnMap,
                                                convertersToJsonMap);
        ParallelGatewayJsonConverter.fillTypes(convertersToBpmnMap,
                                               convertersToJsonMap);
        EventGatewayJsonConverter.fillTypes(convertersToBpmnMap,
                                            convertersToJsonMap);

        // scope constructs
        SubProcessJsonConverter.fillTypes(convertersToBpmnMap,
                                          convertersToJsonMap);
        EventSubProcessJsonConverter.fillTypes(convertersToBpmnMap,
                                               convertersToJsonMap);

        // catch events
        CatchEventJsonConverter.fillTypes(convertersToBpmnMap,
                                          convertersToJsonMap);

        // throw events
        ThrowEventJsonConverter.fillTypes(convertersToBpmnMap,
                                          convertersToJsonMap);

        // boundary events
        BoundaryEventJsonConverter.fillTypes(convertersToBpmnMap,
                                             convertersToJsonMap);

        // artifacts
        TextAnnotationJsonConverter.fillTypes(convertersToBpmnMap,
                                              convertersToJsonMap);
        DataStoreJsonConverter.fillTypes(convertersToBpmnMap,
                                         convertersToJsonMap);
    }

拓展实现

public static void convertListenersToJson(List<ActivitiListener> listeners, boolean isExecutionListener, ObjectNode propertiesNode) {
      String propertyName = null;
      String valueName = null;
      if (isExecutionListener) {
          propertyName = PROPERTY_EXECUTION_LISTENERS;
          valueName = "executionListeners";

      } else {
          propertyName = PROPERTY_TASK_LISTENERS;
          valueName = "taskListeners";
      }

      ObjectNode listenersNode = objectMapper.createObjectNode();
      ArrayNode itemsNode = objectMapper.createArrayNode();
      for (ActivitiListener listener : listeners) {
          ObjectNode propertyItemNode = objectMapper.createObjectNode();

          propertyItemNode.put(PROPERTY_LISTENER_EVENT, listener.getEvent());

          if (ImplementationType.IMPLEMENTATION_TYPE_CLASS.equals(listener.getImplementationType())) {
              propertyItemNode.put(PROPERTY_LISTENER_CLASS_NAME, listener.getImplementation());
          } else if (ImplementationType.IMPLEMENTATION_TYPE_EXPRESSION.equals(listener.getImplementationType())) {
              propertyItemNode.put(PROPERTY_LISTENER_EXPRESSION, listener.getImplementation());
          } else if (ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION.equals(listener.getImplementationType())) {
              propertyItemNode.put(PROPERTY_LISTENER_DELEGATE_EXPRESSION, listener.getImplementation());
          }

          if (CollectionUtils.isNotEmpty(listener.getFieldExtensions())) {
              ArrayNode fieldsArray = objectMapper.createArrayNode();
              for (FieldExtension fieldExtension : listener.getFieldExtensions()) {
                  ObjectNode fieldNode = objectMapper.createObjectNode();
                  fieldNode.put(PROPERTY_FIELD_NAME, fieldExtension.getFieldName());
                  if (StringUtils.isNotEmpty(fieldExtension.getStringValue())) {
                      fieldNode.put(PROPERTY_FIELD_STRING_VALUE, fieldExtension.getStringValue());
                  }
                  if (StringUtils.isNotEmpty(fieldExtension.getExpression())) {
                      fieldNode.put(PROPERTY_FIELD_EXPRESSION, fieldExtension.getExpression());
                  }
                  fieldsArray.add(fieldNode);
              }
              propertyItemNode.set(PROPERTY_LISTENER_FIELDS, fieldsArray);
          }

          itemsNode.add(propertyItemNode);
      }

参考资料和推荐阅读

[1]. https://www.activiti.org/

欢迎阅读，各位老铁，如果对你有帮助，点个赞加个关注呗！~

执于代码
关注
专栏目录
VBA-JSON-2.3.1_JSON_Windows编程_jsonexcel_ExcelVBA_circleinn_
09-29
planilha com codigo para converter json em tabela usando o excel
.net 自定义转换器JsonConverter的使用
何浩翔的博客
01-30 2712
.netcore 自定义转换器JsonConverter的使用
使用VBA从新浪财经（或其他类似财经网站）抓取股票价格、成交量、涨跌幅等数据
weitingfu的博客
08-01 518
确定数据源：首先，你需要确定新浪财经或类似网站提供股票数据的API接口。这通常需要对网站的网络请求进行分析，使用开发者工具（如Chrome的开发者工具）来查看网络请求和响应。编写VBA程序：在Excel中，使用VBA编写程序来发送HTTP请求到确定的API接口，并接收返回的JSON或XML格式的数据。解析数据：由于VBA本身不支持直接解析JSON，你需要使用额外的库（如）来解析接收到的JSON数据。存储和处理数据：将解析后的数据存储到Excel工作表中，并进行进一步的处理和分析。
推荐使用：JSONConverter - 美观而强大的JSON转换工具
gitblog_00084的博客
05-16 678
推荐使用：JSONConverter - 美观而强大的JSON转换工具 JSONConverter???? ???? ???? Powerful and beautiful JSON-to-model MacOS app, supports multiple development languages and popular third-party libraries, flexible custom confi...
分享基于.NET动态编译&Newtonsoft.Json封装实现JSON转换器（JsonConverter）原理及JSON操作技巧...
weixin_30488313的博客
06-15 1012
　　看文章标题就知道，本文的主题就是关于JSON，JSON转换器（JsonConverter）具有将C#定义的类源代码直接转换成对应的JSON字符串，以及将JSON字符串转换成对应的C#定义的类源代码，而JSON操作技巧则说明如何通过JPath来快速的定位JSON的属性节点从而达到灵活读写JSON目的。 一、JSON转换器（JsonConverter）使用及原理介绍篇 　　现在都流行微服务，前...
NewtonJson 自定义的JsonConverter用于自定义文本解析函数
zxcvb036的博客
09-09 1705
先看一下Json的格式。要解析其中的时间戳字段，自带的Converter无法进行，只能自己创建所需的转换函数 { "id": 1384552022690369570, "machineId": 101, "msgCode": 80002, "startTime": 1618937902137, "endTime": 1618937915316, "createStartTime": 16189379005
activiti-json-converter-5.21.0-API文档-中英对照版.zip
07-13
赠送jar包：activiti-json-converter-5.21.0.jar； 赠送原API文档：activiti-json-converter-5.21.0-javadoc.jar； 赠送源代码：activiti-json-converter-5.21.0-sources.jar； 赠送Maven依赖信息文件：activiti-...
activiti-json-converter-5.21.0-API文档-中文版.zip
07-13
赠送jar包：activiti-json-converter-5.21.0.jar； 赠送原API文档：activiti-json-converter-5.21.0-javadoc.jar； 赠送源代码：activiti-json-converter-5.21.0-sources.jar； 赠送Maven依赖信息文件：activiti-...
newtonsoft.json.dll 3.5
07-16
**四、转换器（Converter）** 转换器允许自定义类型如何被序列化和反序列化。`JsonConverter`是一个抽象类，你可以继承它并实现自己的逻辑。例如，自定义一个转换器处理枚举类型： ```csharp public class ...
pio.deploy.converter
06-30
在描述中提到的“默认情况下可用：json”，意味着`pio.deploy.converter`工具默认支持JSON格式的配置文件进行转换。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也方便...
Service.Liquidity.Converter
04-17
"Service.Liquidity.Converter" 是一个基于C#编程语言的客户端库，专注于处理与服务相关的流动性转换问题。在IT领域，特别是在金融技术（FinTech）或者交易系统中，流动性转换是一个关键概念。这个库可能提供了高效...
JSONConverter 使用教程
最新发布
gitblog_01133的博客
08-08 936
JSONConverter 使用教程 JSONConverter???? ???? ???? Powerful and beautiful JSON-to-model MacOS app, supports multiple development languages and popular third-party libraries, flexible custom configuration options ...
C#使用JsonConvert类的NullValueHandling属性来控制处理JSON中的null值
weixin_42064877的博客
04-30 1653
在C#中，您可以使用JsonConvert类的NullValueHandling属性来控制如何处理JSON中的null值。默认情况下，NullValueHandling设置为Include，这意味着将包括JSON中的所有null值。如果您希望忽略null值或将其替换为其他值（如空字符串），则可以将NullValueHandling设置为其他选项，并使用JsonConverter属性指定如何处理null值。
Newton.Json中JsonConverter的使用
ElegantHedgehog的博客
03-10 2072
一、使用场景： 有两个类都继承了同一个抽象类： /// <summary> /// 沙盒基类 /// </summary> abstract class SandBoxGanmeBase { /// <summary> /// 名称 /// </summary> public string Name { get; set; } /// <summary> /// 版本 /// </.
.NET(C#) Newtonsoft.JSON 自定义JsonConverter处理不同的JSON数据
weixin_42098295的博客
03-02 1775
本文主要介绍.NET(C#)中，使用Newtonsoft.JSON的自定义转换器JsonConverter，处理不同的JSON数据输入，能够实现对老数据的兼容。 原文地址：.NET(C#) Newtonsoft.JSON 自定义JsonConverter处理不同的JSON数据
Excel将单元格中的json本文格式化
会打代码的扫地王大爷的专栏
07-31 1459
选择"引用"，然后在弹出的对话框中找到并勾选"Microsoft Scripting Runtime"，以及“Microsoft XML 6.0”。打开Excel文件并按下ALT + F11打开Visual Basic for Applications（VBA）编辑器。进入https://github.com/VBA-tools/VBA-JSON，下载release的最新代码。VBA编辑器，“文件”->“导入”, 导入文件 JsonConverter.bas。点击VBA编辑器的菜单栏上的"工具"。
开源一个扩展性强的Json库(jsonconvert0.1.0beta版)
毛笔程序员
08-14 363
    由于工作上有json格式的数据需要处理， 需要一个json库， 但是网上的json库不是性能不好就是功能有限。 不得已逼自己动手写一个。 由于时间有限， 目前这个库只是用最基础的反射实现。 我打算分三个阶段完善这个jsonconvert库。  1、 json的框架与扩展性设计 2、 反序列化与序列化功能的优化 3、 性能优化，去掉反射改用asm   虽然目前是用反射实现的， 但是...
自定义JsonConverter，反序列化不符合规范的数组属性
极客神殿
10-13 1901
如果json 字符串不符合规范，可以通过自定义jsonconvert 解决 public class SingleValueArrayConverter : JsonConverter { public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { throw new No...
VB.net解析Json数据(附类库+Demo)
望月听涛
10-25 6424
今天整理电脑的时候，偶然看到一年前使用Vb.net开发的点餐项目，翻腾翻腾找到了这个东西。   记得当时使用Vb.net做了一个服务器，需要对Json数据进行解析。在Android或者C#上有比较成熟的Json解析工具类，在Vb.net上还没有。在国外一家网站上找到的这个类库。现在整理出来，供有需要的人使用。   这个类库仅支持ObjectToString，StringToObject简单的转
key.converter.schemas.enable=false value.converter.schemas.enable=false，完成这些设置后json数据仍包括schema,怎么解决
07-12
如果您将`key.converter.schemas.enable`和`value.converter.schemas.enable`设置为`false`，但仍然在JSON数据中看到了模式信息，这可能是因为您使用的转换器默认会包含模式信息。 为了解决这个问题，您可以尝试...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

执于代码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值