Hibernate之树状结构设计

（一）在系统中，经常会用到无限级递归的树形结构，比如菜单、组织机构管理、多级分类等等，一般是在同一个表中定义父子关系实现这种树形结构。

（二）对于父类来说，它与子类的关系是一对多；对于子类来说，它与父类的关系是多对一。由于父类和子类都存在对方的对象引用，因此它们之间的关系是一对多，多对一之间的双向关联。因此需要设置mappedby，以及测试代码中的父类与子类、子类与父类之间的关系都要设置好。

加载树状结构的时候需要用到递归。Region类 fetch=FetchType.EAGER，取父类的时候也会将子类一并取出。这样一般适用于树状结构不复杂的情况。当然也可以默认设置为lazy，当有需要的时候再取出。

（三）解释一下mappedBy，mappedBy是用来定义类与类之间的关系的，如果类与类是单向关系，那么可以不用定义；如果是双向关系，那么就必须定义mappedBy，mappedBy表示外键在”对方“已经设置过了，这里不用再设置了，如果没有设置mappedBy，就很可能会产生数据的不一致性。另外mappedBy的值应该设成多方对应的class里”一“方的变量名，实际上更确切的讲是应该设置成一方变量名对应的getXXX方法里那个XXX,因为极少数情况下getXXX()和对应的变量名不一致(当然这是一种极不提倡的做法)。

 

再来解释一下cascade，该属性定义的是类与类之间的级联关系,定义的级联关系将被容器视为将当前类对象以及与之关联的类对象采取相同的操作，而且这种级联关系是递归的。cascade属性值有：ALL：表示所有情况都进行相同操作，即save、update、delete；PERSIST：这个表示在保存时采取相同的操作，MERGE是JPA的官方叫法，实际上就跟sava()一样；REMOVE：这个表示级联删除，实际上跟delete()方法一样；REFRESH：级联刷新。

接着解释一下fetch：fetch是读操作，它有俩属性，LAZY：表示只读取当前对象，关联对象不读；EAGER：当前对象被读取的时候，关联对象也会被读取，而且这种级联关系是递归的。

@OneToMany：表示当前这个类对象(实体)对应getXXX()方法表示的属性XXX对应的对象(实体)是一对多的关系。

@ManyToOne：表示当前这个类对象(实体)对应getXXX()方法表示的属性XXX对应的对象(实体)是多对一的关系。

@JoinColumn：用来注释表中的字段名字。

（四）实例：

实体类：

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

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
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(cascade=CascadeType.ALL, mappedBy="parent")
	public Set<Org> getChildren() {
		return children;
	}
	public void setChildren(Set<Org> children) {
		this.children = children;
	}
	
	@ManyToOne
	@JoinColumn(name="parent_id")
	public Org getParent() {
		return parent;
	}
	public void setParent(Org parent) {
		this.parent = parent;
	}
}

测试类：

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

public class HibernateTreeTest {
	private static SessionFactory sessionFactory;
	
	@BeforeClass
	public static void beforeClass() {
		new SchemaExport(new AnnotationConfiguration().configure()).create(false, true);
		sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
	}
	@AfterClass
	public static void afterClass() {
		sessionFactory.close();
	}
	
	@Test
	public void testSave() {
		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);
		o1.getChildren().add(o11);
		o1.getChildren().add(o12);
		o11.setParent(o1);
		o12.setParent(o1);
		o1.setParent(o);
		o2.setParent(o);
				
		
		Session session = sessionFactory.openSession();
		session.beginTransaction();
		session.save(o);
	
		session.getTransaction().commit();
		session.close();
	}
	@Test
	public void testLoad() {
		testSave();
		Session session = sessionFactory.openSession();
		session.beginTransaction();
		Org o = (Org)session.load(Org.class, 1);
		print(o, 0);
		session.getTransaction().commit();
		session.close();
		
	}
	
	private void print(Org o, int level) {
		String preStr = "";
		for(int i=0; i<level; i++) {
			preStr += "----";
		}
		System.out.println(preStr + o.getName());
		for(Org child : o.getChildren()) {
			print(child, level+1);
		}
	}
	@Test
	public void testSchemaExport() {
		new SchemaExport(new AnnotationConfiguration().configure()).create(false, true);
	}
	
	
	public static void main(String[] args) {
		beforeClass();
	}
}

测试结果：

总公司
----分公司2
----分公司1
--------分公司1下部门1
--------分公司1下部门2