hibernate的级联-----many-to-one

一对多和多对一是相对而言的，这种表关系是最常见到的，也是应用最多的一种关系，

以地区---街道 设置一对多的双向关联，

街道(Street)entity：

注意一点，在street表中，设有district表的id，但是在实体类中，要以district对应的实体类为成员变量，这是关联的必要条件，因为hibernate操作的是持久化对象，而非数据库本身，因此只要做适当的配置，就可以通过street操作district了，从而达到关联的目的

package com.entity;

public class Street {

	private Integer id;
	private District district;
	private String name;
	private String length;
	private String manager;
	private String creater;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public District getDistrict() {
		return district;
	}
	public void setDistrict(District district) {
		this.district = district;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getLength() {
		return length;
	}
	public void setLength(String length) {
		this.length = length;
	}
	public String getManager() {
		return manager;
	}
	public void setManager(String manager) {
		this.manager = manager;
	}
	public String getCreater() {
		return creater;
	}
	public void setCreater(String creater) {
		this.creater = creater;
	}
}

地区(District)entity:

一般情况下，多对一只需要在多的一方设置一的一方的实体类变量即可，如果有特殊需要，要从一的一方操作多的一方，可以在设置为set集合的形式，因为set集合是不能重复的，更符合数据库的特征

package com.entity;

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

public class District {

	private Integer id;
	private String name;
	private String manager;
	private String square;
	private Integer population;
	private Set<Street> streets = new HashSet<Street>();
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getManager() {
		return manager;
	}
	public void setManager(String manager) {
		this.manager = manager;
	}
	public String getSquare() {
		return square;
	}
	public void setSquare(String square) {
		this.square = square;
	}
	public Integer getPopulation() {
		return population;
	}
	public void setPopulation(Integer population) {
		this.population = population;
	}
	public Set<Street> getStreets() {
		return streets;
	}
	public void setStreets(Set<Street> streets) {
		this.streets = streets;
	}
}

street.hbm.xml：

在many-to-one标签中，有很多属性，比如lazy(延迟加载)、cascade(级联)，等。

<hibernate-mapping package="com.entity">

	<class name="Street" table="HOUSE_STREET">
		<id name="id" type="integer" column="ID" >
			<generator class="increment"/>
		</id>
		<property name="name" column="NAME"></property>
		<property name="length" column="LENGTH"></property>
		<property name="manager" column="MANAGER"></property>
		<property name="creater" column="CREATER"></property>
		<many-to-one name="district" column="DISTRICT_ID" class="District"></many-to-one>
	</class>
</hibernate-mapping>

district.hbm.xml:

在一的一方设置对应多的一方的元素，用set标签，如下，其中cascade一共有四个值，none、all、save-update、delete，当不为null的时候，该表的操作会级联关系到关联表，这个属性一般不使用，如果要用，一般设置在一的一方，比如删除掉某一个地区的时候，会对应删除掉这个地区中的所有街道，或者比如在district中取出street的set集合，对set集合的操作也会作用到street表中，set.remove()某一个街道的话，对应数据库中的街道也会被删除掉;lazy=false，表示不使用hibernate的延迟加载机制，这是集合级别的延迟加载，默认为true，当集合中的元素被用到时，才会去数据库查询，如果用不到，为了减少内存开销，就不会去调用，如果在页面才调用set集合中的属性，就会报NoSession的异常，这个也尽量少用。

在hibernate与spring结合之后。就可以完全省掉这两个属性了，spring的AOP提供了事务处理，可以解决级联删除的问题，spring中还可以在web.xml中设OpenSessionInViewFilter，从名字上看，它将session的活动范围扩展到了视图层，可以在视图层调用set的元素之后再自动关闭session;

另外一个fetch是抓取策略，fetch=“join”，表示用的迫切左外链接，hibernate对数据查询的时候，会使用左外链接的sql进行查询，减少了sql语句数量，提高了效率，当然，它还有别的属性，这里先不提，在spring篇中进行回顾

<hibernate-mapping package="com.entity">

	<class name="District" table="HOUSE_DISTRICT">
		<id name="id" type="integer" column="ID" >
			<generator class="increment"/>
		</id>
		<property name="name" column="NAME"></property>
		<property name="manager" column="MANAGER"></property>
		<property name="square" column="SQUARE"></property>
		<property name="population" column="POPULATION"></property>
		<set name="streets" cascade="all" lazy="false" fetch="join" > 
			<key column="DISTRICT_ID"></key>
			<one-to-many class="Street"/>
		</set>
	</class>
</hibernate-mapping>

下面是测试类:

package com.test;

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

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import com.entity.District;
import com.entity.Street;

public class TestOne2Many {

	public static void main(String[] args) {
		TestOne2Many test = new TestOne2Many();
		test.save();
	}
	
	public void query(){
		Configuration config = new Configuration().configure();
		SessionFactory factory = config.buildSessionFactory();
		Session session = factory.openSession();
		District district = (District) session.get(District.class, 2);
		Set<Street> streets = district.getStreets();
		Iterator<Street> iter = streets.iterator();
		while(iter.hasNext()){
			Street street = iter.next();
			System.out.println(street.getName());
		}
		session.close();
		factory.close();		
	}
	
	public void save(){
		Configuration config = new Configuration().configure();
		SessionFactory factory = config.buildSessionFactory();
		Session session = factory.openSession();
		District district = new District();
		district.setName("惠济区");
		Street street1 = new Street();
		street1.setName("长兴路");
		Street street2 = new Street();
		street2.setName("江山路");
//		street1.setDistrict(district);
//		street2.setDistrict(district);
		Set<Street> streets = new HashSet<Street>();
		streets.add(street1);
		streets.add(street2);
		district.setStreets(streets);
		district.getStreets().add(street1);
		district.getStreets().add(street2);
		Transaction tr = session.beginTransaction();
		session.save(district);//在District中设置级联cascard,双向关联的时候，可以在一的那一端set标签里加入inverse属性，=true的时候一的这一段放弃关联
		session.save(street1);
		session.save(street2);
		tr.commit();
		session.close();
		factory.close();	
	}
}