工作流第六章之用户组与用户

某些企业会将相同职能的人作为一类人进行管理，也会有某些企业，将相同的角色（职能不同）作为一类人进行管理，这些类别就是本章所说的用户组。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配置文件

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans   http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/act" />
		<property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
		<property name="jdbcUsername" value="root" />
		<property name="jdbcPassword" value="root" />
		<property name="databaseSchemaUpdate" value="true"/>
	</bean>

</beans>

创建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<Group> 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("yangenxiong@163.com");
		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", "yangenxiong@163.com", "abc");
		// 查询用户
		User user = identityService.createUserQuery().userId(id).singleResult();
		user.setEmail("abc@163.com");
		// 执行保存
		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", "yangenxiong@163.com", "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", "yangenxiong@163.com", "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",
				"yangenxiong@163.com", "abc");
		creatUser(identityService, id2, "angus2", "young2", "abc@163.com",
				"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<User> 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("abc@163.com")
				.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", "yangenxiong@163.com").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", "yangenxiong@163.com", "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", "yangenxiong@163.com", "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", "yangenxiong@163.com", "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", "yangenxiong@163.com", "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", "yangenxiong@163.com", "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", "yangenxiong@163.com", "abc");
		User user2 = creatUser(identityService, UUID.randomUUID().toString(),
				"李经理", "young2", "yangenxiong@163.com", "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", "yangenxiong@163.com", "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();
	}
}