Activiti实战

 List<Task> taskUser = taskService.createTaskQuery()
                .processDefinitionKey(procInstId)
                .taskCandidateOrAssigned(userId)
                .list();

 HistoricTaskInstance task = historyService.createHistoricTaskInstanceQuery()
                .taskDefinitionKey(taskDefKey)
                .processInstanceId(procInstId)
                .singleResult();

HistoricProcessInstance processInstance = historyService
                .createHistoricProcessInstanceQuery()
                .processInstanceId(procInstId)
                .singleResult();

repositoryService.createDeployment()
                .name(deployFile.getOriginalFilename())
                .addZipInputStream(new ZipInputStream(deployFile.getInputStream()))
                .deploy();

repositoryService.createDeployment()
                .name(deployName)
                .addClasspathResource("processes/" + fileName + ".bpmn20.xml")
                .addClasspathResource("processes/" + fileName + ".png")
                .deploy();

ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(procKey);

ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                        .processInstanceId(pi.getId()).singleResult();
if (processInstance == null) {
    historyService.deleteHistoricProcessInstance(pi.getId());
} else {
    runtimeService.deleteProcessInstance(pi.getId()， "");
    historyService.deleteHistoricProcessInstance(pi.getId());
}

public class TaskListenerImpl implements TaskListener {
    @Override
    public void notify(DelegateTask delegateTask) {
        delegateTask.deleteCandidateGroup("manager");
        delegateTask.addCandidateGroup("president");
    }
}

Map<String， Object> variables = new HashMap<String， Object>();
variables.put("hrUserId"， hrUserId);
taskService.complete(taskId， variables);

@Configuration
@AutoConfigureBefore(org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration.class)
public class ActivitiConfiguration implements ProcessEngineConfigurationConfigurer {

    @Resource(name = "customGroupEntityFactory")
    private SessionFactory groupManagerFactory;

    @Resource(name = "customUserEntityFactory")
    private SessionFactory userManagerFactory;

    @Override
    public void configure(SpringProcessEngineConfiguration pec) {
        pec.setDbIdentityUsed(false);
        List<SessionFactory> customSessionFactories = new ArrayList<>();
        customSessionFactories.add(userManagerFactory);
        customSessionFactories.add(groupManagerFactory);
        if (pec.getCustomSessionFactories() == null) {
            pec.setCustomSessionFactories(customSessionFactories);
        } else {
            pec.getCustomSessionFactories().addAll(customSessionFactories);
        }
    }
}

@Service
public class CustomUserEntityFactory implements SessionFactory{
    private CustomUserEntityManager customUserEntityManager;

    @Autowired
    public void setUserEntityManager(CustomUserEntityManager customUserEntityManager) {
        this.customUserEntityManager = customUserEntityManager;
    }

    @Override
    public Class<?> getSessionType() {
        return UserIdentityManager.class;
    }

    @Override
    public Session openSession() {
        return customUserEntityManager;
    }
}

@Service
public class CustomUserEntityManager extends UserEntityManager {

    @Resource
    private OemUserRepo oemUserRepo;
    @Resource
    private CategoryRepo categoryRepo;

    @Override
    public User createNewUser(String userId) {
        return new UserEntity(userId);
    }

    @Override
    public void updateUser(User updatedUser) {
        throw new CustomEntityManagerException(CANNOT_USE_FUNC);
    }

    @Override
    public UserEntity findUserById(String userId) {
        return ActivitiUtil.toActivitiUser(oemUserRepo.getOne(Integer.parseInt(userId)));
    }

    @Override
    public void deleteUser(String userId) {
        throw new CustomEntityManagerException(CANNOT_USE_FUNC);
    }

    @Override
    public List<Group> findGroupsByUser(String userId) {
        List<Group> list = new ArrayList<>();
        // list by customize service
        return list;
    }
    // need override all function
}   

InputStream inputStream = repositoryService.getResourceAsStream(deploymentId, diagramResourceName);

ProcessInstance pi = runtimeService.createProcessInstanceQuery()
        .processInstanceId(processInstanceId)
        .singleResult();
ActivityImpl activityImpl = processDefinitionEntity.findActivity(pi.getActivityId());
modelView.addObject("x", activityImpl.getX());
modelView.addObject("y", activityImpl.getY());
modelView.addObject("width", activityImpl.getWidth());
modelView.addObject("height", activityImpl.getHeight());

Task task=taskService.createTaskQuery().singleResult();
// set assignee
taskService.claim(task.getId(), "billy");
// change assignee and set owner
taskService.delegateTask(task.getId(), "cc");

// suspend process instance 
ProcessInstance pi = runtimeService.createProcessInstanceQuery()
    .processInstanceId(procInstId).singleResult();
    if (!pi.isSuspended()) {
        runtimeService.suspendProcessInstanceById(procInstId);
    }
// active process instance
if (pi.isSuspended()) {
    runtimeService.activateProcessInstanceById(procInstId);
}
// suspend process definition
ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
        .processDefinitionId(procDefId)
        .singleResult();
if (!processDefinition.isSuspended()) {
    repositoryService.suspendProcessDefinitionById(procDefId);
}
// activie process definition
ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
        .processDefinitionId(procDefId)
        .singleResult();
if (processDefinition.isSuspended()) {
    repositoryService.activateProcessDefinitionById(procDefId, true, null);
}

SuspensionState ACTIVE = new SuspensionState.SuspensionStateImpl(1, "active");
SuspensionState SUSPENDED = new SuspensionState.SuspensionStateImpl(2, "suspended");

Model modelData = repositoryService.getModel(modelId);
ObjectNode modelNode = (ObjectNode) new ObjectMapper().readTree(repositoryService.getModelEditorSource(modelData.getId()));
BpmnModel model = new BpmnJsonConverter().convertToBpmnModel(modelNode);
ProcessValidatorFactory processValidatorFactory = new ProcessValidatorFactory();
ProcessValidator defaultProcessValidator = processValidatorFactory.createDefaultProcessValidator();
List<ValidationError> validate = defaultProcessValidator.validate(model);

// deploy
Model modelData = repositoryService.getModel(modelId);
ObjectNode modelNode = (ObjectNode) new ObjectMapper().readTree(repositoryService.getModelEditorSource(modelData.getId()));
BpmnModel model = new BpmnJsonConverter().convertToBpmnModel(modelNode);
String processName = modelData.getName() + ".bpmn20.xml";
repositoryService.createDeployment().name(modelData.getName()).addBpmnModel(processName, model).deploy();
// export xml
Model modelData = repositoryService.getModel(modelId);
BpmnJsonConverter jsonConverter = new BpmnJsonConverter();
JsonNode editorNode = new ObjectMapper().readTree(repositoryService.getModelEditorSource(modelData.getId()));
BpmnModel bpmnModel = jsonConverter.convertToBpmnModel(editorNode);
BpmnXMLConverter xmlConverter = new BpmnXMLConverter();
byte[] bpmnBytes = xmlConverter.convertToXML(bpmnModel);
ByteArrayInputStream in = new ByteArrayInputStream(bpmnBytes);
IOUtils.copy(in, response.getOutputStream());
String filename = bpmnModel.getMainProcess().getId() + ".bpmn20.xml";
response.setHeader("Content-Disposition", "attachment; filename=" + filename);
response.flushBuffer();
// export png
Model modelData = repositoryService.getModel(modelId);
ObjectNode modelNode;
try {
    modelNode = (ObjectNode) new ObjectMapper()
            .readTree(repositoryService.getModelEditorSource(modelData.getId()));
    BpmnModel model = new BpmnJsonConverter().convertToBpmnModel(modelNode);
    ProcessDiagramGenerator processDiagramGenerator = new DefaultProcessDiagramGenerator();
    ProcessEngineConfiguration processEngineConfiguration = ProcessEngines.getDefaultProcessEngine().getProcessEngineConfiguration();
    InputStream inputStream = processDiagramGenerator.generateDiagram(model, "png",
            processEngineConfiguration.getActivityFontName(),
            processEngineConfiguration.getLabelFontName(),
            processEngineConfiguration.getAnnotationFontName(),
            processEngineConfiguration.getClassLoader(), 1.0);
    OutputStream out = response.getOutputStream();
    for (int b = -1; (b = inputStream.read()) != -1; ) {
        out.write(b);
    }
    out.close();
    inputStream.close();
} catch (IOException e) {
    // logger
}