Java Process类代码示例

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
public static ProcessBuilder createProcess() {
  BpmnModelInstance modelInstance = INSTANCE.doCreateEmptyModel();
  Definitions definitions = modelInstance.newInstance(Definitions.class);
  definitions.setTargetNamespace(BPMN20_NS);
  definitions.getDomElement().registerNamespace("camunda", CAMUNDA_NS);
  modelInstance.setDefinitions(definitions);
  Process process = modelInstance.newInstance(Process.class);
  definitions.addChildElement(process);

  BpmnDiagram bpmnDiagram = modelInstance.newInstance(BpmnDiagram.class);

  BpmnPlane bpmnPlane = modelInstance.newInstance(BpmnPlane.class);
  bpmnPlane.setBpmnElement(process);

  bpmnDiagram.addChildElement(bpmnPlane);
  definitions.addChildElement(bpmnDiagram);

  return process.builder();
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
@Test
public void createProcessWithParallelGateway() {
  // create process
  Process process = createElement(definitions, "process-with-parallel-gateway", Process.class);

  // create elements
  StartEvent startEvent = createElement(process, "start", StartEvent.class);
  ParallelGateway fork = createElement(process, "fork", ParallelGateway.class);
  UserTask task1 = createElement(process, "task1", UserTask.class);
  ServiceTask task2 = createElement(process, "task2", ServiceTask.class);
  ParallelGateway join = createElement(process, "join", ParallelGateway.class);
  EndEvent endEvent = createElement(process, "end", EndEvent.class);

  // create flows
  createSequenceFlow(process, startEvent, fork);
  createSequenceFlow(process, fork, task1);
  createSequenceFlow(process, fork, task2);
  createSequenceFlow(process, task1, join);
  createSequenceFlow(process, task2, join);
  createSequenceFlow(process, join, endEvent);
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
@Test
@BpmnModelResource
public void shouldImportProcess() {

  ModelElementInstance modelElementById = bpmnModelInstance.getModelElementById("exampleProcessId");
  assertThat(modelElementById).isNotNull();

  Collection<RootElement> rootElements = bpmnModelInstance.getDefinitions().getRootElements();
  assertThat(rootElements).hasSize(1);
  org.camunda.bpm.model.bpmn.instance.Process process = (Process) rootElements.iterator().next();

  assertThat(process.getId()).isEqualTo("exampleProcessId");
  assertThat(process.getName()).isNull();
  assertThat(process.getProcessType()).isEqualTo(ProcessType.None);
  assertThat(process.isExecutable()).isFalse();
  assertThat(process.isClosed()).isFalse();



}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
@Test
public void testCreateEmptyProcess() {
  modelInstance = Bpmn.createProcess()
    .done();

  Definitions definitions = modelInstance.getDefinitions();
  assertThat(definitions).isNotNull();
  assertThat(definitions.getTargetNamespace()).isEqualTo(BPMN20_NS);

  Collection<ModelElementInstance> processes = modelInstance.getModelElementsByType(processType);
  assertThat(processes)
    .hasSize(1);

  Process process = (Process) processes.iterator().next();
  assertThat(process.getId()).isNotNull();
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
@Before
public void createModel() {
  testBpmnModelInstance = Bpmn.createEmptyModel();
  Definitions definitions = testBpmnModelInstance.newInstance(Definitions.class);
  testBpmnModelInstance.setDefinitions(definitions);

  message = testBpmnModelInstance.newInstance(Message.class);
  message.setId("message-id");
  definitions.getRootElements().add(message);

  Process process = testBpmnModelInstance.newInstance(Process.class);
  process.setId("process-id");
  definitions.getRootElements().add(process);

  startEvent = testBpmnModelInstance.newInstance(StartEvent.class);
  startEvent.setId("start-event-id");
  process.getFlowElements().add(startEvent);

  messageEventDefinition = testBpmnModelInstance.newInstance(MessageEventDefinition.class);
  messageEventDefinition.setId("msg-def-id");
  messageEventDefinition.setMessage(message);
  startEvent.getEventDefinitions().add(messageEventDefinition);

  startEvent.getEventDefinitionRefs().add(messageEventDefinition);
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
public void testJavaDelegateModelExecutionContext() {
  deploy();

  runtimeService.startProcessInstanceByKey(PROCESS_ID);

  BpmnModelInstance modelInstance = ModelExecutionContextServiceTask.modelInstance;
  assertNotNull(modelInstance);

  Model model = modelInstance.getModel();
  Collection<ModelElementInstance> events = modelInstance.getModelElementsByType(model.getType(Event.class));
  assertEquals(2, events.size());
  Collection<ModelElementInstance> tasks = modelInstance.getModelElementsByType(model.getType(Task.class));
  assertEquals(1, tasks.size());

  Process process = (Process) modelInstance.getDefinitions().getRootElements().iterator().next();
  assertEquals(PROCESS_ID, process.getId());
  assertTrue(process.isExecutable());

  ServiceTask serviceTask = ModelExecutionContextServiceTask.serviceTask;
  assertNotNull(serviceTask);
  assertEquals(ModelExecutionContextServiceTask.class.getName(), serviceTask.getCamundaClass());
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
/**
 * @return start -> user -> end
 */
public static BpmnModelInstance build(String key, String versionTag) {
  BpmnModelInstance modelInstance = build(key);

  Collection<Process> modelElementsByType = modelInstance.getModelElementsByType(Process.class);
  Process process = modelElementsByType.iterator().next();
  process.setAttributeValueNs("http://camunda.org/schema/1.0/bpmn", "versionTag", versionTag);

  return modelInstance;
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
public static void registerType(ModelBuilder modelBuilder) {
  ModelElementTypeBuilder typeBuilder = modelBuilder.defineType(Participant.class, BPMN_ELEMENT_PARTICIPANT)
    .namespaceUri(BPMN20_NS)
    .extendsType(BaseElement.class)
    .instanceProvider(new ModelTypeInstanceProvider<Participant>() {
      public Participant newInstance(ModelTypeInstanceContext instanceContext) {
        return new ParticipantImpl(instanceContext);
      }
    });

  nameAttribute = typeBuilder.stringAttribute(BPMN_ATTRIBUTE_NAME)
    .build();

  processRefAttribute = typeBuilder.stringAttribute(BPMN_ATTRIBUTE_PROCESS_REF)
    .qNameAttributeReference(Process.class)
    .build();

  SequenceBuilder sequenceBuilder = typeBuilder.sequence();

  interfaceRefCollection = sequenceBuilder.elementCollection(InterfaceRef.class)
    .qNameElementReferenceCollection(Interface.class)
    .build();

  endPointRefCollection = sequenceBuilder.elementCollection(EndPointRef.class)
    .qNameElementReferenceCollection(EndPoint.class)
    .build();

  participantMultiplicityChild = sequenceBuilder.element(ParticipantMultiplicity.class)
    .build();

  typeBuilder.build();
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
public SequenceFlow createSequenceFlow(Process process, FlowNode from, FlowNode to) {
  SequenceFlow sequenceFlow = createElement(process, from.getId() + "-" + to.getId(), SequenceFlow.class);
  process.addChildElement(sequenceFlow);
  sequenceFlow.setSource(from);
  from.getOutgoing().add(sequenceFlow);
  sequenceFlow.setTarget(to);
  to.getIncoming().add(sequenceFlow);
  return sequenceFlow;
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
@Test
public void createProcessWithOneTask() {
  // create process
  Process process = createElement(definitions, "process-with-one-task", Process.class);

  // create elements
  StartEvent startEvent = createElement(process, "start", StartEvent.class);
  UserTask task1 = createElement(process, "task1", UserTask.class);
  EndEvent endEvent = createElement(process, "end", EndEvent.class);

  // create flows
  createSequenceFlow(process, startEvent, task1);
  createSequenceFlow(process, task1, endEvent);
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
@Override
public void validate(Process process, ValidationResultCollector validationResultCollector) {
  Collection<StartEvent> startEvents = process.getChildElementsByType(StartEvent.class);
  int startEventCount = startEvents.size();

  if(startEventCount != 1) {
    validationResultCollector.addError(10, String.format("Process does not have exactly one start event. Got %d.", startEventCount));
  }
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
@Test
public void shouldNotGenerateIdsOnRead() {
  BpmnModelInstance modelInstance = Bpmn.readModelFromStream(GenerateIdTest.class.getResourceAsStream("GenerateIdTest.bpmn"));
  Definitions definitions = modelInstance.getDefinitions();
  assertThat(definitions.getId()).isNull();

  Process process = modelInstance.getModelElementsByType(Process.class).iterator().next();
  assertThat(process.getId()).isNull();

  StartEvent startEvent = modelInstance.getModelElementsByType(StartEvent.class).iterator().next();
  assertThat(startEvent.getId()).isNull();

  UserTask userTask = modelInstance.getModelElementsByType(UserTask.class).iterator().next();
  assertThat(userTask.getId()).isNull();
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
@Test
public void shouldGenerateIdsOnCreate() {
  BpmnModelInstance modelInstance = Bpmn.createEmptyModel();
  Definitions definitions = modelInstance.newInstance(Definitions.class);
  assertThat(definitions.getId()).isNotNull();

  Process process = modelInstance.newInstance(Process.class);
  assertThat(process.getId()).isNotNull();

  StartEvent startEvent = modelInstance.newInstance(StartEvent.class);
  assertThat(startEvent.getId()).isNotNull();

  UserTask userTask = modelInstance.newInstance(UserTask.class);
  assertThat(userTask.getId()).isNotNull();
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
@BeforeClass
public static void getElementTypes() {
  Model model = Bpmn.createEmptyModel().getModel();
  taskType = model.getType(Task.class);
  gatewayType = model.getType(Gateway.class);
  eventType = model.getType(Event.class);
  processType = model.getType(Process.class);
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
@Test
public void testProcessCamundaExtensions() {
  modelInstance = Bpmn.createProcess(PROCESS_ID)
    .camundaJobPriority("${somePriority}")
    .camundaTaskPriority(TEST_PROCESS_TASK_PRIORITY)
    .camundaHistoryTimeToLive(TEST_HISTORY_TIME_TO_LIVE)
    .startEvent()
    .endEvent()
    .done();

  Process process = modelInstance.getModelElementById(PROCESS_ID);
  assertThat(process.getCamundaJobPriority()).isEqualTo("${somePriority}");
  assertThat(process.getCamundaTaskPriority()).isEqualTo(TEST_PROCESS_TASK_PRIORITY);
  assertThat(process.getCamundaHistoryTimeToLive()).isEqualTo(TEST_HISTORY_TIME_TO_LIVE);
}