jeasyui的树递归

       大家都知道,树, 有很多枝干,枝干下有很多分支,分支下又有很多分支.....循环往复,如果我们想得到一棵对下的所有分支信息, 我们要通过一般的循环显然是很难实现的,因为你不知道每一个分去下会有多少分支, 这是不定的, 但我们可以写程序,让程序自己去判断节点下是否还有节点.

       jeasyui,自学过的也许很清楚,  获取树只需要传一个链接得到这个json数据,然后它自己会加载这棵树.以下是我做权限时,自己写的一个递归.

       首先,我们需要创建一个关于树的bean,名为TreeNode

public class TreeNode {

	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getText() {
		return text;
	}
	public void setText(String text) {
		this.text = text;
	}
	public String getState() {
		return state;
	}
	public void setState(String state) {
		this.state = state;
	}
	public Map<String, Object> getAttributes() {
		return attributes;
	}
	public void setAttributes(Map<String, Object> attributes) {
		this.attributes = attributes;
	}
	public List<TreeNode> getChildren() {
		return children;
	}
	public void setChildren(List<TreeNode> children) {
		this.children = children;
	}
	public void setIconCls(String iconCls) {
		this.iconCls = iconCls;
	}
	public String getIconCls() {
		return iconCls;
	}
	private String id; //节点标识
	private String text;//节点显示名称
	private String state;//状态,'open' or  'closed'
	private String iconCls; //图标样式(该插件有个样式,可以自己修改或添加图标样式,如'icon-ok')
	private Map<String,Object> attributes;//附加信息(该字段说明树的信息是可扩展的,你可以将一个pojo的其它数据,也附给这个对象,下面会有说明)
	private List<TreeNode> children;	//子节点信息
	
	
}

      演示的pojo为模块实体,  该实体,你可以改成你自己的实体,这里只做演示.

        

@Entity
@Table(name="t_b_module")
public class Module extends IdEntity {    

    private String parentId="0";    //父模块ID,parentId值为0代表是应用即根节点，根模块
    private String name;        	//模块名称
    private String description; 	//模块描述
    private String pic;         	//模块图片
    private String site;        	//模块地址，如果是组件，则为组件标识
    private String target;      	//打开方式1._blank 表示在新窗口中打开2. _iframe表示在框架中打开窗口
    private Boolean alwaysDisplay;  //是否显示
    private String moduleIcon;      //模块图标样式
    private Long sort;				//模块排序号
    private String type;			// 类型： 1、模块，2、组件
    private String projectString;	// 项目标识，同一项目使用同一标识
    
    private Boolean isChecked;
    
    private List<Module> moduleListTemp = new ArrayList<Module>();	//子模块(如未全选中,则不包含子模块的父模块)
    private List<Module> moduleList=new ArrayList<Module>();    //子模块
    private List<Role> roles=new ArrayList<Role>();				//角色映射
    
    @Column(length=64)
    public String getParentId() {
		return parentId;
	}
	public void setParentId(String parentId) {
		this.parentId = parentId;
	}
    @Column(nullable=false,length=32)
    public String getName() {
        return name;
    } 
	public void setName(String name) {
        this.name = name;
    }
    @Column(length=256)
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    @Column(length=128)
    public String getPic() {
        return pic;
    }
    public void setPic(String pic) {
        this.pic = pic;
    }
    @Column(length=128)
    public String getSite() {
        return site;
    }
    public void setSite(String site) {
        this.site = site;
    }
    @Column(length=12)
    public String getTarget() {
        return target;
    }
    public void setTarget(String target) {
        this.target = target;
    }
    public Boolean getAlwaysDisplay() {
		return alwaysDisplay;
	}
	public void setAlwaysDisplay(Boolean alwaysDisplay) {
		this.alwaysDisplay = alwaysDisplay;
	}
    @Column(length=128)
    public String getModuleIcon() {
		return moduleIcon;
	}
	public void setModuleIcon(String moduleIcon) {
		this.moduleIcon = moduleIcon;
	}     
    @Column(length=128)
    public String getProjectString() {
        return projectString;
    }
    public void setProjectString(String projectString) {
        this.projectString = projectString;
    }
    @Column(nullable=false,length=2)
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    @Transient
	public List<Module> getModuleList() {
		return moduleList;
	}
	public void setModuleList(List<Module> moduleList) {
		this.moduleList = moduleList;
	}
	@Transient
	public List<Module> getModuleListTemp() {
		return moduleListTemp;
	}
	public void setModuleListTemp(List<Module> moduleListTemp) {
		this.moduleListTemp = moduleListTemp;
	}
	@Transient
	public Boolean getIsChecked() {
		return isChecked;
	}
	public void setIsChecked(Boolean isChecked) {
		this.isChecked = isChecked;
	}
	public Long getSort() {
		return sort;
	}
	public void setSort(Long sort) {
		this.sort = sort;
	}
	public void setRoles(List<Role> roles) {
		this.roles = roles;
	}
	@Transient
	@ManyToMany(mappedBy="modules")
	public List<Role> getRoles() {
		return roles;
	}

            其实我们如果直接将数据库实体封装成树数据,也不是不可以,但如果关联关系一旦复杂了,转json的时候,递归json数据会出错, 就相当于在转圈圈似的.  以下代码即为递归树数据的主要代码, 请注意看注释.

/**
     * 根据父ID,得到模块树列表
     */
    public List<TreeNode> getAllTreeNodesById(String pid){
    	List<Module> modules = moduleTree(pid); //该方法可不用理会,这是内部得到数据的方法,通过父ID,得到下面的数据节点集合
    	List<TreeNode> treeNodes = null;
    	if(null != modules && modules.size() > 0){
    		treeNodes = new ArrayList<TreeNode>();
	    	for (Module module : modules) {
	    		TreeNode treeNode = getTreeNodeByModuleNew(module); //分别得到每个节点下的子节点集合
	    		treeNodes.add(treeNode);
			}
    	}
    	return treeNodes;
    }
    
    /**
     * 递归模块树
     * @param module
     * @return
     */
    public TreeNode getTreeNodeByModuleNew(Module module){
    	TreeNode treeNode = new TreeNode();
    	treeNode.setIconCls(module.getModuleIcon());
    	treeNode.setText(module.getName());
    	treeNode.setState("close");
		Map<String, Object> map = new HashMap<String, Object>(); //附加数据,前台获取数据可(json对象.attributes.site)
		map.put("id", module.getId());
		map.put("pid", module.getParentId());
		map.put("site", module.getSite());
		treeNode.setAttributes(map);
		
		List<Module> modules = moduleTree(module.getId());   //得到子节点集合
		List<TreeNode> treeNodes = new ArrayList<TreeNode>();
		for (Module m : modules) {
			TreeNode tn = getTreeNodeByModuleNew(m);  //循环子节点,得到子节点下的孙节点集合,调用本身,可一直向下递归,直到modules为空
			treeNodes.add(tn);
		}
		treeNode.setChildren(treeNodes);   //添加封装好数据的子节点集合
		return treeNode;
    }

       自己写出了这个递归,真的好开心,跟大家分享一下.  前台的代码我就不贴了, 用以上代码,可实现树的无限级显示.如不懂或有建议,可留言.亲,下一章还有ztree的讲解哦,都是差不多的.