java - 我想在将json传递给我的服务时创建BPMN工作流图

Question

我要创建此图

我创建了一个包含整个逻辑的服务

package com.camundafluent.diagram.utils;

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Logger;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.camunda.bpm.model.bpmn.Bpmn;
import org.camunda.bpm.model.bpmn.BpmnModelInstance;
import org.camunda.bpm.model.bpmn.builder.ProcessBuilder;
import org.camunda.bpm.model.bpmn.builder.StartEventBuilder;
import org.camunda.bpm.model.bpmn.builder.UserTaskBuilder;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

import com.camundafluent.diagram.constants.DiagramConstants;
import com.camundafluent.diagram.exception.SchemaException;
import com.camundafluent.diagram.model.CamundaObject;
import com.camundafluent.diagram.model.Event;
import com.camundafluent.diagram.model.ProcessName;
import com.camundafluent.diagram.model.Task;

@Component
public class CamundaUtilsDiagram {

    @Value("${app.filepaths}")
    String filePath;

    @Value("${app.file.extension}")
    String fileExtension;

    @Value("${app.filename}")
    String fileName;


    private ProcessBuilder processBuilder;
    private StartEventBuilder startEventBuilder;
    private BpmnModelInstance modelInstance ;
    private UserTaskBuilder userTaskBuilder;
    final static Logger logger = Logger.getLogger(CamundaUtilsDiagram.class.getName());

    public void createDiagram(CamundaObject camundaObject) {
        // TODO Auto-generated method stub
        if (camundaObject.getProcessName() != null)
            setProcessDetails(camundaObject.getProcessName());
        if (camundaObject.getEvents() != null && !camundaObject.getEvents().isEmpty())
            setEventsDetails(camundaObject.getEvents(), camundaObject);

        writeBpmnInstance();

    }

    private void writeBpmnInstance() {
        // TODO Auto-generated method stub
        File file;
        try {
            file = File.createTempFile(fileName, fileExtension,
                    new File(filePath));
            Bpmn.writeModelToFile(file, modelInstance);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            logger.info("Exception occured"+e.getMessage());
        }
    }

    private void setEventsDetails(List<Event> events, CamundaObject camundaObject) {
        // TODO Auto-generated method stub
        events.forEach(startEvent -> {
            if (startEvent.getType().equalsIgnoreCase(DiagramConstants.StartEvent.toString())) {
                createStartEvent(startEvent, camundaObject);
                getNextProcess(startEvent.getId(), startEvent.getOutgoing(),  camundaObject);
            }
        });

    }

    private void createStartEvent(Event startEvent, CamundaObject camundaObject) {
        // TODO Auto-generated method stub
        //TODO Check for ID and name
        startEventBuilder = processBuilder.startEvent().id(startEvent.getId()).name(startEvent.getName());
    }

    private String firstUserTask =""; 
    private void createUserTask(String id, String outgoingObjectId, Task task)  {
        // TODO Auto-generated method stub

        if(id.startsWith(DiagramConstants.startEvent.toString())) {
            userTaskBuilder=startEventBuilder.userTask().id(task.getId()).name(task.getName()).camundaAssignee(task.getAssigneTaskToAssignee());
            firstUserTask = task.getId();
        }
        else {  
            if(firstUserTask.equals(id))
                userTaskBuilder.userTask().id(task.getId()).name(task.getName()).camundaAssignee(task.getAssigneTaskToAssignee());
            else
                userTaskBuilder.connectTo(id).userTask().id(task.getId()).name(task.getName()).camundaAssignee(task.getAssigneTaskToAssignee());

        }

    }
    private void getNextProcess(String id, List<String> listOfOutgoing, CamundaObject camundaObject) {
        if(!CollectionUtils.isEmpty(listOfOutgoing) && StringUtils.isNotBlank(id)){
            listOfOutgoing.forEach(outgoingObjectId->{
                List<String> outgoingId =  new ArrayList<>();
                String currentObjectId =  "";
                if(outgoingObjectId.startsWith(DiagramConstants.userTask.toString())) {
                    Task task = camundaObject.getTasks().stream().filter(result-> result.getId().equals(outgoingObjectId))
                            .findAny()
                            .orElseThrow(()->new SchemaException("Schema not in proper format"));
                    outgoingId=task.getOutgoing();
                    currentObjectId = task.getId();

                    createUserTask(id, outgoingObjectId,  task );
                }
                else if (outgoingObjectId.startsWith(DiagramConstants.endEvent.toString())) 
                    createEndEvent(id, outgoingObjectId, camundaObject);


                if(outgoingId!=null && StringUtils.isNotBlank(currentObjectId))
                    getNextProcess(currentObjectId, outgoingId,  camundaObject);
            });
        }
        else
            throw new SchemaException("Specify Outgoings");

    }

    private void createEndEvent(String id, String outgoingObjectId, CamundaObject camundaObject) {
        // TODO Auto-generated method stub
        modelInstance = startEventBuilder.connectTo(id).endEvent().done();

    }
    private void setProcessDetails(ProcessName processName) {
        // TODO Auto-generated method stub  
        processBuilder = Bpmn.createExecutableProcess(processName.getId()).name(processName.getName());
    }

}

下一个CamundaObject值从

CamundaObject camundaObject =new Gson().fromJson(payload, CamundaObject.class);
        camundaUtils.createDiagram(camundaObject);

有效负载是json

{
  "processName": {
    "id": "Process00vams5",
    "name": "BPMN API Vacation Process"
  },
  "events": [
    {
      "type": "StartEvent",
      "id": "startEvent1g26bmn",
      "name": "Standard Payroll",
      "outgoing": [
        "userTaskf62450cb-9a75-4206-b612-9f3111e214f7"
      ]
    },
    {
      "type": "EndEvent",
      "id": "endEvent0oe2hgw",
      "name": "End event for Approval",
      "incoming": [
        "userTaskTask0ah91xl"
      ]
    }
  ],
  "tasks": [
    {
      "type": "UserTask",
      "id": "userTaskf62450cb-9a75-4206-b612-9f3111e214f7",
      "name": "Approve Payroll",
      "assigneTaskToAssignee": "Lauren Contrara",
      "incoming": [
        "startEvent1g26bmn"
      ],
      "outgoing": [
        "userTaskTask1wh80eb"
      ]
    },
    {
      "type": "UserTask",
      "id": "userTaskTask1wh80eb",
      "name": "Lead Accountant",
      "assigneTaskToAssignee": "Felicity Dobrov",
      "incoming": [
        "userTaskf62450cb-9a75-4206-b612-9f3111e214f7"
      ],
      "outgoing": [
        "userTaskTask0ah91xl"
      ]
    },
    {
      "type": "UserTask",
      "id": "userTaskTask0ah91xl",
      "name": "Unit Production Manager",
      "assigneTaskToAssignee": "Sandra Xandar",
      "incoming": [
        "userTaskTask1wh80eb"
      ],
      "outgoing": [
        "endEvent0oe2hgw"
      ]
    }
  ]
}

我得到的图是

所以这是我面临问题的整个过程，Camunda具有流利的构建器模式，他们在其中创建了一个测试示例，其中所有数据都进行了硬编码，此处引用在 github中

Answer 1

因此，我解决了这个问题，创建了一些辅助类，其中创建了一些具有父子关系的顺序流FROM和TO，其中需要传递坐标，宽度，高度以生成形状。我没有使用过构建器模式，而是使用了自定义的camunda预定义类

这是JSON FILE结构

{
    "processName": {
        "id": "Process00vams5",
        "name": "BPMN API Vacation Process"
    },
    "events": [
        {
            "type": "StartEvent",
            "id": "startEvent1g26bmn",
            "name": "Standard Payroll",
            "ordinateX": 15,
            "ordinateY": 15,
            "width": 50,
            "height": 50,
            "outgoing": [
                "userTaskf62450cb-9a75-4206-b612-9f3111e214f7"
            ]
        },
        {
            "type": "EndEvent",
            "id": "endEvent0oe2hgw",
            "name": "End event for Approval",
            "ordinateX": 250,
            "ordinateY": 15,
            "width": 50,
            "height": 50,
            "incoming": [
                "userTaskTask0ah91xl"
            ]
        }
    ],
    "tasks": [
        {
            "type": "UserTask",
            "id": "userTaskf62450cb-9a75-4206-b612-9f3111e214f7",
            "name": "Approve Payroll",
            "assigneTaskToAssignee": "Lauren Contrara",
            "incoming": [
                "startEvent1g26bmn"
            ],
            "outgoing": [
                "userTaskTask1wh80eb"
            ],
            "ordinateX": 100,
            "ordinateY": 0,
            "width": 80,
            "height": 100
        },
        {
            "type": "UserTask",
            "id": "userTaskTask1wh80eb",
            "name": "Lead Accountant",
            "assigneTaskToAssignee": "Felicity Dobrov",
            "incoming": [
                "userTaskf62450cb-9a75-4206-b612-9f3111e214f7"
            ],
            "outgoing": [
                "userTaskTask0ah91xl"
            ],
            "ordinateX": 90,
            "ordinateY": 40,
            "width": 80,
            "height": 100
        },
        {
            "type": "UserTask",
            "id": "userTaskTask0ah91xl",
            "name": "Unit Production Manager",
            "assigneTaskToAssignee": "Sandra Xandar",
            "incoming": [
                "userTaskTask1wh80eb"
            ],
            "outgoing": [
                "endEvent0oe2hgw"
            ],
            "ordinateX": 70,
            "ordinateY": 40,
            "width": 80,
            "height": 100
        }
    ],
    "sequenceFlow": [
        {
            "sourceRef": "startEvent1g26bmn",
            "targetRef": "userTaskf62450cb-9a75-4206-b612-9f3111e214f7",
            "waypoints": [
                65,
                40,
                100,
                40
            ]
        },
        {
            "sourceRef": "userTaskf62450cb-9a75-4206-b612-9f3111e214f7",
            "targetRef": "userTaskTask1wh80eb",
            "waypoints": [
                65,
                40,
                100,
                40
            ]
        },
        {
            "sourceRef": "userTaskTask1wh80eb",
            "targetRef": "userTaskTask0ah91xl",
            "waypoints": [
                65,
                40,
                100,
                40
            ]
        },
        {
            "sourceRef": "userTaskTask0ah91xl",
            "targetRef": "endEvent0oe2hgw",
            "waypoints": [
                65,
                40,
                100,
                40
            ]
        }
    ]
}

接下来在这里我创建了1个服务，整个逻辑都在那里
软件包com.camundafluent.diagram.utils;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.camunda.bpm.model.bpmn.Bpmn;
import org.camunda.bpm.model.bpmn.instance.EndEvent;
import org.camunda.bpm.model.bpmn.instance.StartEvent;
import org.camunda.bpm.model.bpmn.instance.UserTask;

import com.camundafluent.diagram.constants.DiagramConstants;
import com.camundafluent.diagram.exception.SchemaException;
import com.camundafluent.diagram.model.CamundaObject;
import com.camundafluent.diagram.model.Event;
import com.camundafluent.diagram.model.HelpClass;
import com.camundafluent.diagram.model.ProcessName;
import com.camundafluent.diagram.model.SequenceFlow;
import com.camundafluent.diagram.model.Task;

public class CreateCamundaDiagram {

    private StartEvent startEvent;


    private EndEvent endEvent;

    HelpClass helpClass = new HelpClass();
    List<UserTask> listOfUserTask = new ArrayList<UserTask>();
    Map<String,UserTask> checkMapping = new HashMap<String,UserTask>();

    public void createDiagram(CamundaObject camundaObject) throws Exception {
        // TODO Auto-generated method stub
        if (camundaObject.getProcessName() != null)
            setProcessDetails(camundaObject.getProcessName());
        if (camundaObject.getEvents() != null && !camundaObject.getEvents().isEmpty())
            setEventsDetails(camundaObject.getEvents(), camundaObject);

        createSequencFlows(camundaObject);
        writeBpmnInstance();

    }

    private void createSequencFlows(CamundaObject camundaObject) {
        // TODO Auto-generated method stub

        for(SequenceFlow flow : camundaObject.getSequenceFlow()) {
            if(flow.getSourceRef().startsWith(DiagramConstants.startEvent.toString()) && 
                    flow.getTargetRef().startsWith(DiagramConstants.userTask.toString())){
                UserTask task = listOfUserTask.stream().filter(result->result.getId().equals(flow.getTargetRef())).findAny().orElseThrow(()->new SchemaException("Schema not in proper format"));
                helpClass.createSequenceFlow(helpClass.process, startEvent,task, 
                        helpClass.plane, flow.getWaypoints().stream().mapToInt(Integer::intValue).toArray());
            }
            else if(flow.getSourceRef().startsWith(DiagramConstants.userTask.toString()) &&
                    flow.getTargetRef().startsWith(DiagramConstants.userTask.toString())) {
                UserTask taskIncoming = listOfUserTask.stream().filter(result->result.getId().equals(flow.getSourceRef())).findAny().orElseThrow(()->new SchemaException("Schema not in proper format"));
                UserTask taskOutgoing = listOfUserTask.stream().filter(result->result.getId().equals(flow.getTargetRef())).findAny().orElseThrow(()->new SchemaException("Schema not in proper format"));
                helpClass.createSequenceFlow(helpClass.process, taskIncoming,taskOutgoing, 
                        helpClass.plane, flow.getWaypoints().stream().mapToInt(Integer::intValue).toArray());
            }
            else if(flow.getSourceRef().startsWith(DiagramConstants.userTask.toString()) &&
                    flow.getTargetRef().startsWith(DiagramConstants.endEvent.toString())) {
                UserTask task = listOfUserTask.stream().filter(result->result.getId().equals(flow.getSourceRef())).findAny().orElseThrow(()->new SchemaException("Schema not in proper format"));
                helpClass.createSequenceFlow(helpClass.process, task,endEvent, 
                        helpClass.plane, flow.getWaypoints().stream().mapToInt(Integer::intValue).toArray());
            }
        }
    }

    private void writeBpmnInstance() throws Exception {
        // TODO Auto-generated method stub
        File file = File.createTempFile("bpmn-model-api-", ".bpmn",new File("/home/tanmaynaik/Documents/Camunda-FluentApi"));
        Bpmn.writeModelToFile(file, helpClass.modelInstance);
    }

    private void setEventsDetails(List<Event> events, CamundaObject camundaObject) {
        // TODO Auto-generated method stub
        events.forEach(getStartEvent -> {
            if (getStartEvent.getType().equalsIgnoreCase(DiagramConstants.StartEvent.toString())) {
                createStartEvent(getStartEvent, camundaObject);
                getNextProcess(getStartEvent.getId(), getStartEvent.getOutgoing(),  camundaObject);
            }
        });
    }

    private void getNextProcess(String id, List<String> listOfOutgoing, CamundaObject camundaObject) {
        // TODO Auto-generated method stub
        if(!CollectionUtils.isEmpty(listOfOutgoing) && StringUtils.isNotBlank(id)){
            listOfOutgoing.forEach(outgoingObjectId->{
                List<String> outgoingId =  new ArrayList<>();
                String currentObjectId =  "";
                if(outgoingObjectId.startsWith(DiagramConstants.userTask.toString())) {
                    Task task = camundaObject.getTasks().stream().filter(result-> result.getId().equals(outgoingObjectId))
                            .findAny()
                            .orElseThrow(()->new SchemaException("Schema not in proper format"));
                    outgoingId=task.getOutgoing();
                    currentObjectId = task.getId();
                    createUserTask(task,id);
                }
                else if (outgoingObjectId.startsWith(DiagramConstants.endEvent.toString())) {
                    Event events =camundaObject.getEvents().stream().filter(eventsResult->eventsResult.getId().equals(outgoingObjectId))
                            .findAny()
                            .orElseThrow(()-> new SchemaException("Schema not in proper format"));
                    createEndEvent(events);
                }

                if(outgoingId!=null && StringUtils.isNotBlank(currentObjectId))
                    getNextProcess(currentObjectId, outgoingId,  camundaObject);
            });

        }
        else
            throw new SchemaException("Specify Outgoings");
    }


    private void createUserTask(Task task,String id)  {
        UserTask userTask = helpClass.createElement(helpClass.process, task.getId(), task.getName(), UserTask.class,
                helpClass.plane, task.getOrdinateX(), task.getOrdinateY(), task.getHeight(),task.getWidth(), true);
        listOfUserTask.add(userTask);

    }


    private void createStartEvent(Event getStartEvent, CamundaObject camundaObject) {
        // TODO Auto-generated method stub
        startEvent =helpClass.createElement(helpClass.process, getStartEvent.getId(), getStartEvent.getName(), StartEvent.class,
                helpClass.plane, getStartEvent.getOrdinateX(),getStartEvent.getOrdinateY(), getStartEvent.getHeight(), getStartEvent.getWidth(), true);
    }

    private void setProcessDetails(ProcessName processName) {
        // TODO Auto-generated method stub
        helpClass.create();

    }
    private void createEndEvent(Event endEvents) {
        // TODO Auto-generated method stub
        endEvent = helpClass.createElement(helpClass.process,endEvents.getId(),endEvents.getName(), EndEvent.class,
                helpClass.plane, endEvents.getOrdinateX(),endEvents.getOrdinateY(), endEvents.getHeight(), endEvents.getWidth(), true);
        //helpClass.createSequenceFlow(helpClass.process, userTask, endEvent, helpClass.plane, 80, 30, 190, 40);

    }

}

这是主要的帮助程序类，您将创建节点并设计结构

package com.camundafluent.diagram.model;

import org.camunda.bpm.model.bpmn.Bpmn;
import org.camunda.bpm.model.bpmn.BpmnModelInstance;
import org.camunda.bpm.model.bpmn.instance.BaseElement;
import org.camunda.bpm.model.bpmn.instance.BpmnModelElementInstance;
import org.camunda.bpm.model.bpmn.instance.Definitions;
import org.camunda.bpm.model.bpmn.instance.FlowNode;
import org.camunda.bpm.model.bpmn.instance.Process;
import org.camunda.bpm.model.bpmn.instance.SequenceFlow;
import org.camunda.bpm.model.bpmn.instance.bpmndi.BpmnDiagram;
import org.camunda.bpm.model.bpmn.instance.bpmndi.BpmnEdge;
import org.camunda.bpm.model.bpmn.instance.bpmndi.BpmnLabel;
import org.camunda.bpm.model.bpmn.instance.bpmndi.BpmnPlane;
import org.camunda.bpm.model.bpmn.instance.bpmndi.BpmnShape;
import org.camunda.bpm.model.bpmn.instance.dc.Bounds;
import org.camunda.bpm.model.bpmn.instance.di.Waypoint;

public class HelpClass {
    public BpmnModelInstance modelInstance;
    public Definitions definitions;
    public Process process;
    public BpmnPlane plane;

    public class create {}

    public void create() {

        modelInstance = Bpmn.createEmptyModel();

        definitions = modelInstance.newInstance(Definitions.class);
        definitions.setTargetNamespace("http://camunda.org/examples");
        modelInstance.setDefinitions(definitions);

        process = modelInstance.newInstance(Process.class);
        process.setId("process");
        process.setName("TestProcess");
        process.setExecutable(true);
        definitions.addChildElement(process);

        BpmnDiagram diagram = modelInstance.newInstance(BpmnDiagram.class);
        plane = modelInstance.newInstance(BpmnPlane.class);
        plane.setBpmnElement(process);
        diagram.setBpmnPlane(plane);
        definitions.addChildElement(diagram);

    }

    // public <T extends BpmnModelElementInstance> T
    // createElement(BpmnModelElementInstance parentElement, String id, Class<T>
    // elementClass) {
    // T element = modelInstance.newInstance(elementClass);
    // element.setAttributeValue("id", id, true);
    // parentElement.addChildElement(element);
    // return element;
    // }

    public <T extends BpmnModelElementInstance> T createElement(BpmnModelElementInstance parentElement, String id,
            String name, Class<T> elementClass, BpmnPlane plane, double x, double y, double heigth, double width,
            boolean withLabel) {
        T element = modelInstance.newInstance(elementClass);
        element.setAttributeValue("id", id, true);
        element.setAttributeValue("name", name, false);
        parentElement.addChildElement(element);

        BpmnShape bpmnShape = modelInstance.newInstance(BpmnShape.class);
        bpmnShape.setBpmnElement((BaseElement) element);

        Bounds bounds = modelInstance.newInstance(Bounds.class);
        bounds.setX(x);
        bounds.setY(y);
        bounds.setHeight(heigth);
        bounds.setWidth(width);
        bpmnShape.setBounds(bounds);

        if (withLabel) {
            BpmnLabel bpmnLabel = modelInstance.newInstance(BpmnLabel.class);
            Bounds labelBounds = modelInstance.newInstance(Bounds.class);
            labelBounds.setX(x);
            labelBounds.setY(y + heigth);
            labelBounds.setHeight(heigth);
            labelBounds.setWidth(width);
            bpmnLabel.addChildElement(labelBounds);
            bpmnShape.addChildElement(bpmnLabel);
        }
        plane.addChildElement(bpmnShape);

        return element;
    }

    // public SequenceFlow createSequenceFlow(Process process, FlowNode from,
    // FlowNode to) {
    // String identifier = from.getId() + "-" + to.getId();
    // SequenceFlow sequenceFlow = createElement(process, identifier,
    // SequenceFlow.class);
    // process.addChildElement(sequenceFlow);
    // sequenceFlow.setSource(from);
    // from.getOutgoing().add(sequenceFlow);
    // sequenceFlow.setTarget(to);
    // to.getIncoming().add(sequenceFlow);
    // return sequenceFlow;
    // }

    public SequenceFlow createSequenceFlow(Process process, FlowNode from, FlowNode to, BpmnPlane plane,
            int... waypoints) {
        String identifier = from.getId() + "-" + to.getId();
        SequenceFlow sequenceFlow = modelInstance.newInstance(SequenceFlow.class);
        sequenceFlow.setAttributeValue("id", identifier, true);
        process.addChildElement(sequenceFlow);
        sequenceFlow.setSource(from);
        from.getOutgoing().add(sequenceFlow);
        sequenceFlow.setTarget(to);
        to.getIncoming().add(sequenceFlow);

        BpmnEdge bpmnEdge = modelInstance.newInstance(BpmnEdge.class);
        bpmnEdge.setBpmnElement(sequenceFlow);
        for (int i = 0; i < waypoints.length / 2; i++) {
            double waypointX = waypoints[i * 2];
            double waypointY = waypoints[i * 2 + 1];
            Waypoint wp = modelInstance.newInstance(Waypoint.class);
            wp.setX(waypointX);
            wp.setY(waypointY);
            bpmnEdge.addChildElement(wp);
        }
        plane.addChildElement(bpmnEdge);

        return sequenceFlow;
    }

}

我已经对宽度，高度和坐标进行了硬编码，但可以像camunda在那里创建类那样创建一些逻辑