Java web开发（9）Hibernate使用_b

多表之间配置和操作

1.一对多关系

典型的如一个班级对一个学生的关系。一个班级可以有多个学生，一个学生只属于一个班级。在学生表中有一个外键，指向班级表的主键。

Hibernate要求实体类中除了正常成员，还要有数据结构表明其关系。

”一“的那一方需要一个HashSet<多的一方实体类>对象，在CRUD的时候，使用该对象可以轻松操作。

”多“的那一方需要一个”一“那一方的对象。

现在用客户公司和其联系人作为例子。一个客户公司有多个联系人，一个联系只属于一个公司。

客户实体类Customer.java

public class Customer {
    //客户id
    private Integer cid;
    //客户名称
    private String custName;
    //客户级别
    private String custLevel;
    //客户来源
    private String custSource;
    //联系电话
    private String custPhone;
    //手机
    private String custMobile;
    
    //在客户实体类里面表示多个联系人，一个客户有多个联系人
    //hibernate要求使用集合表示多的数据，使用set集合
    private Set<LinkMan> setLinkMan = new HashSet<LinkMan>();
//getter and setter
}

联系人实体类LinkMan.java

public class LinkMan {
    private Integer lkm_id; // 联系人编号(主键)
    private String lkm_name;// 联系人姓名
    private String lkm_gender;// 联系人性别
    private String lkm_phone;// 联系人办公电话
    
    // 在联系人实体类里面表示所属客户,一个联系人只能属于一个客户
    private Customer customer;
//getter and setter
.....
}

在同一个包中分别建立实体类的配置文件

Customer.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>

    <class name="cn.itcast.entity.Customer" table="t_customer">
        <id name="cid" column="cid">
            <generator class="native"></generator>
        </id>
        <property name="custName" column="custName"></property>
        <property name="custLevel" column="custLevel"></property>
        <property name="custSource" column="custSource"></property>
        <property name="custPhone" column="custPhone"></property>
        <property name="custMobile" column="custMobile"></property>
        
        <set name="setLinkMan" cascade="save-update,delete">
            
            <key column="clid"></key>
            
            <one-to-many class="cn.itcast.entity.LinkMan"/>
        </set>
    </class>
</hibernate-mapping>

显示成员和表字段的对应关系。

标签set 的name就是实体类中SetHash对象名称。然后指明一对多中 的多的实体类，指明 多的一方表中的外键名称clid。

LinkMan.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>
    
    <class name="cn.itcast.entity.LinkMan" table="t_linkman">
        <id name="lkm_id" column="lkm_id">
            <generator class="native"></generator>
        </id>
        <property name="lkm_name" column="lkm_name"></property>
        <property name="lkm_gender" column="lkm_gender"></property>
        <property name="lkm_phone" column="lkm_phone"></property>
        
        <!-- 一的那一方的实体类
　　　　　　　　和多的一方表中的外键名称
        -->
        <many-to-one name="customer" class="cn.itcast.entity.Customer" column="clid"></many-to-one>
    </class>
</hibernate-mapping>

hibernate.cfg.xml 使用mapping resource指定上述两个配置文件。

<?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>
        <!-- 第一部分： 配置数据库信息 必须的 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql:///hello</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">123456</property>
        
        <!-- 第二部分： 配置hibernate信息  可选的-->
        <!-- 输出底层sql语句 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 输出底层sql语句格式 -->
        <property name="hibernate.format_sql">true</property>
        <!-- hibernate帮创建表，需要配置之后 
            update: 如果已经有表，更新，如果没有，创建
        -->
        <property name="hibernate.hbm2ddl.auto">update</property>
        <!-- 配置数据库方言
            在mysql里面实现分页 关键字 limit，只能使用mysql里面
            在oracle数据库，实现分页rownum
            让hibernate框架识别不同数据库的自己特有的语句
         -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        
        <!-- 在hibernate核心配置文件中配置 -->
        <property name="hibernate.current_session_context_class">thread</property>
        
        <!-- 第三部分： 把映射文件放到核心配置文件中 必须的-->
        <mapping resource="cn/itcast/entity/Customer.hbm.xml"/>
        <mapping resource="cn/itcast/entity/LinkMan.hbm.xml"/>
        
    </session-factory>
</hibernate-configuration>

程序操作框架依然是

SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        System.out.println("hi");
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();
            ........................
            
            //提交事务
            tx.commit();

        }catch(Exception e) {
            //e.printStackTrace();
            System.out.println("something wrong");
            tx.rollback();
        }finally {
            session.close();
           
        }

使用例子

1.级联保存

Customer customer = new Customer();
customer.setCustName("Bili");
customer.setCustLevel("客户");
customer.setCustSource("网络");
customer.setCustPhone("110");
customer.setCustMobile("999");

LinkMan linkman = new LinkMan();
linkman.setLkm_name("William");
linkman.setLkm_gender("男");
linkman.setLkm_phone("911");
System.out.println("hi3");
//2 把联系人放到客户里面
customer.getSetLinkMan().add(linkman);

//3 保存客户
session.save(customer);     

因为Customer.hbm.xml中配置了save-update的级联，

这里会自动在linkman的表中插入一条Williman的linkman记录，并且设置好外键，对应新增Customer的主键。

2.级联删除

// 1 根据id查询客户对象
Customer customer = session.get(Customer.class, 3);
//2 调用方法删除
session.delete(customer);

这里删除id为3的Customer记录，（因为配置了delete的级联）并且删除其对应的linkman，也就是linkman表中外键为3的记录全部删除。

如果没有配置delete级联，就不会删除对应的linkman记录，但是会把外键为3的linkman外键设置为null。

3.级联修改

Customer c = session.get(Customer.class, 5);
LinkMan l = session.get(LinkMan.class, 1);

c.getSetLinkMan().add(l);

把id为5的Customer拥有id为1的linkman。

也就是 ，将id为1的linkman外键修改为5.

 2.多对多关系

类似一个教师可以有多个学生，一个学生有多个教师。

这里用用户和角色为例，一个用户对应多个角色，一个角色对应多个用户。

在各自的实体类都有一个HashSet，用来包含另外一方的对象。

除了各自的表，会有第三张表，每一条记录有2个外键，对应了user和Role的主键。

User类

public class User {
      private Integer user_id;//用户id
      private String user_name;//用户名称
      private String user_password;//用户密码
      
      //一个用户可以有多个角色
      private Set<Role> setRole = new HashSet<Role>();
//getter and setter
........
}

Role类

public class Role {
      private Integer role_id;//角色id
      private String role_name;//角色名称
      private String role_memo;//角色描述
      
      // 一个角色有多个用户
      private Set<User> setUser = new HashSet<User>();
//getter and setter.
...
}

Role.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>
    
    <class name="cn.itcast.manytomany.Role" table="t_role">
        <id name="role_id" column="role_id">
            <generator class="native"></generator>
        </id>
        <property name="role_name" column="role_name"></property>
        <property name="role_memo" column="role_memo"></property>
        
        <!-- 在角色里面表示所有用户，使用set标签 -->
        <set name="setUser" table="user_role">
            <!-- 角色在第三张表外键 -->
            <key column="roleid"></key>
            <many-to-many class="cn.itcast.manytomany.User" column="userid"></many-to-many>
        </set>
    </class>
</hibernate-mapping>

User.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>
    <!-- 1 配置类和表对应 
        class标签
        name属性：实体类全路径
        table属性：数据库表名称
    -->
    <class name="cn.itcast.manytomany.User" table="t_user">
        <id name="user_id" column="user_id">
            <generator class="native"></generator>
        </id>
        <property name="user_name" column="user_name"></property>
        <property name="user_password" column="user_password"></property>
        
        <set name="setRole" table="user_role" cascade="save-update">
            <!-- key标签里面配置
                配置当前映射文件在第三张表外键名称
             -->
            <key column="userid"></key>
            <!-- class：角色实体类全路径
                 column：角色在第三张表外键名称
             -->
            <many-to-many class="cn.itcast.manytomany.Role" column="roleid"></many-to-many>
        </set>
    </class>
</hibernate-mapping>

使用例子

1级联保存

User user1 = new User();
user1.setUser_name("lucy");
user1.setUser_password("123");

User user2 = new User();
user2.setUser_name("mary");
user2.setUser_password("456");

Role r1 = new Role();
r1.setRole_name("总经理");
r1.setRole_memo("总经理");

Role r2 = new Role();
r2.setRole_name("秘书");
r2.setRole_memo("秘书");

Role r3 = new Role();
r3.setRole_name("保安");
r3.setRole_memo("保安");

//2 建立关系，把角色放到用户里面
// user1 -- r1/r2
user1.getSetRole().add(r1);
user1.getSetRole().add(r2);

// user2 -- r2/r3
user2.getSetRole().add(r2);
user2.getSetRole().add(r3);

//3 保存用户
session.save(user1);
session.save(user2);

创建2个用户，id分别是5,6，3个角色，id分别是7,8,9，

用户5 拥有角色7,8

用户6拥有角色8,9.

第三个表如图所示

2.级联删除

User user = session.get(User.class, 5);
session.delete(user);

删除id为5的用户，如果配置了delete级联，会删除第三张表中userid为5的记录，再删除和userid为5有关联的Role，

也就是删除id 7和8 的role，再删除id7和8的role在第三张表中的关系。

一般不使用delete级联，只删除id为5的User，删除第三张表中和 id5有关的关系。对应的角色和其他关系不会删除。

3

建立和删除关系

User lucy = session.get(User.class, 6);
Role role = session.get(Role.class, 7);

//2 把角色放到用户的set集合里面
lucy.getSetRole().add(role);

等效于在第三张表中插入 6,7记录

User user = session.get(User.class, 2);
Role role = session.get(Role.class, 3);

//2 从用户里面把角色去掉
user.getSetRole().remove(role);

等效于在第三张表中删除2,3记录