resobjecthibernate.java

java实现的可配置的工作流引擎,采用jsp+javabean实现

package com.hongsoft.res.database;

import com.hongsoft.res.pojo.*;

import org.hibernate.*;

import java.util.*;
import org.hibernate.type.*;

public class ResObjectHibernate {
    private static ResObjectHibernate dao = null;

    static ResObjectHibernate getInstance() {
        return new ResObjectHibernate();
    }

    private ResObjectHibernate() {
    }

    /**
     * 根据child_id来获取ResObject
     *
     * @param child_id
     * @return
     */
    private ResObject getTypeByID(Session session, long child_id) throws ResException {
        int errorCode = ResException.OTHER_DATABASE_ERROR;
        ResObject resObject = null;
        try {
            List resObjectList = null;
            // session.find(ResQuery.GET_OBJECT_TYPE_BY_ID,
            // new Long(child_id), new LongType());
            Iterator itr = resObjectList.iterator();
            if (itr.hasNext())
                resObject = (ResObject) itr.next();
        } catch (HibernateException e) {
            throw new ResException(errorCode);
        }
        return resObject;

    }

    /**
     * 通过orgID来获取对象的类型: private中不用this.beginTransaction
     *
     * @param ou
     * @return true:是 false:否
     * @throws ResException
     */
    private int getObjectType(Session session, long orgID) throws ResException {
        boolean abort = true;
        int errorCode = ResException.OTHER_DATABASE_ERROR;
        int type = -1;
        try {
            List userList = null;
            // session.find(ResQuery.GET_OBJECT_TYPE_BY_ID,
            // new Long(orgID), new LongType());
            Iterator itr = userList.iterator();
            if (itr.hasNext())
                type = ((ResObject) itr.next()).getType();
        } catch (HibernateException e) {
            throw new ResException(errorCode);
        } finally {
        }
        return type;
    }

    /**
     * 向下查找子类,类型要求为type parent=false
     *
     * @param rootResID
     * @return
     */
    private ResObjectElement getResObjectElement(Session session, long rootResID, int type, boolean extendFlag)
            throws ResException {
        boolean abort = true;
        int errorCode = ResException.OTHER_DATABASE_ERROR;
        // 设置顶层的resID和type
        ResObjectElement roElement = new ResObjectElement(rootResID, getObjectType(session, rootResID));
        try {
            StringBuffer searchQuery = new StringBuffer();
            if (extendFlag) // true,不论怎样,均向下查找
                searchQuery
                        .append("SELECT r FROM ResObjectRela as r,ResObject as m WHERE r.id.parent_id=:parent_id and m.type=:type and r.id.child_id=m.id and m.orgUnit.is_deleted=0");
            else
                // false,当遇到不继承权限的标志时不再向下查找
                searchQuery
                        .append("SELECT r FROM ResObjectRela as r,ResObject as m WHERE r.id.parent_id=:parent_id and m.type=:type and r.is_extend=1 and r.id.child_id=m.id and m.orgUnit.is_deleted=0");
            Query q = session.createQuery(searchQuery.toString());
            q.setLong("parent_id", rootResID);
            q.setInteger("type", type);
            Iterator itr = q.iterate();
            while (itr.hasNext()) {
                // 取出每个ResObjectRela子对象,转化为一个ResobjectElement
                ResObjectRela roRelation = (ResObjectRela) itr.next();
                // 递归调用,子对象的类型满足条件才做
                if (getObjectType(session, roRelation.getId().getChild_id()) == type) {
                    ResObjectElement oneChildElement = getResObjectElement(session, roRelation.getId().getChild_id(),
                            type, extendFlag);
                    // 将生成的ResObejctElement作为孩子添加给总的ResObjectElement
                    roElement.addChild(oneChildElement);
                } else {
                    break;
                }
            }
        } catch (HibernateException e) {
            throw new ResException(errorCode);
        }
        return roElement;
    }

    /**
     * 向上查找父类,类型要求为type parent=true
     *
     * @param rootResID
     * @return
     */
    private ResObjectElement getResObjectElement2(Session session, long rootResID, int type, boolean extendFlag)
            throws ResException {
        boolean abort = true;
        int errorCode = ResException.OTHER_DATABASE_ERROR;
        // 设置顶层的resID和type
        ResObjectElement roElement = new ResObjectElement(rootResID, getObjectType(session, rootResID));
        try {
            StringBuffer searchQuery = new StringBuffer();
            if (extendFlag) // true,不论怎样,均向下查找
                searchQuery
                        .append("SELECT r FROM ResObjectRela as r,ResObject as m WHERE r.id.child_id=:child_id and m.type=:type and r.id.parent_id=m.id and m.orgUnit.is_deleted=0");
            else
                // false,当遇到不继承权限的标志时不再向下查找
                searchQuery
                        .append("SELECT r FROM ResObjectRela as r,ResObject as m WHERE r.id.child_id=:child_id and m.type=:type and r.is_extend=1 and r.id.parent_id=m.id and m.orgUnit.is_deleted=0");
            Query q = session.createQuery(searchQuery.toString());
            q.setLong("child_id", rootResID);
            q.setInteger("type", type);
            Iterator itr = q.iterate();
            while (itr.hasNext()) {
                // 取出每个ResObjectRela子对象,转化为一个ResobjectElement
                ResObjectRela roRelation = (ResObjectRela) itr.next();
                // 父对象的类型满足条件才做
                if (getObjectType(session, roRelation.getId().getParent_id()) == type) {
                    // 递归调用
                    ResObjectElement oneChildElement = getResObjectElement(session, roRelation.getId().getChild_id(),
                            getTypeByID(session, roRelation.getId().getChild_id()).getType(), extendFlag);
                    // 将生成的ResObejctElement作为孩子添加给总的ResObjectElement
                    roElement.addChild(oneChildElement);
                } else {
                    break;
                }
            }
        } catch (HibernateException e) {
            throw new ResException(errorCode);
        }
        return roElement;
    }

    /**
     * 从数据库获取资源管理对象关联对象,并将其层次关系保存于ResObjectElement对象中，返回的
     * !!!!ResObjectRela和ResObject通过child_id和id相关联,否则,可能会返回多个ResObjectElement
     * ResObjectElement是最开始的根目录，其ID等于参数中的rootResID.
     *
     * @param rootResID 根目录资源对象ID.
     * @param parent 如果是查找其父类关联则输入true，如果是查找其子类关联则输入false.
     * @param extendFlag 如果输入false,则当遇到不继承权限的标志时不再向下查找;否则继续查找
     * @param type 查找的资源管理对象的类型,表示只查找该类型的资源对象。参见 <code>ResType</code>
     * @return 根ResObjectElement
     */
    public ResObjectElement getResObjectElement(Session session, long rootResID, boolean parent, boolean extendFlag,
            int type) throws ResException {

        try {
            if (parent == true)
                return getResObjectElement2(session, rootResID, type, extendFlag);
            else
                return getResObjectElement(session, rootResID, type, extendFlag);
        } catch (Exception ex) {
            throw new ResException(ResException.OTHER_DATABASE_ERROR);
        }

    }

    /**
     * 向下查找子类 parent=false
     *
     * @param rootResID
     * @return
     */
    private ResObjectElement getResObjectElement(Session session, long rootResID, boolean extendFlag)
            throws ResException {
        int errorCode = ResException.OTHER_DATABASE_ERROR;