某些企业会将相同职能的人作为一类人举行管理，也会有某些企业，将相同的脚色（职能差别）作为一类人举行管理，这些种别就是本章所说的用户组。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提供了一套数据查询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.ConsoleAppenderlog4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayoutlog4j.appender.CONSOLE.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1} - %m%nlog4j.logger.org.apache=INFOlog4j.logger.org.htmlparser=INFOlog4j.logger.org.htmlparser=INFOlog4j.logger.org.crazyit=DEBUGlog4j.logger.org.drools=DEBUGlog4j.logger.org.mule=ERRORlog4j.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 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); }}
- 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 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.sql22:44:25,329 INFO DbSqlSession - Found MySQL: majorVersion=5 minorVersion=722:44:25,449 INFO ProcessEngineImpl - ProcessEngine default created22:44:25,483 INFO ProcessEngines - initialised process engine default3---GroupC 4---GroupD 5---GroupE
该方法用于盘算查询效果的数据量，雷同于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 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); }}
在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 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 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); }}
该方法根据查询条件，到数据库中查询唯一的数据记载，如果没有找到符合条件的数据，则返回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); }}
在各个服务组件中，都提供了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 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 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 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 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(); }}
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！ |
