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);
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
public Collection<FlowDefinition> fromBpmnXml(InputStream bpmnStream) {
    BpmnModelInstance modelInstance = Bpmn.readModelFromStream(bpmnStream);
    Collection<Process> processes = modelInstance.getModelElementsByType(Process.class);

    List<FlowDefinition> flowDefinitions = new ArrayList<FlowDefinition>();

    for (Process process: processes) {
        flowDefinitions.add(new BpmnProcessFlowBuilder(process).getDefinition());
    }
    return flowDefinitions;
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
public ModifiableBpmnModelInstance addDocumentation(String content) {
  Collection<Process> processes = modelInstance.getModelElementsByType(Process.class);
  Documentation documentation = modelInstance.newInstance(Documentation.class);
  documentation.setTextContent(content);
  for (Process process : processes) {
    process.addChildElement(documentation);
  }
  return this;
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
private void assertModelInstance() {
  BpmnModelInstance modelInstance = ModelExecutionContextTaskListener.modelInstance;
  assertNotNull(modelInstance);

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

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

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

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
private static List<String> extractProcessDefinitionKeys(List<String> deployableFileNames) {
  ArrayList<String> keys = new ArrayList<String>();
  for (String file : deployableFileNames) {
    if(file.endsWith(".bpmn") || file.endsWith(".bpmn20.xml")) {
      BpmnModelInstance modelInstance = Bpmn.readModelFromFile(new File(file));
      Collection<Process> processes = modelInstance.getModelElementsByType(Process.class);
      for (Process process : processes) {
        if(process.isExecutable()) {
          keys.add(process.getId());
        }
      }
    }
  }
  return keys;
}
 

import org.camunda.bpm.model.bpmn.instance.Process; //导入依赖的package包/类
public static void main(String[] args) throws InterruptedException {

    final Properties properties = PerfTestProcessEngine.loadProperties();
    final ProcessEngine processEngine = PerfTestProcessEngine.getInstance();

    final LoadGeneratorConfiguration config = new LoadGeneratorConfiguration();
    config.setColor(Boolean.parseBoolean(properties.getProperty("loadGenerator.colorOutput", "false")));
    config.setNumberOfIterations(Integer.parseInt(properties.getProperty("loadGenerator.numberOfIterations", "10000")));

    final List<BpmnModelInstance> modelInstances = createProcesses(config.getNumberOfIterations());

    Runnable[] setupTasks = new Runnable[] {
        new DeployModelInstancesTask(processEngine, modelInstances)
    };
    config.setSetupTasks(setupTasks);

    ProcessEngineConfigurationImpl processEngineConfiguration = (ProcessEngineConfigurationImpl) processEngine.getProcessEngineConfiguration();
    processEngineConfiguration.setMetricsEnabled(true);
    processEngineConfiguration.getDbMetricsReporter().setReporterId(REPORTER_ID);
    final Runnable[] workerRunnables = new Runnable[2];
    Process process = modelInstances.get(0).getModelElementsByType(Process.class).iterator().next();
    String processDefKey = process.getId();
    workerRunnables[0] = new StartProcessInstanceTask(processEngine, processDefKey);
    workerRunnables[1] = new GenerateMetricsTask(processEngine);
    config.setWorkerTasks(workerRunnables);

    new LoadGenerator(config).execute();

    System.out.println(processEngine.getHistoryService().createHistoricProcessInstanceQuery().count()+ " Process Instances in DB");
    processEngineConfiguration.setMetricsEnabled(false);
  }