java：Hibernate框架2（关联映射（多对一，一对多，一对多双向，一对一主键，一对一唯一外键，多对多双向））

 

　　hibernate.cfg.xml:

　　

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!--驱动名称,URL,用户名,密码 -->
        <property name="connection.driver_class">
            com.mysql.jdbc.Driver
        </property>
        <property name="connection.url">
            jdbc:mysql://localhost:3306/test
        </property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <!--方言 -->
        <property name="hibernate.dialect">
            org.hibernate.dialect.MySQL5Dialect
        </property>
        <!-- 输出SQL语句 -->
        <property name="show_sql">true</property>
        <!-- 格式化SQL语句 -->
        <property name="format_sql">true</property>
        <!-- 根据映射文件生产表: create:创建(不推荐:先删除原有表，重新创建表，原有数据丢失) update:创建+更新记录(推荐，会保存原有数据) -->
        <property name="hbm2ddl.auto">update</property>
        <mapping resource="cn/zzsxt/entity/Classinfo.hbm.xml" />
        <mapping resource="cn/zzsxt/entity/Studentinfo.hbm.xml" />

        <mapping resource="cn/zzsxt/entity2/Employee.hbm.xml" />
        <mapping resource="cn/zzsxt/entity2/Dept.hbm.xml" />

        <mapping resource="cn/zzsxt/entity3/Province.hbm.xml" />
        <mapping resource="cn/zzsxt/entity3/City.hbm.xml" />

        <mapping resource="cn/zzsxt/entity4/IdCard.hbm.xml" />
        <mapping resource="cn/zzsxt/entity4/Person.hbm.xml" />

        <mapping resource="cn/zzsxt/entity5/IdCard2.hbm.xml" />
        <mapping resource="cn/zzsxt/entity5/Person2.hbm.xml" />

        <mapping resource="cn/zzsxt/entity6/Emp.hbm.xml" />
        <mapping resource="cn/zzsxt/entity6/Project.hbm.xml" />

    </session-factory>
</hibernate-configuration>    

　

1.单向多对一：

　　Classinfo:

　　

package cn.zzsxt.entity;

import java.io.Serializable;

public class Classinfo implements Serializable {
    private int classId;
    private String className;

    public int getClassId() {
        return classId;
    }
    public void setClassId(int classId) {
        this.classId = classId;
    }
    public String getClassName() {
        return className;
    }
    public void setClassName(String className) {
        this.className = className;
    }

}

　　Classinfo.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zzsxt.entity">
    <class name="Classinfo">
        <id name="classId">
            <generator class="native"></generator>
        </id>
        <property name="className"></property>
    </class>
</hibernate-mapping>    

　　Studentinfo:

package cn.zzsxt.entity;

import java.io.Serializable;

public class Studentinfo implements Serializable {
    private int studentId;
    private String studentName;
    private int studentAge;
    private String studentAddress;
    //和一方关联的实体对象(多对一)
    private Classinfo classinfo;

    public Studentinfo() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Studentinfo(String studentName, int studentAge, String studentAddress) {
        super();
        this.studentName = studentName;
        this.studentAge = studentAge;
        this.studentAddress = studentAddress;
    }

    public int getStudentId() {
        return studentId;
    }
    public void setStudentId(int studentId) {
        this.studentId = studentId;
    }
    public String getStudentName() {
        return studentName;
    }
    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }
    public int getStudentAge() {
        return studentAge;
    }
    public void setStudentAge(int studentAge) {
        this.studentAge = studentAge;
    }
    public String getStudentAddress() {
        return studentAddress;
    }
    public void setStudentAddress(String studentAddress) {
        this.studentAddress = studentAddress;
    }
    public Classinfo getClassinfo() {
        return classinfo;
    }
    public void setClassinfo(Classinfo classinfo) {
        this.classinfo = classinfo;
    }

}

　　Studentinfo.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zzsxt.entity">
    <class name="Studentinfo">
        <id name="studentId">
            <generator class="native"></generator>
        </id>
        <property name="studentName"></property>
        <property name="studentAge"></property>
        <property name="studentAddress"></property>
        <!-- 多对一 -->
        <many-to-one name="classinfo" class="Classinfo" column="classId" lazy="false"></many-to-one>
    </class>
</hibernate-mapping>    

　　

　　TestManyToOneSave:

package cn.zzsxt.test;

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

import cn.zzsxt.entity.Classinfo;
import cn.zzsxt.entity.Studentinfo;
import cn.zzsxt.utils.HibernateUtil;

public class TestManyToOneSave {
    /**
     * 新建一个班级:Java01,添加两个学生zhangsan和lisi，并将这两个学生添加到Java01班级中
     * @param args
     */
    public static void main(String[] args) {
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        //新建班级Java01
        Classinfo classinfo = new Classinfo();
        classinfo.setClassName("Java01");
        //新建两个学生zhangsan和lisi
        Studentinfo stu1 = new Studentinfo("zhangsan",20,"郑州");
        Studentinfo stu2 = new Studentinfo("lisi",22,"北京");
        //维护班级和学生之间的关系：单向多对一(从多方维护关联关系)：为学生指定班级
        stu1.setClassinfo(classinfo);
        stu2.setClassinfo(classinfo);
        //保存班级和学生
        session.save(classinfo);
        session.save(stu1);
        session.save(stu2);
        tx.commit();
        session.close();

    }
}

　　TestManyToOneSelect:

package cn.zzsxt.test;

import org.hibernate.Session;

import cn.zzsxt.entity.Classinfo;
import cn.zzsxt.entity.Studentinfo;
import cn.zzsxt.utils.HibernateUtil;

public class TestManyToOneSelect {
    /**
     * 查询编号为1的学生信息及对应的班级信息
     * @param args
     */
    public static void main(String[] args) {
        Session session = HibernateUtil.getSession();
        Studentinfo student = session.get(Studentinfo.class,1);
        System.out.println(student.getStudentName()+"---"+student.getStudentAge());
        //获取学生对应的班级信息
        Classinfo classinfo = student.getClassinfo();
        System.out.println("班级名称:"+classinfo.getClassName());
        session.close();

    }
}

 2.单向一对多：

　　Dept：

package cn.zzsxt.entity2;

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

public class Dept {
    private int deptId;
    private String deptName;
    //在一方添加一个包含多方的集合
    private Set<Employee> emps = new HashSet<Employee>();
    public int getDeptId() {
        return deptId;
    }
    public void setDeptId(int deptId) {
        this.deptId = deptId;
    }
    public String getDeptName() {
        return deptName;
    }
    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }
    public Set<Employee> getEmps() {
        return emps;
    }
    public void setEmps(Set<Employee> emps) {
        this.emps = emps;
    }

}

　　Dept.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zzsxt.entity2">
    <class name="Dept">
        <id name="deptId">
            <generator class="native"></generator>
        </id>
        <property name="deptName"></property>
        <!--
            name="包含多方的集合名称"
         -->
        <set name="emps">
            <!-- column="外键名称" -->
            <key column="deptId"></key>
            <!-- 一对多 class="集合中元素的类型(多方的类型)" -->
            <one-to-many class="Employee"/>
        </set>
    </class>
</hibernate-mapping>    

　　Employee:

package cn.zzsxt.entity2;

public class Employee {
    private int empId;
    private String empName;

    public int getEmpId() {
        return empId;
    }
    public void setEmpId(int empId) {
        this.empId = empId;
    }
    public String getEmpName() {
        return empName;
    }
    public void setEmpName(String empName) {
        this.empName = empName;
    }

}

　　Employee.hbm,xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zzsxt.entity2">
    <class name="Employee">
        <id name="empId">
            <generator class="native"></generator>
        </id>
        <property name="empName"></property>
    </class>
</hibernate-mapping>    

　　TestOneToManySave:

package cn.zzsxt.test;

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

import cn.zzsxt.entity2.Dept;
import cn.zzsxt.entity2.Employee;
import cn.zzsxt.utils.HibernateUtil;

public class TestOneToManySave {
    /**
     * 添加一个部门：开发部
     * 添加两个员工:小三和小四，并且将这两个员工分配到开发部
     * @param args
     * 推荐从多方维护关系:
     * 1.生产的SQL语句数量少，执行效率较高。
     * 2.可以避免因外键不能为NULL带来的异常。
     */
    public static void main(String[] args) {
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        //创建开发部
        Dept dept = new Dept();
        dept.setDeptName("开发部2");
        //创建两个员工
        Employee emp1 = new Employee();
        emp1.setEmpName("小三2");
        Employee emp2 = new Employee();
        emp2.setEmpName("小四2");
        //单项一对多(只能在一方维护关联关系):为部门添加员工
        dept.getEmps().add(emp1);
        dept.getEmps().add(emp2);
        //保存部门和员工
        session.save(dept);
        session.save(emp1);
        session.save(emp2);
        tx.commit();
        session.close();

    }
}

3.双向一对多,控制反转,级联：

　　City：

package cn.zzsxt.entity3;

public class City {
    private int cityId;
    private String cityName;
    //多方添加一个和一方关联的实体对象
    private Province province;
    public int getCityId() {
        return cityId;
    }
    public void setCityId(int cityId) {
        this.cityId = cityId;
    }
    public String getCityName() {
        return cityName;
    }
    public void setCityName(String cityName) {
        this.cityName = cityName;
    }
    public Province getProvince() {
        return province;
    }
    public void setProvince(Province province) {
        this.province = province;
    }

}

　　City.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zzsxt.entity3">
    <class name="City">
        <id name="cityId">
            <generator class="native"></generator>
        </id>
        <property name="cityName"></property>
        <!--
            many-to-one :多对一
            cascade:级联(存在关联的数据表，一份随另外关联一方做相同的操作)
                delete:级联删除
                save-update:级联新增或修改
                all:所有操作都级联
                none:不级联
        -->
        <many-to-one name="province" class="Province" column="provinceId" cascade="save-update" ></many-to-one>
    </class>
</hibernate-mapping>    

　　Province:

package cn.zzsxt.entity3;

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

public class Province {
    private int provinceId;
    private String provinceName;
    //一份添加一个包含多方的set集合
    private Set<City> cities = new HashSet<City>();
    public int getProvinceId() {
        return provinceId;
    }
    public void setProvinceId(int provinceId) {
        this.provinceId = provinceId;
    }
    public String getProvinceName() {
        return provinceName;
    }
    public void setProvinceName(String provinceName) {
        this.provinceName = provinceName;
    }
    public Set<City> getCities() {
        return cities;
    }
    public void setCities(Set<City> cities) {
        this.cities = cities;
    }

}

　　Province.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zzsxt.entity3">
    <class name="Province">
        <id name="provinceId">
            <generator class="native"></generator>
        </id>
        <property name="provinceName"></property>
        <!--
            name="包含多方的集合名称"
            cascade="save-update|delete|all|none" 级联
            inverse="true|false"
            inverse代表关系维护的控制权是否反转,如果inverse值为true代表将关系维护的控制权交与对方
         -->
        <set name="cities" cascade="all" inverse="true">
            <!-- column="外键名称" -->
            <key column="provinceId"></key>
            <!-- 一对多 class="集合中元素的类型(多方的类型)" -->
            <one-to-many class="City"/>
        </set>
    </class>
</hibernate-mapping>    

　　TestOneToMany:

package cn.zzsxt.test;

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

import cn.zzsxt.entity2.Dept;
import cn.zzsxt.entity2.Employee;
import cn.zzsxt.entity3.City;
import cn.zzsxt.entity3.Province;
import cn.zzsxt.utils.HibernateUtil;

public class TestOneToMany {
    /**
     * 添加一个省份:河南省
     * 添加一个城市:郑州市
     * 将郑州市添加到河南省中
     */
    public static void main(String[] args) {
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        //创建省份
        Province province = new Province();
        province.setProvinceName("河南省");
        //创建城市
        City city = new City();
        city.setCityName("郑州市");
        //从一份维护关系:为省份添加城市;从多方维护关系:为城市设置省份
        city.setProvince(province);
        session.save(province);
        session.save(city);
        tx.commit();
        session.close();

    }
}

　　TestInverse:

package cn.zzsxt.test;

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

import cn.zzsxt.entity3.City;
import cn.zzsxt.entity3.Province;
import cn.zzsxt.utils.HibernateUtil;
/**
 * inverse="true"：代表将关系维护的控制权交与对方(多方)进行维护，自身无法维护关联关系
 * @author Think
 *
 */
public class TestInverse {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        //创建一个河北省
        Province province = new Province();
        province.setProvinceName("山东省2");
        //创建一个城市
        City city = new City();
        city.setCityName("济南2");
        City city2 = new City();
        city2.setCityName("菏泽2");
        //为省份添加城市
        province.getCities().add(city);
        province.getCities().add(city2);
        //通过省份级联城市
        session.save(province);
        tx.commit();
        session.close();

    }
}

　　TestCascade:

package cn.zzsxt.test;

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

import cn.zzsxt.entity3.City;
import cn.zzsxt.entity3.Province;
import cn.zzsxt.utils.HibernateUtil;

public class TestCascade {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        //创建一个河北省
        Province province = new Province();
        province.setProvinceName("山东省");
        //创建一个城市
        City city = new City();
        city.setCityName("济南");
        City city2 = new City();
        city2.setCityName("菏泽");
        //为省份添加城市
        province.getCities().add(city);
        province.getCities().add(city2);
        //通过省份级联城市
        session.save(province);
        tx.commit();
        session.close();

    }
}

　　TestCascade2:

package cn.zzsxt.test;

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

import cn.zzsxt.entity3.City;
import cn.zzsxt.entity3.Province;
import cn.zzsxt.utils.HibernateUtil;

public class TestCascade2 {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        //创建一个河北省
        Province province = new Province();
        province.setProvinceName("河北省");
        //创建一个城市
        City city = new City();
        city.setCityName("石家庄");
        //为城市设置省份
        city.setProvince(province);
        //使用级联新增城市的同时新增省份
        session.save(city);
        tx.commit();
        session.close();

    }
}

4.一对一主键关联：

　　IdCard：

package cn.zzsxt.entity4;

public class IdCard {
    private int id;
    private String cardNo;//身份证号;
    private Person person;//关联的实体对象

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getCardNo() {
        return cardNo;
    }
    public void setCardNo(String cardNo) {
        this.cardNo = cardNo;
    }
    public Person getPerson() {
        return person;
    }
    public void setPerson(Person person) {
        this.person = person;
    }

}

　　IdCard.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zzsxt.entity4">
    <class name="IdCard">
        <id name="id">
            <!-- foreign:主键生产策略,该主键的值来源"外部"-->
            <generator class="foreign">
                <!-- 利用property属性指定主键来源于person中的主键 -->
                <param name="property">person</param>
            </generator>
        </id>
        <property name="cardNo"></property>
        <!--
         one-to-one:一对一
             name属性:关联对象的名称
             class属性:关联对象的类型
             cascade:级联
             constrained="true|false":可选属性. 代表是否是约束属性.
                配置在这里,代表当前属性为约束属性,一定在这个属性对应的表中有
                数据与本表数据对应.

        -->
        <one-to-one name="person" class="Person" constrained="true"></one-to-one>
    </class>
</hibernate-mapping>    

　　Person:

package cn.zzsxt.entity4;

public class Person {
    private int id;
    private String name;
    private IdCard idCard;//关联的实体对象
    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;
    }
    public IdCard getIdCard() {
        return idCard;
    }
    public void setIdCard(IdCard idCard) {
        this.idCard = idCard;
    }

}

　　Person.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zzsxt.entity4">
    <class name="Person">
        <id name="id">
            <generator class="native"></generator>
        </id>
        <property name="name"></property>
        <!--
         one-to-one:一对一
             name属性:关联对象的名称
             class属性:关联对象的类型
             cascade:级联
             constrained="true|false":可选属性. 代表是否是约束属性.
                配置在这里,代表当前属性为约束属性,一定在这个属性对应的表中有
                数据与本表数据对应.

        -->
        <one-to-one name="idCard" class="IdCard" cascade="save-update"></one-to-one>
    </class>
</hibernate-mapping>    

　　TestOneToOne：

package cn.zzsxt.test2;

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

import cn.zzsxt.entity4.IdCard;
import cn.zzsxt.entity4.Person;
import cn.zzsxt.utils.HibernateUtil;

public class TestOneToOne {
    public static void main(String[] args) {
        Session session =HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        Person person = new Person();
        person.setName("zhangsan");
        IdCard idCard = new IdCard();
        idCard.setCardNo("412722199001011234");
        //为人设置身份证
        person.setIdCard(idCard);
        //为身份证指定人
        idCard.setPerson(person);
        //通过级联添加人和身份证
        session.save(person);
        tx.commit();
        session.close();

     }
}
 

5.一对唯一外键关联：

　　IdCard2：

package cn.zzsxt.entity5;

public class IdCard2 {
    private int id;
    private String cardNo;//身份证号;
    private Person2 person2;//关联的实体对象

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getCardNo() {
        return cardNo;
    }
    public void setCardNo(String cardNo) {
        this.cardNo = cardNo;
    }
    public Person2 getPerson2() {
        return person2;
    }
    public void setPerson2(Person2 person2) {
        this.person2 = person2;
    }

}

　　Idcard2.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zzsxt.entity5">
    <class name="IdCard2">
        <id name="id">
            <generator class="native"></generator>
        </id>
        <property name="cardNo"></property>
        <!-- 多对一 -->
        <many-to-one name="person2" class="Person2" column="pid" unique="true"></many-to-one>
    </class>
</hibernate-mapping>    

　　Person2:

package cn.zzsxt.entity5;

public class Person2 {
    private int id;
    private String name;
    private IdCard2 idCard2;//关联的实体对象
    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;
    }
    public IdCard2 getIdCard2() {
        return idCard2;
    }
    public void setIdCard2(IdCard2 idCard2) {
        this.idCard2 = idCard2;
    }

}

　　Person2.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zzsxt.entity5">
    <class name="Person2">
        <id name="id">
            <generator class="native"></generator>
        </id>
        <property name="name"></property>
        <!--
         one-to-one:一对一
             name属性:关联对象的名称
             class属性:关联对象的类型
             cascade:级联
             constrained="true|false":可选属性. 代表是否是约束属性.
                配置在这里,代表当前属性为约束属性,一定在这个属性对应的表中有
                数据与本表数据对应.

        -->
        <one-to-one name="idCard2" class="IdCard2" cascade="save-update"></one-to-one>
    </class>
</hibernate-mapping>    

　　TestOneToOne2:

package cn.zzsxt.test2;

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

import cn.zzsxt.entity5.IdCard2;
import cn.zzsxt.entity5.Person2;
import cn.zzsxt.utils.HibernateUtil;

public class TestOneToOne2 {
    public static void main(String[] args) {
        Session session =HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        Person2 person = new Person2();
        person.setName("zhangsan");
        IdCard2 idCard = new IdCard2();
        idCard.setCardNo("412722199001011234");
        //为人设置身份证
        person.setIdCard2(idCard);
        //为身份证指定人
        idCard.setPerson2(person);
        //通过级联添加人和身份证
        session.save(person);
        tx.commit();
        session.close();

     }
}
 

6.多对多双向关联：

　　Emp：

package cn.zzsxt.entity6;

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

public class Emp {
    private int empId;
    private String empName;
    private Set<Project> projects = new HashSet<Project>();
    public int getEmpId() {
        return empId;
    }
    public void setEmpId(int empId) {
        this.empId = empId;
    }
    public String getEmpName() {
        return empName;
    }
    public void setEmpName(String empName) {
        this.empName = empName;
    }
    public Set<Project> getProjects() {
        return projects;
    }
    public void setProjects(Set<Project> projects) {
        this.projects = projects;
    }

}　　

　　Emp.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zzsxt.entity6">
    <class name="Emp" table="tbl_emp">
        <id name="empId">
            <generator class="native"></generator>
        </id>
        <property name="empName"></property>
        <!--
            table="中间表的表名"
         -->
        <set name="projects" table="tbl_emp_project" cascade="all">
            <!-- column:中间表中与Emp对应的外键名称 -->
            <key column="empId"></key>
            <!--
                many-to-many:多对多
                class="集合中的元素类型"
                column="中间表中与Project对应的外键名称"
            -->
            <many-to-many class="Project" column="projectId"></many-to-many>
        </set>
    </class>
</hibernate-mapping>    

　　project:

package cn.zzsxt.entity6;

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

public class Project {
    private int projectId;
    private String projectName;
    private Set<Emp> emps = new HashSet<Emp>();

    public int getProjectId() {
        return projectId;
    }
    public void setProjectId(int projectId) {
        this.projectId = projectId;
    }
    public String getProjectName() {
        return projectName;
    }
    public void setProjectName(String projectName) {
        this.projectName = projectName;
    }
    public Set<Emp> getEmps() {
        return emps;
    }
    public void setEmps(Set<Emp> emps) {
        this.emps = emps;
    }

}

　　Project.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zzsxt.entity6">
    <class name="Project" table="tbl_project">
        <id name="projectId">
            <generator class="native"></generator>
        </id>
        <property name="projectName"></property>
        <!--
            table="中间表的表名"
         -->
        <set name="emps" table="tbl_emp_project" inverse="true">
            <!-- column:中间表中与Project对应的外键名称 -->
            <key column="projectId"></key>
            <!--
                many-to-many:多对多
                class="集合中的元素类型"
                column="中间表中与Emp对应的外键名称"
            -->
            <many-to-many class="Emp" column="empId"></many-to-many>
        </set>
    </class>
</hibernate-mapping>    

　　TestManyToMany:

package cn.zzsxt.test2;

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

import cn.zzsxt.entity6.Emp;
import cn.zzsxt.entity6.Project;
import cn.zzsxt.utils.HibernateUtil;
/**
 *
 * 添加两个员工:zhangsan和lisi
 * 添加两个项目:OA项目和CRM项目
 * 将zhangsan和lisi分配到OA项目组
 * 将lisi分配到CRM项目组
 * @author Think
 *
 */
public class TestManyToMany {
    public static void main(String[] args) {
        Session session =HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        //创建两个员工
        Emp emp1 = new Emp();
        emp1.setEmpName("张三");
        Emp emp2 = new Emp();
        emp2.setEmpName("李四");
        //创建两个项目
        Project project1 = new Project();
        project1.setProjectName("OA项目");
        Project project2 = new Project();
        project2.setProjectName("CRM项目");
        //关系维护的控制权在emp方,为员工添加项目
        emp1.getProjects().add(project1);//为张三分配OA项目
        emp2.getProjects().add(project1);//为李四分配OA项目
        emp2.getProjects().add(project2);//为李四分配CRM项目
        //保存员工和项目(级联)
        session.save(emp1);
        session.save(emp2);
        tx.commit();
        session.close();

     }
}