Java Hibernate多表操作

最新推荐文章于 2021-02-16 21:42:43 发布
最新推荐文章于 2021-02-16 21:42:43 发布
阅读量208 收藏
点赞数
分类专栏： Java Hibernate Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qg_zhang/article/details/79352384
版权

Hibernate 多表关系

  • 1:1 关系
class A{
    B b;
}
class B{
    A a;
}
  • 1:n关系
class A{
    Set<B> bs;//B的集合
}
class B{
    A a;
}
  • m:n关系
class A{
    Set<B> bs;//B的集合
}
class B{
    Set<A> as;//A的集合
}

1:n案例

【Customer对象】（表示一个客户拥有多个联系人 即一对多）

public class Customer {
    private Long cust_id;
    private String cust_name;
    private String cust_source;
    private String cust_industry;
    private String cust_level;
    private String cust_linkman;
    private String cust_phone;
    private String cust_mobile;
    // 使用set集合,表达一对多关系
    private Set<LinkMan> linkMens = new HashSet<LinkMan>();

    public Set<LinkMan> getLinkMens() {
        return linkMens;
    }

    public void setLinkMens(Set<LinkMan> linkMens) {
        this.linkMens = linkMens;
    }

    public Long getCust_id() {
        return cust_id;
    }

    public void setCust_id(Long cust_id) {
        this.cust_id = cust_id;
    }

    public String getCust_name() {
        return cust_name;
    }

    public void setCust_name(String cust_name) {
        this.cust_name = cust_name;
    }

    public String getCust_source() {
        return cust_source;
    }

    public void setCust_source(String cust_source) {
        this.cust_source = cust_source;
    }

    public String getCust_industry() {
        return cust_industry;
    }

    public void setCust_industry(String cust_industry) {
        this.cust_industry = cust_industry;
    }

    public String getCust_level() {
        return cust_level;
    }

    public void setCust_level(String cust_level) {
        this.cust_level = cust_level;
    }

    public String getCust_linkman() {
        return cust_linkman;
    }

    public void setCust_linkman(String cust_linkman) {
        this.cust_linkman = cust_linkman;
    }

    public String getCust_phone() {
        return cust_phone;
    }

    public void setCust_phone(String cust_phone) {
        this.cust_phone = cust_phone;
    }

    public String getCust_mobile() {
        return cust_mobile;
    }

    public void setCust_mobile(String cust_mobile) {
        this.cust_mobile = cust_mobile;
    }

    @Override
    public String toString() {
        return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name + "]";
    }

}

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 package="cn.pure.domain" >
    <class name="Customer" table="cst_customer" >
        <id name="cust_id"  >
            <generator class="native"></generator>
        </id>
        <property name="cust_name" column="cust_name" ></property>
        <property name="cust_source" column="cust_source" ></property>
        <property name="cust_industry" column="cust_industry" ></property>
        <property name="cust_level" column="cust_level" ></property>
        <property name="cust_linkman" column="cust_linkman" ></property>
        <property name="cust_phone" column="cust_phone" ></property>
        <property name="cust_mobile" column="cust_mobile" ></property>

        <!-- 集合,一对多关系,在配置文件中配置 -->
        <!-- 
            name属性:集合属性名
            column属性: 外键列名
            class属性: 与我关联的对象完整类名
         -->
        <set name="linkMens" >
            <key column="lkm_cust_id" ></key>
            <one-to-many class="LinkMan" />
        </set>

    </class>
</hibernate-mapping>

【LinkMan对象】（表示多个联系人对象对应一个客户）

public class LinkMan {
    private Long lkm_id;
    private Character lkm_gender;
    private String lkm_name;
    private String lkm_phone;
    private String lkm_email;
    private String lkm_qq;
    private String lkm_mobile;
    private String lkm_memo;
    private String lkm_position;

    //表达多对一关系
    private Customer customer ;
    public Customer getCustomer() {
        return customer;
    }
    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
    public Long getLkm_id() {
        return lkm_id;
    }
    public void setLkm_id(Long lkm_id) {
        this.lkm_id = lkm_id;
    }
    public Character getLkm_gender() {
        return lkm_gender;
    }
    public void setLkm_gender(Character lkm_gender) {
        this.lkm_gender = lkm_gender;
    }
    public String getLkm_name() {
        return lkm_name;
    }
    public void setLkm_name(String lkm_name) {
        this.lkm_name = lkm_name;
    }
    public String getLkm_phone() {
        return lkm_phone;
    }
    public void setLkm_phone(String lkm_phone) {
        this.lkm_phone = lkm_phone;
    }
    public String getLkm_email() {
        return lkm_email;
    }
    public void setLkm_email(String lkm_email) {
        this.lkm_email = lkm_email;
    }
    public String getLkm_qq() {
        return lkm_qq;
    }
    public void setLkm_qq(String lkm_qq) {
        this.lkm_qq = lkm_qq;
    }
    public String getLkm_mobile() {
        return lkm_mobile;
    }
    public void setLkm_mobile(String lkm_mobile) {
        this.lkm_mobile = lkm_mobile;
    }
    public String getLkm_memo() {
        return lkm_memo;
    }
    public void setLkm_memo(String lkm_memo) {
        this.lkm_memo = lkm_memo;
    }
    public String getLkm_position() {
        return lkm_position;
    }
    public void setLkm_position(String lkm_position) {
        this.lkm_position = lkm_position;
    }
}

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 package="cn.pure.domain" >
    <class name="LinkMan" table="cst_linkman" >
        <id name="lkm_id"  >
            <generator class="native"></generator>
        </id>
        <property name="lkm_gender"  ></property>
        <property name="lkm_name"  ></property>
        <property name="lkm_phone"  ></property>
        <property name="lkm_email"  ></property>
        <property name="lkm_qq"  ></property>
        <property name="lkm_mobile"  ></property>
        <property name="lkm_memo"  ></property>
        <property name="lkm_position"  ></property>

        <!-- 多对一 -->
        <!-- 
            name属性:引用属性名
            column属性: 外键列名
            class属性: 与我关联的对象完整类名
         -->
        <many-to-one name="customer" column="lkm_cust_id" class="Customer" >
        </many-to-one>
    </class>
</hibernate-mapping>

将配置引入到 hibernate.cfg.xml 里

    <mapping resource="cn/pure/domain/Customer.hbm.xml" />
    <mapping resource="cn/pure/domain/LinkMan.hbm.xml" />
  • 保存联系人
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();
        // 1.创建客户
        Customer c = new Customer();
        c.setCust_name("我爱黎明");
        // 2. 创建联系人
        LinkMan lm1 = new LinkMan();
        lm1.setLkm_name("黎明111");
        LinkMan lm2 = new LinkMan();
        lm2.setLkm_name("黎明222");

        // 表达一对多，客户下面有多个联系人
        c.getLinkMens().add(lm1);
        c.getLinkMens().add(lm2);

        // 表达多对一,联系人属于哪个客户
        lm1.setCustomer(c);
        lm2.setCustomer(c);

        // 将对象转为持久化状态
        session.save(c);
        session.save(lm1);

        tx.commit();
        session.close();

结果如下：
这里写图片描述
这里写图片描述
- 为用户增加联系人

Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();
        // 1.获得客户对象
        Customer customer = session.get(Customer.class, 1l);
        // 2.创建联系人
        LinkMan lm1 = new LinkMan();
        lm1.setLkm_name("黎明333");
        // 3.将联系人添加到客户,将客户设置到联系人
        customer.getLinkMens().add(lm1);
        lm1.setCustomer(customer);
        // 4.执行保存
        session.save(customer);
        session.save(lm1);
        tx.commit();
        session.close();

结果如下
这里写图片描述
- 为客户删除联系人

        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();
        // 1.获得客户对象
        Customer customer = session.get(Customer.class, 1l);
        LinkMan lml = session.get(LinkMan.class, 3l);
        boolean remove = customer.getLinkMens().remove(lml);
        lml.setCustomer(null);
        tx.commit();
        session.close();

结果如下:
这里写图片描述
【操作进阶—级联操作】

级联操作:cascade
save-update: 级联保存更新
delete: 级联删除
all: save-update+delete
级联操作: 简化操作.目的就是为了少些两行代码.

级联保存
1.配置好 cascade=”save-update”

        session.save(customer);
        session.save(lm1);
=>简化
        session.save(customer);

级联删除
1.配置 cascate=”delete”

        // 1.创建客户
        Customer c = new Customer();
        c.setCust_name("张大佛爷");
        // 2. 创建联系人
        LinkMan lm1 = new LinkMan();
        lm1.setLkm_name("张大佛爷111");

        // 表达一对多，客户下面有多个联系人
        c.getLinkMens().add(lm1);

        // 表达多对一,联系人属于哪个客户
        lm1.setCustomer(c);

        // session.save(c); 这行代码可以去掉
        session.save(lm1);

cascate=”delete” <==> save-update+delete
【注意】建议使用 cascade=”save-update”，delete操作很危险

【操作进阶—inverse属性】

配置关系是否维护.
true: customer不维护关系
false(默认值): customer维护关系
inverse属性: 性能优化.提高关系维护的性能.
原则: 无论怎么放弃,总有一方必须要维护关系.
一对多关系中: 一的一方放弃.也只能一的一方放弃.多的一方不能放弃.

再回头看一下我们第一个操作保存客户下面的联系人控制台输出的打印

Hibernate: 
    insert 
    into
        cst_customer
        (cust_name, cust_source, cust_industry, cust_level, cust_linkman, cust_phone, cust_mobile) 
    values
        (?, ?, ?, ?, ?, ?, ?)
Hibernate: 
    insert 
    into
        cst_linkman
        (lkm_gender, lkm_name, lkm_phone, lkm_email, lkm_qq, lkm_mobile, lkm_memo, lkm_position, lkm_cust_id) 
    values
        (?, ?, ?, ?, ?, ?, ?, ?, ?)
Hibernate: 
    insert 
    into
        cst_linkman
        (lkm_gender, lkm_name, lkm_phone, lkm_email, lkm_qq, lkm_mobile, lkm_memo, lkm_position, lkm_cust_id) 
    values
        (?, ?, ?, ?, ?, ?, ?, ?, ?)
Hibernate: 
    update
        cst_linkman 
    set
        lkm_cust_id=? 
    where
        lkm_id=?
Hibernate: 
    update
        cst_linkman 
    set
        lkm_cust_id=? 
    where
        lkm_id=?

会发现有5句sql操作，其实我们只需要前面3句sql,就是因为默认关系都维护造成的，我们给Customer对象的配置加上 inverse=”true” 表示不维护，默认是维护的导致冗余的操作。
原则是: 1:n关系中，1的一方配置上 inverse=”true”。下面的代码就可以省略
c.getLinkMens().add(lm1);

m:n关系案例

【Role对象】

public class Role {
    private Long role_id;
    private String role_name;
    private String role_memo;
    //表达多对多
    private Set<User> users = new HashSet<User>();
    public Long getRole_id() {
        return role_id;
    }
    public void setRole_id(Long role_id) {
        this.role_id = role_id;
    }
    public String getRole_name() {
        return role_name;
    }
    public void setRole_name(String role_name) {
        this.role_name = role_name;
    }
    public String getRole_memo() {
        return role_memo;
    }
    public void setRole_memo(String role_memo) {
        this.role_memo = role_memo;
    }
    public Set<User> getUsers() {
        return users;
    }
    public void setUsers(Set<User> users) {
        this.users = users;
    }

}

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 package="cn.pure.domain" >
    <class name="Role" table="sys_role" >
        <id name="role_id"  >
            <generator class="native"></generator>
        </id>
        <property name="role_name"  ></property>
        <property name="role_memo"  ></property>

    <!-- 使用inverse属性
            true: 放弃维护外键关系
            false(默认值):维护关系

        结论: 将来在开发中,如果遇到多对多关系.一定要选择一方放弃维护关系.
             一般谁来放弃要看业务方向. 例如录入员工时,需要为员工指定所属角色.
             那么业务方向就是由员工维护角色. 角色不需要维护与员工关系.角色放弃维护
         -->        
        <set name="users" table="sys_user_role" inverse="true" >
            <key column="role_id" ></key>
            <many-to-many class="User" column="user_id" ></many-to-many>
        </set>
    </class>
</hibernate-mapping>

【User对象】

public class User {
    private Long user_id;
    private String user_code;
    private String user_name;
    private String user_password;
    private Character user_state;
    //表达多对多
    private Set<Role> roles = new HashSet<Role>();
    public Long getUser_id() {
        return user_id;
    }
    public void setUser_id(Long user_id) {
        this.user_id = user_id;
    }
    public String getUser_code() {
        return user_code;
    }
    public void setUser_code(String user_code) {
        this.user_code = user_code;
    }
    public String getUser_name() {
        return user_name;
    }
    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }
    public String getUser_password() {
        return user_password;
    }
    public void setUser_password(String user_password) {
        this.user_password = user_password;
    }
    public Character getUser_state() {
        return user_state;
    }
    public void setUser_state(Character user_state) {
        this.user_state = user_state;
    }
    public Set<Role> getRoles() {
        return roles;
    }
    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }

}

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 package="cn.pure.domain" >
    <class name="User" table="sys_user" >
        <id name="user_id"  >
            <generator class="native"></generator>
        </id>
        <property name="user_code"  ></property>
        <property name="user_name"  ></property>
        <property name="user_password"  ></property>
        <property name="user_state"  ></property>

        <!-- 多对多关系表达 -->
        <!-- 
            name: 集合属性名
            table: 配置中间表名
            key
             |-column:外键,别人引用"我"的外键列名
             class: 我与哪个类是多对多关系
             column:外键.我引用比人的外键列名
         -->
         <!-- cascade级联操作:
                    save-update: 级联保存更新
                    delete:级联删除
                    all:级联保存更新+级联删除
            结论: cascade简化代码书写.该属性使不使用无所谓. 建议要用只用save-update.
                 如果使用delete操作太过危险.尤其在多对多中.不建议使用.
                     -->
        <set name="roles" table="sys_user_role" cascade="save-update" >
            <key column="user_id" ></key>
            <many-to-many class="Role" column="role_id" ></many-to-many>
        </set>

    </class>
</hibernate-mapping>

操作关联属性

Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();

        User u1 = new User();
        User u2 = new User();
        u1.setUser_name("u1");
        u2.setUser_name("u2");

        Role r1 = new Role();
        Role r2 = new Role();
        r1.setRole_name("r1");
        r2.setRole_name("r2");

        // 用户关系表达
        u1.getRoles().add(r1);
        u1.getRoles().add(r2);
        u2.getRoles().add(r1);
        u2.getRoles().add(r2);

        //角色关系表达
//      r1.getUsers().add(u1);
//      r1.getUsers().add(u2);
//      r2.getUsers().add(u1);
//      r2.getUsers().add(u2);

        session.save(u1);
        session.save(u2);
        session.save(r1);
        session.save(r2);
        tx.commit();
        session.close();

inverse属性

使用inverse属性
true: 放弃维护外键关系
false(默认值):维护关系
结论: 将来在开发中,如果遇到多对多关系.一定要选择一方放弃维护关系.
一般谁来放弃要看业务方向. 例如录入员工时,需要为员工指定所属角色.
那么业务方向就是由员工维护角色. 角色不需要维护与员工关系.角色放弃维护

级联属性

cascade级联操作:
save-update: 级联保存更新
delete:级联删除
all:级联保存更新+级联删除
结论: cascade简化代码书写.该属性使不使用无所谓. 建议要用只用save-update.
如果使用delete操作太过危险.尤其在多对多中.不建议使用.

【总结】 inverse属性决定了维护关系，cascade只用save-update

张大佛爷__zhang
关注
专栏目录
Hibernate(多对多表操作)
10-09
Hibernate(多对多表操作)
hibernate多表操作
咖啡杯里的茶
04-03 212
数据库的表与表之间的关系 一对多关系 一对多关系的建表原则：在多的一方创建外键指向一的一方的主键 多对多关系 多对多关系的建表原则：多对多建表原则是，需要创建一个中间表，中间表至少需要两个字段，分别作为外键指向多对多双方的主键。 一对一关系 对于一对一关系一般来说是可以作为一个表来进行存储，除非是有特殊的需求需要用到两个表来存储的时候。如果一定要创建两个表，那么一对一关系可以使用两种方式来实现：...
hibernate 多对多表操作
weixin_43478300的博客
09-17 281
hibernate 多对多表操作 1.建立表（多对多关系） 建立法方法 1).建立两张表（两张表各自有各自对应主键即id） 2).建立中间表（包括两个字段，分别为已建立的两张表的主键，并将这个两个字段均设置成主键，这样就做到了联合主键的目的了。） 联合主键：两两之间的对应关系是唯一的。 3).两张表分别与中间表建立外键，从而达到两张表之间多对多的关系。 2.建立实体类和关系映射 1). 在d...
Hibernate(一对多表操作)
10-08
Hibernate(一对多表操作)
hibernate多表操作详解
wonabi的博客
09-08 344
一.简介 在进行关系型数据库设计时，表与表之间的关系往往不是独立的，而是相互关联的，这就是所谓的多表设计。一般来说，数据库表与表包含以下几种关系。 建表原则 一对一：主键对应，一方的主键作为另一方的主键。 一对多：在多的一方创建外键指向一的一方的主键 多对多：创建一个中间表，中间表的最少两个字段作为外键分别指向多对多双方的主键。 此种关系在hibernate中用Java对象
Java封装hibernate操作数据库.rar
最新发布
03-25
Hibernate是一个开源的Java库，它提供了对象-关系映射（ORM）功能，将Java类与数据库表进行映射，使得开发者可以使用面向对象的方式来处理数据库操作。这样不仅减少了SQL的编写，还降低了数据库依赖，提高了代码的...
javahibernate
07-27
5. 支持多种数据库：Hibernate对多种数据库（如MySQL、Oracle、PostgreSQL等）提供了很好的支持，只需更改配置即可切换数据库。 6. 查询语言：Hibernate Query Language (HQL) 是一种面向对象的查询语言，类似于SQL...
Hibernate单表操作实例解析
08-28
在这个实例中，我们将深入理解如何使用 Hibernate 对单表进行基本的操作，包括创建、读取、更新和删除（CRUD）记录。 ### 单一主键 在 Hibernate 中，每个实体类通常都有一个主键，用于唯一标识数据库中的记录。...
hibernate多表联合查询
05-11
hibernate多表联合查询实例,很经典的查询语句和总结.
hibernate代码优化基于配置的多表查询
08-16
博客对应代码
Java操作数据库方式三Hibernate的使用之多表操作
fightingXia的博客
07-07 506
##概述在开发中经常会遇到多表操作，Hibernate支持多表关联的操作。数据库表的关联关系分为三种：一对一，一对多，多对多，下面以“一对多”的栗子讲述Hibernate对多表的操作。##准备工作该博客继承上个博客，继续使用student表，再创建一个score表，student表与score是“一对多”的关系，即一个学生可以有多个分数。创建score表的sql语句如下：create table ...
Hibernate入门第十三讲——Hibernate中的多表查询
李阿昀的博客
04-23 4046
Hibernate中的多表操作在实际开发中，我们不可能只是简简单单地去操作单表，绝大部分都是要对多表进行操作的。所以本文就来讲述Hibernate中的多表操作，讲之前，先复习一下使用SQL语句是如何进行多表操作的。提示：本文所有案例代码的编写都是建立在前文Hibernate检索方式概述的案例基础之上的！！！SQL多表操作SQL多表操作可分为如下几类： 交叉连接(CROSS JOIN) 交叉连接其实
Hibernate超简单多表操作
weixin_33832340的博客
05-20 105
所谓一对多映射 在数据库中我们通常会通过添加外键的方式将表关联起来，表现一对多的关系。 而在Hibernate中，我们则要通过在一方持有多方的集合来实现，即在“一”的一端中使用元素表示持有“多”的一段的对象。 下面是针对这个知识点的一个小案例： Grade.java: import java.io.Serializab...
Hibernate 事务管理 多表操作
风继续吹
07-02 343
Hibernate事务管理： 我们在真正进行事务管理的时候，需要考虑事务的应用场景，也就是说我们的事务控制不应该是在DAO层实现的，应该在Service层实现的，并且在Service中调用多个DAO实现一个业务逻辑的操作。其实最主要的是如何保证在Service中开启事务时使用的Session对象和DAO中多个操作使用的是同一个Session对象。可以有两种方法实现： 在业务层获取到Session，并将Session作为参数传递给DAO 使用ThreadLocal将业务层获取的Session绑定到当前线
java hibernate 联合查询_hibernate实现多表联合查询
weixin_42685438的博客
02-16 1058
以前用sql实现联合查询 是非常简单的事，只需要写sql语句就可以，第一次遇到hibernate要实现多表联合查询的时候还楞了一下。最后看了下资料，才恍然大悟，hibernate实现多表联合查询跟SQL没多大差别。hibernate很多实现都是靠喜欢配关系，但是如果两张表，数据量都非常大的时候，并不合适配关系。例如：student表和score表需要做联合查询。1)sql: selects.id...
Java Hibernate多对多映射详解及实战代码示例
总结来说，Java Hibernate的多对多映射涉及实体之间的关联表配置、关联类的映射以及Java代码中对应集合的维护。理解并掌握这些概念对于在实际开发中处理复杂的数据关系至关重要。通过配置文件和代码的配合，我们可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值