关于FoxBPM选择器介绍

  

  目前FoxBPM提供两种连接器：1：连接器，2：选择器，关于选择器，请参考gihub官方(https://github.com/FoxBPM)的foxbpm-connector工程

    

  选择器如下图
   

 

    下面介绍以上每种选择器的功能:

    参考图: 
     

     首先我们所有选择器都是继承ActorConnectorHandler.java抽象类并实现public abstract void assign(DelegateTask task) throws Exception;方法，而ActorConnectorHandler类又实现FlowConnectorHandler接口并实现void execute(ConnectorExecutionContext executionContext) throws Exception;方法，

import org.foxbpm.engine.execution.ConnectorExecutionContext;
import org.foxbpm.engine.impl.entity.TokenEntity;
import org.foxbpm.engine.task.DelegateTask;

public abstract class ActorConnectorHandler implements FlowConnectorHandler {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	public void execute(ConnectorExecutionContext executionContext) throws Exception {
		assign(((TokenEntity) executionContext).getAssignTask());
	}
	public abstract void assign(DelegateTask task) throws Exception;
}

   选择器统一调用时机是在任务分配的时候,

/** 判断是否有强制任务处理者指定 */
		if(StringUtil.isNotEmpty(tokenEntity.getTaskAssignee())){
			/** 根据强制任务处理者设置任务 */
			task.setAssignee(tokenEntity.getTaskAssignee());
		}else{
			/** 重新分配任务 */
			for (Connector connector : taskDefinition.getActorConnectors()) {
				try {
					connector.notify((ListenerExecutionContext) executionContext);
				} catch (Exception e) {
					if(e instanceof FoxBPMException)
						throw (FoxBPMException)e;
					else{
						throw new FoxBPMException("执行选择人处理器失败！节点"+this.getId()+",处理器："+connector.getConnectorId() , e);
					}
				}
			}
		}

    最后执行Connector中的execute方法,

public void execute(ListenerExecutionContext executionContext) throws Exception {
		try {
			String classNameObj = packageName + "." + className;
			Class<?> connectorHandlerClass = Class.forName(classNameObj);
			FlowConnectorHandler connectorInstance = (FlowConnectorHandler) connectorHandlerClass
					.newInstance();

			FlowNodeExecutionContext flowNodeExecutionContext = (FlowNodeExecutionContext) executionContext;
			for (ConnectorInputParam connectorParameterInputs : this.getConnectorInputsParam()) {
				Class<?> ptypes[] = new Class[1];
				ptypes[0] = Class.forName(connectorParameterInputs.getDataType());
				String parameterInputsId = connectorParameterInputs.getId();
				String methodString = SETFUNCTION_PREFFIX
						+ parameterInputsId.substring(0, 1).toUpperCase()
						+ parameterInputsId.substring(1, parameterInputsId.length());
				Method m = connectorHandlerClass.getMethod(methodString, ptypes);
				if (connectorParameterInputs.getExpression() != null) {
					Object arg[] = new Object[1];
					if (!connectorParameterInputs.getExpression().isNullText()
							&& connectorParameterInputs.isExecute()) {
						arg[0] = connectorParameterInputs.getExpression().getValue(
								flowNodeExecutionContext);
					} else {
						arg[0] = connectorParameterInputs.getExpression().getExpressionText();
					}
					m.invoke(connectorInstance, arg);
				}

			}

			connectorInstance.execute((ConnectorExecutionContext) executionContext);
			for (ConnectorOutputParam connectorParameterOutputs : this.getConnectorOutputsParam()) {
				if (!StringUtil.isEmpty(connectorParameterOutputs.getOutputId())) {
					String parameterOutputsId = connectorParameterOutputs.getOutputId();
					String methodString = GETFUNCTION_PREFFIX
							+ parameterOutputsId.substring(0, 1).toUpperCase()
							+ parameterOutputsId.substring(1, parameterOutputsId.length());
					Method m = connectorHandlerClass.getMethod(methodString);
					String variableTarget = connectorParameterOutputs.getVariableTarget();
					// Object arg[] = new Object[1];
					// arg[0] =Context.getBshInterpreter().eval(scriptString);

					Object objectValue = m.invoke(connectorInstance);
					ExpressionMgmt.setVariable(variableTarget, objectValue,
							flowNodeExecutionContext);
				}

			}

		} catch (Exception e) {
			throw new FoxBPMConnectorException(e.getMessage(), e);
		}
	}

    对于选择器如果出现异常情况，一般从以上调用入口排查。
 

    1、发起人

          功能描述：根据“发起人”选择器，来指定任务的处理者。

          实现参考：

         

public class InitiatorActorConnector extends ActorConnectorHandler {

	private static final long serialVersionUID = 1L;

	@Override
	public void assign(DelegateTask task) throws Exception {
		String initiator=task.getExecutionContext().getInitiator();
		if(StringUtil.isEmpty(initiator)){
			throw new FoxBPMConnectorException("流程的提交人未找到,请重新检查借点的人员配置.");
		}
		task.setAssignee(initiator);
	}

}

        

    其中assignType是保留参数。

          实例说明：例如A用户提交“请假申请”---》“项目主管”，而“项目主管”任务分配使用“发起人”选择器，那么A用户可以处理"项目主管"任务。

         注意：

         1、该连接器不需要指定输入参数。

         2、发起人是从流程实例上获取的，参考UserTaskBehavior.java中execute方法。    

 
    2、所有人

          功能描述：根据“所有人”选择器，来指定任务的处理者。

          实现参考： 

         

public class AllUserActorConnector extends ActorConnectorHandler {

	private static final long serialVersionUID = 1L;

	@Override
	public void assign(DelegateTask task) throws Exception {
		task.addCandidateUser(Constant.FOXBPM_ALL_USER);
	}

}

 

          实例说明：例如A用户提交“请假申请”---》“项目主管”，而“项目主管”任务分配使用“所有人”选择器，那么A用户以及系统中其他用户都可以来领取"项目主管"任务（如果有一个用户领取任务，那么该任务对其他人不可见）。

         注意：该链接器不需要指定输入参数。
    3、启动人

          功能描述：指定任务的处理者为任务的“启动人”。

          实现参考：

         

public class StartAuthorActorConnector extends ActorConnectorHandler {
	private static final long serialVersionUID = 1L;
        /** humanPerformer独占 potentialOwner共享*/
	private String assignType;
	public void setAssignType(String assignType) {
		this.assignType = assignType;
	}
	@Override
	public void assign(DelegateTask task) throws Exception {
		String initiator=task.getExecutionContext().getStartAuthor();
		if(StringUtil.isEmpty(initiator)){
			throw new FoxBPMConnectorException("流程的提交人未找到,请重新检查借点的人员配置.");
		}
		
		if(assignType!=null){
			if(assignType.equals("humanPerformer")){
				task.setAssignee(initiator);
			}
			else{
				task.addCandidateUser(initiator);
			}
		}else{
			task.setAssignee(initiator);
		}
	}
}

    其中assignType是保留参数。

          实例说明：例如A用户提交“请假申请”---》“项目主管”，而“项目主管”任务分配使用选择器“启动人”，那么A用户可以来处理"项目主管"任务。

          注意：

          1、该链接器不需要指定输入参数。

          2、启动人是指首次启动流程时的用户（系统登录人），参考启动流程命令StartProcessInstanceCmd类      

     // 启动流程实例
      ProcessInstanceEntity processInstance = processDefinition.createProcessInstance(bizKey);
     if (transientVariables != null) {
	    processInstance.setTransVariables(transientVariables);
	}
     if (persistenceVariables != null) {
	    processInstance.setVariables(persistenceVariables);
	}
     String initiator = Authentication.getAuthenticatedUserId();
     processInstance.setInitiator(initiator);
     processInstance.setStartAuthor(initiator);
     processInstance.start();

    关于Authentication.getAuthenticatedUserId();是通过用户登录系统后设置（具体参考foxBPM的foxbpm-webapps-base项目中FoxbpmUserInterceptor拦截器）。
    4、上一步骤处理者

           功能描述：指定任务的处理者为任务的“上一步处理者”。

           实现参考：

          

/**
 * 上一步骤处理者
 * 
 * @author yangguangftlp
 * @date 2014年7月14日
 */
public class LastStepActorConnector extends ActorConnectorHandler {

	private static final long serialVersionUID = 1L;

	@Override
	public void assign(DelegateTask task) throws Exception {
		String userId = Authentication.getAuthenticatedUserId();
		if (StringUtil.isEmpty(userId)) {
			throw new FoxBPMConnectorException("上一步处理者未找到,请重新检查借点的人员配置.");
		}
		task.setAssignee(userId);
	}
}

 

          实例说明：例如A用户提交“请假申请”---》“项目主管”，而“项目主管”任务分配使用选择器“上一步处理者”，那么“项目主管”任务处理者就是A用户。

          注意：该链接器不需要指定输入参数。
    5、系统登陆人

          功能描述：指定任务的处理者为“系统登陆人”。

          实现参考：

         

public class UserIdActorConnector extends ActorConnectorHandler {
	private static final long serialVersionUID = 1L;
	/** humanPerformer独占 potentialOwner共享*/
	private String assignType;
	public void setAssignType(String assignType) {
		this.assignType = assignType;
	}
	@Override
	public void assign(DelegateTask task) throws Exception {
	       String userId = Authentication.getAuthenticatedUserId();
		if(StringUtil.isEmpty(userId)){
			throw new FoxBPMConnectorException("流程的提交人未找到,请重新检查借点的人员配置.");
		}
		if(assignType!=null){
			if(assignType.equals("humanPerformer")){
				task.setAssignee(userId);
			}
			else{
				task.addCandidateUser(userId);
			}
		}else{
			task.setAssignee(userId);
		}
	}
}

   其中assignType是保留参数。

          实例说明：该选择器和“上一步骤处理者”选择器处理是相同。

          注意：该链接器不需要指定输入参数。

    6、选择用户

          功能描述：通过“选择用户”来指定任务的处理者。

          实现参考：

         

public class SelectUserActorConnector extends ActorConnectorHandler {

	private static final long serialVersionUID = 1L;

	private java.lang.String userId;

	public void setUserId(java.lang.String userId) {
		this.userId = userId;
	}

	@Override
	public void assign(DelegateTask task) throws Exception {

		if (StringUtil.isEmpty(StringUtil.trim(userId))) {
			throw new FoxBPMConnectorException("userId is null !");
		}

		List<String> userList = AssigneeUtil.executionExpressionObj(userId);
		if (userList.size() == 1) {
			task.setAssignee(userList.get(0));
		} else {
			task.addCandidateUsers(userList);
		}
	}
}

 

          实例说明：例如A用户提交“请假申请”---》“项目主管”，而“项目主管”任务处理指定B用户，那么有B用户来处理“项目主管”任务。

           注意：

           1、该连接器需要输入用户ID，可以输入多用户ID（逗号分隔），输入的用户ID必须存在，否则任务分配失败。

           2、如果只输入一个用户ID，那么该用户就是任务处理者，如果输入多个用户ID，那么这些用户就是任务的候选人（这些用户都可以领取任务）。
    7、选择部门

          功能描述：通过“选择部门”来指定任务处理的候选人。

          实现参考：

         

public class SelectDeptActorConnector extends ActorConnectorHandler {
	private static final long serialVersionUID = 1L;
	private java.lang.String deptId;
	public void setDeptId(java.lang.String deptId) {
		this.deptId = deptId;
	}
	@Override
	public void assign(DelegateTask task) throws Exception {

		if (StringUtil.isEmpty(StringUtil.trim(deptId))) {
			throw new FoxBPMConnectorException("deptId is null !");
		}
		List<String> deptList = AssigneeUtil.executionExpressionObj(deptId);
		for (String deptId : deptList) {
			GroupEntity group = new GroupEntity(deptId, "dept");
			task.addCandidateGroupEntity(group);
		}
	}
}

 

          实例说明：例如A用户提交“请假申请”---》“项目主管”，而将“项目主管”任务分配给C部门处理，那么C部门下的所有人都可以处理“项目主管”审批任务。

          注意：

           1、该连接器需要输入部门ID，可以输入多个部门ID（逗号分隔），输入的部门ID必须存在，否则任务分配失败。

           2、对于输入一个部门ID或多个部门ID,该连接器都是将这些部门设置为任务的候选组，这些部门的下的所有用户都可以处理该任务。
    8、选择角色

          功能描述：通过“选择角色”来指定任务处理的候选人。

          实现参考：

         

public class SelectRole extends ActorConnectorHandler {
	/**
	 * 
	 */
	private static final long serialVersionUID = -5466313199990930905L;
	private java.lang.String roleId;
	public void assign(DelegateTask task) throws Exception {
		if (StringUtil.isEmpty(StringUtil.trim(roleId))) {
			throw new FoxBPMConnectorException("roleId is null!");
		}
		// 处理角色重复
		StringTokenizer st = new StringTokenizer(StringUtil.trim(roleId), Constants.COMMA);
		Set<String> roleIdSet = new HashSet<String>();
		while (st.hasMoreTokens()) {
			roleIdSet.add(StringUtil.trim(st.nextToken()));
		}
		// 处理角色
		for (String id : roleIdSet) {
			task.addGroupIdentityLink(id, Constant.ROLE_TYPE, IdentityLinkType.CANDIDATE);
		}
	}
	public void setRoleId(java.lang.String roleId) {
		this.roleId = roleId;
	}
}

 

          注意：

          1、该连接器需要输入角色ID，可以输入多个角色ID（逗号分隔），输入的角色ID必须存在，否则任务分配失败。

          2、该连接器和“选择部门”连接器，处理方式相同。
    9、资源中任务最少者

          功能描述：根据用户当前的资源情况来指定任务处理者。

          实现参考：

         

public class SelectTaskByLeast extends ActorConnectorHandler {
	/**
	 * 
	 */
	private static final long serialVersionUID = -7475673707019152696L;
	private java.lang.String userId;

	public void assign(DelegateTask task) throws Exception {

		if (StringUtil.isEmpty(StringUtil.trim(userId))) {
			throw new FoxBPMConnectorException("userId is null!");
		}
		// 获取待分配的用户
		List<String> userIds = Arrays.asList(StringUtil.trim(userId).split(Constants.COMMA));
		if (userIds.size() == 1) {
			// 直接分配
			task.setAssignee(StringUtil.trim(userId));
		} else {
			// 过滤重复用户id
			Set<String> userIdSet = new HashSet<String>();
			for (String id : userIds) {
				userIdSet.add(StringUtil.trim(id));
			}
			// 处理用户id重复输入
			Map<String, Integer> userTasks = new HashMap<String, Integer>();
			TaskService taskService = Context.getProcessEngineConfiguration().getTaskService();
			TaskQuery taskQuery = null;
			// 记录每个用户的任务数
			for (String id : userIdSet) {
				taskQuery = taskService.createTaskQuery();
				taskQuery.taskAssignee(id);
				taskQuery.taskCandidateUser(id);
				taskQuery.taskNotEnd();
				// 如果数据量大 long 转换int 可能存在问题
				userTasks.put(id, StringUtil.getInt(taskQuery.count()));
			}
			// 排序
			List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(userTasks.entrySet());
			Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
				public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
					return (o1.getValue()).compareTo(o2.getValue());
				}
			});
			task.setAssignee(list.get(0).getKey());
		}
	}

	public void setUserId(java.lang.String userId) {
		this.userId = userId;
	}

}

 

          实例说明：例如：A用户提交“请假申请”---》“项目主管”，而“项目主管”任务分配选择“资源中任务最少者”，其中输入用户ID为A,B,C,D四个用户ID，该选择器将会根据用户ID遍历获取用户的当前
 的任务数（包括“共享”和“独占”），并且取任务最少者作为“项目主管”任务处理者，如果只存在一个用户ID，那么就默认设置为“项目主管”任务的处理者。

         注意：

         1、该连接器需要输入用户ID，可以输入多个用户ID（逗号分隔），输入的用户ID必须存在，否则任务分配失败。

   10、资源中随机分配

          功能描述：根据用户当前的资源随机指定任务处理者。

          实现参考：

         

public class RandomAssign extends ActorConnectorHandler {

	/**
	 * 
	 */
	private static final long serialVersionUID = 325047500772052099L;
	private java.lang.String userId;

	public void assign(DelegateTask task) throws Exception {
		if (StringUtil.isEmpty(StringUtil.trim(userId))) {
			throw new FoxBPMConnectorException("userId is null!");
		}
		// 获取待分配的用户
		List<String> userIds = Arrays.asList(StringUtil.trim(userId).split(Constants.COMMA));
		if (userIds.size() == 1) {
			task.setAssignee(StringUtil.trim(userId));
		} else {
			// 随机产生
			Random random = new Random();
			int index = random.nextInt(userIds.size());
			task.setAssignee(StringUtil.trim(userIds.get(index)));
		}

	}

	public void setUserId(java.lang.String userId) {
		this.userId = userId;
	}

}

 

          实例说明：例如：A用户提交“请假申请”---》“项目主管”，而“项目主管”任务分配选择“资源中任务最少者”，其中输入用户ID为A,B,C,D四个用户ID，该选择器将会自动随机选中一个用户作为“项目主管”任务处理者，如果只存在一个用户ID，那么就默认设置为“项目主管”任务的处理者。

         注意：

         1、该连接器需要输入用户ID，可以输入多个用户ID（逗号分隔），输入的用户ID必须存在，否则任务分配失败。
   12、选择某部门和某角色

          功能描述：根据用户当前的资源随机指定任务处理者。

          实现参考：

         

public class SelectDepartmentAndRole extends ActorConnectorHandler {

	/**
	 * 
	 */
	private static final long serialVersionUID = 6171386850998648156L;

	private java.lang.String departmentId;

	private java.lang.String roleId;

	public void assign(DelegateTask task) throws Exception {

		if (StringUtil.isEmpty(StringUtil.trim(departmentId))) {
			throw new FoxBPMConnectorException("departmentId is null!");
		}
		if (StringUtil.isEmpty(StringUtil.trim(roleId))) {
			throw new FoxBPMConnectorException("roleId is null!");
		}
		// 获取部门下所有用户
		List<String> deptList = Authentication.selectUserIdsByGroupIdAndType(departmentId, Constant.DEPT_TYPE);
		// 获取角色下所有用户
		List<String> roleList = Authentication.selectUserIdsByGroupIdAndType(roleId, Constant.ROLE_TYPE);
		// 取部门和角色同时存在的用户
		int min = Math.min(roleList.size(), deptList.size());
		// 自动过滤重复
		Set<String> userIds = new HashSet<String>();
		for (int i = 0; i < min; i++) {
			// 取在deptList中相同值
			if (deptList.contains(roleList.get(i))) {
				userIds.add(roleList.get(i));
			}// 取在roleList中相同值
			if (roleList.contains(deptList.get(i))) {
				userIds.add(deptList.get(i));
			}
		}
		// 当只有一个用户时直接交给该用户处理
		if (userIds.size() == 1) {
			task.setAssignee(userIds.toArray(new String[0])[0]);
		} else {
			task.addCandidateUsers(userIds);
		}
	}

	public void setDepartmentId(java.lang.String departmentId) {
		this.departmentId = departmentId;
	}

	public void setRoleId(java.lang.String roleId) {
		this.roleId = roleId;
	}

}

 

          实例说明：例如：A用户提交“请假申请”---》“项目主管”，而“项目主管”任务分配选择“选择某部门和某角色”，其中输入部门A和角色B，该选择器将会获取既是属于部门A又是属于角色B下的所有用户，并且将这些用户作为“项目主管”任务的候选人，如果只存在一个用户，那么就默认设置为“项目主管”任务的处理者。

         注意：

         1、该连接器需要同时输入部门ID和角色ID，输入的部门ID和角色ID都必须存在，否则任务分配失败。
         2、如果没有获取到同时属于部门和角色的用户，那么任务最终也将分配失败。

   13、选择部门(只包含子部门)

          功能描述：根据选择部门(只包含子部门)来处理任务分配。

          实现参考：

          

public class SelectDepartment extends ActorConnectorHandler {

	/**
	 * 
	 */
	private static final long serialVersionUID = 2721883158970190680L;
	private java.lang.String departmentId;

	public void assign(DelegateTask task) throws Exception {

		if (StringUtil.isEmpty(StringUtil.trim(departmentId))) {
			throw new FoxBPMConnectorException("departmentId is null!");
		}
		// 处理部门重复
		StringTokenizer st = new StringTokenizer(StringUtil.trim(departmentId), Constants.COMMA);
		Set<String> depIdSet = new HashSet<String>();
		while (st.hasMoreTokens()) {
			depIdSet.add(StringUtil.trim(st.nextToken()));
		}
		// 存放查询组
		List<GroupEntity> groupList = null;
		// 存在不包含组本身的子组
		Set<String> groupIdList = null;
		for (String depId : depIdSet) {
			groupList = Authentication.findGroupChildMembersIncludeByGroupId(depId, Constant.DEPT_TYPE);
			if (null != groupList) {
				for (GroupEntity group : groupList) {
					if (!depIdSet.contains(group.getGroupId())) {
						if (null == groupIdList) {
							groupIdList = new HashSet<String>();
						}
						groupIdList.add(group.getGroupId());
					}
				}
			}
		}
		if (null != groupIdList) {
			for (String groupId : groupIdList) {
				task.addCandidateGroup(groupId, Constant.DEPT_TYPE);
			}
		}
	}

	public void setDepartmentId(java.lang.String departmentId) {
		this.departmentId = departmentId;
	}
}

 

          实例说明：例如：A用户提交“请假申请”---》“项目主管”，而“项目主管”任务分配选择“选择某部门和某角色”，其中输入部门A和部门B，那么该选择器将会获取部门A和部门B下的所有子部门，并且将这些子部门作为“项目主管”任务的候选组。

         注意：

         1、该连接器需要同时输入部门ID，可以输入多个部门ID（逗号分隔），输入的部门ID必须存在，否则任务分配失败。
         2、如果没有获取到部门子部门，那么任务最终也将分配失败。

 

   总结：

       1、根据以上选择器特性，可以分为处理任务的“独占”、“共享”和“独占或共享”三大类选择器

            独占：1、3、4、5、9、10

            共享：2、7、8、11、13

            独占或共享：6、12

       2、选择器主要是用来对人工任务分配处理（独占，共享），所有人工任务默认任务分配使用“所有人” 选择器。

        3、针对部门、角色的处理是有GroupRoleImpl.java和GroupDeptImpl.java实现的，用户也可以自己实现GroupDefinition定义，关于部门，角色集成请参看FoxBPM组织结构集成（http://yang-ch.iteye.com/blog/2099244）

        4、针对任务独占处理，需要注意处理人会覆盖情况，例如：如果一个任务同时使用多个“选择用户”选择器，并且每个选择器都只输入一个用户ID，根据选择器特性，会存在两个用户来独占任务，而实际只有一个用户独占该任务，即会存在用户覆盖情况。

       5、最后，选择器在含有人工任务交互的流程运转中起到很关键的作用，具体使用请大家到gihub官方(https://github.com/FoxBPM)下载相关FoxBPM的项目运行。

 

       以上是FoxBPM选择器所有介绍，关于FoxBPM连接器将在下一章节介绍。