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