diff --git a/samples/user/src/main/java/com/supwisdom/leaveschool/user/controller/api/admin/Api1AdminGroupController.java b/samples/user/src/main/java/com/supwisdom/leaveschool/user/controller/api/admin/Api1AdminGroupController.java
index 518dfd0..0bc74ff 100644
--- a/samples/user/src/main/java/com/supwisdom/leaveschool/user/controller/api/admin/Api1AdminGroupController.java
+++ b/samples/user/src/main/java/com/supwisdom/leaveschool/user/controller/api/admin/Api1AdminGroupController.java
@@ -18,12 +18,12 @@
 import com.supwisdom.leaveschool.common.model.SuccessResponseModel;
 import com.supwisdom.leaveschool.user.domain.Group;
 import com.supwisdom.leaveschool.user.domain.GroupRole;
-import com.supwisdom.leaveschool.user.domain.GroupUser;
+import com.supwisdom.leaveschool.user.domain.UserGroup;
 import com.supwisdom.leaveschool.user.model.GroupRoles;
-import com.supwisdom.leaveschool.user.model.GroupUsers;
+import com.supwisdom.leaveschool.user.model.UserGroups;
 import com.supwisdom.leaveschool.user.repository.GroupRepository;
 import com.supwisdom.leaveschool.user.repository.GroupRoleRepository;
-import com.supwisdom.leaveschool.user.repository.GroupUserRepository;
+import com.supwisdom.leaveschool.user.repository.UserGroupRepository;
 
 @RestController
 @RequestMapping("/api/v1/admin/groups")
@@ -33,7 +33,7 @@
   private GroupRepository groupRepository;
 
   @Autowired
-  private GroupUserRepository groupUserRepository;
+  private UserGroupRepository userGroupRepository;
 
   @Autowired
   private GroupRoleRepository groupRoleRepository;
@@ -57,7 +57,7 @@
    */
   @RequestMapping(value = "/{id}/users", method = RequestMethod.GET, produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
   @ResponseBody
-  public PagerResponseModel<GroupUser> groupUsers(@PathVariable("id") String id, PagerRequestModel pagerRequestModel) {
+  public PagerResponseModel<UserGroup> groupUsers(@PathVariable("id") String id, PagerRequestModel pagerRequestModel) {
 
     if (id == null || id.length() == 0) {
       throw new RuntimeException("exception.get.id.must.not.empty"); // FIXME: RestException
@@ -74,10 +74,10 @@
     }
     pagerRequestModel.getMapBean().put("groupId", group.getId());
 
-    Page<GroupUser> page = groupUserRepository.selectGroupUsers(pagerRequestModel.getPageIndex(),
+    Page<UserGroup> page = userGroupRepository.selectUserGroups(pagerRequestModel.getPageIndex(),
         pagerRequestModel.getPageSize(), pagerRequestModel.getMapBean());
 
-    PagerResponseModel<GroupUser> pagerResponseModel = PagerResponseModel.of(pagerRequestModel);
+    PagerResponseModel<UserGroup> pagerResponseModel = PagerResponseModel.of(pagerRequestModel);
     pagerResponseModel.setPageCount(page.getTotalPages());
     pagerResponseModel.setRecordCount(page.getTotalElements());
     pagerResponseModel.setItems(page.getContent());
@@ -97,7 +97,7 @@
    */
   @RequestMapping(value = "/{id}/users", method = RequestMethod.POST, consumes = MimeTypeUtils.APPLICATION_JSON_VALUE, produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
   @ResponseBody
-  public SuccessResponseModel relateUsers(@PathVariable("id") String id, @RequestBody GroupUsers groupUsers) {
+  public SuccessResponseModel relateUsers(@PathVariable("id") String id, @RequestBody UserGroups groupUsers) {
 
     if (id == null || id.length() == 0) {
       throw new RuntimeException("exception.get.id.must.not.empty"); // FIXME: RestException
@@ -109,7 +109,7 @@
       throw new RuntimeException("exception.get.domain.not.exist"); // FIXME: RestException
     }
 
-    groupUserRepository.relateGroupUsers(group, groupUsers.getGroupUsers());
+    userGroupRepository.relateGroupUsers(group, groupUsers.getGroupUsers());
 
     SuccessResponseModel res = new SuccessResponseModel();
     res.setSuccess("info.set.success");
diff --git a/samples/user/src/main/java/com/supwisdom/leaveschool/user/controller/api/admin/Api1AdminUserController.java b/samples/user/src/main/java/com/supwisdom/leaveschool/user/controller/api/admin/Api1AdminUserController.java
index 2e9ca21..e89aa49 100644
--- a/samples/user/src/main/java/com/supwisdom/leaveschool/user/controller/api/admin/Api1AdminUserController.java
+++ b/samples/user/src/main/java/com/supwisdom/leaveschool/user/controller/api/admin/Api1AdminUserController.java
@@ -24,12 +24,12 @@
 import com.supwisdom.leaveschool.common.model.PagerResponseModel;
 import com.supwisdom.leaveschool.common.model.SuccessResponseModel;
 import com.supwisdom.leaveschool.common.util.DomainUtils;
-import com.supwisdom.leaveschool.user.domain.GroupUser;
+import com.supwisdom.leaveschool.user.domain.UserGroup;
 import com.supwisdom.leaveschool.user.domain.User;
 import com.supwisdom.leaveschool.user.domain.UserRole;
-import com.supwisdom.leaveschool.user.model.GroupUsers;
+import com.supwisdom.leaveschool.user.model.UserGroups;
 import com.supwisdom.leaveschool.user.model.UserRoles;
-import com.supwisdom.leaveschool.user.repository.GroupUserRepository;
+import com.supwisdom.leaveschool.user.repository.UserGroupRepository;
 import com.supwisdom.leaveschool.user.repository.UserRepository;
 import com.supwisdom.leaveschool.user.repository.UserRoleRepository;
 
@@ -41,7 +41,7 @@
   private UserRepository userRepository;
 
   @Autowired
-  private GroupUserRepository groupUserRepository;
+  private UserGroupRepository userGroupRepository;
 
   @Autowired
   private UserRoleRepository userRoleRepository;
@@ -431,7 +431,7 @@
    */
   @RequestMapping(value = "/{id}/groups", method = RequestMethod.GET, produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
   @ResponseBody
-  public PagerResponseModel<GroupUser> userGroups(@PathVariable("id") String id, PagerRequestModel pagerRequestModel) {
+  public PagerResponseModel<UserGroup> userGroups(@PathVariable("id") String id, PagerRequestModel pagerRequestModel) {
 
     if (id == null || id.length() == 0) {
       throw new RuntimeException("exception.get.id.must.not.empty"); // FIXME: RestException
@@ -448,10 +448,10 @@
     }
     pagerRequestModel.getMapBean().put("username", user.getUsername());
 
-    Page<GroupUser> page = groupUserRepository.selectGroupUsers(pagerRequestModel.getPageIndex(),
+    Page<UserGroup> page = userGroupRepository.selectUserGroups(pagerRequestModel.getPageIndex(),
         pagerRequestModel.getPageSize(), pagerRequestModel.getMapBean());
 
-    PagerResponseModel<GroupUser> pagerResponseModel = PagerResponseModel.of(pagerRequestModel);
+    PagerResponseModel<UserGroup> pagerResponseModel = PagerResponseModel.of(pagerRequestModel);
     pagerResponseModel.setPageCount(page.getTotalPages());
     pagerResponseModel.setRecordCount(page.getTotalElements());
     pagerResponseModel.setItems(page.getContent());
@@ -471,7 +471,7 @@
    */
   @RequestMapping(value = "/{id}/groups", method = RequestMethod.POST, consumes = MimeTypeUtils.APPLICATION_JSON_VALUE, produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
   @ResponseBody
-  public SuccessResponseModel relateGroups(@PathVariable("id") String id, @RequestBody GroupUsers groupUsers) {
+  public SuccessResponseModel relateGroups(@PathVariable("id") String id, @RequestBody UserGroups groupUsers) {
 
     if (id == null || id.length() == 0) {
       throw new RuntimeException("exception.get.id.must.not.empty"); // FIXME: RestException
@@ -483,7 +483,7 @@
       throw new RuntimeException("exception.get.domain.not.exist"); // FIXME: RestException
     }
 
-    groupUserRepository.relateUserGroups(user, groupUsers.getGroupUsers());
+    userGroupRepository.relateUserGroups(user, groupUsers.getGroupUsers());
 
     SuccessResponseModel res = new SuccessResponseModel();
     res.setSuccess("info.set.success");
diff --git a/samples/user/src/main/java/com/supwisdom/leaveschool/user/domain/GroupUser.java b/samples/user/src/main/java/com/supwisdom/leaveschool/user/domain/UserGroup.java
similarity index 90%
rename from samples/user/src/main/java/com/supwisdom/leaveschool/user/domain/GroupUser.java
rename to samples/user/src/main/java/com/supwisdom/leaveschool/user/domain/UserGroup.java
index 82b9323..e91dba1 100644
--- a/samples/user/src/main/java/com/supwisdom/leaveschool/user/domain/GroupUser.java
+++ b/samples/user/src/main/java/com/supwisdom/leaveschool/user/domain/UserGroup.java
@@ -7,8 +7,8 @@
 import com.supwisdom.leaveschool.common.domain.ABaseDomain;
 
 @Entity
-@Table(name = "TB_U_GROUP_USER")
-public class GroupUser extends ABaseDomain {
+@Table(name = "TB_U_USER_GROUP")
+public class UserGroup extends ABaseDomain {
 
   /**
    * 
@@ -16,24 +16,16 @@
   private static final long serialVersionUID = -4239845385965871983L;
 
   /**
-   * 用户组ID
-   */
-  @Column(name = "GROUP_ID")
-  private String groupId;
-
-  /**
    * 用户名
    */
   @Column(name = "USERNAME")
   private String username;
 
-  public String getGroupId() {
-    return groupId;
-  }
-
-  public void setGroupId(String groupId) {
-    this.groupId = groupId;
-  }
+  /**
+   * 用户组ID
+   */
+  @Column(name = "GROUP_ID")
+  private String groupId;
 
   public String getUsername() {
     return username;
@@ -43,4 +35,12 @@
     this.username = username;
   }
 
+  public String getGroupId() {
+    return groupId;
+  }
+
+  public void setGroupId(String groupId) {
+    this.groupId = groupId;
+  }
+
 }
diff --git a/samples/user/src/main/java/com/supwisdom/leaveschool/user/model/GroupUsers.java b/samples/user/src/main/java/com/supwisdom/leaveschool/user/model/GroupUsers.java
deleted file mode 100644
index 205b3a8..0000000
--- a/samples/user/src/main/java/com/supwisdom/leaveschool/user/model/GroupUsers.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package com.supwisdom.leaveschool.user.model;
-
-import java.io.Serializable;
-import java.util.List;
-
-import com.supwisdom.leaveschool.user.domain.GroupUser;
-
-public class GroupUsers implements Serializable {
-
-  /**
-   * 
-   */
-  private static final long serialVersionUID = 8195230337021165172L;
-
-  private List<GroupUser> groupUsers;
-
-  public List<GroupUser> getGroupUsers() {
-    return groupUsers;
-  }
-
-  public void setGroupUsers(List<GroupUser> groupUsers) {
-    this.groupUsers = groupUsers;
-  }
-
-}
diff --git a/samples/user/src/main/java/com/supwisdom/leaveschool/user/model/UserGroups.java b/samples/user/src/main/java/com/supwisdom/leaveschool/user/model/UserGroups.java
new file mode 100644
index 0000000..9f0cc72
--- /dev/null
+++ b/samples/user/src/main/java/com/supwisdom/leaveschool/user/model/UserGroups.java
@@ -0,0 +1,25 @@
+package com.supwisdom.leaveschool.user.model;
+
+import java.io.Serializable;
+import java.util.List;
+
+import com.supwisdom.leaveschool.user.domain.UserGroup;
+
+public class UserGroups implements Serializable {
+
+  /**
+   * 
+   */
+  private static final long serialVersionUID = 8195230337021165172L;
+
+  private List<UserGroup> groupUsers;
+
+  public List<UserGroup> getGroupUsers() {
+    return groupUsers;
+  }
+
+  public void setGroupUsers(List<UserGroup> groupUsers) {
+    this.groupUsers = groupUsers;
+  }
+
+}
diff --git a/samples/user/src/main/java/com/supwisdom/leaveschool/user/repository/GroupUserRepository.java b/samples/user/src/main/java/com/supwisdom/leaveschool/user/repository/UserGroupRepository.java
similarity index 63%
rename from samples/user/src/main/java/com/supwisdom/leaveschool/user/repository/GroupUserRepository.java
rename to samples/user/src/main/java/com/supwisdom/leaveschool/user/repository/UserGroupRepository.java
index ae28e04..ef8dea6 100644
--- a/samples/user/src/main/java/com/supwisdom/leaveschool/user/repository/GroupUserRepository.java
+++ b/samples/user/src/main/java/com/supwisdom/leaveschool/user/repository/UserGroupRepository.java
@@ -13,14 +13,14 @@
 import com.supwisdom.leaveschool.common.repository.BaseJpaRepository;
 import com.supwisdom.leaveschool.common.util.MapBeanUtils;
 import com.supwisdom.leaveschool.user.domain.Group;
-import com.supwisdom.leaveschool.user.domain.GroupUser;
+import com.supwisdom.leaveschool.user.domain.UserGroup;
 import com.supwisdom.leaveschool.user.domain.User;
 
 @Repository
-public interface GroupUserRepository extends BaseJpaRepository<GroupUser> {
+public interface UserGroupRepository extends BaseJpaRepository<UserGroup> {
 
-  public default Page<GroupUser> selectPageList(int pageIndex, int pageSize, Map<String, Object> mapBean) {
-    GroupUser probe = new GroupUser();
+  public default Page<UserGroup> selectPageList(int pageIndex, int pageSize, Map<String, Object> mapBean) {
+    UserGroup probe = new UserGroup();
     if (mapBean != null) {
       probe.setGroupId(MapBeanUtils.getString(mapBean, "groupId"));
       probe.setUsername(MapBeanUtils.getString(mapBean, "username"));
@@ -30,18 +30,18 @@
         .withMatcher("groupId", ExampleMatcher.GenericPropertyMatchers.exact())
         .withMatcher("username", ExampleMatcher.GenericPropertyMatchers.exact());
 
-    Example<GroupUser> example = Example.of(probe, matcher);
+    Example<UserGroup> example = Example.of(probe, matcher);
 
     PageRequest pageRequest = PageRequest.of(pageIndex, pageSize);
 
-    Page<GroupUser> page = this.findAll(example, pageRequest);
+    Page<UserGroup> page = this.findAll(example, pageRequest);
 
     return page;
   }
 
-  public default Page<GroupUser> selectGroupUsers(int pageIndex, int pageSize, Map<String, Object> mapBean) {
+  public default Page<UserGroup> selectUserGroups(int pageIndex, int pageSize, Map<String, Object> mapBean) {
 
-    GroupUser probe = new GroupUser();
+    UserGroup probe = new UserGroup();
     if (mapBean != null) {
       probe.setGroupId(MapBeanUtils.getString(mapBean, "groupId"));
       probe.setUsername(MapBeanUtils.getString(mapBean, "username"));
@@ -51,70 +51,27 @@
         .withMatcher("groupId", ExampleMatcher.GenericPropertyMatchers.exact())
         .withMatcher("username", ExampleMatcher.GenericPropertyMatchers.exact());
 
-    Example<GroupUser> example = Example.of(probe, matcher);
+    Example<UserGroup> example = Example.of(probe, matcher);
 
     PageRequest pageRequest = PageRequest.of(pageIndex, pageSize);
 
-    Page<GroupUser> page = this.findAll(example, pageRequest);  // FIXME: 多表关联查询
+    Page<UserGroup> page = this.findAll(example, pageRequest);  // FIXME: 多表关联查询
 
     return page;
   }
 
-  public default void relateGroupUsers(Group group, List<GroupUser> groupUsers) {
 
-    List<GroupUser> existGroupUsers = this.selectListByGroupId(group.getId());
+  public default void relateUserGroups(User user, List<UserGroup> groupUsers) {
 
-    Map<String, GroupUser> existMapGroupUsers = new LinkedHashMap<String, GroupUser>();
-    for (GroupUser groupUser : existGroupUsers) {
-      String k = String.format("%s", groupUser.getUsername());
-      existMapGroupUsers.put(k, groupUser);
-    }
+    List<UserGroup> existUserGroups = this.selectListByUsername(user.getUsername());
 
-    for (GroupUser groupUser : groupUsers) {
-      String k = String.format("%s", groupUser.getUsername());
-
-      if (existMapGroupUsers.containsKey(k)) {
-        existMapGroupUsers.remove(k);
-      } else {
-        groupUser.setCompanyId(group.getCompanyId());
-        groupUser.setGroupId(group.getId());
-
-        this.insert(groupUser);
-      }
-    }
-
-    for (GroupUser groupUser : existMapGroupUsers.values()) {
-      this.deleteById(groupUser.getId());
-    }
-  }
-
-  public default List<GroupUser> selectListByGroupId(String groupId) {
-
-    GroupUser probe = new GroupUser();
-    probe.setGroupId(groupId);
-
-    ExampleMatcher matcher = ExampleMatcher.matching()
-        .withMatcher("groupId", ExampleMatcher.GenericPropertyMatchers.exact());
-
-    Example<GroupUser> example = Example.of(probe, matcher);
-
-    List<GroupUser> groupUsers = this.findAll(example);
-
-    return groupUsers;
-  }
-
-
-  public default void relateUserGroups(User user, List<GroupUser> groupUsers) {
-
-    List<GroupUser> existUserGroups = this.selectListByUsername(user.getUsername());
-
-    Map<String, GroupUser> existMapUserGroups = new LinkedHashMap<String, GroupUser>();
-    for (GroupUser groupUser : existUserGroups) {
+    Map<String, UserGroup> existMapUserGroups = new LinkedHashMap<String, UserGroup>();
+    for (UserGroup groupUser : existUserGroups) {
       String k = String.format("%s", groupUser.getGroupId());
       existMapUserGroups.put(k, groupUser);
     }
 
-    for (GroupUser groupUser : groupUsers) {
+    for (UserGroup groupUser : groupUsers) {
       String k = String.format("%s", groupUser.getGroupId());
 
       if (existMapUserGroups.containsKey(k)) {
@@ -127,24 +84,69 @@
       }
     }
 
-    for (GroupUser groupUser : existMapUserGroups.values()) {
+    for (UserGroup groupUser : existMapUserGroups.values()) {
       this.deleteById(groupUser.getId());
     }
   }
 
-  public default List<GroupUser> selectListByUsername(String username) {
+  public default List<UserGroup> selectListByUsername(String username) {
 
-    GroupUser probe = new GroupUser();
+    UserGroup probe = new UserGroup();
     probe.setUsername(username);
 
     ExampleMatcher matcher = ExampleMatcher.matching()
         .withMatcher("username", ExampleMatcher.GenericPropertyMatchers.exact());
 
-    Example<GroupUser> example = Example.of(probe, matcher);
+    Example<UserGroup> example = Example.of(probe, matcher);
 
-    List<GroupUser> groupUsers = this.findAll(example);
+    List<UserGroup> groupUsers = this.findAll(example);
 
     return groupUsers;
   }
 
+  
+  public default void relateGroupUsers(Group group, List<UserGroup> groupUsers) {
+
+    List<UserGroup> existGroupUsers = this.selectListByGroupId(group.getId());
+
+    Map<String, UserGroup> existMapGroupUsers = new LinkedHashMap<String, UserGroup>();
+    for (UserGroup groupUser : existGroupUsers) {
+      String k = String.format("%s", groupUser.getUsername());
+      existMapGroupUsers.put(k, groupUser);
+    }
+
+    for (UserGroup groupUser : groupUsers) {
+      String k = String.format("%s", groupUser.getUsername());
+
+      if (existMapGroupUsers.containsKey(k)) {
+        existMapGroupUsers.remove(k);
+      } else {
+        groupUser.setCompanyId(group.getCompanyId());
+        groupUser.setGroupId(group.getId());
+
+        this.insert(groupUser);
+      }
+    }
+
+    for (UserGroup groupUser : existMapGroupUsers.values()) {
+      this.deleteById(groupUser.getId());
+    }
+  }
+
+  public default List<UserGroup> selectListByGroupId(String groupId) {
+
+    UserGroup probe = new UserGroup();
+    probe.setGroupId(groupId);
+
+    ExampleMatcher matcher = ExampleMatcher.matching()
+        .withMatcher("groupId", ExampleMatcher.GenericPropertyMatchers.exact());
+
+    Example<UserGroup> example = Example.of(probe, matcher);
+
+    List<UserGroup> groupUsers = this.findAll(example);
+
+    return groupUsers;
+  }
+
+
 }
diff --git a/sql/sample-user.sql b/sql/sample-user.sql
index 1350738..18719d8 100644
--- a/sql/sample-user.sql
+++ b/sql/sample-user.sql
@@ -78,7 +78,7 @@
 
 
 
-CREATE TABLE `TB_U_GROUP_USER` (
+CREATE TABLE `TB_U_USER_GROUP` (
   `ID` VARCHAR(100) NOT NULL COMMENT '',
   `COMPANY_ID` VARCHAR(100) COMMENT 'CompanyID',
   `DELETED` INT(1) COMMENT '是否删除',
@@ -89,8 +89,8 @@
   `DELETE_ACCOUNT` VARCHAR(100) COMMENT '删除人',
   `DELETE_TIME` DATETIME COMMENT '删除时间',
 
-  `GROUP_ID` VARCHAR(200) NOT NULL COMMENT '用户组ID',
   `USERNAME` VARCHAR(200) NOT NULL COMMENT '用户名',
+  `GROUP_ID` VARCHAR(200) NOT NULL COMMENT '用户组ID',
 
   PRIMARY KEY (`ID`)
 )
