Hibernate注解实现单表递归树形结构

最新推荐文章于 2021-07-13 14:57:29 发布
最新推荐文章于 2021-07-13 14:57:29 发布
阅读量1.3w 收藏 10
点赞数 1
分类专栏： 数据库方面

目录：

  1. 概述
  2. 环境
  3. 代码示例测试结果

[一]、概述

在系统中，经常会用到无限级递归的树形结构，比如菜单、组织机构管理、多级分类等等，一般是在同一个表中定义父子关系实现这种树形结构，本文主要讲述如何运用hibernate全注解的方式实现这个功能。

[二]、环境

  • hibernate 4.1.2
  • java 1.6
  • mysql 5.1

[三]、代码示例

第一步：创建Entity类，并添加注解实现关联关系

ps: 主要是利用@ManyToOne 和 @OneToMany 配置在同一个Entity类中实现树形递归的结构。

TreeNode.java

package com.micmiu.hibernate.anno.entity;

import java.util.LinkedHashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;

/**
 * 树形结构示例
 *
 * @author <a href="http://www.micmiu.com">Michael Sun</a>
 */
@Entity
@Table(name = "DEMO_T_TREE_NODE")
public class TreeNode {

	public TreeNode() {
	}

	public TreeNode(String name) {
		this.name = name;
	}

	private int id;

	private String name;
	// 父节点
	private TreeNode parent;
	// 子节点
	private Set<TreeNode> children = new LinkedHashSet<TreeNode>();

	@Id
	@Column(name = "ID")
	@GeneratedValue
	public int getId() {
		return id;
	}

	@Column(name = "NAME", length = 20)
	public String getName() {
		return name;
	}

	@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
	@JoinColumn(name = "PARENT_ID")
	public TreeNode getParent() {
		return parent;
	}

	@OneToMany(cascade = CascadeType.ALL, mappedBy = "parent", fetch = FetchType.EAGER)
	public Set<TreeNode> getChildren() {
		return children;
	}

	public void setId(int id) {
		this.id = id;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void setParent(TreeNode parent) {
		this.parent = parent;
	}

	public void setChildren(Set<TreeNode> children) {
		this.children = children;
	}
}

第二步：创建hibernate默认配置文件：

hibernate.cfg.xml

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

	<session-factory>

		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="connection.url">jdbc:mysql://localhost:3306/michaeldemo</property>
		<property name="connection.username">root</property>
		<property name="connection.password"></property>

		<property name="show_sql">true</property>
		<property name="format_sql">true</property>

		<property name="current_session_context_class">thread</property>
		<property name="hbm2ddl.auto">update</property>

		<mapping class="com.micmiu.hibernate.anno.entity.TreeNode" />
	</session-factory>

</hibernate-configuration>

第三步：创建测试文件：

HibernateAnnoTreeTest.java

package com.micmiu.hibernate;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

import com.micmiu.hibernate.anno.entity.TreeNode;

/**
 * 测试
 *
 * @author <a href="http://www.micmiu.com">Michael Sun</a>
 */
public class HibernateAnnoTreeTest {

	private static SessionFactory sessionFactory;

	@BeforeClass
	public static void beforeClass() {
		Configuration configuration = new Configuration().configure();
		ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()
				.applySettings(configuration.getProperties())
				.buildServiceRegistry();
		sessionFactory = configuration.buildSessionFactory(serviceRegistry);

	}

	@AfterClass
	public static void afterClass() {
		sessionFactory.close();
	}

	@Test
	public void testTreeCRUD() {
		// 先运行添加测试
		// testSave();

		// 读取测试
		// testRead();

		// 更新测试
		testUpdate();

		// 删除测试
		// testDelete();
	}

	public void testSave() {
		System.out.println("========>测试添加 start <========");
		Session session = sessionFactory.openSession();

		session.beginTransaction();
		TreeNode rootNode = initData();
		session.save(rootNode);
		session.getTransaction().commit();
		session.close();
		System.out.println("========>测试添加 end <========");
		// 读取添加的数据
		testRead();
	}

	public void testRead() {
		System.out.println("========>读取 start <========");
		Session session = sessionFactory.openSession();
		session.beginTransaction();
		System.out.println("-----> get root node:");
		TreeNode rootNode = (TreeNode) session.get(TreeNode.class, 1);

		System.out.println("-----> 输出树形结构如下:");
		printNode(rootNode, 0);

		session.getTransaction().commit();
		session.close();
		System.out.println("========>读取 end <========");
	}

	public void testUpdate() {
		// 更新前读取信息
		testRead();
		System.out.println("========>测试更新 start <========");
		Session session = sessionFactory.openSession();
		session.beginTransaction();

		System.out.println("---> 更新节点属性");
		TreeNode rootNode = (TreeNode) session.get(TreeNode.class, 1);
		System.out.println("get root node:" + rootNode.getName()
				+ " child size:" + rootNode.getChildren().size());
		rootNode.setName(rootNode.getName() + "(我的blog)");

		TreeNode node_del = null;
		for (TreeNode node : rootNode.getChildren()) {
			if ("Hazel".equals(node.getName())) {
				node_del = node;
			}
		}
		System.out.println("---> 删除节点(包含子节点)");
		System.out.println("delete node:" + node_del.getName() + " child size:"
				+ node_del.getChildren().size());
		node_del.setParent(null);
		rootNode.getChildren().remove(node_del);
		session.delete(node_del);

		System.out.println("---> 添加节点(包含子节点)");
		TreeNode node_add = new TreeNode("企业应用");
		node_add.setParent(rootNode);
		rootNode.getChildren().add(node_add);

		TreeNode node_add_0 = new TreeNode("SNMP");
		node_add_0.setParent(node_add);
		node_add.getChildren().add(node_add_0);

		TreeNode node_add_1 = new TreeNode("SSO");
		node_add_1.setParent(node_add);
		node_add.getChildren().add(node_add_1);

		session.update(rootNode);

		System.out.println("---> 节点下添加子节点");
		TreeNode node_update = (TreeNode) session.get(TreeNode.class, 6);
		TreeNode node_child_add = new TreeNode("go(新增)");
		System.out.println("append child node:" + node_child_add.getName()
				+ " to parent node: " + node_update.getName());
		node_child_add.setParent(node_update);
		node_update.getChildren().add(node_child_add);

		System.out.println("---> 节点下删除子节点");

		TreeNode node_child_del = node_update.getChildren().iterator().next();
		System.out.println("delete node child :" + node_child_del.getName()
				+ " from parent node: " + node_update.getName());
		node_update.getChildren().remove(node_child_del);
		node_child_del.setParent(null);
		session.delete(node_child_del);

		session.update(node_update);

		session.getTransaction().commit();
		session.close();
		System.out.println("========>测试更新 end <========");
		// 更新后读取信息
		testRead();
	}

	public void testDelete() {
		// 删除前读取信息
		testRead();
		System.out.println("========>测试删除 start <========");
		Session session = sessionFactory.openSession();
		session.beginTransaction();
		TreeNode node = (TreeNode) session.get(TreeNode.class, 6);
		System.out.println("node:" + node.getName() + " child size:"
				+ node.getChildren().size());
		TreeNode childNode = node.getChildren().iterator().next();
		childNode.setParent(null);
		node.getChildren().remove(childNode);
		session.delete(childNode);
		System.out.println("delete node:" + childNode.getName()
				+ " from parent:" + node.getName());

		session.update(node);
		session.getTransaction().commit();
		session.close();
		System.out.println("========>测试删除 end <========");
		// 删除后读取信息
		testRead();

	}

	/**
	 * 模拟测试数据
	 */
	private TreeNode initData() {
		TreeNode rootNode = new TreeNode("micmiu.com");

		// 一级
		TreeNode node0 = new TreeNode("Michael");
		node0.setParent(rootNode);
		rootNode.getChildren().add(node0);

		// 二级
		TreeNode node0_0 = new TreeNode("J2EE");
		node0_0.setParent(node0);
		node0.getChildren().add(node0_0);
		// 二级
		TreeNode node0_1 = new TreeNode("SOA");
		node0_1.setParent(node0);
		node0.getChildren().add(node0_1);
		// 二级
		TreeNode node0_2 = new TreeNode("NoSQL");
		node0_2.setParent(node0);
		node0.getChildren().add(node0_2);

		// 二级
		TreeNode node0_3 = new TreeNode("编程语言");
		node0_3.setParent(node0);
		node0.getChildren().add(node0_3);

		// 三级
		TreeNode node0_3_0 = new TreeNode("Java");
		node0_3_0.setParent(node0_3);
		node0_3.getChildren().add(node0_3_0);

		TreeNode node0_3_1 = new TreeNode("Groovy");
		node0_3_1.setParent(node0_3);
		node0_3.getChildren().add(node0_3_1);

		TreeNode node0_3_2 = new TreeNode("javascript");
		node0_3_2.setParent(node0_3);
		node0_3.getChildren().add(node0_3_2);

		// 一级
		TreeNode node1 = new TreeNode("Hazel");
		node1.setParent(rootNode);
		rootNode.getChildren().add(node1);
		// 二级
		TreeNode node1_0 = new TreeNode("life");
		node1_0.setParent(node1);
		node1.getChildren().add(node1_0);
		// 二级
		TreeNode node1_1 = new TreeNode("美食");
		node1_1.setParent(node1);
		node1.getChildren().add(node1_1);
		// 二级
		TreeNode node1_2 = new TreeNode("旅游");
		node1_2.setParent(node1);
		node1.getChildren().add(node1_2);

		return rootNode;
	}

	private void printNode(TreeNode node, int level) {
		String preStr = "";
		for (int i = 0; i < level; i++) {
			preStr += "|----";
		}
		System.out.println(preStr + node.getName());
		for (TreeNode children : node.getChildren()) {
			printNode(children, level + 1);
		}
	}

}

第四步：创建日志输出配置文件：

log4j.properties

# Output pattern : date [thread] priority category - message
log4j.rootLogger=info, Console

#Console
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n

log4j.logger.org.hibernate.tool.hbm2ddl=debug
log4j.logger.org.hibernate.test=info

[四]、测试结果

测试添加方法，输出日志如下：

========>测试添加 start <========
========>测试添加 end <========
========>读取 start <========
-----> get root node:
-----> 输出树形结构如下:
micmiu.com
|----Michael
|----|----J2EE
|----|----SOA
|----|----NoSQL
|----|----编程语言
|----|----|----Java
|----|----|----Groovy
|----|----|----javascript
|----Hazel
|----|----life
|----|----美食
|----|----旅游
========>读取 end <========

 

[四]、测试结果

测试添加方法，输出日志如下：

========>测试添加 start <========
========>测试添加 end <========
========>读取 start <========
-----> get root node:
-----> 输出树形结构如下:
micmiu.com
|----Michael
|----|----J2EE
|----|----SOA
|----|----NoSQL
|----|----编程语言
|----|----|----Java
|----|----|----Groovy
|----|----|----javascript
|----Hazel
|----|----life
|----|----美食
|----|----旅游
========>读取 end <========

 --------------------------------------------------------------

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);
		}
	}
}


 

budapest
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
spring-data-jpa(单表复杂查询)
傲雪当歌的博客
12-28 448
上一篇:多表联查和新增——多对多 在customer表里新增四条数据 求得以下查询结果 select * from customer where name like '%a%' and cust_id < 12 在服务实现层 @Override public Page findBySpecification() { Specification specification = new Specification() { @SneakyThrows
用hibernate对递归数据的操作
键者天行
08-13 7741
在工作中，我们常常会碰到具有递归性质记录的数据，最常见的是某个机构部门节点的数据，某个节点一定会有个父节点属性，同时它也许会有若干子节点。所有的节点数据都会存在数据库中一张表中。这种现象在设计模式上叫Composite模式。下面我就给出一个用hibernate操作这种表的例子,关于hibernate配置和建立表结构的部分请参考我的前一篇文章《利用weblogic的数据源作为hibernate的数据
hibernate实现递归查询
10-13
实际开发中碰到一个使用hibernate递归查询的问题。我解决了发出来给大家一起分享
jpa单表递归树形结构实现
07-23
springJpa单标递归树形结构
springBoot jpa创建树形结构数据库
weixin_47615289的博客
07-13 1003
创建数据库表 数据库表的创建 @Entity @Table(name = “treeTable”) @Slf4j @Audited @Data public class TreeTable extends BaseModel implements Serializable { private String name;//省市名 private Long parentId;//代指父节点 @Override public boolean equals(Object o) { if (this == o) r
Hibernate映射树形结构
04-22
在给定的压缩包`hibernate_2300_tree`中，可能包含了示例代码、配置文件或者教程资源，用于展示如何在实际项目中实现Hibernate对树形结构的映射。通过学习这些材料，开发者可以更深入地理解Hibernate映射树形结构的...
struts2 hibernate 实现无限级联 树形分类
12-25
在视图层，我们可能使用JSP或者FreeMarker等模板技术来展示树形结构。这些模板可以接受Action返回的数据，利用循环和条件语句来遍历和渲染分类节点。同时，为了实现无限级联的效果，我们需要使用递归算法，根据`...
使用SSH框架实现的树形结构
11-20
树形结构的实现通常涉及递归和回溯算法，以便正确地展示层级关系。在前端，可以使用JavaScript库，如jQuery UI的Treeview插件，或者更现代的React、Vue等框架，来创建交互式的树形视图。后端则需要提供API，返回JSON...
struts+hibernate树形菜单
01-22
3. **获取树形数据**：在服务层（Service层），使用Hibernate的HQL（Hibernate查询语言）或SQL查询语句，检索所有菜单，并按照父ID进行排序，构建出树形结构。可以使用递归方法或者预加载子菜单的方式来实现。 4. *...
Hibernate 单表实现树结构
03-28
NULL 博文链接：https://dreamzhong.iteye.com/blog/1256055
java树形菜单实现 JPA实现树形菜单
Sigod
06-12 6486
基于springboot + JPA 方法一： 树结构： @Setter @Getter public class TreeNode<T> { @ApiModelProperty(value = "id", notes = "id") public Long id; @ApiModelProperty(value = "父ID", notes = "...
springMVC返回hibernate多对多对象的json时 出现无限循环
StackOverFLow
01-24 1467
jackson中的@JsonBackReference和@JsonManagedReference，以及@JsonIgnore均是为了解决对象中存在双向引用导致的无限递归（infinite recursion）问题。这些标注均可用在属性或对应的get、set方法中。  @JsonBackReference和@JsonManagedReference：这两个标注通常配对使用，通常用在父子关系中
nodejs 无限递归创建文件夹
米斯特尔曾的博客
12-06 3285
nodejs 创建文件夹
树形结构单表 查询 递归SQL
wangmingyue123456的专栏
07-24 547
Start with...Connect By子句递归查询 下面是从网上转载的内容： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 CREATE TABLE TBL_TEST ( ID NUMBER, NAME VARCHAR2(...
mysql多表树形结构递归实现_MySQL实现递归查找树形结构
最新发布
09-16
MySQL是一种关系型数据库管理系统，它本身并不支持递归查询，但可以通过多表联接和递归实现树形结构的查询。 在MySQL中，可以使用两种方式来实现树形结构的递归查询：使用递归函数或使用临时表。 使用递归函数可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值