相信每個涉及到使用者的系統都有一套使用者許可權管理平臺或者模組，用來維護使用者以及在系統內的功能、資料許可權，我們使用的Activiti工作流引擎配套設計了包括User、Group的Identify模組，怎麼和業務資料同步呢，這個問題是每個新人必問的問題之一，下面介紹幾種同步方案，最後總結比較。

方案一：呼叫IdentifyService介面完成同步

介面定義：

1. importjava.util.List; 
2. importcom.foo.arch.entity.id.User;  
3. importcom.foo.arch.service.ServiceException;  
4. /**
    
5.  * 維護使用者、角色、許可權介面
6.  * @author HenryYan 
7.  */  
8. public interface AccountService {  
9.     /** 
10.      * 新增使用者並[同步其他資料庫] 
11.      * <ul> 
12.      * <li>step 1: 儲存系統使用者，同時設定和部門的關係</li> 
13.      * <li>step 2: 同步使用者資訊到activiti的identity.User，同時設定角色</li> 
14.      * </ul> 
15.      * @param user              使用者物件
     
16.      * @param orgId             部門ID 
17.      * @param roleIds           角色ID集合 
18.      * @param synToActiviti     是否同步到Activiti資料庫，通過配置檔案方式設定，使用屬性：account.user.add.syntoactiviti 
19.      * @throws OrganizationNotFoundException    關聯使用者和部門的時候從資料庫查詢不到哦啊部門物件 
20.      * @throws  Exception                       其他未知異常
     
21.      */  
22.     public void save(User user, Long orgId, List<long> roleIds, booleansynToActiviti)  
23.             throws OrganizationNotFoundException, ServiceException, Exception;  
24.     /** 
25.      * 刪除使用者 
26.      * @param userId        使用者ID 
27.      * @param synToActiviti     是否同步到Activiti資料庫，通過配置檔案方式設定，使用屬性：account.user.add.syntoactiviti 
28.      * @throws Exception 
29.      */  
30.     public void delete(Long userId, booleansynToActiviti) throwsServiceException, Exception;  
31.     /** 
32.      * 同步使用者、角色資料到工作流 
33.      * @throws Exception 
34.      */  
35.     public void synAllUserAndRoleToActiviti() throwsException;  
36.     /** 
37.      * 刪除工作流引擎Activiti的使用者、角色以及關係 
38.      * @throws Exception 
39.      */  
40.     public void deleteAllActivitiIdentifyData() throwsException;  
41. }  

同步單個介面實現片段：

1. @Service  
2. @Transactional  
3. public class AccountServiceImpl implements AccountService {   
4.     /** 
5.      * 儲存使用者資訊，並且同步使用者資訊到activiti的identity.User和identify.Group 
6.      * @param user              使用者物件{@link User} 
7.      * @param roleIds           使用者擁有的角色ID集合 
8.      * @param synToActiviti     是否同步資料到Activiti 
9.      * @see Role 
10.      */  
11.     public void saveUser(User user, List<long> roleIds, booleansynToActiviti) {  
12.         String userId = ObjectUtils.toString(user.getId());  
13.         // 儲存系統使用者  
14.         accountManager.saveEntity(user);  
15.         // 同步資料到Activiti Identify模組  
16.         if(synToActiviti) {  
17.             UserQuery userQuery = identityService.createUserQuery();  
18.             List<org.activiti.engine.identity.user> activitiUsers = userQuery.userId(userId).list();  
19.             if(activitiUsers.size() == 1) {  
20.                 updateActivitiData(user, roleIds, activitiUsers.get(0));  
21.             }elseif (activitiUsers.size() > 1) {  
22.                 String errorMsg = "發現重複使用者：id="+ userId;  
23.                 logger.error(errorMsg);  
24.                 thrownew RuntimeException(errorMsg);  
25.             }else{  
26.                 newActivitiUser(user, roleIds);  
27.             }  
28.         }  
29.     }  
30.     /** 
31.      * 新增工作流使用者以及角色 
32.      * @param user      使用者物件{@link User} 
33.      * @param roleIds   使用者擁有的角色ID集合 
34.      */  
35.     private void newActivitiUser(User user, List<long> roleIds) {  
36.         String userId = user.getId().toString();  
37.         // 新增使用者  
38.         saveActivitiUser(user);  
39.         // 新增membership  
40.         addMembershipToIdentify(roleIds, userId);  
41.     }  
42.     /** 
43.      * 新增一個使用者到Activiti {@link org.activiti.engine.identity.User} 
44.      * @param user  使用者物件, {@link User} 
45.      */  
46.     private void saveActivitiUser(User user) {  
47.         String userId = user.getId().toString();  
48.         org.activiti.engine.identity.User activitiUser = identityService.newUser(userId);  
49.         cloneAndSaveActivitiUser(user, activitiUser);  
50.         logger.debug("add activiti user: {}", ToStringBuilder.reflectionToString(activitiUser));  
51.     }  
52.     /** 
53.      * 新增Activiti Identify的使用者於組關係 
54.      * @param roleIds   角色ID集合 
55.      * @param userId    使用者ID 
56.      */  
57.     private void addMembershipToIdentify(List<long> roleIds, String userId) {  
58.         for(Long roleId : roleIds) {  
59.             Role role = roleManager.getEntity(roleId);  
60.             logger.debug("add role to activit: {}", role);  
61.             identityService.createMembership(userId, role.getEnName());  
62.         }  
63.     }  
64.     /** 
65.      * 更新工作流使用者以及角色 
66.      * @param user          使用者物件{@link User} 
67.      * @param roleIds       使用者擁有的角色ID集合 
68.      * @param activitiUser  Activiti引擎的使用者物件，{@link org.activiti.engine.identity.User} 
69.      */  
70.     private void updateActivitiData(User user, List<long> roleIds, org.activiti.engine.identity.User activitiUser) {  
71.         String userId = user.getId().toString();  
72.         // 更新使用者主體資訊  
73.         cloneAndSaveActivitiUser(user, activitiUser);  
74.         // 刪除使用者的membership  
75.         List<group> activitiGroups = identityService.createGroupQuery().groupMember(userId).list();  
76.         for(Group group : activitiGroups) {  
77.             logger.debug("delete group from activit: {}", ToStringBuilder.reflectionToString(group));  
78.             identityService.deleteMembership(userId, group.getId());  
79.         }  
80.         // 新增membership  
81.         addMembershipToIdentify(roleIds, userId);  
82.     }  
83.     /** 
84.      * 使用系統使用者物件屬性設定到Activiti User物件中 
85.      * @param user          系統使用者物件 
86.      * @param activitiUser  Activiti User 
87.      */  
88.     private void cloneAndSaveActivitiUser(User user, org.activiti.engine.identity.User activitiUser) {  
89.         activitiUser.setFirstName(user.getName());  
90.         activitiUser.setLastName(StringUtils.EMPTY);  
91.         activitiUser.setPassword(StringUtils.EMPTY);  
92.         activitiUser.setEmail(user.getEmail());  
93.         identityService.saveUser(activitiUser);  
94.     }  
95.     @Override  
96.     public void delete(Long userId, booleansynToActiviti, booleansynToChecking) throwsServiceException, Exception {  
97.         // 查詢需要刪除的使用者物件  
98.         User user = accountManager.getEntity(userId);  
99.         if(user == null) {  
100.             thrownew ServiceException("刪除使用者時，找不到ID為"+ userId + "的使用者");  
101.         }  
102.         /** 
103.          * 同步刪除Activiti User Group 
104.          */  
105.         if(synToActiviti) {  
106.             // 同步刪除Activiti User  
107.             List<role> roleList = user.getRoleList();  
108.             for(Role role : roleList) {  
109.                 identityService.deleteMembership(userId.toString(), role.getEnName());  
110.             }  
111.             // 同步刪除Activiti User  
112.             identityService.deleteUser(userId.toString());  
113.         }  
114.         // 刪除本系統使用者  
115.         accountManager.deleteUser(userId);  
116.         // 刪除考勤機使用者  
117.         if(synToChecking) {  
118.             checkingAccountManager.deleteEntity(userId);  
119.         }  
120.     }  
121. } 

同步全部資料步驟：

• 刪除Activiti的User、Group、Membership資料

• 複製Role物件資料到Group

• 複製使用者資料以及Membership資料

ActivitiIdentifyCommonDao.java

1. public class ActivitiIdentifyCommonDao {  
2.     protectedLogger logger = LoggerFactory.getLogger(getClass());  
3.     @Autowired  
4.     private JdbcTemplate jdbcTemplate;  
5.     /** 
6.      * 刪除使用者和組的關係 
7.      */  
8.     public void deleteAllUser() {  
9.         String sql = "delete from ACT_ID_USER";  
10.         jdbcTemplate.execute(sql);  
11.         logger.debug("deleted from activiti user.");  
12.     }  
13.     /** 
14.      * 刪除使用者和組的關係 
15.      */  
16.     public void deleteAllRole() {  
17.         String sql = "delete from ACT_ID_GROUP";  
18.         jdbcTemplate.execute(sql);  
19.         logger.debug("deleted from activiti group.");  
20.     }  
21.     /** 
22.      * 刪除使用者和組的關係 
23.      */  
24.     public void deleteAllMemerShip() {  
25.         String sql = "delete from ACT_ID_MEMBERSHIP";  
26.         jdbcTemplate.execute(sql);  
27.         logger.debug("deleted from activiti membership.");  
28.     }  
29. }  

ActivitiIdentifyService.java（下面兩段程式碼重複）

1. public class ActivitiIdentifyService extends AbstractBaseService {  
2.     @Autowired  
3.     protected ActivitiIdentifyCommonDao activitiIdentifyCommonDao;  
4.     /** 
5.      * 刪除使用者和組的關係 
6.      */  
7.     public void deleteAllUser() {  
8.         activitiIdentifyCommonDao.deleteAllUser();  
9.     }  
10.     /** 
11.      * 刪除使用者和組的關係 
12.      */  
13.     public void deleteAllRole() {  
14.         activitiIdentifyCommonDao.deleteAllRole();  
15.     }  
16.     /** 
17.      * 刪除使用者和組的關係 
18.      */  
19.     public void deleteAllMemerShip() {  
20.         activitiIdentifyCommonDao.deleteAllMemerShip();  
21.     }  
22. }  

publicclass ActivitiIdentifyService extendsAbstractBaseService {
     
    @Autowired
    protectedActivitiIdentifyCommonDao activitiIdentifyCommonDao;
     
    /**
     * 刪除使用者和組的關係
     */
    publicvoid deleteAllUser() {
        activitiIdentifyCommonDao.deleteAllUser();
    }
     
    /**
     * 刪除使用者和組的關係
     */
    publicvoid deleteAllRole() {
        activitiIdentifyCommonDao.deleteAllRole();
    }
     
    /**
     * 刪除使用者和組的關係
     */
    publicvoid deleteAllMemerShip() {
        activitiIdentifyCommonDao.deleteAllMemerShip();
    }
}

AccountServiceImpl.java（下面兩段程式碼重複）

1. public  class AccountServiceImpl implements AccountService { 
2. @Override  
3.     public void synAllUserAndRoleToActiviti() throwsException {  
4.         // 清空工作流使用者、角色以及關係  
5.         deleteAllActivitiIdentifyData();  
6.         // 複製角色資料  
7.         synRoleToActiviti();  
8.         // 複製使用者以及關係資料  
9.         synUserWithRoleToActiviti();  
10.     }  
11.     /** 
12.      * 複製使用者以及關係資料 
13.      */  
14.     private void synUserWithRoleToActiviti() {  
15.         List<user> allUser = accountManager.getAll();  
16.         for(User user : allUser) {  
17.             String userId = user.getId().toString();  
18.             // 新增一個使用者到Activiti  
19.             saveActivitiUser(user);  
20.             // 角色和使用者的關係  
21.             List<role> roleList = user.getRoleList();  
22.             for(Role role : roleList) {  
23.                 identityService.createMembership(userId, role.getEnName());  
24.                 logger.debug("add membership {user: {}, role: {}}", userId, role.getEnName());  
25.             }  
26.         }  
27.     }  
28.     /** 
29.      * 同步所有角色資料到{@link Group} 
30.      */  
31.     private void synRoleToActiviti() {  
32.         List<role> allRole = roleManager.getAll();  
33.         for(Role role : allRole) {  
34.             String groupId = role.getEnName().toString();  
35.             Group group = identityService.newGroup(groupId);  
36.             group.setName(role.getName());  
37.             group.setType(role.getType());  
38.             identityService.saveGroup(group);  
39.         }  
40.     }  
41.     @Override  
42.     public void deleteAllActivitiIdentifyData() throwsException {  
43.         activitiIdentifyService.deleteAllMemerShip();  
44.         activitiIdentifyService.deleteAllRole();  
45.         activitiIdentifyService.deleteAllUser();  
46.     }  
47. }  

publicclass AccountServiceImpl implementsAccountService {
@Override
    publicvoid synAllUserAndRoleToActiviti() throwsException {
 
        // 清空工作流使用者、角色以及關係
        deleteAllActivitiIdentifyData();
 
        // 複製角色資料
        synRoleToActiviti();
 
        // 複製使用者以及關係資料
        synUserWithRoleToActiviti();
    }
 
    /**
     * 複製使用者以及關係資料
     */
    privatevoid synUserWithRoleToActiviti() {
        List<user> allUser = accountManager.getAll();
        for(User user : allUser) {
            String userId = user.getId().toString();
 
            // 新增一個使用者到Activiti
            saveActivitiUser(user);
 
            // 角色和使用者的關係
            List<role> roleList = user.getRoleList();
            for(Role role : roleList) {
                identityService.createMembership(userId, role.getEnName());
                logger.debug("add membership {user: {}, role: {}}", userId, role.getEnName());
            }
        }
    }
 
    /**
     * 同步所有角色資料到{@link Group}
     */
    privatevoid synRoleToActiviti() {
        List<role> allRole = roleManager.getAll();
        for(Role role : allRole) {
            String groupId = role.getEnName().toString();
            Group group = identityService.newGroup(groupId);
            group.setName(role.getName());
            group.setType(role.getType());
            identityService.saveGroup(group);
        }
    }
 
    @Override
    publicvoid deleteAllActivitiIdentifyData() throwsException {
        activitiIdentifyService.deleteAllMemerShip();
        activitiIdentifyService.deleteAllRole();
        activitiIdentifyService.deleteAllUser();
    }
}

方案二：覆蓋IdentifyService介面的實現

此方法覆蓋IdentifyService介面的預設實現類：org.activiti.engine.impl.IdentityServiceImpl。

讀者可以根據現有的使用者管理介面實現覆蓋IdentityServiceImpl的每個方法的預設實現，這樣就等於放棄使用系列表：ACT_ID_。

此方法不再提供程式碼，請讀者自行根據現有介面逐一實現介面定義的功能。

方案三：用檢視覆蓋同名的ACT_ID_系列表

此方案和第二種類似，放棄使用系列表：ACT_ID_，建立同名的檢視。

1.刪除已建立的ACT_ID_*表

建立檢視必須刪除引擎自動建立的ACT_ID_*表，否則不能建立檢視。

2.建立檢視：

• ACT_ID_GROUP
• ACT_ID_INFO
• ACT_ID_MEMBERSHIP
• ACT_ID_USER

建立的檢視要保證資料型別一致，例如使用者的ACT_ID_MEMBERSHIP表的兩個欄位都是字元型，一般系統中都是用NUMBER作為使用者、角色的主鍵型別，所以建立檢視的時候要把數字型別轉換為字元型。

3.修改引擎預設配置

在引擎配置中設定屬性dbIdentityUsed為false即可。

1. <beanidbeanid="processEngineConfiguration"class="org.activiti.spring.SpringProcessEngineConfiguration">  
2.     ...  
3.     <propertynamepropertyname="dbIdentityUsed"ref="false">  
4.     ...  
5. </property></bean>  

<beanid="processEngineConfiguration"class="org.activiti.spring.SpringProcessEngineConfiguration">
    ...
    <propertyname="dbIdentityUsed"ref="false">
    ...
</property></bean>

• 方案一：不破壞、不修改原始碼，面向介面程式設計，推薦；

• 方案二：放棄原有的Identify模組，使用自定義的實現，特殊情況可以使用此方式；

• 方案三：不需要編寫Java程式碼，只需要建立同名檢視即可，對於現有系統的整合、強烈推薦；