AI 助理
备案控制台
开发者社区 数据库 文章 正文

【hibernate框架】练习-树状结构设计(非常重要)

2015-02-22 1342
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
作业：树状结构的设计
在同一个类中使用OneToMany和ManyToOne

首先想数据库的模型，再想面向对象的模型，然后再来想怎么去做映射，做完映射在想怎么去做CRUD。

1.首先设计数据库的模型
应该是Id、parent_Id.单一父亲，好多孩子这就是一棵树。

数据库首先存在的属性有：
Id<int> parent_Id<int> name<String>

例子：
ID   Parent_ID   公司
1       null     分公司1
2       1        分公司2
3       2        分公司2_1

实体类： 
package cn.edu.hpu.treeStruct;


import java.util.HashSet;
import java.util.Set;


import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;


@Entity
public class Org {
	private int id;
	private String name;
	private Set<Org> children=new HashSet<Org>();
	private Org parent;
	
	@Id
	@GeneratedValue
	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;
	}
	
	@OneToMany
	public Set<Org> getChildren() {
		return children;
	}
	public void setChildren(Set<Org> children) {
		this.children = children;
	}
	
	@ManyToOne
	public Org getParent() {
		return parent;
	}
	public void setParent(Org parent) {
		this.parent = parent;
	}
	
}


如何来理解这张表，我们假设这是三张表(都是id、name)。
A、B、C假设B的父亲是A，B的孩子是C，B通过parent_id去找父亲A，
C通过parent_id去找父亲B。只不过是多张表合成一张表。然后每一个人
的parent_id都去参考另外一条记录了，也就是参考自身这张表。是
一对多和多对一的双向关联关系。

测试，输出的建表sql语句：
alter table Org 
        drop 
        foreign key FK136C4424F8DF5


    drop table if exists Org


    create table Org (
        id integer not null auto_increment,
        name varchar(255),
        parent_id integer,
        primary key (id)
    )


    alter table Org 
        add index FK136C4424F8DF5 (parent_id), 
        add constraint FK136C4424F8DF5 
        foreign key (parent_id) 
        references Org (id)


添加测试： 
@Test
public void testTreeAdd(){
	Org o=new Org();
	o.setName("总公司");
	Org o1=new Org();
	o1.setName("分公司1");
	Org o2=new Org();
	o2.setName("分公司2");
	Org o11=new Org();
	o11.setName("分公司1下公司1");
	Org o12=new Org();
	o12.setName("分公司1下公司2");
	
	o.getChildren().add(o1);
	o.getChildren().add(o2);
	o.getChildren().add(o11);
	o.getChildren().add(o12);
	o11.setParent(o1);
	o12.setParent(o1);
	o1.setParent(o);
	o2.setParent(o);
	//可以先存父亲，再存孩子，也可以让Org的Childern设置CascadeType.ALL
        //这里用的是设置CascadeType.ALL，所以只存父亲就可以了
	sessionFactory=new AnnotationConfiguration().configure().buildSessionFactory();
	Session session=sessionFactory.openSession();
	session.beginTransaction();
	session.save(o);
	session.getTransaction().commit();
	session.close();
}


输出的sql语句：
Hibernate: 
    insert 
    into
        Org
        (name, parent_id) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        Org
        (name, parent_id) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        Org
        (name, parent_id) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        Org
        (name, parent_id) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        Org
        (name, parent_id) 
    values
        (?, ?)
Hibernate: 
    update
        Org 
    set
        name=?,
        parent_id=? 
    where
        id=?
Hibernate: 
    update
        Org 
    set
        name=?,
        parent_id=? 
    where
        id=?


结果：
id    name            parent_id
1     总公司           null
2     分公司1下公司1   5
3     分公司1下公司2   5      
4     分公司2           1
5     分公司1           1


读取测试(用递归)：
简单的方式就是Org的Childern设置fetch=FetchType.EAGER，最好的方式是递归。


首先用fetch=FetchType.EAGER测试： 
@Test
public void testTreeLoad(){
	
	sessionFactory=new AnnotationConfiguration().configure().buildSessionFactory();
	Session session=sessionFactory.openSession();
	session.beginTransaction();
	Org o =(Org) session.load(Org.class,1);
	Treeprint(o);
	session.getTransaction().commit();
	session.close();
}


private void Treeprint(Org o) {
	System.out.println(o.getName());
	for(Org child:o.getChildren()){
		Treeprint(child);
	}
}

测试结果：
Hibernate: 
    select
        org0_.id as id0_1_,
        org0_.name as name0_1_,
        org0_.parent_id as parent3_0_1_,
        children1_.parent_id as parent3_0_3_,
        children1_.id as id3_,
        children1_.id as id0_0_,
        children1_.name as name0_0_,
        children1_.parent_id as parent3_0_0_ 
    from
        Org org0_ 
    left outer join
        Org children1_ 
            on org0_.id=children1_.parent_id 
    where
        org0_.id=?
Hibernate: 
    select
        children0_.parent_id as parent3_0_1_,
        children0_.id as id1_,
        children0_.id as id0_0_,
        children0_.name as name0_0_,
        children0_.parent_id as parent3_0_0_ 
    from
        Org children0_ 
    where
        children0_.parent_id=?
Hibernate: 
    select
        children0_.parent_id as parent3_0_1_,
        children0_.id as id1_,
        children0_.id as id0_0_,
        children0_.name as name0_0_,
        children0_.parent_id as parent3_0_0_ 
    from
        Org children0_ 
    where
        children0_.parent_id=?
Hibernate: 
    select
        children0_.parent_id as parent3_0_1_,
        children0_.id as id1_,
        children0_.id as id0_0_,
        children0_.name as name0_0_,
        children0_.parent_id as parent3_0_0_ 
    from
        Org children0_ 
    where
        children0_.parent_id=?
Hibernate: 
    select
        children0_.parent_id as parent3_0_1_,
        children0_.id as id1_,
        children0_.id as id0_0_,
        children0_.name as name0_0_,
        children0_.parent_id as parent3_0_0_ 
    from
        Org children0_ 
    where
        children0_.parent_id=?
总公司
分公司1
分公司1下公司2
分公司1下公司1
分公司2


如何展现成树状？ 
@Test
public void testTreeLoad(){
	
	sessionFactory=new AnnotationConfiguration().configure().buildSessionFactory();
	Session session=sessionFactory.openSession();
	session.beginTransaction();
	Org o =(Org) session.load(Org.class,1);
	Treeprint(o,0);
	session.getTransaction().commit();
	session.close();
}


private void Treeprint(Org o,int level) {
	//level是构建树状前的缩进
	String preStr="";
	for(int i=0;i<level;i++){
		preStr+="----";
	}
	System.out.println(preStr+o.getName());
	for(Org child:o.getChildren()){
		Treeprint(child,level+1);
	}
}
测试结果：
总公司
----分公司2
----分公司1
--------分公司1下公司2
--------分公司1下公司1

如果这棵树非常大我们用EAGER就不合适了，需要把它去掉了，什么时候需要(get)才从数据库拿出。

尊重开源精神，尊重劳动成果，转载请注明出处:http://blog.csdn.net/acmman/article/details/43907245

文章标签：
Java
数据库连接
数据库
关键词：
Hibernate框架
光仔december
目录
相关文章
蓝易云
|
4月前
|
缓存 Java 数据库连接
Hibernate：Java持久层框架的高效应用
通过上述步骤，可以在Java项目中高效应用Hibernate框架，实现对关系数据库的透明持久化管理。Hibernate提供的强大功能和灵活配置，使得开发者能够专注于业务逻辑的实现，而不必过多关注底层数据库操作。
蓝易云
39 1
土木林森
|
7月前
|
数据库 Java 数据库连接
Struts 2 与 Hibernate 的完美邂逅：如何无缝集成两大框架，轻松玩转高效 CRUD 操作？
【8月更文挑战第31天】本文通过具体示例介绍了如何在 Struts 2 中整合 Hibernate，实现基本的 CRUD 操作。首先创建 Maven 项目并添加相关依赖，接着配置 Hibernate 并定义实体类及其映射文件。然后创建 DAO 接口及实现类处理数据库操作，再通过 Struts 2 的 Action 类处理用户请求。最后配置 `struts.xml` 文件并创建 JSP 页面展示用户列表及编辑表单。此示例展示了如何配置和使用这两个框架，使代码更加模块化和可维护。
土木林森
231 0
众所周知
|
7月前
|
SQL Java 数据库连接
Hibernate 是一款开源 ORM（对象关系映射）框架，封装了 JDBC，允许以面向对象的方式操作数据库，简化了数据访问层的开发。
Hibernate 是一款开源 ORM（对象关系映射）框架，封装了 JDBC，允许以面向对象的方式操作数据库，简化了数据访问层的开发。通过映射机制，它可以自动处理对象与数据库表之间的转换，支持主流数据库，提高了代码的可移植性和可维护性。其核心接口包括 SessionFactory、Session 和 Transaction 等，通过它们可以执行数据库的 CRUD 操作。配置方面，需在项目中引入 Hibernate 及数据库驱动依赖，并创建 `hibernate.cfg.xml` 配置文件来设置数据库连接和 Hibernate 行为参数。
众所周知
87 1
杰哥在此
|
8月前
|
SQL Java 数据库连接
Java面试题：简述ORM框架（如Hibernate、MyBatis）的工作原理及其优缺点。
Java面试题：简述ORM框架（如Hibernate、MyBatis）的工作原理及其优缺点。
杰哥在此
117 0
土木林森
|
9月前
|
Java 数据库连接 数据库
探索JPA生态：Hibernate与其他ORM框架的对比分析
【6月更文挑战第25天】**JPA标准下的Hibernate是流行的ORM实现，提供丰富功能如二级缓存和延迟加载，但其学习曲线较陡，性能优化复杂。相比如MyBatis，Hibernate的JPQL更面向对象，MyBatis则接近SQL。选择ORM需考虑项目需求和个人偏好。**
土木林森
121 0
杨校
|
9月前
|
Java 数据库连接
杨老师课堂之JavaEE三大框架Hibernate入门第一课
杨老师课堂之JavaEE三大框架Hibernate入门第一课
杨校
54 0
长梦
|
10月前
|
SQL 缓存 Java
Java一分钟之-Hibernate：ORM框架实践
【5月更文挑战第15天】Hibernate是Java的ORM框架，简化数据库操作。本文列举并解决了一些常见问题： 1. 配置SessionFactory，检查数据库连接和JDBC驱动。 2. 实体类需标记主键，属性映射应匹配数据库列。 3. 使用事务管理Session，记得关闭。 4. CRUD操作时注意对象状态和查询结果转换。 5. 使用正确HQL语法，防止SQL注入。 6. 根据需求配置缓存。 7. 懒加载需在事务内处理，避免`LazyInitializationException`。理解和避免这些问题能提升开发效率。
长梦
94 0
L&ecirc;v&iuml;
|
10月前
|
SQL Java 数据库连接
Java从入门到精通：3.1.2深入学习Java EE技术——Hibernate与MyBatis等ORM框架的掌握
Java从入门到精通：3.1.2深入学习Java EE技术——Hibernate与MyBatis等ORM框架的掌握
L&ecirc;v&iuml;
103 1
众所周知
|
10月前
|
SQL Java 关系型数据库
数据库访问：什么是Hibernate框架？
【4月更文挑战第15天】Hibernate是开源ORM框架，将Java对象与数据库表映射，简化对象-关系映射，提升开发效率和性能。它自动化处理数据操作，支持多种数据库，自动生成SQL，提供配置选项和高级特性，减少手动SQL编写，便于切换数据库。
众所周知
88 2
学编程的小程
|
10月前
|
SQL 缓存 Java
框架分析（9）-Hibernate
框架分析（9）-Hibernate
学编程的小程
96 2

热门文章

最新文章

  • 1
    Hibernate SQL实际sql语句监控- p6spy+hibernate+proxool 设置
  • 2
    SSH整合方案二(不带hibernate.cfg.xml)
  • 3
    中文命名之Hibernate 5演示 - 使用注解(annotation)而非xml定义映射
  • 4
    hibernate blob 对象序列化保存
  • 5
    一口一口吃掉Hibernate（七）——继承映射
  • 6
    hibernate load与get方法的区别
  • 7
    hibernate错误：IllegalArgumentException以及Could not execute JDBC batch update
  • 8
    Hibernate之多对多表，操作实例
  • 9
    Hibernate-ORM:10.Hibernate中的分页
  • 10
    用Spring的mappingDirectoryLocations来配置Hibernate映射文件
  • 1
    从理论到实践：Hibernate与JPA在Java项目中的实际应用
    106
  • 2
    Hibernate：Java持久层框架的高效应用
    39
  • 3
    springBoot+Jpa(hibernate)数据库基本操作
    161
  • 4
    Hibernate 批量操作来袭！掌握最佳实践，轻松应对数据洪流，开启高效开发新时代
    347
  • 5
    揭秘性能提升的超级武器：掌握Hibernate二级缓存策略！
    125
  • 6
    解锁高效开发秘籍：深入探究 Hibernate 如何优雅处理一对多与多对多关系，让数据映射再无烦恼！
    116
  • 7
    告别繁琐 SQL！Hibernate 入门指南带你轻松玩转 ORM，解锁高效数据库操作新姿势
    556
  • 8
    携手前行：在Java世界中深入挖掘Hibernate与JPA的协同效应
    63
  • 9
    Hibernate性能调优：五大秘籍，让应用效能飙升，告别慢如蜗牛的加载，体验丝滑般流畅！
    305
  • 10
    AI 时代风起云涌，Hibernate 实体映射引领数据库高效之路，最佳实践与陷阱全解析！
    117

    • 相关电子书

    更多
  • 为并行图数据处理提供高层抽象／语言
  • 低代码开发师（初级）实战教程
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    获取百炼API-KEY