Hibernate 第十一讲 表关联关系操作（一）

最新推荐文章于 2021-11-24 00:31:54 发布
最新推荐文章于 2021-11-24 00:31:54 发布
阅读量614 收藏
点赞数
分类专栏： Hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zpf336/article/details/8670783
版权

package com.darren.relation.model;

 

import java.util.HashSet;

import java.util.Set;

import javax.persistence.CascadeType;

import javax.persistence.Entity;

import javax.persistence.FetchType;

import javax.persistence.GeneratedValue;

import javax.persistence.Id;

import javax.persistence.OneToMany;

import javax.persistence.Table;

 

 

@Entity

@Table(name="t_group")

public class Group {

 

    private int id;

    private Stringname;

    private Set<User>users = newHashSet<User>();

    // feteh对读有效

    //cascade 对增，删，改有效

    @OneToMany(mappedBy="group", cascade={CascadeType.ALL}, fetch=FetchType.EAGER)

   

    public Set<User> getUsers() {

        returnusers;

    }

 

    public void setUsers(Set<User> users) {

        this.users = users;

    }

 

    @Id

    @GeneratedValue

    public int getId() {

        returnid;

    }

 

    public void setId(int id) {

        this.id = id;

    }

 

    public String getName() {

        returnname;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

}

 



package com.darren.relation.model;

 

import javax.persistence.CascadeType;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.Id;

import javax.persistence.JoinColumn;

import javax.persistence.ManyToOne;

import javax.persistence.Table;

 

@Entity

@Table(name="t_user")

public class User {

    private int id;

    private Stringname;

    private Groupgroup;

   

 

    @ManyToOne(cascade={CascadeType.ALL})

    @JoinColumn(name="group_id_id")

    public Group getGroup() {

        returngroup;

    }

 

    public void setGroup(Group group) {

        this.group = group;

    }

 

    @Id

    @GeneratedValue

    public int getId() {

        returnid;

    }

 

    public void setId(int id) {

        this.id = id;

    }

 

    public String getName() {

        returnname;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

}

 




package com.darren.relation.model;

 

 

import java.util.HashSet;

import java.util.Set;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.hibernate.cfg.AnnotationConfiguration;

import org.hibernate.classic.Session;

import org.hibernate.tool.hbm2ddl.SchemaExport;

import org.junit.AfterClass;

import org.junit.BeforeClass;

import org.junit.Test;

 

public class ManyToOneTest {

    private static SessionFactory sessionFactory;

    @BeforeClass

    public static void beforeClass() {

        new SchemaExport(newAnnotationConfiguration().configure()).create(false,true);

        sessionFactory =newAnnotationConfiguration().configure().buildSessionFactory();

    }

 

    @AfterClass

    public static void afterClass() {

        sessionFactory.close();

    }

 

    @Test

    public void test1() {

        Session session = sessionFactory.getCurrentSession();

       Transaction transaction =  session.beginTransaction();

        User user = new User();

        user.setName("darren");

       

        Group group = new Group();

        group.setName("zhang");

       

        user.setGroup(group);

        session.save(group);

        session.save(user);

        transaction.commit();

        // 此时会把两张表全存进数据库，包括外键

       

    }

   

    @Test

    public void test2() {

        Session session = sessionFactory.getCurrentSession();

       Transaction transaction =  session.beginTransaction();

        User user = new User();

        user.setName("darren");

       

        Group group = new Group();

        group.setName("zhang");

       

        user.setGroup(group);

     //   session.save(group);

 

        session.save(user);

        transaction.commit();

        // 此时会报错，因为group对象没有被保存到数据库，当然前提是没有设置cascade条件

    }

 

    @Test

    public void test3() {

        Session session = sessionFactory.getCurrentSession();

       Transaction transaction =  session.beginTransaction();

        User user = new User();

        user.setName("darren");

       

        Group group = new Group();

        group.setName("zhang");

       

        user.setGroup(group);

     //   session.save(group);

 

        session.save(user);

        transaction.commit();

        // 此时不会报错，因为User中的@ManyToOne(cascade={CascadeType.ALL})设置了cascade级联条件

    }

   

   

    @Test

    public void test4() {

        Session session = sessionFactory.getCurrentSession();

       Transaction transaction =  session.beginTransaction();

       Set<User> users = newHashSet<User>();

        User user = new User();

        user.setName("darren");

   //     session.save(user);

        users.add(user);

       

        Group group = new Group();

        group.setName("zhang");

        group.setUsers(users);

        session.save(group);

 

       

        transaction.commit();

        // 此时只存了group，因为没有Group里有设置cascade，不会级联更新

    }

   

   

    @Test

    public void test5() {

        Session session = sessionFactory.getCurrentSession();

       Transaction transaction =  session.beginTransaction();

       Set<User> users = newHashSet<User>();

        User user = new User();

        user.setName("darren");

   //     session.save(user);

        users.add(user);

       

        Group group = new Group();

        group.setName("zhang");

        group.setUsers(users);

        session.save(group);

 

       

        transaction.commit();

        // 此时会存储User因为Group设置了 @OneToMany(mappedBy="group",cascade={CascadeType.ALL})

        // 但是不会存外键，因为Group里的mappedBy指向的是group，group被存在User中才会自动维护外键关系

        //而此时刚好相反，是Group里存了users，因此不会有外键

    }

   

    @Test

    public void test6() {

        Session session = sessionFactory.getCurrentSession();

       Transaction transaction =  session.beginTransaction();

       Set<User> users = newHashSet<User>();

        User user = new User();

        user.setName("darren");

   //     session.save(user);

        users.add(user);

       

        Group group = new Group();

        group.setName("zhang");

        group.setUsers(users);

        user.setGroup(group);//此时存储了外键，因为use里存了group

        session.save(group);

 

       

        transaction.commit();

    }

   

    @Test

    public void test7() {

        test6();

        Session session = sessionFactory.getCurrentSession();

       Transaction transaction =  session.beginTransaction();

       User user = (User)session.get(User.class, 1);

        transaction.commit();

        // 此时取User的时候会把group取出来，因为默认状态下，多方可以直接把一方取出来

    }

   

    @Test

    public void test8() {

        test6();

        Session session = sessionFactory.getCurrentSession();

       Transaction transaction =  session.beginTransaction();

       Group group = (Group)session.get(Group.class, 1);

        transaction.commit();

        // 此时取group的时候不会把user取出来，因为默认状态下，一方不可以直接把多方取出来

    }

   

    @Test

    public void test9() {

        test6();

        Session session = sessionFactory.getCurrentSession();

       Transaction transaction =  session.beginTransaction();

       Group group = (Group)session.get(Group.class, 1);

        transaction.commit();

        // 此时取group的时候会把user取出来，因为设置了@OneToMany(mappedBy="group", cascade={CascadeType.ALL},fetch=FetchType.EAGER)

        //fetch=FetchType.EAGER 会直接取出与其关联的数据

        // feteh 对读有效

        //cascade 对增，删，改有效


}


   

    @Test

    public void test10() {

        test6();

        Session session = sessionFactory.getCurrentSession();

       Transaction transaction =  session.beginTransaction();

       User user = (User)session.get(User.class, 1);

        transaction.commit();

        // 如果在user断设置了fetch=FetchType.LAZY @ManyToOne(cascade={CascadeType.ALL}, fetch=FetchType.LAZY)

//       那么就去不到group了

    }

   

    @Test

    public void test11() {

        test6();

        Session session = sessionFactory.getCurrentSession();

       Transaction transaction =  session.beginTransaction();

       User user = (User) session.get(User.class, 1);

       System.out.println(user.getGroup().getName());

        transaction.commit();

        // 如果在user断设置了fetch=FetchType.LAZY @ManyToOne(cascade={CascadeType.ALL}, fetch=FetchType.LAZY)

//       那么就去不到group了

       

//        这样的话可以通过调用一下group里的一个属性，就可以取到group了

//        user.getGroup().getName()

    }

   

    @Test

    public void test12() {

        test6();

        Session session = sessionFactory.getCurrentSession();

       Transaction transaction =  session.beginTransaction();

       User user = (User) session.get(User.class, 1);

 

        transaction.commit();

       

        System.out.println(user.getGroup().getName());

        // 如果在user断设置了fetch=FetchType.LAZY @ManyToOne(cascade={CascadeType.ALL}, fetch=FetchType.LAZY)

//       那么就去不到group了

       

//        这样的话可以通过调用一下group里的一个属性，就可以取到group了

//        user.getGroup().getName()

        

//        此时如果把System.out.println(user.getGroup().getName());放到了commit之后就会报错“懒加载”

//        因为此时的session已经关闭了

       

//        讲一下懒加载

//        在不是懒加载的时候取user的时候同时会把与之关联的group取出来放到内存里，这时不管session关闭与否，

//        都可以从内存中取出group

       

       

        

//        如果是懒加载取user的时候不会同时把与之关联的group取出来放到内存中，如果放到commit之后去取

//        先到内存中找，内存中没有，再到数据库中找，但是此时的session已经关闭了，和数据库没有关系了

//        所以就抛异常

//        如果是在commit之前去取，它又会把group取出来放到内存中，之后再在commit之后去用就不会报异常了

//        这就是解决懒加载的一种方法

       

       

    }

   

   

    @Test

    public void test13() {

        test6();

        Session session = sessionFactory.getCurrentSession();

       Transaction transaction =  session.beginTransaction();

       User user = (User) session.load(User.class, 1);

       System.out.println(user.getGroup().getName());

        transaction.commit();

       

//        此时的load和test12中的get一样效果，不同的就是get方法是立即发sql语句，调用group的时候再发一条

//        而load不同，load执行之后不会立即发sql语句，等到调用group的时候才会发，并且此时一次发两条

    }

}

 


 cascade类型


三 丰
关注
专栏目录
hibernate关联关系
安分_pingping
03-09 274
一、Hibernate关联关系 1 . 实体之间的关系 泛化关系 通过对象之间的继承来实现 关联关系 通过一个对象持有另一个对象的实现来实现 类与类之间最常见的关系就是关联关系 2 . 关联关系 一对多 多对一 多对多 一对一 二、多对一关系 1.数据库表 drop table if exists t_emp; drop table if exists t_dept...
hibernate关联关系的理解
iteye_16259的博客
03-14 96
Hibernate关联关系是学习的难点，理清思路在看相应的书籍，也就不难了。 1）Hibernate是ORM规范的一种实现。 2）ORM规范三个环节，O：对象，R：Relation，指关系数据库，M：Mapping，在Hibernate中用配置文件实现。 3）关联关系是在O对象的概念范畴说的，也就是要在面向对象思想来理解。如果认为是Relation数据库的联系，则在学习关联关系时就容易迷糊。...
Hibernate的多对多关联关系
一点一滴一昆仑
08-27 186
我们拿工程和员工这个例子来说，一个工程可以被多个员工去完成，一个员工也可以同时去完成多个工程我们先来看实体类： 首先是工程的实体类：package cn.itcast.c_many2many;import java.util.HashSet; import java.util.Set;/** * 项目 * * @author Jie.Yuan * */ public class Pr
Hibernate 第十讲 表关联关系（九）双向一对多
三丰的专栏
03-07 727
一：annotation配置方式 package com.darren.relation.model;   import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.JoinColumn;
Hibernate的三种映射关系（笔记）
nm_dzdd的专栏
01-13 272
 Object中的表现形式一对多与多对一Department                                Employee    long id                                         long id    String name                                   String name
Hibernate学习-7-关系映射（多对多）
浮夸的程序员
12-08 190
com.cx.entity.Developer package com.cx.entity; import java.util.HashSet; import java.util.Set; /** * Created by cxspace on 16-8-2. */ public class Developer { private int d_id;
Hibernate入门第一讲——Hibernate框架的快速入门
热门推荐
李阿昀的博客
08-04 12万+
Hibernate框架介绍什么是Hibernate我们可以从度娘上摘抄这样有关Hibernate的介绍： Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以
JavaEE第七次实验——Hibernate关联关系映射
qq_46015650的博客
11-24 596
实验七 Hibernate关联关系映射——登录用户的地址管理 一、基础实验——多对一/一对多关联 （一）实验目的 掌握 Hibernate 关联关系映射的基本概念，理解关联的方向和数量，重点理 解双向一对多/多对一的关联关系，及其在实际应用中的体现； 学习 Hibernate 框架处理一对多/多对一关联关系的方法，掌握关联关系中持 久化类的实现方法、以及相应 Hibernate 映射文件的配置方案； 能在实际应用中通过 Hibernate 建立正确的一对多/多对一关联关系映射，并 以面向对象的方式进行数据
Hibernate关联关系总结
lichuanyuelth的博客
10-20 410
概念          基本映射是对一个实体进行映射，关联映射就是处理多个实体之间的关系，将关联关系映射到数据库中，所谓的关联关系在对象模型中有一个或多个引用。   分类                                关联关系分为上述七种，但是由于相互之间有各种关系，可以简化，例如：多对一与一对多映射，只是侧重的角度不对而已。   映射技巧        
Hibernate关联关系映射目录
06-04
在一对多连接表单向关联中，一个实体（父实体）与多个实体（子实体）相关联，这种关联通过第三个表（连接表或关联表）来实现。 **表结构示例**: - **Department表**: - `departmentid`: 主键 - `departmentName`...
Hibernate入门第十讲——Hibernate的一对多关联映射
李阿昀的博客
04-13 1万+
Hibernate关联映射——一对多（多对一）我们以客户(Customer)与订单(Order)为例来讲解Hibernate关联映射中的一对多关联关系。 首先肯定是搭建好Hibernate的开发环境，我在此也不过多赘述，读者自行实践。接着在src目录下创建一个cn.itheima.oneToMany包，并在该包下创建两个实体类，如下： 客户类// 客户 ---- 一的一方 public class
Hibernate 第九讲 Hibernate的update, clear 和 flush方法
三丰的专栏
03-03 916
dynamic-update的使用方法：         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"         "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
Hibernate 第十讲 表关联关系（二）双向项一对一外键关联
三丰的专栏
03-05 736
一：annotation配置方式： package com.darren.relation.model;   import javax.persistence.Entity; importjavax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.OneToOne; @
Hibernate 第十讲 表关联关系（十）单向多对多
三丰的专栏
03-07 696
一：annotation配置方式 package com.darren.hibernate.model;   import java.util.HashSet; import java.util.Set;   import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax
Hibernate 第十讲 表关联关系（八）单向一对多
三丰的专栏
03-07 686
一：annotation 配置方式 package com.darren.relation.model;   import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.Table;
Hibernate 第十讲 表关联关系（三）单向项一对一主键关联
三丰的专栏
03-05 676
一：Annotation配置方式： package com.darren.relation.model;   import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; @Entity publicclass Wife {     p
Hibernate 第十讲 表关联关系（四）双向一对一主键关联
三丰的专栏
03-05 647
一：Annotation配置方式 package com.darren.relation.model;   import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.OneToOne; i
Hibernate 第十讲 表关联关系（十一）双向多对多
三丰的专栏
03-13 642
一，annotation配置方式 package com.darren.hibernate.model;   import java.util.HashSet; import java.util.Set; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.p
Hibernate多对一继承映射详解与示例
在精通Hibernate的映射继承关系系列教程的第六部分，主要探讨了如何处理在Java对象关系映射中，尤其是多对一（ManyToOne）多态关联的情况。当Company类和Employee类之间的关系为一对多多态，并且考虑到了继承关系树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值