Hibernate 表关系描述之ManyToMany

 上篇写了一对一，那么在这篇我们讲一对多，那么在表中的一对多，是使用外键关联，通过一张表的一个键另一个表的外键来建立一多关系;
 而在类中表示为一个类中有一个集合属性包含对方类的很多对象，而在另一个类中，只包含前术类的一个对象，从而实现一对多关系的建立！
 而在Hibernate中采用的是Set类型集合，而使用<one-to-many>主<many-to-one>来实现，好了，我们来看一下：
在上一篇中讲到一对多，那么在此补充一下多对多;
在数据库中也有多对多的关系，数据中的实现方式一般是采用存在多对多关系的两个对对象表，建立多对多关联表，也就是用一个独立的表来存入两个表的主键字段，通过遍历这张表来获取两表的关联关系。
而在我们的对象中，多对多是通过两者对象类中互相建立对方类的对象集合，类似上一篇讲到的一对多的集合类！
在Hibernate中当然就是通过<many to many>了
我们现在来通过一个案例来学习。学生与老师关系，是多对多。一个学生可以有多个老师，而一个老师也一样可以有多名学生！
Step1：首先建立我们需要的表，如下：

create table teachers
(
    teaID bigint auto_increment primary key,
    teaName varchar(20)
);

create table students
(
    stuID bigint primary key auto_increment,
    sName varchar(20)
);

--关联表   学生与教师
create table student_teacher_table
(
    teaID int,
    stuID int
);

Step2：新建一个HibernateManyToMany项目 ，并添加hibernate。
Step3：我们将前面创建的teachers表和students表导向到Beans中，注意这里的关系表 student_teacher_table并不导出！因为我们数据做持久，持久的是对象，而不是关系， student_teacher_table表存放的是关系，所以我们不需要将 其导出，那么使用呢？接着看吧！
Step4：现在我们开始类对象关系的描述，我们先打开生成的Student.java 在里面添加Set 教师集合，然后在Teachers.java中同样添加Set学生集合！
Step5：我们描述了类与类之间的关系后，剩下的就是让Hibernate知道它们之间的关系，分别修改学生和教师类映射文件！
student.hbm.xml内容如下：

<?xml version="1.0" encoding="GBK"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 
   Autho:fengyan
   date: 2006-12-30 17:04
-->
<hibernate-mapping>
    <class name="hibernate.beans.Students" table="students" catalog="study">
        <id name="stuId" type="java.lang.Long">
            <column name="stuID" />
            <generator class="native" />
        </id>
        <property name="sname" type="java.lang.String">
            <column name="sName" length="20" />
        </property>
        
        <set name="teachers" table="student_teacher_table" cascade="save-update" inverse="false">
            
            <key column="stuID"></key>
            <!--
            它的控制主要是通过stuid来选择，就是我们从student_teacher_table表中我们只
            要select *  from student_teacher_table where  stuID='该学生ID'，这样我
            们就可以获取它的教师的ID了
             -->
         
             <many-to-many class="hibernate.beans.Teachers" column="teaID"></many-to-many>
             <!-- 
             我们从student_teacher_table表中根据stuID拿到了与该stuID关联的teaID,
             然后 select * from teacher where teaID='前一步拿到的teaID' -->
        </set>
    </class>
</hibernate-mapping>

再看teacher.hbm.xml文件内容：

<?xml version="1.0" encoding="GBK"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 
   Authod:fengyan
   date:  2006-12-30 17:10
-->
<hibernate-mapping>
    <class name="hibernate.beans.Teachers" table="teachers" catalog="study">
        <id name="teaId" type="java.lang.Long">
            <column name="teaID" />
            <generator class="native" />
        </id>
        <property name="teaName" type="java.lang.String">
            <column name="teaName" length="20" />
        </property>
        
        <!-- 前面在student中已经级联了，所以这里我没有再级联，简单的演示！ -->
        <set name="students" table="student_teacher_table" inverse="true">
            <key column="teaID"></key>
            <many-to-many class="hibernate.beans.Students" column="stuID"></many-to-many>
        </set>
    </class>
</hibernate-mapping>

然后我们现在建立一个StudentDAO.java用来封装操作：

StudentDAO.java
package hibernateDAOS;
/** *//**
 * Authod：fengyan
 * date:   2006-12-30 17:15    
 */
import hibernate.HibernateSessionFactory;
import hibernate.beans.Students;

import org.hibernate.Session;
import org.hibernate.Transaction;

public class StudentsDAO {
    public void save(Students student)
    {
        Session session = HibernateSessionFactory.getSession();        
        Transaction tx = session.beginTransaction();
        try
        {
            session.save(student);
            tx.commit();
        }
        catch(Exception e)
        {
            System.out.println("stuDAO has errors:"+e);
            tx.rollback();
        }
        finally
        {
            session.close();
        }
    }

}

Step6：建立一个Servlet,MyServlet.java;

MyServlet.java
package hibernate.servlet;

import hibernate.beans.Students;
import hibernate.beans.Teachers;
import hibernateDAOS.StudentsDAO;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyServlet extends HttpServlet {


    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        
        //产生学生
        Students s1 = new Students("学生1");
        Students s2 = new Students("学生2");
        
        //产生教师
        Teachers t1 = new Teachers("教师1");
        Teachers t2 = new Teachers("教师2");
        Teachers t3 = new Teachers("教师3");
        Teachers t4 = new Teachers("教师4");
        
        //学生关联教师(学生选择教师)
        s1.getTeachers().add(t1);
        s1.getTeachers().add(t2);
        //学生 s1 选择 t1 及 t2 二名教师

        s2.getTeachers().add(t1);
        s2.getTeachers().add(t3);
        //学生 s2 选择 t1 及 t3 二名教师
        
        //我们保存学生 s1及 s2
        StudentsDAO sd = new StudentsDAO();
        sd.save(s1);
        sd.save(s2);
    }
}

Step7：最后来个测试index.jsp页面

<a href="servlet/MyServlet">add </a>

运行 结果：



由图片可知，
第一步：首先将 “学生1”插入students表中;
第二步：将"学生1"关联的“教师1”插入到teachers表中;
第三步：将“学生1”关联的“教师2”插入到teachers表中;
第四步：将“学生1”与“教师1”的关联信息(1,1)插入到student_teacher_table表中;
第五步：将“学生1”与“教师2”的关联信息(1,2)插入到student_teacher_table表中;
第六步：将“学生2”插入students表中;
第七步：将“教师3”插入teachers表中;
第八步：更新？更新了“学生2”关联～这步有点不解
第九步：将“学生2”与“教师1”的关联信息(2,1)插入到student_teacher_table表中;
第十步：将“学生2”与“教师3”的关联信息(2,3)插入student_teacher_table表中;

总结：感觉多对多与一对多基本是差不多的～至于每次示例中仅仅是简单的save,，而没其它的操作，是由于打算以后将在SSH项目中运用！