31、多对多配置

学习目标：

1、搭建Hibernate环境

2、理解Hibernate的运行流程

3、能正确运行Hibernate的第一个例子

学习过程：

无可否认多对多的配置应该是最简单的，在数据库中多对多需要一个中间表，在hibernate中你可以使用多对多的标签配置这种关系，当然你也可以使用一对多的关系去维护也是可行的，这个就要看具体情况了，毕竟多对多也是依赖一对多的方式实现的。这节课我们就讲讲如何配置多对多，这种配置就让双方的表维护这种关系，在设计pojo类的时候就不需要为中间表专门设计一个对象。

1、修改pojo属性

在表设计中，帐号和角色之间就是多对多的关系，肯定需要使用集合来描述他们之间的关系，所有修改账号和角色两个pojo类，分别添加Set集合属性。

账号类如下：

public class Login implements java.io.Serializable {
    private Integer loginId;
    private Employee employee;// 一对一
    private String loginName;
    private String loginPass;
    private Set<Role> roles=new HashSet<Role>();//多对多   

角色类如下：

public class Role implements java.io.Serializable {    
   private Integer roleId;    
  private String roleName;    
   private Set<Login> logins = new HashSet<Login>();//多对多

   ..... 省去get/set

}

2、修改映射文件

新建Role.hbm. 如下：

<?  version=\"1.0\"?>
<!DOCTYPE hibernate-mapping PUBLIC
        \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"
        \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">
<hibernate-mapping>
    <class name=\"com.javadayup.stuormrelate.Role\" table=\"role\" catalog=\"hbm_db\">
        <id name=\"roleId\" type=\"java.lang.Integer\">
            <column name=\"role_id\" />
            <generator class=\"native\" />
        </id>
        <property name=\"roleName\" type=\"java.lang.String\">
            <column name=\"role_name\" length=\"200\" />
        </property>
         <set name=\"logins\" table=\"login_role\" inverse=\"true\">
          <key column=\"role_id\"></key>
          <many-to-many column=\"login_id\" class=\"com.javadayup.stuormrelate.Login\"></many-to-many>
        </set>
    </class>
</hibernate-mapping>

修改Login.hbm. ，添加一下代码

        <set name=\"roles\" table=\"login_role\" >
          <key column=\"login_id\"></key>
          <many-to-many column=\"role_id\" class=\"com.javadayup.stuormrelate.Role\"></many-to-many>
        </set>

3、测试

public class Run3 {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        Login login=new Login();
        login.setLoginName(\"new\");
        login.setLoginPass(\"123\");
        Employee employee=new Employee();
        employee.setEmployeeId(8);
        login.setEmployee(employee);
        Set<Role> roles=new HashSet<Role>();
        Role role1=new Role();
        role1.setRoleId(1);
        Role role2=new Role();
        role2.setRoleId(2);
        roles.add(role2);
        roles.add(role1);
        login.setRoles(roles);

        // 开启一个事务
        session.beginTransaction();
        // 操作数据库 直接操作对象 持久化
        session.save(login);
        // 提交事物
        session.getTransaction().commit();
        session.close();
        HibernateUtil.getSessionFactory().close();
    }
}

虽然我们只是添加了一个Login信息，但是因为和员工和角色都已经有关系了，所以hibernate帮我们做了很多操作。包括中间包也已经帮我们建立了。查看一下输出的sql

Hibernate: create table hbm_db.role (role_id integer not null auto_increment, role_name varchar(200), primary key (role_id)) type=MyISAM

Hibernate: create table login_role (login_id integer not null, role_id integer not null, primary key (login_id, role_id)) type=MyISAM

Hibernate: alter table hbm_db.employee add constraint FKcm3b9d5fiw8s6co7lkw8c0lbs foreign key (post_id) references hbm_db.post (post_id)

Hibernate: alter table hbm_db.login add constraint FKrf9u9o9lttvq3jevsf6t8svp2 foreign key (employee_id) references hbm_db.employee (employee_id)

Hibernate: alter table login_role add constraint FK63kgx3alku7oht20p6r560u95 foreign key (role_id) references hbm_db.role (role_id)

Hibernate: alter table login_role add constraint FK9bqlp09e2a52fdq1ywjha2iti foreign key (login_id) references hbm_db.login (login_id)

Hibernate: insert into hbm_db.login (login_name, login_pass, employee_id) values (?, ?, ?)

Hibernate: insert into login_role (login_id, role_id) values (?, ?)

Hibernate: insert into login_role (login_id, role_id) values (?, ?)

public class Run4 {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        Login login=new Login();
        login.setLoginId(4);
        login.setLoginName(\"abcdef\");
        login.setLoginPass(\"abc\");
        Employee employee=new Employee();
        employee.setEmployeeId(8);
        login.setEmployee(employee);
        Set<Role> roles=new HashSet<Role>();
        Role role1=new Role();
        role1.setRoleId(1);
        roles.add(role1);
        login.setRoles(roles);

        // 开启一个事务
        session.beginTransaction();
        // 操作数据库 直接操作对象 持久化
        session.update(login);
        // 提交事物
        session.getTransaction().commit();
        session.close();
        HibernateUtil.getSessionFactory().close();

    }
}

我们再测试一下执行更新的操作。

Hibernate: update hbm_db.login set login_name=?, login_pass=?, employee_id=? where login_id=?

Hibernate: delete from login_role where login_id=?

Hibernate: insert into login_role (login_id, role_id) values (?, ?)

可以看到他会先执行一下delete，清空了所有的关系，然后再重新insert进去的。