HIbernate入门3

HIbernate的一对多操作：

　　1. 创建实体类：一个Customer类（客户类）和一个LinkMan类（联系人），两者的关系为：一个客户中可能有多个联系人（关于一对多的实体类之间的关联，不做详细介绍，看下代码）。

　　Customer：

package com.geore.pojo.customer;

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

import com.geore.pojo.linkman.LinkMan;

public class Customer {
    private String cid = null;
    private String custLevel = null;
    private String custName = null;
    private String custSource = null;
    private String custMobile = null;
    private Set<LinkMan> mans = new HashSet<LinkMan>();

    @Override
    public String toString() {
        return "Customer [cid=" + cid + ", custLevel=" + custLevel
                + ", custName=" + custName + ", custSource="
                + custSource + ", custMobile=" + custMobile + "]";
    }

    public String getCid() {
        return cid;
    }

    public void setCid(String cid) {
        this.cid = cid;
    }

    public String getCustLevel() {
        return custLevel;
    }

    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }

    public String getCustName() {
        return custName;
    }

    public void setCustName(String custName) {
        this.custName = custName;
    }

    public String getCustSource() {
        return custSource;
    }

    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }

    public String getCustMobile() {
        return custMobile;
    }

    public void setCustMobile(String custMobile) {
        this.custMobile = custMobile;
    }

    public Set<LinkMan> getMans() {
        return mans;
    }

    public void setMans(Set<LinkMan> mans) {
        this.mans = mans;
    }
}

　　LinkMan：

package com.geore.pojo.linkman;

import com.geore.pojo.customer.Customer;

public class LinkMan {
    private String lid = null;
    private String linkName = null;
    private String linkGender = null;
    private String linkPhone = null;
    private Customer customer = null;
    
    public LinkMan() {
        super();
    }
    @Override
    public String toString() {
        return "LinkMan [lid=" + lid + ", linkName=" + linkName
                + ", linkGender=" + linkGender + ", linkPhone=" + linkPhone
                + ", customer=" + customer + "]";
    }
    public String getLid() {
        return lid;
    }
    public void setLid(String lid) {
        this.lid = lid;
    }
    public String getLinkName() {
        return linkName;
    }
    public void setLinkName(String linkName) {
        this.linkName = linkName;
    }
    public String getLinkGender() {
        return linkGender;
    }
    public void setLinkGender(String linkGender) {
        this.linkGender = linkGender;
    }
    public String getLinkPhone() {
        return linkPhone;
    }
    public void setLinkPhone(String linkPhone) {
        this.linkPhone = linkPhone;
    }
    public Customer getCustomer() {
        return customer;
    }
    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
}

　　2. 配置实体类的Hibernate实体类配置文件

　　对于Hibernate实体类的配置：第一，首先将基本的class，id和property等标签的内容配置好之后，因为在Customer中，是一个一对多的关系，因此在Customer实体类中用Set集合表示一个Customer可以拥有多个联系人（Hibernate规定，在表示一对多的时候，使用的集合必须为Set集合），因此在配置文件中，需要对这种关系进行配置，而Hibernate配置文件提供了一个set标签进行配置，具体配置见下代码：

<?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="com.geore.pojo.customer.Customer" table="t_customer">
        <id name="cid" column="cid">
            <generator class="uuid"></generator>
        </id>
        <property name="custLevel" column="custLevel"></property>
        <property name="custName" column="custName"></property>
        <property name="custSource" column="custSource"></property>
        <property name="custMobile" column="custMobile"></property>
        <set name="mans" cascade="save-update,delete">
            <key column="clid"></key>
            <one-to-many class="com.geore.pojo.linkman.LinkMan"/>
        </set>
    </class>
</hibernate-mapping>

 　　同时在LinkMan.hbm.xml文件中，也需要进行配置，因为Hibernate是进行双向关联，因此在LinkMan中也会有一个字段关联到Customer类，一般这个字段我们使用Customer的对象来表示，所以在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="com.geore.pojo.linkman.LinkMan" table="t_linkman">
        <id name="lid" column="lid">
            <generator class="uuid"></generator>
        </id>
        <property name="linkName" column="linkName"></property>
        <property name="linkGender" column="linkGender"></property>
        <property name="linkPhone" column="linkPhone"></property>
        <many-to-one name="customer" class="com.geore.pojo.customer.Customer" not-found="ignore">
            <column name="clid"></column>
        </many-to-one>
    </class>
</hibernate-mapping>

　　3. 一对多的级联操作：

　　（1）、保存操作

　　代码片段：

@Test
    public void fun1() {
        Transaction ts = null;
        Session session = null;
        SessionFactory factory = null;
        try {
            factory = Tools.getSessionFactory();
            session = factory.openSession();
            ts = session.beginTransaction();
            // 一对多的操作
            Customer customer = new Customer();
            customer.setCustLevel("vip");
            customer.setCustMobile("1378*******");
            customer.setCustName("Geore");
            customer.setCustSource("Baidu");
            LinkMan linkman = new LinkMan();
            linkman.setLinkGender("M");
            linkman.setLinkName("Mr.Li");
            linkman.setLinkPhone("****-*******");
            // 添加兩個對象的之间的一对多关系
            customer.getMans().add(linkman);
            linkman.setCustomer(customer);
            // 添加到数据库
            session.save(customer);
            session.save(linkman);

            ts.commit();
        } catch (Exception e) {
            ts.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

    @Test
    // 级联保存的简化写法
    public void fun2() {
        Transaction ts = null;
        Session session = null;
        SessionFactory factory = null;
        try {
            factory = Tools.getSessionFactory();
            session = factory.openSession();
            ts = session.beginTransaction();
            // 一对多的操作
            Customer customer = new Customer();
            customer.setCustLevel("svip");
            customer.setCustMobile("1378*******");
            customer.setCustName("Alley");
            customer.setCustSource("Google");
            LinkMan linkman = new LinkMan();
            linkman.setLinkGender("F");
            linkman.setLinkName("Mr.Wang");
            linkman.setLinkPhone("****-*******");
            // 添加兩個對象的之间的一对多关系
            customer.getMans().add(linkman);
            // 添加到数据库
            session.save(customer);
            ts.commit();
        } catch (Exception e) {
            ts.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

　　运行截图：

 

对于上面的简单方法的插入，需要在Hibernate实体类的配置文件中进行配置，配置代码如下：

<set name="mans" cascade="save-update">
需要配置的就是cascade="save-update"，这个save-update表示的就是自动的会对一对多的关系在HIbernate底层进行处理，配置了这个，就不需要在代码中双向关联对应的实体类对象了

　　（2）、删除操作

　　代码片段：

@Test
    // 级联删除操作，在set标签中进行配置
    public void fun3() {
        Transaction ts = null;
        Session session = null;
        SessionFactory factory = null;
        try {
            factory = Tools.getSessionFactory();
            session = factory.openSession();
            ts = session.beginTransaction();

            // 通过id找到对应的数据记录
            Customer customer = session.get(Customer.class,
                    "4028d4015e6dedd5015e6deddbeb0000");
            session.delete(customer);

            ts.commit();
        } catch (Exception e) {
            ts.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

　　运行截图：

同样的，对于删除操作，因为是1对多，删除一个Customer，那么对应的Customer下的LinkMan也要删除，那么这样删除的话，同样要配置Hibernate的配置文件，来实现级联删除。代码如下：

<set name="mans" cascade="save-update,delete">
    <key column="clid"></key>
    <one-to-many class="com.geore.pojo.linkman.LinkMan"/>
</set>
同样的也是在cascade中进行配置，在这个属性中给个只delete，至于之前保存操作的save-update不用删除，只需要在后面加上一个,号，在写上delete表示进行级联删除操作即可

　　

　　（3）、一对多表的维护操作

　　代码片段：

@Test
    // 将Mr.wang公司修改带Baidu，加上not-found="ignore"，否则报错，原因不明
    public void fun4() {
        Transaction ts = null;
        Session session = null;
        SessionFactory factory = null;
        try {
            factory = Tools.getSessionFactory();
            session = factory.openSession();
            ts = session.beginTransaction();

            // 通过id找到baidu公司客户记录
            Customer customer = session.get(Customer.class,
                    "4028d4015e6f04a6015e6f04ad120000");
            System.out.println(customer);
            // 通过id找到联系人Mr.wang的记录
            LinkMan Mr_wang = session.get(LinkMan.class,
                    "4028d4015e6f04d3015e6f04da2c0001");
            System.out.println(Mr_wang);
            customer.getMans().add(Mr_wang);
            Mr_wang.setCustomer(customer);

            ts.commit();
        } catch (Exception e) {
            ts.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

　　运行截图：

　　注意：使用这个修改的时候，须在一对多的多方的实体类配置文件中，配置如下属性值：

<many-to-one name="customer" class="com.geore.pojo.customer.Customer" not-found="ignore">
就是not-found="ignore"，现在还没有发现具体造成原因，不加上此句将报异常

Hibernate 多对多的操作

 1. 创建多对多的实体类，并且在实体类中建立起表的多对多关系（用户表和角色表，一个用户可以有多个角色，一个角色也可以属于多个用户），实体类如下：

　　Role:

package com.geore.pojo.role;

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

import com.geore.pojo.users.Users;

public class Role {
    private String rid = null;
    private String roleName = null;
    private String roleMemo = null;
    private Set<Users> users = new HashSet<Users>();
    
    public Set<Users> getUsers() {
        return users;
    }
    public void setUsers(Set<Users> users) {
        this.users = users;
    }
    @Override
    public String toString() {
        return "Role [rid=" + rid + ", roleName=" + roleName + ", roleMemo="
                + roleMemo + "]";
    }
    public String getRid() {
        return rid;
    }
    public void setRid(String rid) {
        this.rid = rid;
    }
    public String getRoleName() {
        return roleName;
    }
    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }
    public String getRoleMemo() {
        return roleMemo;
    }
    public void setRoleMemo(String roleMemo) {
        this.roleMemo = roleMemo;
    }
}

　　Users:

package com.geore.pojo.users;

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

import com.geore.pojo.role.Role;

public class Users {
    private String uid = null;
    private String username = null;
    private String password = null;
    private Set<Role> roles = new HashSet<Role>();
    
    public Set<Role> getRoles() {
        return roles;
    }
    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }
    @Override
    public String toString() {
        return "Users [uid=" + uid + ", username=" + username + ", password="
                + password + "]";
    }
    public String getUid() {
        return uid;
    }
    public void setUid(String uid) {
        this.uid = uid;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}

2. 多对多关系的配置文件，Hibernate的多对多也是进行双向关联，因此对于多对多关系的两表均需要进行配置

<?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="com.geore.pojo.users.Users" table="t_users">
        <id name="uid" column="uid">
            <generator class="uuid"></generator>
        </id>
        <property name="username" column="username"></property>
        <property name="password" column="password"></property>
        <set name="roles" table="t_roleuser" cascade="save-update,delete">
            <key column="userId"></key>
            <many-to-many class="com.geore.pojo.role.Role" column="roleId"></many-to-many>
        </set>
    </class>
</hibernate-mapping>

<?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="com.geore.pojo.role.Role" table="t_role">
        <id name="rid" column="rid">
            <generator class="uuid"></generator>
        </id>
        <property name="roleName" column="roleName"></property>
        <property name="roleMemo" column="roleMemo"></property>
        <set name="users" table="t_roleuser" cascade="save-update,delete">
            <!-- 第三张表中Users表的外键id -->
            <key column="roleId"></key>
            <!-- class:表示的是set集合关联的对象的全路径；column:表示关联表在第三张表中的外键 -->
            <many-to-many class="com.geore.pojo.users.Users" column="userId"></many-to-many>
        </set>
    </class>
</hibernate-mapping>

　　对于这两个配置文件而言，因为是多对多的关系，因此在实体类中均需要集合进行保存，因此在配置文件中使用set标签来配置多对多的关系，又因为对于多对多的关系，一般使用的是第三张表来维护多对多的欢喜，因此在set标签中有一个属性table，表示的就是第三张表的名字.

3. 多对多的级练操作

　　（1）、保存操作：

代码片段：

@Test
    public void fun1() {
        // 多对多级练操作
        Transaction ts = null;
        Session session = null;
        SessionFactory factory = null;
        try {
            factory = Tools.getSessionFactory();
            session = factory.openSession();
            ts = session.beginTransaction();

            // 往用户中添加角色
            Users u1 = new Users();
            u1.setUsername("Alley");
            u1.setPassword("123456");

            Users u2 = new Users();
            u2.setUsername("Mary");
            u2.setPassword("456789");
            // 设置角色
            Role r1 = new Role();
            r1.setRoleName("HR");
            r1.setRoleMemo("HR");

            Role r2 = new Role();
            r2.setRoleName("Teacher");
            r2.setRoleMemo("Teacher");

            Role r3 = new Role();
            r3.setRoleName("CEO");
            r3.setRoleMemo("CEO");
            // 用户1添加角色r1，r2
            u1.getRoles().add(r1);
            u1.getRoles().add(r2);
            // 用户2添加角色r13，r2
            u2.getRoles().add(r3);

            session.save(u2);
            session.save(u1);

            ts.commit();
        } catch (Exception e) {
            ts.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

　　对于多对多的级联保存操作，也需要对实体类的配置文件的set标签的cascade属性进行配置，如下：

<set name="users" table="t_roleuser" cascade="save-update">

运行截图：

 （2）、级联删除操作

代码片段：

// 级联删除
    @Test
    public void fun2() {
        // 多对多级练操作
        Transaction ts = null;
        Session session = null;
        SessionFactory factory = null;
        try {
            factory = Tools.getSessionFactory();
            session = factory.openSession();
            ts = session.beginTransaction();

            // 第一步：查找用戶
            Users user = session.get(Users.class,
                    "4028d4015e6f140b015e6f1411490000");
            session.delete(user);

            ts.commit();
        } catch (Exception e) {
            ts.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

同样的级联删除也需要配置实体类的HIbernate配置文件，如下：

<set name="users" table="t_roleuser" cascade="save-update,delete">

运行截图：

 （3）、维护第三种表

　　>>>.维护第三张表---为用户添加新的角色（给Mary添加Teacher职责）

代码片段：

// 维护第三张表---为用户添加新的角色
    @Test
    public void fun3() {
        // 多对多级练操作
        Transaction ts = null;
        Session session = null;
        SessionFactory factory = null;
        try {
            factory = Tools.getSessionFactory();
            session = factory.openSession();
            ts = session.beginTransaction();

            // 第一步：查找用戶，
            Users user = session.get(Users.class,
                    "4028d4015e6f1fe3015e6f1fe99a0000");
            // 查找角色
            Role role = session.get(Role.class,
                    "4028d4015e6f1fe3015e6f1fe9da0004");
            // 添加角色到用户
            user.getRoles().add(role);

            ts.commit();
        } catch (Exception e) {
            ts.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

运行截图：

　　>>>.维护第三张表---删除为用户的角色（删除Mary添加Teacher职责）

代码片段：

// 维护第三张表---一处用户的某个角色
    @Test
    public void fun4() {
        // 多对多级练操作
        Transaction ts = null;
        Session session = null;
        SessionFactory factory = null;
        try {
            factory = Tools.getSessionFactory();
            session = factory.openSession();
            ts = session.beginTransaction();

            // 第一步：查找用戶，
            Users user = session.get(Users.class,
                    "4028d4015e6f1fe3015e6f1fe99a0000");
            // 查找角色
            Role role = session.get(Role.class,
                    "4028d4015e6f1fe3015e6f1fe9da0004");
            // 添加角色到用户
            user.getRoles().remove(role);

            ts.commit();
        } catch (Exception e) {
            ts.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

运行截图：