添加微服务节点

flow-common/flow-common-flowable-starter/src/main/java/com/flow/flowable/behavior/MicroActivityBehavior.java

@@ -0,0 +1,47 @@
+package com.flow.flowable.behavior;
+
+import com.flow.flowable.event.CustomFlowableEngineEvent;
+import com.flow.flowable.event.CustomFlowableEventType;
+import org.flowable.common.engine.api.delegate.Expression;
+import org.flowable.common.engine.api.delegate.event.FlowableEventDispatcher;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.impl.bpmn.behavior.AbstractBpmnActivityBehavior;
+import org.flowable.engine.impl.cfg.ProcessEngineConfigurationImpl;
+import org.flowable.engine.impl.persistence.entity.ExecutionEntityImpl;
+import org.flowable.engine.impl.util.CommandContextUtil;
+import org.flowable.http.common.impl.ExpressionUtils;
+
+import java.util.Objects;
+
+public class MicroActivityBehavior extends AbstractBpmnActivityBehavior {
+    private static final long serialVersionUID = 1L;
+    protected Expression serviceId;
+    protected Expression url;
+    protected Expression method;
+    protected Expression headers;
+    protected Expression params;
+    protected Expression body;
+    protected Expression responseVariableName;
+
+    @Override
+    public void execute(DelegateExecution execution) {
+        ProcessEngineConfigurationImpl processEngineConfiguration = CommandContextUtil.getProcessEngineConfiguration();
+        // 发送请求
+        String serviceId = ExpressionUtils.getStringFromField(this.serviceId, execution);
+        String url = ExpressionUtils.getStringFromField(this.url, execution);
+        String method = ExpressionUtils.getStringFromField(this.method, execution);
+        String headers = ExpressionUtils.getStringFromField(this.headers, execution);
+        String params = ExpressionUtils.getStringFromField(this.params, execution);
+        String body = ExpressionUtils.getStringFromField(this.body, execution);
+        String responseVariableName = ExpressionUtils.getStringFromField(this.responseVariableName, execution);
+
+
+        // 发送事件
+        FlowableEventDispatcher eventDispatcher = processEngineConfiguration.getEventDispatcher();
+        if (Objects.nonNull(eventDispatcher) && eventDispatcher.isEnabled()) {
+            CustomFlowableEngineEvent customFlowableEngineEvent = new CustomFlowableEngineEvent((ExecutionEntityImpl) execution, CustomFlowableEventType.MICRO_EXECUTE);
+            eventDispatcher.dispatchEvent(customFlowableEngineEvent, processEngineConfiguration.getEngineCfgKey());
+        }
+        leave(execution);
+    }
+}

flow-common/flow-common-flowable-starter/src/main/java/com/flow/flowable/configure/FlowableConfigure.java

@@ -4,11 +4,13 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import com.flow.flowable.converter.CopyServiceTaskXMLConverter;
 import com.flow.flowable.converter.CustomServiceTaskXMLConverter;
 import com.flow.flowable.converter.JumpServiceTaskXMLConverter;
+import com.flow.flowable.converter.MicroServiceTaskXMLConverter;
 import com.flow.flowable.expression.VariableBetweenExpressionFunction;
 import com.flow.flowable.expression.VariableContainsAllExpressionFunction;
 import com.flow.flowable.parser.factory.CustomDefaultActivityBehaviorFactory;
 import com.flow.flowable.parser.handler.CopyServiceTaskParseHandler;
 import com.flow.flowable.parser.handler.JumpServiceTaskParseHandler;
+import com.flow.flowable.parser.handler.MicroServiceTaskParseHandler;
 import com.flow.flowable.validator.CustomServiceTaskValidator;
 import org.flowable.bpmn.converter.BpmnXMLConverter;
 import org.flowable.common.engine.api.delegate.FlowableFunctionDelegate;
@@ -52,6 +54,7 @@ public class FlowableConfigure implements EngineConfigurationConfigurer<SpringPr
         List<BpmnParseHandler> bpmnParseHandlers = new ArrayList<>();
         bpmnParseHandlers.add(new CopyServiceTaskParseHandler());
         bpmnParseHandlers.add(new JumpServiceTaskParseHandler());
+        bpmnParseHandlers.add(new MicroServiceTaskParseHandler());
         engineConfiguration.setPostBpmnParseHandlers(bpmnParseHandlers);
         engineConfiguration.setCustomServiceTaskValidator(new CustomServiceTaskValidator());
         engineConfiguration.setActivityBehaviorFactory(new CustomDefaultActivityBehaviorFactory());
@@ -61,6 +64,7 @@ public class FlowableConfigure implements EngineConfigurationConfigurer<SpringPr
         engineConfiguration.setCustomFlowableFunctionDelegates(customFlowableFunctionDelegates);
         BpmnXMLConverter.addConverter(new JumpServiceTaskXMLConverter());
         BpmnXMLConverter.addConverter(new CopyServiceTaskXMLConverter());
+        BpmnXMLConverter.addConverter(new MicroServiceTaskXMLConverter());
         BpmnXMLConverter.addConverter(new CustomServiceTaskXMLConverter());
         if (Objects.nonNull(this.objectMapper)) {
             engineConfiguration.setObjectMapper(this.objectMapper);

flow-common/flow-common-flowable-starter/src/main/java/com/flow/flowable/converter/CustomServiceTaskXMLConverter.java

@@ -1,14 +1,19 @@
 package com.flow.flowable.converter;
 
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.flow.flowable.model.CopyServiceTask;
 import com.flow.flowable.model.JumpServiceTask;
+import com.flow.flowable.model.MicroServiceTask;
 import com.flow.flowable.utils.ProcessElementUtil;
 import org.flowable.bpmn.converter.ServiceTaskXMLConverter;
 import org.flowable.bpmn.model.BaseElement;
 import org.flowable.bpmn.model.BpmnModel;
 import org.flowable.bpmn.model.ServiceTask;
+import org.flowable.engine.impl.util.CommandContextUtil;
 
 import javax.xml.stream.XMLStreamReader;
+import java.util.Map;
 
 public class CustomServiceTaskXMLConverter extends ServiceTaskXMLConverter {
     public CustomServiceTaskXMLConverter() {
@@ -31,6 +36,11 @@ public class CustomServiceTaskXMLConverter extends ServiceTaskXMLConverter {
                 jumpServiceTask.setValues(serviceTask);
                 this.convertJumpServiceTaskXMLProperties(jumpServiceTask, model, xtr);
                 return jumpServiceTask;
+            } else if ("micro".equals(serviceTaskType)) {
+                MicroServiceTask microServiceTask = new MicroServiceTask();
+                microServiceTask.setValues(serviceTask);
+                this.convertMicroServiceTaskXMLProperties(microServiceTask, model, xtr);
+                return microServiceTask;
             }
         }
         return baseElement;
@@ -45,4 +55,22 @@ public class CustomServiceTaskXMLConverter extends ServiceTaskXMLConverter {
         String targetNode = ProcessElementUtil.getFieldExtensionValue(jumpServiceTask, "targetNode");
         jumpServiceTask.setTargetNode(targetNode);
     }
+
+    protected void convertMicroServiceTaskXMLProperties(MicroServiceTask microServiceTask, BpmnModel bpmnModel, XMLStreamReader xtr) throws Exception {
+        String serviceId = ProcessElementUtil.getFieldExtensionValue(microServiceTask, "serviceId");
+        String url = ProcessElementUtil.getFieldExtensionValue(microServiceTask, "url");
+        String method = ProcessElementUtil.getFieldExtensionValue(microServiceTask, "method");
+        String headers = ProcessElementUtil.getFieldExtensionValue(microServiceTask, "headers");
+        String params = ProcessElementUtil.getFieldExtensionValue(microServiceTask, "params");
+        String body = ProcessElementUtil.getFieldExtensionValue(microServiceTask, "body");
+        String responseVariableName = ProcessElementUtil.getFieldExtensionValue(microServiceTask, "responseVariableName");
+        microServiceTask.setServiceId(serviceId);
+        microServiceTask.setUrl(url);
+        microServiceTask.setMethod(method);
+        ObjectMapper objectMapper = CommandContextUtil.getProcessEngineConfiguration().getObjectMapper();
+        microServiceTask.setHeaders(objectMapper.readValue(headers, new TypeReference<Map<String, Object>>() {}));
+        microServiceTask.setParams(objectMapper.readValue(params, new TypeReference<Map<String, Object>>() {}));
+        microServiceTask.setBody(objectMapper.readValue(body, new TypeReference<Map<String, Object>>() {}));
+        microServiceTask.setResponseVariableName(responseVariableName);
+    }
 }

flow-common/flow-common-flowable-starter/src/main/java/com/flow/flowable/converter/MicroServiceTaskXMLConverter.java

@@ -0,0 +1,15 @@
+package com.flow.flowable.converter;
+
+import com.flow.flowable.model.MicroServiceTask;
+import org.flowable.bpmn.converter.ServiceTaskXMLConverter;
+import org.flowable.bpmn.model.BaseElement;
+
+public class MicroServiceTaskXMLConverter extends ServiceTaskXMLConverter {
+    public MicroServiceTaskXMLConverter() {
+    }
+
+    public Class<? extends BaseElement> getBpmnElementType() {
+        return MicroServiceTask.class;
+    }
+
+}

flow-common/flow-common-flowable-starter/src/main/java/com/flow/flowable/event/CustomFlowableEventType.java

@@ -4,5 +4,6 @@ import org.flowable.common.engine.api.delegate.event.FlowableEventType;
 
 public enum CustomFlowableEventType implements FlowableEventType {
     ACTIVITY_JUMP,
-    PROCESS_COPY
+    PROCESS_COPY,
+    MICRO_EXECUTE
 }

flow-common/flow-common-flowable-starter/src/main/java/com/flow/flowable/model/MicroServiceTask.java

@@ -0,0 +1,91 @@
+package com.flow.flowable.model;
+
+import org.flowable.bpmn.model.ServiceTask;
+
+import java.util.Map;
+
+public class MicroServiceTask extends ServiceTask {
+    protected String serviceId;
+    protected String url;
+    protected String method;
+    protected Map<String, Object> headers;
+    protected Map<String, Object> params;
+    protected Map<String, Object> body;
+    protected String responseVariableName;
+
+    public MicroServiceTask() {
+    }
+
+    public String getServiceId() {
+        return serviceId;
+    }
+
+    public void setServiceId(String serviceId) {
+        this.serviceId = serviceId;
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+    public String getMethod() {
+        return method;
+    }
+
+    public void setMethod(String method) {
+        this.method = method;
+    }
+
+    public Map<String, Object> getHeaders() {
+        return headers;
+    }
+
+    public void setHeaders(Map<String, Object> headers) {
+        this.headers = headers;
+    }
+
+    public Map<String, Object> getParams() {
+        return params;
+    }
+
+    public void setParams(Map<String, Object> params) {
+        this.params = params;
+    }
+
+    public Map<String, Object> getBody() {
+        return body;
+    }
+
+    public void setBody(Map<String, Object> body) {
+        this.body = body;
+    }
+
+    public String getResponseVariableName() {
+        return responseVariableName;
+    }
+
+    public void setResponseVariableName(String responseVariableName) {
+        this.responseVariableName = responseVariableName;
+    }
+
+    public MicroServiceTask clone() {
+        MicroServiceTask clone = new MicroServiceTask();
+        clone.setValues(this);
+        return clone;
+    }
+
+
+    public void setValues(MicroServiceTask otherElement) {
+        super.setValues(otherElement);
+        this.setServiceId(otherElement.getServiceId());
+        this.setUrl(otherElement.getUrl());
+        this.setMethod(otherElement.getMethod());
+        this.setHeaders(otherElement.getHeaders());
+        this.setParams(otherElement.getParams());
+        this.setResponseVariableName(otherElement.getResponseVariableName());
+    }
+}

flow-common/flow-common-flowable-starter/src/main/java/com/flow/flowable/parser/factory/CustomDefaultActivityBehaviorFactory.java

@@ -2,6 +2,7 @@ package com.flow.flowable.parser.factory;
 
 import com.flow.flowable.behavior.CopyActivityBehavior;
 import com.flow.flowable.behavior.JumpActivityBehavior;
+import com.flow.flowable.behavior.MicroActivityBehavior;
 import org.flowable.bpmn.model.ServiceTask;
 import org.flowable.engine.impl.bpmn.helper.ClassDelegate;
 import org.flowable.engine.impl.bpmn.parser.FieldDeclaration;
@@ -22,4 +23,9 @@ public class CustomDefaultActivityBehaviorFactory extends DefaultActivityBehavio
         return (JumpActivityBehavior) ClassDelegate.defaultInstantiateDelegate(JumpActivityBehavior.class, fieldDeclarations);
     }
 
+        public MicroActivityBehavior createMicroActivityBehavior(ServiceTask serviceTask) {
+        List<FieldDeclaration> fieldDeclarations = super.createFieldDeclarations(serviceTask.getFieldExtensions());
+        return (MicroActivityBehavior) ClassDelegate.defaultInstantiateDelegate(MicroActivityBehavior.class, fieldDeclarations);
+    }
+
 }

flow-common/flow-common-flowable-starter/src/main/java/com/flow/flowable/parser/handler/MicroServiceTaskParseHandler.java

@@ -0,0 +1,22 @@
+package com.flow.flowable.parser.handler;
+
+import com.flow.flowable.model.MicroServiceTask;
+import com.flow.flowable.parser.factory.CustomDefaultActivityBehaviorFactory;
+import org.flowable.bpmn.model.BaseElement;
+import org.flowable.bpmn.model.ServiceTask;
+import org.flowable.engine.impl.bpmn.parser.BpmnParse;
+import org.flowable.engine.impl.bpmn.parser.handler.AbstractActivityBpmnParseHandler;
+
+public class MicroServiceTaskParseHandler extends AbstractActivityBpmnParseHandler<ServiceTask> {
+    @Override
+    public Class<? extends BaseElement> getHandledType() {
+        return MicroServiceTask.class;
+    }
+
+    @Override
+    protected void executeParse(BpmnParse bpmnParse, ServiceTask serviceTask) {
+        CustomDefaultActivityBehaviorFactory activityBehaviorFactory = (CustomDefaultActivityBehaviorFactory) bpmnParse.getActivityBehaviorFactory();
+        serviceTask.setBehavior(activityBehaviorFactory.createMicroActivityBehavior(serviceTask));
+    }
+
+}

flow-common/flow-common-flowable-starter/src/main/java/com/flow/flowable/validator/CustomServiceTaskValidator.java

@@ -21,6 +21,8 @@ public class CustomServiceTaskValidator extends ServiceTaskValidator {
                 this.validateFieldDeclarationsForCopy(process, serviceTask, serviceTask.getFieldExtensions(), errors);
             } else if (type.equalsIgnoreCase("jump")) {
                 this.validateFieldDeclarationsForJump(process, serviceTask, serviceTask.getFieldExtensions(), errors);
+            } else if (type.equalsIgnoreCase("micro")) {
+                this.validateFieldDeclarationsForMicro(process, serviceTask, serviceTask.getFieldExtensions(), errors);
             } else {
                 super.verifyType(process, serviceTask, errors);
             }
@@ -40,4 +42,17 @@ public class CustomServiceTaskValidator extends ServiceTaskValidator {
             addError(errors, "flowable-jumpTask-no-targetNode", process, task, "跳转节点缺少targetNode属性");
         }
     }
+
+    private void validateFieldDeclarationsForMicro(Process process, TaskWithFieldExtensions task, List<FieldExtension> fieldExtensions, List<ValidationError> errors) {
+        String url = ProcessElementUtil.getFieldExtensionValue(task, "url");
+        if (StringUtils.isBlank(url)) {
+            addError(errors, "flowable-microTask-no-url", process, task, "微服务节点缺少url属性");
+        }
+        String method = ProcessElementUtil.getFieldExtensionValue(task, "method");
+        if (StringUtils.isBlank(method)) {
+            addError(errors, "flowable-microTask-no-method", process, task, "微服务节点缺少method属性");
+        }
+
+    }
+
 }