目前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连接器将在下一章节介绍。