hibenate的一对一,一对多的关联操作实践

 应用一对一关联实现级联添加数据
 (作业:实现级联删除的功能)
在Record类中建立类型为IdCard的属性和对应的set()/get()方法,其关键代码如下:

    private IdCard idCard;
    public void setIdCard(IdCard idCard) {
        this.idCard = idCard;
    }
  public IdCard getIdCard()
{ return idCard;
}
在Record.hbm.xml文件中映射从Record类到IdCard类的关联,其关键代码如下:
    <one-to-one name="idCard" class="mrgf.IdCard" cascade="all"/>
cascade属性用来设定级联操纵对象的级别,它的可选 值 及使用方法如下表:
可选值   功能
none 默认值,不进行级联操作
save-update 当保存或裂新当前对象时,级联保存或更新关联对象
delete 当删除当前对象时,级联删除关联对象
all 当保存,更新或删除当前对象时,级联保存,更新或删除关联对象

在IdCard类中建立类型为Record的属性和对应的set()/get()方法,其关键代码如下:
   private Record record;
    public void setRecordId(int recordId) {
        this.recordId = recordId;
    }
    public Record getRecord() {
        return record;
    }
}
在IdCard.hbm.xml文件中映射从IdCard类到IdCard类的关联,其关键代码如下:
   <many-to-one name="record" class="mrgf.Record" unique="true" column="record_id"/>
本例采用外键关联,当unique属性值设为true时,表示一对一关联,它的默认值 为false(一对多关联),column属性值为映射表的外键字段名.

Hibernate的add()方法负责对象的持久化,完整代码如下:
package mrgf;

import org.hibernate.cfg.Configuration;
import org.hibernate.SessionFactory;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.Query;
import java.util.List;
import java.io.*;

public class Hibernate {
    public Hibernate() {
    }

    // 在静态快中加载Hibernate配置信息
    private static SessionFactory sessionFactory;
    static {
        try {
            Configuration config = new Configuration().configure();
            sessionFactory = config.buildSessionFactory();
        } catch (Exception e) {
            System.out.println("------在初始化hibernate时抛出异常，内容如下：");
            e.printStackTrace();
        }
    }

    private Session session = null;
    private Transaction tx = null;

    //添加对象
    public void add(Record record, IdCard idCard) {
        // 打开Session，开启事物
        session = sessionFactory.openSession();
        tx = session.beginTransaction();
        // 建立关联，并持久化
        record.setIdCard(idCard);
        idCard.setRecord(record);
        session.save(record);      //在这里只对实例record进行持久化.运行本例,会发现两个实例均被持久化了,这是因为前面将cascade属性值 设

为了all,将其改为none,将不会关联idcard实例.
        // 提交事物，关闭Session
        tx.commit();
        session.close();
    }

    //检索对象
    public List query(String hql) {
        // 打开Session，开启事物
        session = sessionFactory.openSession();
        tx = session.beginTransaction();
        // 检索数据
        Query query = session.createQuery(hql);
        List result = query.list();
        // 提交事物，关闭Session
        tx.commit();
        session.close();
        return result;
    }

    //解决表单提交中文乱码
    public String toChinese(String str) {
        String result = null;
        try {
            result = new String(str.trim().getBytes("ISO8859_1"), "GB2312");
        } catch (UnsupportedEncodingException ex) {
        }
        return result;
    }

}

query.jsp 使用
String name=request.getParameter("name");
..//此处省略了部分获得参数的代码
Record r=new Record();
r.setName(name);
..//此处省略了部分获得参数的代码
IdCard id=new IdCard();
id.setType(type);
id.setNumber(number);

Hibernate h=new Hibernate();
h.add(r,id);//调用自定义的方法
检索
 List result=h.query("from Record where name='"+name+"'");
 <td>证件类型：<%=record.getIdCard().getType() %></td>
        <td>证件号码：<%=record.getIdCard().getNumber() %></td>
这也是级联操作起的作用. 在此只是检索了Record类.

应用一对多关联实现级联操作
Merchandise类
    private MerchSort merchSort;
    public void setMerchSort(MerchSort merchSort) {
        this.merchSort = merchSort;
    }
    public MerchSort getMerchSort() {
        return merchSort;
    }
Merchandise.hbm.xml
  <many-to-one name="merchSort" column="merchSort_id" class="mrgf.MerchSort" cascade="all" lazy="false"/>

MerchSord类
 private Set merchandises=new HashSet();
    public Set getMerchandises() {
        return merchandises;
    }

    public void setMerchandises(Set merchandises) {
        this.merchandises = merchandises;
    }

MerchSort.hbm.xml
 <set name="merchandises" cascade="all" lazy="false" inverse="true">
      <key column="merchSort_id"/>
      <one-to-many class="mrgf.Merchandise"/>
    </set>

success.jsp
 Hibernate hibernate = new Hibernate();
MerchSort merchSort=new MerchSort();
      merchSort.setName(ssort);  //1

 Merchandise merchandiseA=new Merchandise(); //对多,A和B
      merchandiseA.setName(merchA);
Merchandise merchandiseB=new Merchandise();
      merchandiseB.setName(merchB);

hibernate.add(merchSort,merchandiseA,merchandiseB);
级联检索数据
  <%
          String hql="from MerchSort";
          List list=hibernate.query(hql);
          Iterator itSort=list.iterator();
          while(itSort.hasNext()){
            MerchSort sort=(MerchSort)itSort.next();
            Set set=sort.getMerchandises();             //通过关联获得Merchandise类的对象集合
            Iterator itMer=set.iterator();
            while(itMer.hasNext()){
              Merchandise mer=(Merchandise)itMer.next();
          %>
          <tr align="center">
            <td><%=mer.getId() %></td>
            <td><%=mer.getName() %></td><!--获得商品名称-->
            <td><%=mer.getMerchSort().getName() %></td><!--获得商品类别-->
            <td><%=mer.getProducingArea() %></td>
            <td><%=mer.getIntroduce() %></td>
          </tr>
          <%
            }
          }
          %>

Hibernate类的add方法
public void add(MerchSort merchSort, Merchandise merchandiseA, Merchandise merchandiseB) {
        merchSort.getMerchandises().add(merchandiseA);//建立实例之间的关联关系
        merchSort.getMerchandises().add(merchandiseB);
        merchandiseA.setMerchSort(merchSort);
        merchandiseB.setMerchSort(merchSort);
        // 打开Session，开启事物
        session = sessionFactory.openSession();
        tx = session.beginTransaction();
        // 持久化对象
        session.save(merchSort); //只对merchSort实例化,会发现3个均被持久化了.
        // 提交事物，关闭Session
        tx.commit();
        session.close();

    }

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

在数据库中建立了表之间的关系图.
hibernate建实体Bean的时候可自动生成1对多的关系

cascade="all" 级联等级
lazy 延迟，是指检索当前对象时，是否同时检索与当前对象关系的对象。

多对1
<many-to-one name="bbssection" class="my.bean.Bbssection" cascade="all" lazy="false">
            <column name="RSID" not-null="true" />
        </many-to-one>
1对多
private Set bbstopics = new HashSet(0);
public Set getBbstopics() {
  return this.bbstopics;
 }

 public void setBbstopics(Set bbstopics) {
  this.bbstopics = bbstopics;
 }

   <set name="bbstopics" inverse="true" cascade="all" lazy="false">
            <key>
                <column name="TUID" not-null="true" />
            </key>
            <one-to-many class="my.bean.Bbstopic" />
        </set>
设置

少的.get多的().add(多的其中一个);
少的.get多的().add(多的其中另一个);

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

1对多的添加
 // 添加对象
    public void add(MerchSort merchSort, Merchandise

merchandiseA, Merchandise merchandiseB) {
        merchSort.getMerchandises().add(merchandiseA);
        merchSort.getMerchandises().add(merchandiseB);

//HashSet的add方法。来添加多个对象
        merchandiseA.setMerchSort(merchSort);
        merchandiseB.setMerchSort(merchSort);
        // 打开Session，开启事物
        session = sessionFactory.openSession();
        tx = session.beginTransaction();
        // 持久化对象
        session.save(merchSort);
        // 提交事物，关闭Session
        tx.commit();
        session.close();

    }