Activiti——流程存储RepositoryService API详解

亦凉 2023-10-15 15:39 57阅读 0赞

#### 目录 ####

*  Activiti流程存储
 *   *  1、流程文件部署
     *   *  1.1、Deployment对象
         *  1.2、DeploymentBuilder对象
         *  1.3、添加输入流资源
         *  1.4、添加classpath资源
         *  1.5、添加字符串资源
         *  1.6、添加压缩包资源
         *  1.7、添加BPMN模型资源
         *  1.8、修改部署信息
         *  1.9、过滤重复部署
         *  1.10、取消部署时的验证
     *  2、流程定义的管理
     *   *  2.1、ProcessDefinition对象
         *  2.2、流程部署
         *  2.3、流程图部署
         *  2.4、流程图自动生成
         *  2.5、中止与激活流程定义
         *  2.6、流程定义缓存配置
         *  2.7、自定义缓存
     *  3、流程定义权限
     *   *  3.1、设置流程定义的用户权限
         *  3.2、设置流程定义的用户组权限
         *  3.3、IdentityLink对象
         *  3.4、查询权限数据
     *  4、RepositoryService数据查询与删除
     *   *  4.1、查询部署资源
         *  4.2、查询流程文件
         *  4.3、查询流程图
         *  4.4、查询部署资源名称
         *  4.5、删除部署资源
         *  4.6、DeploymentQuery对象
         *  4.7、ProcessDefinitionQuery对象

## Activiti流程存储 ##

流程存储服务组件RepositoryService。RepositoryService主要用于对Activiti中的流程存储的相关数据进行操作，这些操作包括对流程存储数据的管理、流程部署以及对流程的基本操作等。

### 1、流程文件部署 ###

RepositoryService负责对流程文件的部署以及流程的定义进行管理，不管是JBPM还是Activiti等工作流引擎，都会产生流程文件，工作流引擎需要对这些文件进行管理，这些文件包括流程描述文件、流程图等。

在Activiti中，如果需要对这些资源文件进行操作（包括添加、删除、查询等），可以使用RepositoryService提供的API。这些文件数据被保存在ACT GE BYTEARRAY表中，对应的实体为ResourceEntityImpl。在此需要注意的是用户图片，设置用户图片同样会向ACT\_GE\_BYTEARRAY表中写入数据，但是当数据为用户图片时，对应的实体是ByteArrayEntityImpl。ResourceEntityImpl与ByteArrayEntityImpl区别如下。

*  **ByteArrayEntityImpl**对应的数据有版本管理数据，而ResourceEntityImpl则没有。
 *  **ResourceEntityImpl**会设置ACT\_GE\_BYTEARRAY表的GENERATED字段值，而ByteArrayEntityImpl在进行保存时，该值为null。

#### 1.1、Deployment对象 ####

Deployment对象是一个接口，一个Deployment实例表示一条ACT\_RE\_DEPLOYMENT表的数据，同样，Deployment也遵循Activiti的实体命名规则，子接口为DeploymentEntity,  
实现类为DeploymentEntityImpl。如果要对属性进行修改，需要调用DeploymentBuilder提供的方法，Deployment只提供了一系列getter方法。

DeploymentEntityImpl中包含以下映射属性。

*  id:主键，对应ACT\_RE\_DEPLOYMENT表的ID列。
 *  name:部署名称，对应ACT\_RE\_DEPLOYMENT表的NAME列。
 *  deploymentTime:部署时间，对应DEPLOY TIME列。
 *  category:部署的类别，对应CATEGORY列。
 *  tenantId:在云时代，同一个软件有可能被多个租户所使用，因此Activiti在部署、流程定义等数据中都预留了tenantld字段。
 *  key:为部署设置键属性，保存在KEY列。

#### 1.2、DeploymentBuilder对象 ####

对流程文件进行部署，需要使用DeploymentBuilder对象，获取该对象，可以调用RepositoryService的createDeployment方法，具体如以下代码所示：

DeploymentBuilder中包含了多个addXXX方法，可以用于为部署添加资源，这些方法有：

*  **addClasspathResource(String resource)**:添加classpath下的资源文件。
 *  **addInputStream(String resourceName,nputStream)**:添加输入流资源。
 *  **addString(String resourceName,String text)**:添加字符串资源。
 *  **addZipInputStream(ZipInputStream inputStream)**:添加zip压缩包资源。
 *  **addBpmnModel(String resourceName,BpmnModel bpmnModel)**:解析BPMN模型对象，并作为资源保存。
 *  **addBytes(String resourceName,byte\[\]bytes)**:添加字节资源。

#### 1.3、添加输入流资源 ####

在DeploymentEntityImpl类中，使用一个Map来维护资源，表示一次部署中会有多个资源，就是我们平常所说的一对多关系。调用DeploymentBuilder的addInputStream方法，实际上就是往DeploymentEntityImpl的Map里面添加元素，Map的key是资源名称，value是解析InputStream后获得的byte数组。

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    DeploymentBuilder builder = repositoryService.createDeployment();
    //资源输入流
    InputStream is = new FileInputStream("./src/main/resources/helloworld.bpmn20.xml");
    //创建DeploymentBuilder实例
    builder.addInputStream("helloworld", is);
    builder.deploy();

#### 1.4、添加classpath资源 ####

与addInputStream方法类似，addClasspathResource方法也是往部署实体的Map里面添加元素，但不同的是，addClasspathResource方法会得到当前的ClassLoader对象。调用getResourceAsStream方法将指定的classpath下的资源文件转换为InputStream,再调用  
addInputStream方法。

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    DeploymentBuilder builder = repositoryService.createDeployment();
    //添加classpath下的资源
    builder.addClasspathResource("helloworld.bpmn20.xml");
    builder.deploy();

#### 1.5、添加字符串资源 ####

如果需要将一些流程定义的属性或者公用的变量保存起来，则可以使用addString方法。前面讲述了addInputStream和addClasspathResource方法，关于addString方法，也可以猜到它的实现逻辑，实际上就是调用String的getBytes方法获得字节数组，再将其放到部署对象的Map中。

#### 1.6、添加压缩包资源 ####

在实际应用中，可能需要将多个资源部署到流程引擎中，如果这些关联的资源被放在一个压缩包(zip包)中，则可以使用DeploymentBuilder提供的addZipInputStream方法直接部署压缩包，该方法会遍历压缩包内的全部文件，然后将这些文件转换为byte数组，写到资源表中。

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    DeploymentBuilder builder = repositoryService.createDeployment(); 
    //获取zip文件，创建ZipInputStream对象
    FileInputStream fis = new FileInputStream("./src/main/resources/helloworld.bpmn20.xml");
    ZipInputStream zi = new ZipInputStream(fis);
    //添加Zip压缩包资源
    builder.addZipInputStream(zi);
    builder.deploy();

#### 1.7、添加BPMN模型资源 ####

DeploymentBuilder提供了一个addBpmnModel方法，可传入BPMN规范的模型(BpmnModel类)来进行部署：

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    DeploymentBuilder builder = repositoryService.createDeployment();
    //创建BPMN模型对象
    BpmnModel model = new BpmnModel();
    Process process = new Process();
    model.addProcess(process);
    process.setId("myProcess");
    process.setName("My Process");
    //开始事件
    StartEvent startEvent = new StartEvent();
    startEvent.setId("startEvent");
    process.addFlowElement(startEvent);
    //用户任务
    UserTask userTask = new UserTask();
    userTask.setName("User Task");
    userTask.setId("userTask");
    process.addFlowElement(userTask);
    //结束事件
    EndEvent endEvent = new EndEvent();
    endEvent.setId("endEvent");
    process.addFlowElement(endEvent);
    //添加流程顺序
    process.addFlowElement(new SequenceFlow("startEvent", "userTask"));
    process.addFlowElement(new SequenceFlow("userTask", "endEvent"));
    //添加模型资源
    builder.addBpmnModel("MyCodeProcess", model);
    builder.deploy();

除了前面所讲述的几个addXXX方法外，还有一个addBytes方法，该方法较为简单，直接将资源名称与byte数组添加到DeploymentEntityImpl的Map中，在此不再赘述。

#### 1.8、修改部署信息 ####

使用DeploymentBuilder的name、key、category、tenanId方法可以设置部署属性，保存后会将数据保存到ACT\_RE\_DEPLOYMENT表的对应字段中。

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    DeploymentBuilder builder = repositoryService.createDeployment();
    //设置各个属性
    builder.name("aaa").tenantId("tenanId").key("myKey").category("myCategory");
    builder.deploy();

#### 1.9、过滤重复部署 ####

进行了第一次部署后，资源没有发生变化而再次进行部署，同样会将部署数据写入数据库中，想避免这种情况，可以调用DeploymentBuilder的enableDuplicateFiltering方法，该方法仅将DeploymentBuilder的isDuplicateFilterEnabled属性设置为true。在执行deploy方法时，如果发现该值为tu,则根据部署对象的名称去查找最后一条部署记录，如果发现最后一条部署记录与当前需要部署的记录一致，则不会重复部署。这里所说的记录一致，是指DeploymentEntity下的资源是否相同，包括资源名称与资源内容：

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    //创建的一个部署对象
    DeploymentBuilder builderA = repositoryService.createDeployment();
    builderA.addClasspathResource("helloworld.bpmn20.xml");
    builderA.name("A");
    builderA.deploy();
    //由于资源一样，并且调用了enableDuplicateFiltering方法，因此不会再写入数据库中
    DeploymentBuilder builderB = repositoryService.createDeployment();
    builderB.addClasspathResource("helloworld.bpmn20.xml");
    builderB.name("A");
    builderB.enableDuplicateFiltering();
    builderB.deploy();
    //由于资源不一样，即使调用了enableDuplicateFiltering方法，也会再写入数据库中
    DeploymentBuilder builderC = repositoryService.createDeployment();
    builderB.addClasspathResource("book/start_event.bpmn20.xml");
    builderB.name("A");
    builderB.enableDuplicateFiltering();
    builderB.deploy();

#### 1.10、取消部署时的验证 ####

默认情况下，在部署时会对流程的XML文件进行验证，包括验证是否符合BPMN2.0的规范、定义的流程是否可执行。如果XML文件不符合规范或者定义的流程不可执行，那么将会在部署时抛出异常。如果想跳过这两个验证，可以调用DeploymentBuilder的`disableSchemaValidation`与`disableBpmnValidation`方法。先定义两个有问题的流程文件，以便验证：

xmlError.bpmn20.xml格式存在问题：

bpmnError.bpmn20.xml流程存在问题：

跳过验证后。两个流程均正常部署：

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    //部署一份错误的xml文件，不会报错
    DeploymentBuilder builderA = repositoryService.createDeployment();
    builderA.addClasspathResource("demo7/xmlError.bpmn20.xml");
    builderA.disableSchemaValidation().deploy();
    //部署一份不可执行的bpmn文件，不会报错
    DeploymentBuilder builderB = repositoryService.createDeployment();
    builderB.addClasspathResource("demo7/bpmnError.bpmn20.xml");
    builderB.disableBpmnValidation().deploy();

### 2、流程定义的管理 ###

这里所说的流程定义管理是指由RepositoryService提供的一系列对流程定义的控制，包括中止流程定义、激活流程定义和设置流程权限等。

#### 2.1、ProcessDefinition对象 ####

ProcessDefinition对象是一个接口，一个ProcessDefinition实例表示一条流程定义数据，在Activiti中，它的实现类为ProcessDefinitionEntityImpl,对应的数据表为ACT\_RE\_PROCDEF。

ProcessDefinition接口有以下方法。

*  **getCategory**:返回流程定义的category属性，对应CATEGORY字段的值。
 *  **getDeploymentId**:返回部署的id,这个流程定义是由哪次部署产生的，对应字段为DEPLOYMENT\_ID。
 *  **getDescription**:返回流程定义的描述。
 *  **getDiagramResourceName**:如果流程定义有流程图的话，将返回流程图对应的资源名称。
 *  **getEngine Version**:返回流程引擎版本，当前无须关心该方法。
 *  **getld**:返回流程定义主键。
 *  **getKey**:返回流程定义的名称，此名称唯一。
 *  **getName**:返回流程定义显示的名称。
 *  **getResourceName**:在部署时，会将流程定义的XML文件存到资源表中，该方法返回资源的名称。
 *  **getTenantld**:返回租户ID。
 *  **getVersion**:返回流程定义的版本号，对应VERSION字段，注意并不是revision属性。
 *  **hasGraphicalNotation**:该流程定义文件是否有流程图的XML元素。
 *  **hasStartFormKey**:流程的开始事件中是否存在activiti:formKey的定义。
 *  **isSuspended**:是否为中断状态，SUSPENSION STATE字段值为1表示激活状态，值为2则表示中断状态。

#### 2.2、流程部署 ####

流程部署实际上就是将流程的描述文件写入数据库中，Activiti在获取资源文件后，会对其后缀进行解析，如果后缀名为“BPMN20.xml”或者“bpmm”,则它们均会被看作流程描述文件，交由Activiti的Deployer(部署流程描述文件实现类为BpmnDeployer)进行部署。

<?xml version="1.0" encoding="UTF-8"?>
    <definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:activiti="http://activiti.org/bpmn"
    	xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC"
    	xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" typeLanguage="http://www.w3.org/2001/XMLSchema"
    	expressionLanguage="http://www.w3.org/1999/XPath" targetNamespace="http://www.activiti.org/test">
    	<process id="vacationProcess" name="vacation">
    		<userTask id="usertask1" name="User Task"></userTask>
    		<endEvent id="endevent1" name="End"></endEvent>
    		<sequenceFlow id="flow2" name="" sourceRef="usertask1"
    			targetRef="endevent1"></sequenceFlow>
    		<startEvent id="startevent1" name="Start"></startEvent>
    		<sequenceFlow id="flow3" name="" sourceRef="startevent1"
    			targetRef="usertask1"></sequenceFlow>
    	</process>
    	<bpmndi:BPMNDiagram id="BPMNDiagram_vacationProcess">
    		<bpmndi:BPMNPlane bpmnElement="vacationProcess"
    			id="BPMNPlane_vacationProcess">
    			<bpmndi:BPMNShape bpmnElement="usertask1" id="BPMNShape_usertask1">
    				<omgdc:Bounds height="55" width="105" x="310" y="160"></omgdc:Bounds>
    			</bpmndi:BPMNShape>
    			<bpmndi:BPMNShape bpmnElement="endevent1" id="BPMNShape_endevent1">
    				<omgdc:Bounds height="35" width="35" x="490" y="170"></omgdc:Bounds>
    			</bpmndi:BPMNShape>
    			<bpmndi:BPMNShape bpmnElement="startevent1"
    				id="BPMNShape_startevent1">
    				<omgdc:Bounds height="35" width="35" x="170" y="170"></omgdc:Bounds>
    			</bpmndi:BPMNShape>
    			<bpmndi:BPMNEdge bpmnElement="flow2" id="BPMNEdge_flow2">
    				<omgdi:waypoint x="415" y="187"></omgdi:waypoint>
    				<omgdi:waypoint x="490" y="187"></omgdi:waypoint>
    			</bpmndi:BPMNEdge>
    			<bpmndi:BPMNEdge bpmnElement="flow3" id="BPMNEdge_flow3">
    				<omgdi:waypoint x="205" y="187"></omgdi:waypoint>
    				<omgdi:waypoint x="310" y="187"></omgdi:waypoint>
    			</bpmndi:BPMNEdge>
    		</bpmndi:BPMNPlane>
    	</bpmndi:BPMNDiagram>
    </definitions>

![在这里插入图片描述][395d6a974aa2412cbd9489ac81e84a71.png]

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    DeploymentBuilder builder = repositoryService.createDeployment();
    builder.addClasspathResource("demo7/processDeploy.bpmn");
    builder.deploy();

ACT\_RE\_PROCDEF数据表ID列的生成规则为，由流程XML文件的process节点的id作为前缀，加上该流程定义的部署版本号(VERSION)字段，再加上生成的主键。例如process  
节点的id为vacation,第二次进行部署，数据库自增长id为l0001,最终id为vacation:2:10001。

#### 2.3、流程图部署 ####

DeploymentBuilder的各个方法的使用，其中addClasspathResource方法、addZipInputStream方法和addInputStream方法均可以将文件数据写到数据库中，因此，可以使用这些方法将流程图放到数据库中：

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    DeploymentBuilder builder = repositoryService.createDeployment();
    //部署流程描述文件与流程图
    builder.addClasspathResource("demo7/diagram.bpmn");
    builder.addClasspathResource("demo7/diagram.png");
    Deployment deploy = builder.deploy();
    //查看流程定义实体
    ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().deploymentId(deploy.getId()).singleResult();
    //demo7/diagram.png
    System.out.println(processDefinition.getDiagramResourceName());

addClasspathResource方法将流程描述文件和流程图  
部署到数据库中，最终会在资源表(ACT\_GE\_BYTEARRAY)中写入两条记录：一条为流程描述文件数据，另外一条为流程图片的文件数据。  
![在这里插入图片描述][b4bc5727cff54d968b01c8da2e2d357e.png]

#### 2.4、流程图自动生成 ####

如果在部署时我们不提供流程图，但在流程定义的XML文件中保存了BPMN流程图的元素，则Activiti会自动生成流程图，并保存到资源表中。如果不希望Activiti帮我们生成流程图，则可以在流程引擎配置文件中加入以下属性：

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
            RepositoryService repositoryService = processEngine.getRepositoryService();
            DeploymentBuilder builder = repositoryService.createDeployment();
            Deployment deploy = builder.addClasspathResource("demo7/processDeploy.bpmn").deploy();
            //查询流程定义实体
            ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().deploymentId(deploy.getId()).singleResult();
            //自动生成路程图：demo7/processDeploy.vacationProcess.png
            System.out.println("自动生成路程图：" + processDefinition.getDiagramResourceName());

#### 2.5、中止与激活流程定义 ####

RepositoryService中提供了多个中止与激活流程定义的方法，可以将流程定义的数据置为中止与激活状态。其中有多个suspendProcessDefinitionById、suspendProcessDefinitionByKey重载的中止方法，也有多个activateProcessDefinitionByld、activateProcessDefinitionByKey重载  
的激活方法。以activateProcessDefinitionByld方法为例，有两个重载方法。

*  **activateProcessDefinitionById(String processDefinitionId)**:根据流程定义的id激活流程  
    定义。
 *  **activateProcessDefinitionByld(String processDefinitionId,boolean activateProcessInstances,  
    Date activationDate)**:在某个时间激活流程定义，需要注意的是activateProcessInstances参数，如果为tue,则该流程定义下的流程实例，也会被激活。

本身流程定义就没有所谓的中止与激活的概念（流程才有），这里所说的中止与激活，只是流程定义的数据状态设置为中止状态和激活状态。流程定义文件一旦被部署，那么对应的流程定义数据状态为激活，可以调用RepositoryService的中止流程定义的方法改变其状态。  
RepositoryService提供了两个中止流程定义的方法。

*  **suspendProcessDefinitionById(String processDefinitionId)**:根据流程ID中止流程定义。
 *  **suspendProcessDefinitionByKey(String processDefinitionKey)**:根据流程定义文件中的process节点的id属性中止流程定义，也可以看作根据ACT\_RE\_PROCDEF表中的KEY\_字段值中止流程定义。

当流程定义被中止后，如果想激活流程定义，同样可以使用RepositoryService中提供的激活定义的方法，方法描述如下:

*  **activateProcessDefinitionById(String processDefinitionId)**:根据流程ID激活流程定义。
 *  **activateProcessDefinitionByKey(String processDefinitionKey)**:根据流程的key激活流程定义，与中止流程定义的suspendProcessDefinitionByKey方法一致。

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    DeploymentBuilder builder = repositoryService.createDeployment();
    Deployment deploy = builder.addClasspathResource("demo7/processDeploy.bpmn").deploy();
    //查询流程定义实体
    ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().deploymentId(deploy.getId()).singleResult();
    //中止
    repositoryService.suspendProcessDefinitionById(processDefinition.getId());
    //激活
    repositoryService.activateProcessDefinitionById(processDefinition.getId());
    //中止
    repositoryService.suspendProcessDefinitionByKey(processDefinition.getKey());
    //激活
    repositoryService.activateProcessDefinitionByKey(processDefinition.getKey());

#### 2.6、流程定义缓存配置 ####

为了减少数据的查询，提升流程引擎性能，Activiti本身对某些常用的数据做了缓存。例如在解析完流程定义的XML文件后，会将流程定义缓存到一个Map中，key为流程定义的id(数据库的D字段)，value为封装好的缓存对象。默认情况下，不需要进行配置，流程引擎会进行缓存的工作。

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    //进程10次部署
    for (int i = 0; i < 10; i++) {
        
        repositoryService.createDeployment().addClasspathResource("demo7/processDeploy.bpmn")
                .name("dep_" + i).key("key_" + i).deploy();
    }
    //获取缓存
    ProcessEngineConfigurationImpl configuration = (ProcessEngineConfigurationImpl) processEngine.getProcessEngineConfiguration();
    DeploymentCache<ProcessDefinitionCacheEntry> cache = configuration.getProcessDefinitionCache();
    System.out.println(cache);

由于缓存没有限制，因此部署了10次，缓存(Map)中就有10  
个元素，如果想限制缓存数量，可以在流程引擎的配置文件中使用以下配置：

以上配置表示缓存中只保存两个流程定义的缓存对象，一般情况下，只缓存最后两次部署的流程定义。

#### 2.7、自定义缓存 ####

如果想自己实现缓存，可以新建一个Java类，实现DeploymentCache接口，该接口主要有增、删、改、查方法，用于操作缓存数据。

public class MyCacheBean<T> implements DeploymentCache<T> {
        
        
        public Map<String, T> cache;
    
        public MyCacheBean(Map<String, T> cache) {
        
            this.cache = cache;
        }
    
        public T get(String id) {
        
            return cache.get(id);
        }
    
        public boolean contains(String id) {
        
            return cache.containsKey(id);
        }
    
        public void add(String id, T object) {
        
            cache.put(id, object);
        }
    
        public void remove(String id) {
        
            cache.remove(id);
        }
    
        public void clear() {
        
            cache.clear();
        }
    }

### 3、流程定义权限 ###

对于一个用户或者用户组是否能操作（查看）某个流程定义的数据，需要进行相应的流程定义权限设置。在Activiti中，并没有对流程定义的权限进行检查，而是提供一种反向的方法，让调用者去管理这些权限数据，然后提供相应的API让使用人决定哪种数据可以被查询。

#### 3.1、设置流程定义的用户权限 ####

在默认情况下，所有用户（用户组)均可以根据流程定义创建流程实例（启动流程)，可以使用Activiti提供的API来设置启动流程的权限数据（设置启动流程的候选用户）。Activiti提供了设置流程权限数据的API,可以调用这些API来管理这些权限数据，但是，需要注意的是，Activiti本身并不会对权限进行检查，而是提供了相应的权限查询接口，让开发者决定展示何种数据给使用者，从而达到权限控制的作用。例如提供了根据用户来获取其有权限的流程定义，根据流程定义获取有权限的用户组或者用户。Activiti的这种设计，使得在开发流程权限功能时开发人员可以有更灵活的选择。

RepositoryService中提供了addCandidateStarterUser方法，给流程定义与用户绑定权限，该方法实际上是向一个中间表中加入数据，表示流程与用户之间的关系。addCandidateStarterUser方法的第一个参数为流程定义ID,第二个参数为用户的ID。

ACT\_RU\_IDENTITYLINK表用于保存流程中用户组、用户这些身份数据与流程中各个元素之间的关系，这些流程元素包括流程定义、流程任务等。在此需要再次强调，即使该表中存在权限数据，Activiti也不会对这些权限进行拦截或者检查，只会根据这些关系与查询条件，返回相应的符合要求的数据。  
![在这里插入图片描述][8ca0cad5e6724b428cca31831f180fe0.png]

#### 3.2、设置流程定义的用户组权限 ####

与设置用户的流程定义权限一样，RepositoryService提供了addCandidateStarterGroup方法，使用该方法可以将流程定义与用户组进行权限绑定，权限绑定数据同样被写入  
ACT\_RU\_IDENTITYLINK表中。addCandidateStarterGroup方法的第一个参数为流程定义ID,第二个参数为用户组ID,以下代码调用了addCandidateStarterGroup方法绑定流程定义权限。

repositoryService.addCandidatestarterGroup(def.getId(),"group1");

#### 3.3、IdentityLink对象 ####

一个IdentityLink实例表示一种身份数据与流程数据绑定的关系，此处所说的身份数据包括用户组和用户数据，流程数据包括流程定义、流程任务等数据。IdentityLink是一个接口，与其他数据库映射实体一样，其对应的实现类为IdentityLinkEntityImpl,对应的数据表为  
ACT\_RU\_IDENTITYLINK。它包含以下映射的属性。

*  id:主键，对应D字段。
 *  type:数据类型，对应TYPE字段，Activiti为该字段提供了5个值，分别为assignee、candidate、starter、participant和owner。本章中为用户或者用户组绑定流程定义时，该  
    值为candidate,表示创建流程实例的请求者。
 *  groupld:绑定关系中的用户组ID,对应GROUP\_ID字段。
 *  userId:绑定关系中的用户D,对应USER ID字段。
 *  taskId:绑定关系中的流程任务D,对应TASK ID字段。
 *  processDefld:绑定关系中的流程定义D,对应PROC DEF ID字段。

在此需要注意的是，ACT\_RU\_IDENTITYLINK表中还有一个REV\_字段，IdentityLinkEntityImpl并没有为该字段做相应的属性映射，在实体与数据表映射的配置文件中，该字段的值被设置为1。

#### 3.4、查询权限数据 ####

前面介绍了如何设置流程定义的权限，那么当需要使用这些权限数据时，则可以使用IdentityService中提供的获取流程角色权限数据的方法来获取这些数据，例如根据用户获取该用户有权限启动的流程定义，根据流程定义获取有权限申请的用户和用户组数据。这些获取权限数据的方法分布在各个不同的服务组件中，如果要根据流程定义获取有权限申请的角色数据，则需要使用IdentityService;如果要根据用户或者用户组得到相应的流程定义数据，则需要使  
用RepositoryService。

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    IdentityService identityService = processEngine.getIdentityService();
    //部署流程文件
    Deployment deploy = repositoryService.createDeployment().addClasspathResource("demo7/processDeploy.bpmn").deploy();
    //添加两个用户
    createUser(identityService, "user1", "a1", "x1", "abc@qq.com", "123");
    createUser(identityService, "user2", "a2", "x2", "abc@qq.com", "123");
    //添加两个用户组
    createGroup(identityService, "group1", "经理组", "manager");
    createGroup(identityService, "group2", "员工组", "employee");
    //查询流程定义
    ProcessDefinition def = repositoryService.createProcessDefinitionQuery().deploymentId(deploy.getId()).singleResult();
    //设置权限
    repositoryService.addCandidateStarterGroup(def.getId(), "group1");
    repositoryService.addCandidateStarterGroup(def.getId(), "group2");
    repositoryService.addCandidateStarterUser(def.getId(), "user1");
    repositoryService.addCandidateStarterUser(def.getId(), "user2");
    //根据用户查询有权限的流程定义
    List<ProcessDefinition> defs = repositoryService.createProcessDefinitionQuery().startableByUser("user1").list();
    for (ProcessDefinition dft : defs) {
        
        System.out.println("   " + dft.getName());
    }
    //根据流程定义查询用户组数据
    List<Group> groups = identityService.createGroupQuery().potentialStarter(def.getId()).list();
    for (Group group : groups) {
        
        System.out.println("   " + group.getName());
    }
    //根据流程定义查询用户数据
    List<User> users = identityService.createUserQuery().potentialStarter(def.getId()).list();
    for (User user : users) {
        
        System.out.println("   " + user.getFirstName());
    }
    //根据流程定义查询全部的IdentityLink数据
    List<IdentityLink> links = repositoryService.getIdentityLinksForProcessDefinition(def.getId());
    System.out.println(links.size());

*  ProcessDefinitionQuery的startableByUser方法：该方法用于根据用户D查询该用户有权限启动的流程定义数据。
 *  GroupQuery的potentialStarter方法：根据流程定义D查询有权限启动的用户组数据。
 *  UserQuery的potentialStarter方法：根据流程定义D查询有权限启动的用户数据。
 *  RepositoryService的getldentityLinksForProcessDefinition方法：根据流程定义ID查询与之相关的全部权限数据。

### 4、RepositoryService数据查询与删除 ###

#### 4.1、查询部署资源 ####

部署资源包括与部署相关的文件、流程描述文件、流程图等，可以使用DeploymentBuilder的addXXX方法将相关的资源文件保存到数据库中，如果需要使用这些文件，则可以调用RepositoryService的getResourceAsStream方法，只需要提供部署(Deployment)ID和资源名称，就可以返回资源的输入流对象。

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    Deployment deploy = repositoryService.createDeployment().addClasspathResource("a.txt").deploy();
    //查询资源文件
    InputStream is = repositoryService.getResourceAsStream(deploy.getId(), "a.txt");
    //读取输入流
    int count = is.available();
    byte[] contents = new byte[count];
    is.read(contents);
    String result = new String(contents);
    System.out.println(result);

#### 4.2、查询流程文件 ####

部署流程描述文件的时候，Activiti会向资源表中写入该文件的内容，即先将其看作一份普通的文件进行解析与数据保存，然后再解析它的文件内容，并生成相应的流程定义数据。与查询部署资源的getResourceAsStream方法一样，RepositoryService提供了一个getProcessModel方法，调用该方法只需要提供流程定义的ID即可返回流程文件的InputStream实例。

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    Deployment deploy = repositoryService.createDeployment().addClasspathResource("demo7/processDeploy.bpmn").deploy();
    //查询流程定义实体
    ProcessDefinition def = repositoryService.createProcessDefinitionQuery()
            .deploymentId(deploy.getId()).singleResult();
    //查询资源文件
    InputStream is = repositoryService.getProcessModel(def.getId());
    int count = is.available();
    byte[] contents = new byte[count];
    is.read(contents);
    String result = new String(contents);
    System.out.println(result);

#### 4.3、查询流程图 ####

在部署一个流程的时候，可以由Activiti生成流程图，也可以由我们提供，可以使用RepositoryService的getProcessDiagram方法返回该流程图的InputStream对象。调用getProcessDiagram方法同样需要提供流程定义ID,根据流程定义数据得到部署数据ID与部署资源名称，再到资源表中查询相应的文件数据返回：

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    Deployment deploy = repositoryService.createDeployment()
            .addClasspathResource("demo7/diagram.bpmn")
            .addClasspathResource("demo7/diagram.png").deploy();
    //查询流程定义实体
    ProcessDefinition def = repositoryService.createProcessDefinitionQuery()
            .deploymentId(deploy.getId()).singleResult();
    //查询资源文件
    InputStream is = repositoryService.getProcessDiagram(def.getId());
    //将输入流转换为图片对象
    BufferedImage image = ImageIO.read(is);
    //保存图片文件
    File file = new File("result.png");
    if (!file.exists())
        file.createNewFile();
    FileOutputStream fos = new FileOutputStream(file);
    ImageIO.write(image, "png", fos);
    fos.close();
    is.close();

#### 4.4、查询部署资源名称 ####

查询一次部署所涉及的全部文件名称，可以调用RepositoryService的getDeploymentResourceNames方法。

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    Deployment deploy = repositoryService.createDeployment()
            .addClasspathResource("demo7/diagram.bpmn")
            .addClasspathResource("demo7/diagram.png").deploy();
    //查询资源文件名称集合
    List<String> names = repositoryService.getDeploymentResourceNames(deploy.getId());
    for (String name : names) {
        
        System.out.println(name);
    }

#### 4.5、删除部署资源 ####

在前面章节，使用了RepositoryService的各个方法来查询部署所产生的相关资源数据。如果需要删除这些数据，则可以使用RepositoryService提供的两个删除方法，这两个方法的描述如下。

*  **deleteDeployment(String deploymentId)**:删除部署数据，不进行级联删除，这里所说的级联删除，是指与该部署相关的流程实例数据的删除。
 *  **deleteDeployment(String deploymentId,boolean cascade)**:是否进行级联删除，由调用者决定。如果cascade参数为false,效果等同于deleteDeployment((String deploymentld)方法；如果cascade为true,则会删除部署相关的流程实例数据。

不管删除部署数据时是否指定级联删除，部署的相关数据均会被删除，包括身份数据(IdentityLink)、流程定义数据(ProcessDefinition)、流程资源(Resource)与部署数据  
(Deployment)。

> 如果设置为级联删除，则会删除流程实例数据(ProcessInstance),其中流程实例数据也包括流程任务(Task)与流程实例的历史数据；如果设置为flse,不进行级联删除的话，如果Activiti数据库中已经存在流程实例数据，那么将会删除失败，因为在删除流程定义时，流程定义数据的D已经被流程实例的相关数据所引用。

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    Deployment deploy = repositoryService.createDeployment()
            .addClasspathResource("demo7/diagram.bpmn").deploy();
    //查询流程定义
    ProcessDefinition def = repositoryService.createProcessDefinitionQuery().deploymentId(deploy.getId()).singleResult();
    //启动流程
    processEngine.getRuntimeService().startProcessInstanceById(def.getId());
    try {
        
        //删除部署数据失败，此时将会抛出异常，由于cascade为false
        repositoryService.deleteDeployment(deploy.getId());
    } catch (Exception e) {
        
        System.out.println("删除失败，流程开始，没有设置cascade为true");
    }
    repositoryService.deleteDeployment(deploy.getId(), true);

#### 4.6、DeploymentQuery对象 ####

Activiti中的每个查询对象(XXXQuery)均有自己相应的查询方法和排序方法)，DeploymentQuery对象包括如下方法。

*  **deploymentId(String id)**:添加ID查询条件，查询ID为参数值的数据记录。
 *  **deploymentName(String name)**:添加名称查询条件，查询Deployment名称为参数值的数据记录。
 *  **deploymentNameLike(String name)**:添加模糊查询条件，查询Deployment名称含有参数值的数据记录。
 *  **orderByDeploymentld**:设置查询结果按照Deployment的D进行排序，排序方式由asc与desc方法决定。
 *  **orderByDeploymentTime**:设置查询结果按照DEPLOY TIME字段排序。
 *  **orderByDeploymentName**:设置查询结果按照Deployment名称排序。

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    //写入5条Deployment数据
    Deployment depA = repositoryService.createDeployment().addString("a1", "a1")
            .addString("a2", "a2").addString("a3", "a3")
            .name("a").deploy();
    Deployment depB = repositoryService.createDeployment().addString("b1", "b1")
            .addString("b2", "b2").addString("b3", "b3")
            .name("b").deploy();
    Deployment depC = repositoryService.createDeployment().addString("c1", "c1")
            .addString("c2", "c2").addString("c3", "c3")
            .name("c").deploy();
    Deployment depD = repositoryService.createDeployment().addString("d1", "d1")
            .addString("d2", "d2").addString("d3", "d3")
            .name("d").deploy();
    Deployment depE = repositoryService.createDeployment().addString("e1", "e1")
            .addString("e2", "e2").addString("e3", "e3")
            .name("e").deploy();
    //根据id查询
    Deployment A = repositoryService.createDeploymentQuery().deploymentId(depA.getId()).singleResult();
    System.out.println(A.getName());
    //根据Name查询
    Deployment B = repositoryService.createDeploymentQuery().deploymentName("b").singleResult();
    System.out.println(B.getName());
    //Name模糊查询
    List<Deployment> list = repositoryService.createDeploymentQuery().deploymentNameLike("%b%").list();
    for (Deployment d : list) {
        
        System.out.println(d.getName());
    }
    System.out.println(list.size());

#### 4.7、ProcessDefinitionQuery对象 ####

ProcessDefinitionQuery对象与DeploymentQuery对象类似，是RepositoryService提供的另外一个数据查询对象，该对象主要用于查询流程定义数据。

ProcessDefinitionQuery对象提供了若干个根据字段查询与字段排序的方法，在此需要注意的是，  
`startableByUser(String userId)`方法，该方法根据用户ID返回该用户有权限启动流程定义的流程定义数据。

ProcessDefinitionQuery中的其他根据字段查询、排序的方法，不再赘述。

[395d6a974aa2412cbd9489ac81e84a71.png]: https://img-blog.csdnimg.cn/395d6a974aa2412cbd9489ac81e84a71.png
[b4bc5727cff54d968b01c8da2e2d357e.png]: https://img-blog.csdnimg.cn/b4bc5727cff54d968b01c8da2e2d357e.png
[8ca0cad5e6724b428cca31831f180fe0.png]: https://img-blog.csdnimg.cn/8ca0cad5e6724b428cca31831f180fe0.png