departmentiterator.java

基于java的组号查询模块

/*
 * package com.lily.dap.service.organize.impl.facade;
 * class DepartmentIterator
 * 
 * 创建日期 2005-10-28
 *
 * 开发者 zouxuemo
 *
 * 淄博百合电子有限公司版权所有
 */
package com.lily.dap.service.organize.impl;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;

import com.lily.dap.model.organize.Department;
import com.lily.dap.model.organize.Person;
import com.lily.dap.model.organize.Post;
import com.lily.dap.service.organize.DepartmentIteratorHandle;
import com.lily.dap.service.organize.OrganizeQuery;

/**
 * 组织机构遍历器，遍历组织机构，执行给定的操作
 * 
 * @author zouxuemo
 *
 */
public class DepartmentIterator {
    /*
     * 遍历组织机构的范围：遍历所有部门，遍历所有部门、岗位，遍历所有部门、岗位、人员
     */
    public static final int ITERATOR_RANGE_DEPARTMENT = 1;
    
    public static final int ITERATOR_RANGE_DEPARTMENT_POST = 2;
    
    public static final int ITERATOR_RANGE_DEPARTMENT_POST_PERSON = 3;
    
    /*
     * 节点类型：分公司，部门，岗位，人员
     */
    private static final int NODE_TYPE_DEPARTMENT = 2;
    
    private static final int NODE_TYPE_POST = 3;
    
    private static final int NODE_TYPE_PERSON = 4;
    
    private OrganizeQuery organizeQuery;
    

    
    /**
     * @param departmentManager 要设置的 departmentManager。
     */
    public void setOrganizeQuery(OrganizeQuery organizeQuery) {
        this.organizeQuery = organizeQuery;
    } 
    
    public void iteratorNormal(int iterator_range, DepartmentIteratorHandle handle) {
		Stack stack = new Stack();
		
		Object root = organizeQuery.getRootDepartment();
        boolean handleRootFlag = false;
		Object node = root;
        Object parentNode = null;
		
		//开始遍历
		handle.iteratorBegin();
		
		while (node != null) {
            //遍历处理
            if (!handleRootFlag) {
                iteratorHandleRoot(handle, node);
                handleRootFlag = true;
            } else {
    		    iteratorHandle(handle, node, parentNode);
            }
			
		    List list = this.getChild(node, iterator_range);
			if (!list.isEmpty()) {
                parentNode = node;
                
                StackNode stackNode = new StackNode(list); 
                node = stackNode.next();
                
                stack.push(stackNode);
			} else {
                node = null;
			    while (!stack.isEmpty()) {
			        StackNode stackNode = (StackNode)stack.peek();
			        node = stackNode.next();
                    
			        if (node != null) {
			        	int stackSize = stack.size(); 
                        if (stackSize > 1)
                             parentNode = ((StackNode)stack.get(stack.size()-2)).prev();
                        else if (stackSize > 0)
                        	parentNode = root;
                        else
                            parentNode = null;
                    
			            break;
                    } else
			            stack.pop();
			    }
			}
		}
		
		//结束遍历
		handle.iteratorEnd();
    }

    private void iteratorHandleRoot(DepartmentIteratorHandle handle, Object obj) {
            handle.iteratorRoot((Department)obj);
    }
    
    /**
     * 根据传入的对象，调用遍历处理器的不同方法进行处理
     * 
     * @param handle
     * @param obj
     */
    private void iteratorHandle(DepartmentIteratorHandle handle, Object obj, Object paretnObj) {
        if (obj instanceof Department) {
            Department dep = (Department)obj;
            Department depParent = (Department)paretnObj;
//            int type = dep.getType();
            
            handle.iteratorDepartment(dep, depParent);
        } else if (obj instanceof Post) {
            handle.iteratorPost((Post)obj, (Department)paretnObj);
        } else if (obj instanceof Person) {
    	    handle.iteratorPerson((Person)obj, (Post)paretnObj);
    	}
    }
    
    /**
     * 根据传入的对象和遍历范围，检索对象包含的子项列表集合。
     * 
     * @param obj
     * @param iterator_range
     * @return
     */
    private List getChild(Object obj, int iterator_range) {
        int type = organizeType(obj);
        List list, listAppend;
        
        if (type == NODE_TYPE_DEPARTMENT) {
            long id = ((Department)obj).getId();
            list = OrganizeUtil.sortOrganizeList(organizeQuery.getChildDepartments(id));
            
            if (iterator_range == ITERATOR_RANGE_DEPARTMENT_POST || iterator_range == ITERATOR_RANGE_DEPARTMENT_POST_PERSON) {
                listAppend = OrganizeUtil.sortOrganizeList(organizeQuery.getPosts(id));
                list.addAll(listAppend);
            }
        } else if (type == NODE_TYPE_POST && iterator_range == ITERATOR_RANGE_DEPARTMENT_POST_PERSON) {
            long id = ((Post)obj).getId();
            list = OrganizeUtil.sortOrganizeList(organizeQuery.getPersonsByPost(id));
        } else
            list = new ArrayList();
        
        return list;
    }
    
    /**
     * 返回给定对象的类型（部门、岗位、人员）
     * 
     * @param obj
     * @return
     */
    private int organizeType(Object obj) {
        if (obj instanceof Department) {
            return NODE_TYPE_DEPARTMENT;
        } else if (obj instanceof Post) {
            return NODE_TYPE_POST;
        } else {
            return NODE_TYPE_PERSON;
    	}
    }
}

/*
 * 保存子节点的List是必要的，本来以为只保存List的Iterator就可以了，但是出现了不停的请求连接数据库的问题
 * 初步怀疑是没有保存List，结果在遍历过程中把List内保存的PO对象释放了，引起无休止的数据库连接请求问题 
 */
class StackNode {
    private List list = null;
    
    private Iterator it = null;
    
    private int index;

    public StackNode(List list) {
        if (list != null) {
            this.list = list;
            this.it = list.iterator();
            if (list.size() == 0)
            	index = -1;
            else
            	index = 0;
        }
    }
    
    public Object next() {
        if (it != null && it.hasNext()) {
        	index++;
            return it.next();
        } else
            return null;
    }
    
    public Object curr() {
    	if (index >= 0)
    		return list.get(index-1);
    	else
    		return null;
    }
    
    public Object prev() {
    	if (index > 0)
    		return list.get(index-1);
    	else
    		return null;
    }
}