Hibernate一对多双向关联，多对多单向关联

       cascade属性的部分常用可选值

       none:当Session操纵当前对象时，忽略其他关联的对象，它是cascade属性的默认值。

       save-update:当通过Session的save( ),update( )及saveOrUpdate( )方法来保存或更新当前对象时，级联保存所有关联的瞬时状态的对象，并且级联更新所有关联的游离状态的对象

      delete:当通过Session的delete( )方法删除当前对象时，会级联删除所有关联的对象

      all:包含save-update,delete的行为

        <set>元素的lazy属性

           true;默认值，延迟加载

           false:立即加载

           extra:增加延迟加载

   一对多双向关联

        先创建Dapt类，在该类中使用Set集合植入Emp类，并将其进行封装。

private Integer pid;
private String pname;
private Set<Emp> emps=new HashSet<Emp>();

小配置 Dapt.hbm.xml

<?xml version="1.0"?>
<!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.happy.liancha">
<class name="Dapt" table="Dapt" schema="happyy2165">
    <id name="pid" column="pid">
        <generator class="native"></generator>
    </id>
    <property name="pname"/>
    <set name="emps" cascade="save-update" inverse="true" order-by="ename desc">
            <!--一对多-->
        <key column="pid"></key>
        <one-to-many class="cn.happy.liancha.Emp"></one-to-many>
    </set>
</class>
</hibernate-mapping>

  在大配置中添加路径

<mapping resource="cn/happy/liancha/Emp.hbm.xml"/>
<mapping resource="cn/happy/liancha/Dapt.hbm.xml"/>

测试类
//一对多双向关联
@Test
public void testOneToManyDouble(){
    List<Dapt> list = session.createQuery("from Dapt").list();
    for (Dapt dept : list) {
        System.out.println(dept.getPname());
        System.out.println("======================");
        for (cn.happy.liancha.Emp emp : dept.getEmps()) {
            System.out.println(emp.getEname());
        }
    }
}
//检索指定部门下所有员工集合，打印输出按照工号降序
@Test
public void testPrintEmpByNo(){
    Dapt dept =session.get(Dapt.class,1);
    for (Emp emp:dept.getEmps()){
        System.out.println(emp.getEname());
    }
}
多对多单向关联    
    

先创建Employee类，并使用Set集合植入Project类，并将其进行封装 

private Integer empid;
private String empname;
//在员工的实体中植入一个项目的集合  一个员工可以参与N个工程
private Set<Project> projects = new HashSet<Project>();
Employee.hbm.xml
<?xml version="1.0"?>
<!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.happy.mostmapping">
    <class name="Employee" table="Employee" schema="happyy2165">
        <id name="empid" column="empid">
           <generator class="native"></generator>
        </id>
        <property name="empname" />
        <!--table指的是中间表-->
        <set name="projects" table="PROEMP">
            <key column="REMPID"></key>
            <many-to-many column="RPROID" class="Project"></many-to-many>
        </set>
    </class>
</hibernate-mapping>
然后创建Project类，并使用Set集合植入Employee类，并将其进行封装 
private Integer proid;
private String proname;
private Set<Employee> employees = new HashSet<Employee>();
Project.hbm.xml
<?xml version="1.0"?>
<!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.happy.mostmapping">
    <class name="Project" table="Project" schema="happyy2165">
        <id name="proid" column="proid">
           <generator class="native"></generator>
        </id>
        <property name="proname" />
        <!--table指的是中间表-->
        <set name="employees" table="PROEMP" cascade="save-update" inverse="true">
            <key column="RPROID"></key>
            <many-to-many column="REMPID" class="Employee"></many-to-many>
        </set>
    </class>
</hibernate-mapping>
   大配置 
<!--多对多单向关联-->
<mapping resource="cn/happy/mostmapping/Employee.hbm.xml"/>
<mapping resource="cn/happy/mostmapping/Project.hbm.xml"/>
   测试类
//检索特定员工参与的所有工程名称   多对多
@Test
public void testPrintEmpByNo(){
    Employee employee =session.get(Employee.class,1);
    System.out.println(employee.getEmpname());
    System.out.println("======================");
    for (Project pro:employee.getProjects()){
        System.out.println(pro.getProname());
    }
}
  //添加保存数据
@Test
  public void addtest(){
      Employee   employee=new Employee();
      employee.setEmpname("啦啦");

      Employee employee1=new Employee();
      employee1.setEmpname("娜娜");

      Project  project=new Project();
      project.setProname("1234");

      project.getEmployees().add(employee);
      project.getEmployees().add(employee1);

      employee.getProjects().add(project);
      employee1.getProjects().add(project);

      session.save(project);
      session.save(employee);
      session.save(employee1);
      tx.commit();
  }

 -------------工具类--------------
   先创建HibernateUtil类
   public class HibernateUtil {
   private  static ThreadLocal<Session> tl;
   private static Configuration cfg;
   private static SessionFactory factory;

   static {
       tl=new ThreadLocal<Session>();
       cfg=new Configuration().configure();
       factory=cfg.buildSessionFactory();
   }

   public static Session getSession(){
       //尝试从线程查看有没有线程变量
       Session session=tl.get();
       if(session==null){
           //线程中没有session对象，创建一个
           session=factory.openSession();
           tl.set(session);
       }
       return session; //没有和当前线程绑定
   }

    public static void closeSession(){
        Session session = tl.get();
        tl.set(null);
        session.close();
    }
}
然后创建MyThread类，让他继承Thread类。
public class MyThread extends Thread {
    @Override
    public void run() {
        //获取session
        Session session = HibernateUtil.getSession();
        //获取session2
        Session session2 = HibernateUtil.getSession();
        System.out.println("子线程===1====="+session.hashCode());
        System.out.println("子线程===2====="+session2.hashCode());
    }
}
测试方法 
@Test
//测试方法
public void tt(){
    //开启一个子线程
    MyThread t1=new MyThread();
    t1.start();
    Session session= HibernateUtil.getSession();
    System.out.println("主线程==1=="+session.hashCode());
    Session session2=HibernateUtil.getSession();
    System.out.println("主线程==2=="+session2.hashCode());

}