A
📖 知识库
🌐

组织机构与人员管理

📄 组织与权限 22 分钟阅读 93 次浏览 更新于 2026-10-25

导读

「组织机构与人员管理」是面试与实战中都会被反复问到的问题,下面从结论讲起。

组织机构是 OA 系统的骨架:权限、公文流转、会议室申请都要挂靠到"谁属于哪个部门"上。这一篇讲清楚树形结构怎么存、怎么查、怎么展示,以及人员与登录账号的关系。


一、领域模型

1.1 Organization(机构)

/**
 * @hibernate.class table="T_Organization"
 */
public class Organization {
    /** @hibernate.id generator-class="native" */
    private int id;
    private String name;          // 机构名称
    private String sn;            // 路径标识,如 1_3_7
    private String description;   // 描述
    private Organization parent;  // 父机构(顶级机构为 null)
    private Set children;         // 子机构集合
}

映射要点:

<class table="T_Organization" name="com.oa.model.Organization">
  <id name="id"><generator class="native"/></id>
  <property name="name"/>
  <property name="sn"/>
  <property name="description"/>
  <many-to-one column="pid" name="parent"/>
  <set lazy="false" inverse="true" name="children">
    <key column="pid"/>
    <one-to-many class="com.oa.model.Organization"/>
  </set>
</class>
  • many-to-one 用 pid 列自关联,形成树;
  • children 设为 lazy="false",因为机构树要在页面上递归渲染(配合 OpenSessionInView 使用);
  • inverse="true" 把外键维护权交给"多"的一方,避免多余 update。

1.2 Person(人员)与 User(账号)

public class Person {
    private int id;
    private String name;         // 姓名
    private String sex;          // 性别
    private String address;      // 住址
    private String duty;         // 职务
    private String phone;        // 电话
    private String description;
    private Organization org;    // 所属机构(多对一)
    private User user;           // 对应的登录账号(一对一)
}

public class User {
    private int id;
    private String username;     // 登录名
    private String password;     // 密码(明文存储,示例项目未加密)
    private Date createTime;     // 账号创建时间
    private Date expireTime;     // 账号失效时间
    private Person person;       // 对应人员
}

为什么要拆成 Person 和 User? 因为"人"和"账号"生命周期不同:

  • 一个 Person 可以没有账号(比如通讯录里的外部联系人);
  • 账号有独立的启用/失效时间;
  • 授权系统(ACL)的主体是 User(principalType="User"),而人员信息展示时取 Person。

二、机构树的实现

2.1 两种查询视角

public PagerModel findOrgs(int parentId) {
    // parentId == 0 表示查顶级机构
    if (parentId == 0) {
        return searchPaginated("from Organization o where o.parent is null");
    }
    return searchPaginated("from Organization o where o.parent.id = ?", parentId);
}

这叫逐级下钻(懒加载树):页面一次只显示当前层,点开某个节点再把 parentId 传回来查下一层。优点是数据量可控,缺点是交互上要不断请求。

另一种是用 sn 前缀一次查出整棵子树:

-- 查 id=3 的机构及其所有后代
SELECT * FROM T_Organization WHERE sn LIKE '1_3%' ORDER BY sn;

2.2 新增机构与 sn 计算

sn 是"从根到当前节点的 id 路径",新增时必须先 save 拿到自增 ID,再回填 sn:

public void addOrg(Organization org, int parentId) {
    if (parentId != 0) {
        org.setParent((Organization) getHibernateTemplate().load(Organization.class, parentId));
    }

    getHibernateTemplate().save(org);      // 先保存,生成 id

    org.setSn(org.getParent() == null
            ? ("" + org.getId())                              // 顶级:sn = "1"
            : (org.getParent().getSn() + "_" + org.getId())); // 子级:sn = "1_3"

    getHibernateTemplate().update(org);    // 再更新 sn
}
id name pid sn
1 总公司 NULL 1
3 研发部 1 1_3
7 一组 3 1_3_7

有了 sn,就能用一次 SQL 拿到整条祖先链或整棵子树,不必递归查询。

2.3 删除机构的安全校验

public void delOrg(int orgId) {
    Organization org = (Organization) getHibernateTemplate().load(Organization.class, orgId);

    // 存在子机构则不允许删除
    if (org.getChildren().size() > 0) {
        throw new SystemException("存在子机构,不允许删除", "exception.org.del", org.getId());
    }

    getHibernateTemplate().delete(org);
}

真实项目里还要补两条校验:机构下是否还有人员、机构是否已被授权记录引用。否则删除后会产生脏数据。

2.4 修改机构

public void updateOrg(Organization org, int parentId) {
    if (parentId != 0) {
        org.setParent((Organization) getHibernateTemplate().load(Organization.class, parentId));
    }
    getHibernateTemplate().update(org);
}

注意:一旦允许"移动机构"(改父节点),就必须同步重算该节点及所有后代的 sn,否则 sn 会失效。示例项目未实现移动功能,实际开发需要补一个递归更新。


三、页面展示:Dojo Tree + Freemarker 递归模板

3.1 递归模板

机构树用 Freemarker 渲染,技巧是模板自己包含自己:

tree.ftl(外层,构造 Dojo 控件容器):

<div dojoType="TreeBasicController" widgetId="treeController"></div>
<div dojoType="TreeSelector" widgetId="treeSelector" eventNames="select:nodeSelected"></div>
<div dojoType="Tree" selector="treeSelector">
<#list orgs as org>
    <#include "tree_node.ftl">
</#list>
</div>

tree_node.ftl(递归体):

<div dojoType="TreeNode" title="${org.name}" objectId="${org.id}">
    <#list org.children as org>
        <#include "tree_node.ftl">
    </#list>
</div>

<#list org.children as org> 把外层变量 org 遮蔽为子节点,再 <#include> 自身,就完成了任意深度的递归。

3.2 用 EL 函数包装

为了让 JSP 里一行就能输出整棵树,把它封装成自定义 EL 函数:

public class OrgTreeFunction {
    public static String tree(List orgs) {
        try {
            Configuration cfg = FreemarkerManager.getConfiguration();
            Template template = cfg.getTemplate("tree.ftl");
            Writer out = new StringWriter();
            Map rootMap = new HashMap();
            rootMap.put("orgs", orgs);
            template.process(rootMap, out);
            return out.toString();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

在 my.tld 中声明:

<function>
    <name>orgTree</name>
    <function-class>com.oa.web.OrgTreeFunction</function-class>
    <function-signature>java.lang.String tree(java.util.List)</function-signature>
</function>

JSP 中使用:

<%@ taglib prefix="my" uri="http://www.example.com/oa/functions" %>
${my:orgTree(orgs)}

递归渲染整棵树在机构数量大时会很慢,实际项目建议保留懒加载(点节点再查子节点)的方式,或加缓存。


四、人员管理

人员模块与机构模块结构完全对称,是练习"模块开发套路"的最佳范例:

层 机构 人员
实体 Organization Person
接口 OrgManager PersonManager
实现 OrgManagerImpl PersonManagerImpl
ActionForm OrgActionForm PersonActionForm
Action OrgAction PersonAction
JSP WebRoot/org/* WebRoot/person/*

人员的特殊性在于它要关联两个对象:

public void addPerson(Person person, int orgId) {
    person.setOrg((Organization) getHibernateTemplate().load(Organization.class, orgId));
    getHibernateTemplate().save(person);
}

以及在用户管理里给人员分配账号(一个 Person 对应 0 或 1 个 User)。


五、Action 的写法:DispatchAction 一统增删改查

以机构为例,一个 Action 承载全部操作,用 method 参数分发:

public class OrgAction extends BaseAction {

    private OrgManager orgManager;
    public void setOrgManager(OrgManager orgManager) { this.orgManager = orgManager; }

    /** 未指定 method 时默认执行,显示机构列表 */
    @Override
    protected ActionForward unspecified(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response) throws Exception {
        int parentId = ((OrgActionForm) form).getParentId();
        request.setAttribute("pm", orgManager.findOrgs(parentId));
        return mapping.findForward("index");
    }

    public ActionForward add(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response) throws Exception {
        OrgActionForm oaf = (OrgActionForm) form;
        Organization org = new Organization();
        BeanUtils.copyProperties(org, oaf);
        orgManager.addOrg(org, oaf.getParentId());
        return mapping.findForward("pub_add_success");
    }

    public ActionForward del(...)    { orgManager.delOrg(oaf.getId());   return mapping.findForward("pub_del_success"); }
    public ActionForward update(...) { ... }
}

访问方式:

/org.do                        → 列表(unspecified)
/org.do?method=add             → 新增
/org.do?method=del&id=7        → 删除
/org.do?parentId=3             → 查看 id=3 的子机构

六、开发顺序建议

按这个顺序开发一个模块,几乎不会走弯路:

  1. 熟悉需求 —— 机构要支持无限层级、顶级机构、删除保护;
  2. 建立领域模型 —— 画出 Organization 的字段与自关联;
  3. 写实体类并加 XDoclet 注释 —— 跑 Ant 生成映射;
  4. 建表验证 —— 启动 Tomcat 看 DDL 是否符合预期;
  5. 从用例出发设计业务接口 —— addOrg / delOrg / updateOrg / findOrg / findOrgs;
  6. 实现接口并用 JUnit 验证 —— 用 OrgManagerTest 跑一遍;
  7. 设计页面流程 —— 列表 → 新增 → 成功提示;
  8. 写 Action / ActionForm / JSP —— 按上面的 DispatchAction 模板;
  9. 逐步补全 —— 校验、分页、树形展示。

这套流程在权限、公文、会议室模块中会被反复使用。

要点小结

  • 人员模块与机构模块结构完全对称,是练习"模块开发套路"的最佳范例: | 层 | 机构 | 人员 | |---|---|---| | 实体 | Organization …
  • 以机构为例,一个 Action 承载全部操作,用 method 参数分发: ```java public class OrgAction extends BaseAct…
    1. 建表验证 —— 启动 Tomcat 看 DDL 是否符合预期
  • 按这个顺序开发一个模块,几乎不会走弯路: 1. 熟悉需求 —— 机构要支持无限层级、顶级机构、删除保护

由站内小编编辑整理

相关条目