026 hibernate操作树形结构

树形结构:也就是目录结构,有父目录、子目录、文件等信息,而在程序中树形结构只是称为节点。

         一棵树有一个根节点,而根节点也有一个或多个子节点,而一个子节点有且仅有一个父节点(当前除根节点外),而且也存在一个或多个子节点。

         也就是说树形结构,重点就是节点,也就是我们需要关心的节点对象。

         节点:一个节点有一个ID、一个名称、它所属的父节点(根节点无父节点或为null),有一个或多的子节点等其它信息。

Hibernate将节点抽取出成实体类,节点相对于父节点是“多对一”映射关系,节点相对于子节点是“一对多”映射关系。  

节点实体类:

/** * 节点*/

public class Node {

    private int id; //标识符

    private String name; //节点名称 

    private int level; //层次,为了输出设计   

    private boolean leaf; //是否为叶子节点,这是为了效率设计,可有可无

    //父节点:因为多个节点属于一个父节点,因此用hibernate映射关系说是多对一

    private Node parent;

    //子节点:因为一个节点有多个子节点,因此用hibernate映射关系说是一对多

    private Set children;

 

    public int getId() {

        return id;

    }

    public void setId(int id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getLevel() {

        return level;

    }

    public void setLevel(int level) {

        this.level = level;

    }

    public boolean isLeaf() {

        return leaf;

    }

    public void setLeaf(boolean leaf) {

        this.leaf = leaf;

    }

    public Node getParent() {

        return parent;

    }

    public void setParent(Node parent) {

        this.parent = parent;

    }

    public Set getChildren() {

        return children;

    }

    public void setChildren(Set children) {

        this.children = children;

    }

}

 

节点映射文件:

<hibernate-mapping>

    <class name="com.wjt276.hibernate.Node" table="t_node">

        <id name="id" column="id">

            <generator class="native"/>

        </id>

        <property name="name"/>

        <property name="level"/>

        <property name="leaf"/>

<!— 一对多:加入一个外键,参照当前表t_node主键

    而属性parent类型为Node,也就是当前类,则会在同一个表中加入这个字段,参照这个表的主键-->

        <many-to-one name="parent" column="pid"/>

    <!-- <set>标签是映射一对多的方式,加入一个外键,参照主键。-->

        <set name="children" lazy="extra" inverse="true">

            <key column="pid"/>

            <one-to-many class="com.wjt276.hibernate.Node"/>

        </set>

       

    </class>

</hibernate-mapping>

测试代码:

 

public class NodeTest extends TestCase {

    //测试节点的存在

    public void testSave1(){

        NodeManage.getInstanse().createNode("F:\\JAVA\\JavaProject\\hibernate\\hibernate_training_tree");

    }

   

    //测试节点的加载

    public void testPrintById(){

        NodeManage.getInstanse().printNodeById(1);

    }

}

 

相应的类代码:

public class NodeManage {

   

    private static NodeManage nodeManage= new NodeManage();

   

    private NodeManage(){}//因为要使用单例,所以将其构造方法私有化

   

    //向外提供一个接口

    public static NodeManage getInstanse(){

        return nodeManage;

    }

 

    /**

     * 创建树

     * @param filePath 需要创建树目录的根目录

     */

    public void createNode(String dir) {

        Session session = null;

       

        try {

            session = HibernateUtils.getSession();

            session.beginTransaction();

           

            File root = new File(dir);

            //因为第一个节点无父节点,因为是null

            this.saveNode(root, session, null, 0);

           

            session.getTransaction().commit();

        } catch (HibernateException e) {

            e.printStackTrace();

            session.getTransaction().rollback();

        } finally {

            HibernateUtils.closeSession(session);

        }

    }

 

    /**

     * 保存节点对象至数据库

     * @param file 节点所对应的文件

     * @param session session

     * @param parent 父节点

     * @param level 级别

     */

    public void saveNode(File file, Session session, Node parent, int level) {

       

        if (file == null || !file.exists()){

            return;

        }

       

        //如果是文件则返回true,则表示是叶子节点,否则为目录,非叶子节点

        boolean isLeaf = file.isFile();

       

        Node node = new Node();

        node.setName(file.getName());

        node.setLeaf(isLeaf);

        node.setLevel(level);

        node.setParent(parent);

       

        session.save(node);

       

        //进行循环迭代子目录

        File[] subFiles = file.listFiles();

        if (subFiles != null && subFiles.length > 0){

            for (int i = 0; i < subFiles.length ; i++){

                this.saveNode(subFiles[i], session, node, level + 1);

            }

        }

    }

 

    /**

     * 输出树结构

     * @param id

     */

    public void printNodeById(int id) {

 

        Session session = null;

       

        try {

            session = HibernateUtils.getSession();

            session.beginTransaction();

           

            Node node = (Node)session.get(Node.class, 1);

           

            printNode(node);

           

            session.getTransaction().commit();

        } catch (HibernateException e) {

            e.printStackTrace();

            session.getTransaction().rollback();

        } finally {

            HibernateUtils.closeSession(session);

        }      

    }

 

   

    private void printNode(Node node) {

       

        if (node == null){

            return;

        }

       

        int level = node.getLevel();

       

        if (level > 0){

            for (int i = 0; i < level; i++){

                System.out.print("  |");

            }

            System.out.print("--");            

        }

        System.out.println(node.getName() + (node.isLeaf() ? "" : "[" + node.getChildren().size() + "]"));

       

        Set children = node.getChildren();

        for (Iterator iter = children.iterator(); iter.hasNext(); ){

            Node child = (Node)iter.next();

            printNode(child);

        }

    }

}

 

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。