工作流第六章之用户组与用户
某些企业会将相同职能的人作为一类人进行管理，也会有某些企业，将相同的角色（职能不同）作为一类人进行管理，这些类别就是本章所说的用户组。Activiti中用户组对应的表为ACT_ID_GROUP，该表只有4个字段。
Group对象
Group是一个接口，一个Group实例表示一条用户组数据，对应的表为ACT_ID_GROUP。该接口只提供了相应字段的getter和setter方法，这种数据与对象的映射关系，在各个ORM框架中使用很普遍，例如Hibernate、MyBatis等。
GroupEntity中包含以下映射属性。
➢ id：主键，对应ACT_ID_GROUP表的ID_列。
➢ name：用户组名称，对应ACT_ID_GROUP表的NAME_列。
➢ type：用户组类型，对应ACT_ID_GROUP表的TYPE_列。
➢ revision：该用户组数据的版本，对应ACT_ID_GROUP表的REV_列。
添加用户
package org.crazyit.activiti;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.Group;
/**
* 添加用户组
* @author yangenxiong
*
*/
public class AddGroup {
public static void main(String[] args) {
// 创建默认的流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
// 生成UUID
String genId = UUID.randomUUID().toString();
//调用newGroup方法创建Group实例
Group group = identityService.newGroup(genId);
group.setName("经理组");
group.setType("manager");
//保存Group到数据库
identityService.saveGroup(group);
// 查询用户组
Group data = identityService.createGroupQuery().groupId(genId).singleResult();
// 保存后查询Group
System.out.println("Group ID：" + data.getId() + ", Name：" + data.getName());
// // 设置名称
// data.setName("经理2组");
// identityService.saveGroup(data);
// // 再次查询
// data = identityService.createGroupQuery().groupId(genId).singleResult();
// System.out.println("Group ID：" + data.getId() + ", Name：" + data.getName());
}
}
删除用户
package org.crazyit.activiti;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.Group;
/**
* 添加用户组
*
* @author yangenxiong
*
*/
public class DeleteGroup {
public static void main(String[] args) {
// 创建默认的流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
String genId = UUID.randomUUID().toString();
// 调用newGroup方法创建Group实例
Group group = identityService.newGroup(genId);
group.setName("经理组");
group.setType("manager");
// 保存Group到数据库
identityService.saveGroup(group);
// 查询用户组
System.out.println("保存后用户组数量："
+ identityService.createGroupQuery().count());
// 根据ID删除用户组
identityService.deleteGroup(genId);
System.out.println("删除后用户组数量："
+ identityService.createGroupQuery().count());
}
}
Activiti数据查询
Activiti提供了一套数据查询API提供给开发者使用，可以使用各个服务组件的createXXXQuery方法来获取这些查询对象。
查询对象
Activiti的各个服务组件（XXXService）均提供了createXXXQuery方法，例如IdentityService中的createGroupQuery方法和createUserQuery方法，TaskService中的craeteTaskQuery方法等。这些方法返回一个Query实例，例如createGroupQuery返回GroupQuery，GroupQuery是Query的子接口。
Query是所有查询对象的父接口，该接口中定义了若干个基础方法，各个查询对象均可以使用这些公共方法，包括设置排序方式、数据量统计（count）、列表、分页和唯一记录查询。这些方法描述如下。
➢ asc：设置查询结果的排序方式为升序。
➢ count：计算查询结果的数据量。
➢ desc：设置查询结果的排序方式为降序。
➢ list：封装查询结果，返回相应类型的集合。
➢ listPage：分页返回查询结果。
➢ singleResult：查询单条符合条件的数据，如果查询不到，则返回 null；如果查询到多条记录，则抛出异常。
List方法
Query接口的list方法，将查询对象对应的实体数据以集合形式返回，对于返回的集合要指定特定的元素类型。如果没有查询条件，则会将表中的全部的数据查出，默认按照主键升序排序。
创建activiti.cfg.xml配置文件
创建log4j.properties配置文件
# Set root category priority to INFO and its only appender to CONSOLE.
log4j.rootCategory=INFO, CONSOLE
#log4j.rootCategory=INFO, CONSOLE, LOGFILE
# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{
ABSOLUTE} %5p %c{
1} - %m%n
log4j.logger.org.apache=INFO
log4j.logger.org.htmlparser=INFO
log4j.logger.org.htmlparser=INFO
log4j.logger.org.crazyit=DEBUG
log4j.logger.org.drools=DEBUG
log4j.logger.org.mule=ERROR
log4j.logger.org.springframework=ERROR
测试
package org.crazyit.activiti;
import java.util.List;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.Group;
/**
* 使用Query的list方法
*
* @author yangenxiong
*
*/
public class ListData {
public static void main(String[] args) {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
// 写入5条用户组数据
createGroup(identityService, "1", "GroupA", "typeA");
createGroup(identityService, "2", "GroupB", "typeB");
createGroup(identityService, "3", "GroupC", "typeC");
createGroup(identityService, "4", "GroupD", "typeD");
createGroup(identityService, "5", "GroupE", "typeE");
// 使用list方法查询全部的部署数据
List<Group> datas = identityService.createGroupQuery().list();
for (Group data : datas) {
System.out.println(data.getId() + "---" + data.getName() + " ");
}
}
// 将用户组数据保存到数据库中
static void createGroup(IdentityService identityService, String id,
String name, String type) {
// 调用newGroup方法创建Group实例
Group group = identityService.newGroup(id);
group.setName(name);
group.setType(type);
identityService.saveGroup(group);
}
}
listPage方法与list方法类似，最终也是以主键升序排序返回结果集，与list方法不一样的是，listPage方法需要提供两个int参数，第一个参数为数据的开始索引，从0开始，第二个参数为结果数量，不难看出，该方法适用于分页查询。
package org.crazyit.activiti;
import java.util.List;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.Group;
/**
* 使用Query的listPage方法
* @author yangenxiong
*
*/
public class ListPage {
/**
* @param args
*/
public static void main(String[] args) {
//创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
// 写入5条用户组数据
createGroup(identityService, "1", "GroupA", "typeA");
createGroup(identityService, "2", "GroupB", "typeB");
createGroup(identityService, "3", "GroupC", "typeC");
createGroup(identityService, "4", "GroupD", "typeD");
createGroup(identityService, "5", "GroupE", "typeE");
//调用listPage方法，从索引为2的记录开始，查询3条记录
List<Group> datas = identityService.createGroupQuery().listPage(2, 3);
for (Group data : datas) {
System.out.println(data.getId() + "---" + data.getName() + " ");
}
}
// 将用户组数据保存到数据库中
static void createGroup(IdentityService identityService, String id,
String name, String type) {
// 调用newGroup方法创建Group实例
Group group = identityService.newGroup(id);
group.setName(name);
group.setType(type);
identityService.saveGroup(group);
}
}
22:44:25,328 INFO DbSqlSession - performing create on identity with resource org/activiti/db/create/activiti.mysql.create.identity.sql
22:44:25,329 INFO DbSqlSession - Found MySQL: majorVersion=5 minorVersion=7
22:44:25,449 INFO ProcessEngineImpl - ProcessEngine default created
22:44:25,483 INFO ProcessEngines - initialised process engine default
3---GroupC
4---GroupD
5---GroupE
count方法
该方法用于计算查询结果的数据量，类似于SQL中的SELECT COUNT语句，如果不加任何条件，将会统计整个表的数据量。
package org.crazyit.activiti;
import java.util.List;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.Group;
/**
* 使用Query的count方法
*
* @author yangenxiong
*
*/
public class Count {
public static void main(String[] args) {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
// 写入5条用户组数据
createGroup(identityService, UUID.randomUUID().toString(), "GroupA", "typeA");
createGroup(identityService, UUID.randomUUID().toString(), "GroupB", "typeB");
createGroup(identityService, UUID.randomUUID().toString(), "GroupC", "typeC");
createGroup(identityService, UUID.randomUUID().toString(), "GroupD", "typeD");
createGroup(identityService, UUID.randomUUID().toString(), "GroupE", "typeE");
// 使用list方法查询全部的部署数据
long size = identityService.createGroupQuery().count();
System.out.println("Group 数量：" + size);
}
// 将用户组数据保存到数据库中
static void createGroup(IdentityService identityService, String id,
String name, String type) {
// 调用newGroup方法创建Group实例
Group group = identityService.newGroup(id);
group.setName(name);
group.setType(type);
identityService.saveGroup(group);
}
}
排序方法
Query中提供了asc和desc方法，使用这两个方法可以设置查询结果的排序方式，但是调用这两个方法的前提是，必须告诉Query对象，按何种条件进行排序，例如要按照ID排序，就要调用相应查询对象的orderByXXX方法，或者GroupQuery的orderByGroupId、orderByGroupName等方法，如果不调用这些方法而直接使用asc或者desc方法，则会抛出ActivitiException，异常信息为：You should call any of the orderBy methods first before specifying a direction。要求Activiti进行排序，却不告诉它以哪个字段进行排序，因此会抛出异常。
package org.crazyit.activiti;
import java.util.List;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.Group;
/**
* Query的排序
* @author yangenxiong
*
*/
public class Sort {
/**
* @param args
*/
public static void main(String[] args) {
//创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
// 写入5条用户组数据
createGroup(identityService, UUID.randomUUID().toString(), "1", "typeA");
createGroup(identityService, UUID.randomUUID().toString(), "2", "typeB");
createGroup(identityService, UUID.randomUUID().toString(), "3", "typeC");
createGroup(identityService, UUID.randomUUID().toString(), "4", "typeD");
createGroup(identityService, UUID.randomUUID().toString(), "5", "typeE");
//调用orderByGroupId和asc方法，结果为按照ID升序排序
System.out.println("asc排序结果：");
List<Group> datas = identityService.createGroupQuery().orderByGroupName().asc().list();
for (Group data : datas) {
System.out.println(" " + data.getId() + "---" + data.getName());
}
System.out.println("desc排序结果");
//调用orderByGroupName和desc方法，结果为名称降序排序
datas = identityService.createGroupQuery().orderByGroupName().desc().list();
for (Group data : datas) {
System.out.println(" " + data.getId() + "---" + data.getName());
}
}
// 将用户组数据保存到数据库中
static void createGroup(IdentityService identityService, String id,
String name, String type) {
// 调用newGroup方法创建Group实例
Group group = identityService.newGroup(id);
group.setName(name);
group.setType(type);
identityService.saveGroup(group);
}
}
ID排序问题
在Activiti的设计中，每个数据表的主键均被设置为字符型，这样的设计使得Activiti各个数据表的主键可以被灵活设置，但是如果使用数字字符串作为其主键，那么按照ID排序
package org.crazyit.activiti;
import java.util.List;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.Group;
/**
* Query的的排序问题
* @author yangenxiong
*
*/
public class SortProblem {
/**
* @param args
*/
public static void main(String[] args) {
//创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
// 写入5条用户组数据
createGroup(identityService, "1", "GroupA", "typeA");
createGroup(identityService, "12", "GroupB", "typeB");
createGroup(identityService, "13", "GroupC", "typeC");
createGroup(identityService, "2", "GroupD", "typeD");
createGroup(identityService, "3", "GroupE", "typeE");
//根据ID升序排序
System.out.println("asc排序结果");
List<Group> datas = identityService.createGroupQuery().orderByGroupId().asc().list();
for (Group data : datas) {
System.out.print(data.getId() + " ");
}
}
// 将用户组数据保存到数据库中
static void createGroup(IdentityService identityService, String id,
String name, String type) {
// 调用newGroup方法创建Group实例
Group group = identityService.newGroup(id);
group.setName(name);
group.setType(type);
identityService.saveGroup(group);
}
}
多字段排序
在进行数据查询时，如果想对多个字段进行排序，例如按名称降序、ID升序排序，那么在调用asc和desc方法时就需要注意，asc和desc方法会根据Query实例（AbstractQuery）中的orderProperty属性来决定排序的字段，由于orderProperty是AbstractQuery的类属性，因此在第二次调用orderByXXX方法后，会覆盖第一次调用时所设置的值。
package org.crazyit.activiti;
import java.util.List;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.Group;
/**
* Query的多字段排序
* @author yangenxiong
*
*/
public class SortMix {
/**
* @param args
*/
public static void main(String[] args) {
//创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
// 写入5条用户组数据
createGroup(identityService, "1", "GroupE", "typeB");
createGroup(identityService, "2", "GroupD", "typeC");
createGroup(identityService, "3", "GroupC", "typeD");
createGroup(identityService, "4", "GroupB", "typeE");
createGroup(identityService, "5", "GroupA", "typeA");
//优先按照id降序、名称升序排序
System.out.println("ID降序排序：");
List<Group> datas = identityService.createGroupQuery()
.orderByGroupId().desc()
.orderByGroupName().asc().list();
for (Group data : datas) {
System.out.println(" " + data.getId() + "---" + data.getName() + " ");
}
System.out.println("名称降序排序：");
//下面结果将按名称排序
datas = identityService.createGroupQuery().orderByGroupId()
.orderByGroupName().desc().list();
for (Group data : datas) {
System.out.println(" " + data.getId() + "---" + data.getName() + " ");
}
}
// 将用户组数据保存到数据库中
static void createGroup(IdentityService identityService, String id,
String name, String type) {
// 调用newGroup方法创建Group实例
Group group = identityService.newGroup(id);
group.setName(name);
group.setType(type);
identityService.saveGroup(group);
}
}
singleResult方法
该方法根据查询条件，到数据库中查询唯一的数据记录，如果没有找到符合条件的数据，则返回null，如果找到多于一条的记录，则抛出异常，异常信息为：Query return 2 results instead of max 1。代码清单6-10为一个使用singleResult方法的示例，并且体现三种查询结果
package org.crazyit.activiti;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.identity.Group;
import org.activiti.engine.repository.Deployment;
/**
* 使用Query的singleResult方法
* @author yangenxiong
*
*/
public class SingleResult {
public static void main(String[] args) {
//创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
// 写入5条用户组数据
createGroup(identityService, UUID.randomUUID().toString(), "GroupA", "typeA");
createGroup(identityService, UUID.randomUUID().toString(), "GroupB", "typeB");
createGroup(identityService, UUID.randomUUID().toString(), "GroupC", "typeC");
createGroup(identityService, UUID.randomUUID().toString(), "GroupD", "typeD");
createGroup(identityService, UUID.randomUUID().toString(), "GroupE", "typeE");
//再写入一条名称为GroupA的数据
createGroup(identityService, UUID.randomUUID().toString(), "GroupA", "typeF");
//查询名称为GroupB的记录
Group groupB = identityService.createGroupQuery()
.groupName("GroupB").singleResult();
System.out.println("查询到一条GroupB数据：" + groupB.getId() + "---" + groupB.getName());
//查询名称为GroupF的记录
Group groupF = identityService.createGroupQuery()
.groupName("GroupF").singleResult();
System.out.println("没有groupF的数据：" + groupF);
//查询名称为GroupA的记录，这里将抛出异常
Group groupA = identityService.createGroupQuery()
.groupName("GroupA").singleResult();
}
// 将用户组数据保存到数据库中
static void createGroup(IdentityService identityService, String id,
String name, String type) {
// 调用newGroup方法创建Group实例
Group group = identityService.newGroup(id);
group.setName(name);
group.setType(type);
identityService.saveGroup(group);
}
}
用户组数据查询
在前面几节中，以用户组数据为基础，讲解了Activiti的数据查询机制以及一些公用的查询方法。Activiti的每种数据均有对应的查询对象，例如用户组的查询对象为GroupQuery，它继承了AbstractQuery，除了拥有基类的方法（asc、count、desc、list、ListPage及singleResult方法）外，它还拥有自己的查询及排序方法。
➢ groupId（String groupId）：根据ID查询与参数值一致的记录。
➢ groupMember（String groupMemberUserId）：根据用户ID查询用户所在的用户组，用户组与用户为多对多关系，因此一个用户有可能属于多个用户组。
➢ groupName（String groupName）：根据用户组名称查询用户组。
➢ groupNameLike（String groupName）：根据用户组名称模糊查询用户组数据。
➢ groupType（String groupType）：根据用户组类型查询用户组数据。
➢ orderByGroupId（）：设置排序条件为根据ID排序。
➢ orderByGroupName（）：设置排序条件为根据名称排序。
➢ orderByGroupType（）：设置排序条件为根据类型排序。
➢ potentialStarter（String procDefId）：根据流程定义的ID查询有权限启动该流程定义的用户组。
package org.crazyit.activiti;
import java.util.List;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.Group;
/**
*
* @author yangenxiong
*
*/
public class GroupQuery {
public static void main(String[] args) {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
// 写入5条用户组数据
String aId = UUID.randomUUID().toString();
createGroup(identityService, aId, "GroupA", "typeA");
createGroup(identityService, UUID.randomUUID().toString(), "GroupB", "typeB");
createGroup(identityService, UUID.randomUUID().toString(), "GroupC", "typeC");
createGroup(identityService, UUID.randomUUID().toString(), "GroupD", "typeD");
createGroup(identityService, UUID.randomUUID().toString(), "GroupE", "typeE");
// groupId方法
Group groupA = identityService.createGroupQuery().groupId(aId).singleResult();
System.out.println("groupId method: " + groupA.getId());
// groupName方法
Group groupB = identityService.createGroupQuery().groupName("GroupB").singleResult();
System.out.println("groupName method: " + groupB.getName());
// groupType方法
Group groupC = identityService.createGroupQuery().groupType("typeC").singleResult();
System.out.println("groupType method: " + groupC.getName());
// groupNameLike方法
List groups = identityService.createGroupQuery().groupNameLike("%group%").list();
System.out.println("groupNameLike method: " + groups.size());
}
// 将用户组数据保存到数据库中
static void createGroup(IdentityService identityService, String id,
String name, String type) {
// 调用newGroup方法创建Group实例
Group group = identityService.newGroup(id);
group.setName(name);
group.setType(type);
identityService.saveGroup(group);
}
}
原生SQL查询
在各个服务组件中，都提供了createNativeXXXQuery方法，该方法返回NativeXXXQuery的实例，这些对象均是NativeQuery的子接口。使用NativeQuery的方法，可以传入原生的SQL进行数据查询，主要使用sql方法传入SQL语句，使用parameter方法设置查询参数。
package org.crazyit.activiti;
import java.util.List;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.Group;
/**
* 使用NativeQuery
*
* @author yangenxiong
*
*/
public class NativeQueryTest {
public static void main(String[] args) {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
// 写入5条用户组数据
createGroup(identityService, UUID.randomUUID().toString(), "GroupA",
"typeA");
createGroup(identityService, UUID.randomUUID().toString(), "GroupB",
"typeB");
createGroup(identityService, UUID.randomUUID().toString(), "GroupC",
"typeC");
createGroup(identityService, UUID.randomUUID().toString(), "GroupD",
"typeD");
createGroup(identityService, UUID.randomUUID().toString(), "GroupE",
"typeE");
// 使用原生SQL查询全部数据
List<Group> groups = identityService.createNativeGroupQuery()
.sql("select * from ACT_ID_GROUP").list();
System.out.println("查询全部数据：" + groups.size());
// 使用原生SQL按条件查询，并设入参数，只查到一条数据
groups = identityService.createNativeGroupQuery()
.sql("select * from ACT_ID_GROUP where NAME_ = 'GroupC'")
.list();
System.out.println("按条件查询：" + groups.get(0).getName());
// 使用parameter方法设置查询参数
groups = identityService.createNativeGroupQuery()
.sql("select * from ACT_ID_GROUP where NAME_ = #{name}")
.parameter("name", "GroupD").list();
System.out.println("使用parameter方法按条件查询：" + groups.get(0).getName());
}
// 将用户组数据保存到数据库中
static void createGroup(IdentityService identityService, String id,
String name, String type) {
// 调用newGroup方法创建Group实例
Group group = identityService.newGroup(id);
group.setName(name);
group.setType(type);
identityService.saveGroup(group);
}
}
用户管理
作为流程基本元素之一，Activiti同样为用户数据提供了一套管理的API，用户数据保存在ACT_ID_USER表中，除了该表外，Activiti还提供了ACT_ID_INFO表用于保存用户信息数据
User对象
与Group对象一样，User对象同样为一个接口，其有一个子接口UserEntity，实现类为UserEntityImpl。UserEntityImpl包含以下映射属性。
➢ id：用户ID，对应ACT_ID_USER表的ID_列。
➢ firstName：用户的姓，对应ACT_ID_USER表的FIRST_列。
➢ lastName：用户的名，对应ACT_ID_USER表的LAST_列。
➢ email：用户邮箱，对应ACT_ID_USER表的EMAIL_列。
➢ password：用户密码，对应ACT_ID_USER表的PWD_列。
➢ pictureByteArrayId：用户图片的数据记录ID，对应ACT_ID_USER表的PICTURE_ID_列，该列保存ACT_GE_BYTEARRAY表数据的ID。
➢ revision：该用户数据的版本，对应ACT_ID_USER表的REV_列。
在API文档中，只能看到User接口的方法，revision字段并不让外部操作与获取。
添加用户
添加用户与创建用户组类似，Activiti也提供了一个创建User实例的方法（newUser），还提供了一个保存用户数据的方法（saveUser），类似于用户组的newGroup与saveGroup方法。
添加用户
package org.crazyit.activiti;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.User;
/**
* 添加用户
* @author yangenxiong
*
*/
public class AddUser {
public static void main(String[] args) {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
String id = UUID.randomUUID().toString();
// 使用newUser方法创建User实例
User user = identityService.newUser(id);
// 设置用户的各个属性
user.setFirstName("Angus");
user.setLastName("Young");
user.setEmail("[email protected]");
user.setPassword("abc");
// 使用saveUser方法保存用户
identityService.saveUser(user);
// 根据 id 查询
user = identityService.createUserQuery().userId(id).singleResult();
System.out.println(user.getEmail());
}
}
修改用户
package org.crazyit.activiti;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.User;
/**
* 修改用户
* @author yangenxiong
*
*/
public class UpdateUser {
public static void main(String[] args) {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
String id = UUID.randomUUID().toString();
// 创建用户
creatUser(identityService, id, "angus", "young", "[email protected]", "abc");
// 查询用户
User user = identityService.createUserQuery().userId(id).singleResult();
user.setEmail("[email protected]");
// 执行保存
identityService.saveUser(user);
}
//创建用户方法
static void creatUser(IdentityService identityService, String id, String first, String last, String email, String passwd) {
// 使用newUser方法创建User实例
User user = identityService.newUser(id);
// 设置用户的各个属性
user.setFirstName(first);
user.setLastName(last);
user.setEmail(email);
user.setPassword(passwd);
// 使用saveUser方法保存用户
identityService.saveUser(user);
}
}
删除用户
package org.crazyit.activiti;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.User;
/**
* 删除用户
* @author yangenxiong
*
*/
public class DeleteUser {
public static void main(String[] args) {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
String id = UUID.randomUUID().toString();
// 创建用户
creatUser(identityService, id, "angus", "young", "[email protected]", "abc");
System.out.println("删除前数量：" + identityService.createUserQuery().userId(id).count());
// 删除用户
identityService.deleteUser(id);
System.out.println("删除后数量：" + identityService.createUserQuery().userId(id).count());
}
//创建用户方法
static void creatUser(IdentityService identityService, String id, String first, String last, String email, String passwd) {
// 使用newUser方法创建User实例
User user = identityService.newUser(id);
// 设置用户的各个属性
user.setFirstName(first);
user.setLastName(last);
user.setEmail(email);
user.setPassword(passwd);
// 使用saveUser方法保存用户
identityService.saveUser(user);
}
}
验证用户密码
IdentityService中提供了一个checkPassword方法来验证用户的密码。在用户模块，需要分清用户与账号的概念。对于Activiti来说，用户是一类数据，而账号则是从属于某个用户的数据。此处所说的验证密码，是指验证用户的密码（ACT_ID_USER表的PWD_字段），而不是用户账号的密码。
package org.crazyit.activiti;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.User;
/**
* 验证用户密码
* @author yangenxiong
*
*/
public class CheckPasswd {
public static void main(String[] args) {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
String id = UUID.randomUUID().toString();
// 创建用户
creatUser(identityService, id, "angus", "young", "[email protected]", "abc");
// 验证用户密码
System.out.println("验证密码结果：" + identityService.checkPassword(id, "abc"));
System.out.println("验证密码结果：" + identityService.checkPassword(id, "c"));
}
//创建用户方法
static void creatUser(IdentityService identityService, String id, String first, String last, String email, String passwd) {
// 使用newUser方法创建User实例
User user = identityService.newUser(id);
// 设置用户的各个属性
user.setFirstName(first);
user.setLastName(last);
user.setEmail(email);
user.setPassword(passwd);
// 使用saveUser方法保存用户
identityService.saveUser(user);
}
}
用户数据查询
与用户组类似，用户同样有一个UserQuery查询对象，并且该对象也提供了相应的查询与排序方法，我们也可以调用list或者singleResult方法返回查询数据。UserQuery中包括了如下这些方法。
➢ userEamil（String email）：根据Email值查询用户数据。
➢ usreEmailLike（String emailLike）：根据Email值模糊查询用户数据。
➢ userFirstName（String firstName）：根据用户的姓查询用户数据。
➢ userFirstNameLike（String firstNameLike）：根据用户的姓模糊查询用户数据。
➢ userId（String id）：根据用户ID查询用户数据。
➢ userLastName（String lastName）：根据用户的名查询用户数据。
➢ userLastNameLike（String lastNameLike）：根据用户的名模糊查询用户数据。
➢ memberOfGroup（String groupId）：根据用户组ID查询属于该组的全部用户数据。
➢ orderByUserEmail（）：设置根据Email进行排序。
➢ orderByUserFirstName（）：设置根据用户的姓进行排序。
➢ orderByUserId（）：设置根据ID进行排序。
➢ orderByUserLastName（）：设置根据用户的名进行排序。
➢ potentialStarter（String procDefId）：根据流程定义的ID查询有权限启动流程定义的用户。
package org.crazyit.activiti;
import java.util.List;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.User;
/**
* 查询用户数据
*
* @author yangenxiong
*
*/
public class UserQuery {
/**
* @param args
*/
public static void main(String[] args) {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
String id1 = UUID.randomUUID().toString();
String id2 = UUID.randomUUID().toString();
// 创建两个用户
creatUser(identityService, id1, "angus", "young",
"[email protected]", "abc");
creatUser(identityService, id2, "angus2", "young2", "[email protected]",
"123");
// 调用UserQuery的各个查询方法
// userId
User user = identityService.createUserQuery().userId(id1)
.singleResult();
System.out.println("userId:" + user.getFirstName());
// userFirstName
user = identityService.createUserQuery().userFirstName("angus")
.singleResult();
System.out.println("userFirstName:" + user.getFirstName());
// userFirstNameLike
List datas = identityService.createUserQuery()
.userFirstNameLike("angus%").list();
System.out.println("createUserQuery:" + datas.size());
// userLastName
user = identityService.createUserQuery().userLastName("young")
.singleResult();
System.out.println("userLastName:" + user.getFirstName());
// userLastNameLike
datas = identityService.createUserQuery().userLastNameLike("young%")
.list();
System.out.println("userLastNameLike:" + datas.size());
// userEmail
user = identityService.createUserQuery().userEmail("[email protected]")
.singleResult();
System.out.println("userEmail:" + user.getFirstName());
// userEmailLike
datas = identityService.createUserQuery().userEmailLike("%163.com")
.list();
System.out.println("userEmailLike:" + datas.size());
// 使用NativeQuery
datas = identityService.createNativeUserQuery()
.sql("select * from ACT_ID_USER where EMAIL_ = #{email}")
.parameter("email", "[email protected]").list();
System.out.println("native query:" + datas.get(0).getEmail());
}
// 创建用户方法
static void creatUser(IdentityService identityService, String id,
String first, String last, String email, String passwd) {
// 使用newUser方法创建User实例
User user = identityService.newUser(id);
// 设置用户的各个属性
user.setFirstName(first);
user.setLastName(last);
user.setEmail(email);
user.setPassword(passwd);
// 使用saveUser方法保存用户
identityService.saveUser(user);
}
}
设置认证用户
IdentityService中提供了一个setAuthenticatedUserId方法来将用户ID设置到当前的线程中，setAuthenticatedUserId方法最终调用的是ThreadLocal的set方法。这意味着，如果启动两条线程，在线程中分别调用setAuthenticatedUserId方法，则在相应线程中会输出不同的结果
package org.crazyit.activiti;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.User;
import org.activiti.engine.impl.identity.Authentication;
public class AuthenticatedUserId {
/**
* @param args
*/
public static void main(String[] args) {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
final IdentityService identityService = engine.getIdentityService();
// 设置当前线程的userId为1
identityService.setAuthenticatedUserId("3");
System.out.println("当前线程usreId：" + Authentication.getAuthenticatedUserId());
// 启动两条线程
new Thread() {
public void run() {
try {
identityService.setAuthenticatedUserId("1");
Thread.sleep(5000);
System.out.println("线程1的userId：" + Authentication.getAuthenticatedUserId());
} catch (Exception e) {
}
}
}.start();
new Thread() {
public void run() {
identityService.setAuthenticatedUserId("2");
System.out.println("线程2的usrId：" + Authentication.getAuthenticatedUserId());
}
}.start();
}
//创建用户方法
static void creatUser(IdentityService identityService, String id, String first, String last, String email, String passwd) {
// 使用newUser方法创建User实例
User user = identityService.newUser(id);
// 设置用户的各个属性
user.setFirstName(first);
user.setLastName(last);
user.setEmail(email);
user.setPassword(passwd);
// 使用saveUser方法保存用户
identityService.saveUser(user);
}
}
用户信息管理
在Activiti中，用户与账号为不同的概念，用户数据已经在上一节讲述过了，Activiti将一些用户相关的信息抽象出来，使用单独的一个数据表来保存。这些用户相关的信息包括账号信息和自定义的用户信息，这些信息均保存在ACT_ID_INFO表中。除了这些用户信息外，还有用户的图片资源，图片被保存在Activiti公共的资源表ACT_GE_BYTEARRAY中
添加和删除用户信息
就像用户组与用户的数据一样，同样有一个实体与用户信息映射，对应的实体类为IdentityInfoEntityImpl，但是与用户和用户组不一样的是，Activiti并没有为其提供相应的Query对象，因为这个表的数据结构是key-value形式，只需要知道key就可以查询到相应的数据。以下为添加和删除用户方法的描述。
➢ setUserInfo（String userId，String key，String value）：为用户添加用户信息，第一个参数为用户数据的ID，第二个参数为用户信息的名称，第三个参数为该用户信息的值。
➢ deleteUserInfo（String userId，String key）：删除用户信息，第一个参数为用户ID，第二个参数为用户信息的名称。
package org.crazyit.activiti;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.User;
/**
* 添加删除用户信息
* @author yangenxiong
*
*/
public class AddDeleteUserInfo {
/**
* @param args
*/
public static void main(String[] args) {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
String id = UUID.randomUUID().toString();
// 创建用户
creatUser(identityService, id, "angus", "young", "[email protected]", "abc");
// 创建一个用户信息
identityService.setUserInfo(id, "age", "30");
// 创建第二个用户信息
identityService.setUserInfo(id, "weight", "60KG");
// 删除用户年龄信息
identityService.deleteUserInfo(id, "age");
}
//创建用户方法
static void creatUser(IdentityService identityService, String id, String first, String last, String email, String passwd) {
// 使用newUser方法创建User实例
User user = identityService.newUser(id);
// 设置用户的各个属性
user.setFirstName(first);
user.setLastName(last);
user.setEmail(email);
user.setPassword(passwd);
// 使用saveUser方法保存用户
identityService.saveUser(user);
}
}
查询用户信息
成功将用户信息保存到数据库后，如果需要使用这些信息，则可以调用IdentityService的getUserInfo方法来查找这些信息，使用该方法需要提供用户的ID与信息的键值。调用该方法后，将返回相应信息的字符串。
package org.crazyit.activiti;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.User;
/**
* 查询用户信息
* @author yangenxiong
*
*/
public class GetUserInfo {
/**
* @param args
*/
public static void main(String[] args) {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
String id = UUID.randomUUID().toString();
// 创建用户
creatUser(identityService, id, "angus", "young", "[email protected]", "abc");
// 创建一个用户信息
identityService.setUserInfo(id, "age", "30");
// 创建第二个用户信息
identityService.setUserInfo(id, "weight", "60KG");
// 查询用户信息
String value = identityService.getUserInfo(id, "age");
System.out.println("用户年龄为：" + value);
}
//创建用户方法
static void creatUser(IdentityService identityService, String id, String first, String last, String email, String passwd) {
// 使用newUser方法创建User实例
User user = identityService.newUser(id);
// 设置用户的各个属性
user.setFirstName(first);
user.setLastName(last);
user.setEmail(email);
user.setPassword(passwd);
// 使用saveUser方法保存用户
identityService.saveUser(user);
}
}
设置用户图片
Activiti专门提供了一个数据表来保存文件数据，即ACT_GE_BYTEARRAY表。Activiti会读取文件，并将这些文件转换为byte数组，然后保存到表中。IdentityService提供了setUserPicture和getUserPicture方法用来设置和查找用户图片数据，其中对setUserPicture方法需要设置两个参数：用户ID和Picture实例。
package org.crazyit.activiti;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.util.UUID;
import javax.imageio.ImageIO;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.Picture;
import org.activiti.engine.identity.User;
/**
* 设置用户图片
* @author yangenxiong
*
*/
public class UserPicture {
public static void main(String[] args) throws Exception {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
String id = UUID.randomUUID().toString();
// 创建用户
creatUser(identityService, id, "angus", "young", "[email protected]", "abc");
// 读取图片并转换为byte数组
FileInputStream fis = new FileInputStream(new File("resource/artifact/picture.png"));
BufferedImage img = ImageIO.read(fis);
ByteArrayOutputStream output = new ByteArrayOutputStream();
ImageIO.write(img, "png", output);
//获取图片的byte数组
byte[] picArray = output.toByteArray();
// 创建Picture实例
Picture picture = new Picture(picArray, "angus image");
// 为用户设置图片
identityService.setUserPicture(id, picture);
}
//创建用户方法
static void creatUser(IdentityService identityService, String id, String first, String last, String email, String passwd) {
// 使用newUser方法创建User实例
User user = identityService.newUser(id);
// 设置用户的各个属性
user.setFirstName(first);
user.setLastName(last);
user.setEmail(email);
user.setPassword(passwd);
// 使用saveUser方法保存用户
identityService.saveUser(user);
}
}
用户组与用户的关系
在Activiti中，一个用户可以被分配到多个用户组中，一个用户组中可以包含多个用户，针对这种情况，Activiti使用了中间表来保存这两种数据间的关系。通过关系表的数据，可以清楚地看到用户组与用户之间的关系，Activiti也提供了相应的API来操作这种关系。这个中间表为ACT_ID_MEMBERSHIP表，这里需要注意的是，Activiti并没有为这个表做实体的映射。
绑定关系
绑定关系，意味着向ACT_ID_MEMBERSHIP表写入一条关系数据，只需要指定这个关系的用户ID和用户组ID，再调用IdentityService的createMembership方法即可，该方法第一个参数为用户ID，第二个参数为用户组ID。
package org.crazyit.activiti;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.Group;
import org.activiti.engine.identity.User;
/**
* 绑定用户组与用户的关系
*
* @author yangenxiong
*
*/
public class CreateMemberShip {
public static void main(String[] args) {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
// 保存一个用户
User user = creatUser(identityService, UUID.randomUUID().toString(),
"angus", "young", "[email protected]", "abc");
// 保存一个用户组
Group group = createGroup(identityService,
UUID.randomUUID().toString(), "经理组", "manager");
// 绑定关系
identityService.createMembership(user.getId(), group.getId());
}
// 创建用户方法
static User creatUser(IdentityService identityService, String id,
String first, String last, String email, String passwd) {
// 使用newUser方法创建User实例
User user = identityService.newUser(id);
// 设置用户的各个属性
user.setFirstName(first);
user.setLastName(last);
user.setEmail(email);
user.setPassword(passwd);
// 使用saveUser方法保存用户
identityService.saveUser(user);
return identityService.createUserQuery().userId(id).singleResult();
}
// 将用户组数据保存到数据库中
static Group createGroup(IdentityService identityService, String id,
String name, String type) {
// 调用newGroup方法创建Group实例
Group group = identityService.newGroup(id);
group.setName(name);
group.setType(type);
identityService.saveGroup(group);
return identityService.createGroupQuery().groupId(id).singleResult();
}
}
解除绑定
package org.crazyit.activiti;
import java.util.List;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.Group;
import org.activiti.engine.identity.User;
/**
* 根据用户组ID查询用户组下的用户
* @author yangenxiong
*
*/
public class DeleteMemberShip {
public static void main(String[] args) {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
// 保存两个用户
User user = creatUser(identityService, "1", "angus", "young", "[email protected]", "abc");
// 保存一个用户组
Group group = createGroup(identityService, "2", "Group A", "manager");
// 将两个用户分配到用户组下
identityService.createMembership(user.getId(), group.getId());
// 删除绑定关系
identityService.deleteMembership(user.getId(), group.getId());
}
//创建用户方法
static User creatUser(IdentityService identityService, String id, String first, String last, String email, String passwd) {
// 使用newUser方法创建User实例
User user = identityService.newUser(id);
// 设置用户的各个属性
user.setFirstName(first);
user.setLastName(last);
user.setEmail(email);
user.setPassword(passwd);
// 使用saveUser方法保存用户
identityService.saveUser(user);
return identityService.createUserQuery().userId(id).singleResult();
}
// 将用户组数据保存到数据库中
static Group createGroup(IdentityService identityService, String id,
String name, String type) {
// 调用newGroup方法创建Group实例
Group group = identityService.newGroup(id);
group.setName(name);
group.setType(type);
identityService.saveGroup(group);
return identityService.createGroupQuery().groupId(id).singleResult();
}
}
查询用户组下的用户
根据中间表的设计，大致可以猜到memberOfGroup方法的实现过程，先到ACT_ID_MEMBERSHIP表中根据groupId进行查询，获取全部的userId后，再到ACT_ID_USER表中查询用户数据
package org.crazyit.activiti;
import java.util.List;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.Group;
import org.activiti.engine.identity.User;
/**
* 绑定用户组与用户的关系
*
* @author yangenxiong
*
*/
public class QueryUsersByGroup {
public static void main(String[] args) {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
// 保存两个用户
User user1 = creatUser(identityService, UUID.randomUUID().toString(),
"张经理", "young", "[email protected]", "abc");
User user2 = creatUser(identityService, UUID.randomUUID().toString(),
"李经理", "young2", "[email protected]", "abc");
// 保存一个用户组
Group group = createGroup(identityService,
UUID.randomUUID().toString(), "经理组", "manager");
// 将两个用户分配到用户组下
identityService.createMembership(user1.getId(), group.getId());
identityService.createMembership(user2.getId(), group.getId());
List<User> users = identityService.createUserQuery()
.memberOfGroup(group.getId()).list();
System.out.println("经理组有如下人员：");
for (User user : users) {
System.out.println(user.getFirstName());
}
}
// 创建用户方法
static User creatUser(IdentityService identityService, String id,
String first, String last, String email, String passwd) {
// 使用newUser方法创建User实例
User user = identityService.newUser(id);
// 设置用户的各个属性
user.setFirstName(first);
user.setLastName(last);
user.setEmail(email);
user.setPassword(passwd);
// 使用saveUser方法保存用户
identityService.saveUser(user);
return identityService.createUserQuery().userId(id).singleResult();
}
// 将用户组数据保存到数据库中
static Group createGroup(IdentityService identityService, String id,
String name, String type) {
// 调用newGroup方法创建Group实例
Group group = identityService.newGroup(id);
group.setName(name);
group.setType(type);
identityService.saveGroup(group);
return identityService.createGroupQuery().groupId(id).singleResult();
}
}
查询用户所属的用户组
与memberOfGroup方法类似，groupMember方法会根据用户的ID，查询该用户所属的用户组。同样，该方法会到中间表中查询该用户的全部关系数据并且得到groupId，然后根据这些groupId再到用户组的表中查询用户组数据。
package org.crazyit.activiti;
import java.util.List;
import java.util.UUID;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.identity.Group;
import org.activiti.engine.identity.User;
/**
* 绑定用户组与用户的关系
*
* @author yangenxiong
*
*/
public class QueryGroupsByUser {
public static void main(String[] args) {
// 创建流程引擎
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 得到身份服务组件实例
IdentityService identityService = engine.getIdentityService();
// 创建一个用户
User user = creatUser(identityService, UUID.randomUUID().toString(),
"张三", "young", "[email protected]", "abc");
// 创建两个用户组
Group group1 = createGroup(identityService, UUID.randomUUID()
.toString(), "经理组", "manager");
Group group2 = createGroup(identityService, UUID.randomUUID()
.toString(), "员工组", "manager");
// 将用户与两个用户组绑定关系
identityService.createMembership(user.getId(), group1.getId());
identityService.createMembership(user.getId(), group2.getId());
// 调用memberOfGroup方法查询用户所在的用户组
List<Group> groups = identityService.createGroupQuery()
.groupMember(user.getId()).list();
System.out.println("张三属于的用户组有：");
for (Group group : groups) {
System.out.println(group.getName());
}
}
// 创建用户方法
static User creatUser(IdentityService identityService, String id,
String first, String last, String email, String passwd) {
// 使用newUser方法创建User实例
User user = identityService.newUser(id);
// 设置用户的各个属性
user.setFirstName(first);
user.setLastName(last);
user.setEmail(email);
user.setPassword(passwd);
// 使用saveUser方法保存用户
identityService.saveUser(user);
return identityService.createUserQuery().userId(id).singleResult();
}
// 将用户组数据保存到数据库中
static Group createGroup(IdentityService identityService, String id,
String name, String type) {
// 调用newGroup方法创建Group实例
Group group = identityService.newGroup(id);
group.setName(name);
group.setType(type);
identityService.saveGroup(group);
return identityService.createGroupQuery().groupId(id).singleResult();
}
}