Hibernate(6)—— 一对多和多对多关联关系映射(xml和注解)总结

合集下载

Hibernate关联关系注解配置简单理解

Hibernate关联关系注解配置简单理解

Hibernate关联关系注解配置简单理解Hibernate关联关系注解配置什么是关联关系?关联关系有哪⼏种?关联关系指实体之间的关系,也就是表与表之间的关系。

⼀个关系⽤两个属性来描述,数量性和⽅向性。

从数量上来看,表与表之间主要有三种关系,⼀对⼀,⼀对多,多对多。

加上关系的⽅向,还有⼀个多对⼀。

hibernate中关联关系的维护在实际的业务开发中,对于两个有关联的数据库实体,⽐如学⽣对教室,我们通常还需要在操作⼀⽅时,维护两⽅彼此之间的关系。

关系的维护分为两类:1.级联Cascade,在操作⼀⽅时,是否对另⼀⽅也执⾏同样的操作。

2.外键的维护inverse,在操作⼀⽅时,是否⾃动维护外键关系。

⽐如如果将多⽅的对象添加给以⼀的⼀⽅,因为外键由多⽅维护,hibernate 为了保证添加的这个多⽅对象的外键是正确的,会⾃动给这个多⽅的外键设置值(也就是⼀的⼀⽅的主键)外键维护,在xml配置中使⽤inverse属性,在注解中使⽤mappedBy注解来声明。

cascade与inverse1.cascade,指把对当前对象的操作级联到关联对象上。

⼀般在one to one ,one to many设置级联。

配置了这个属性后,当对当前对象执⾏如save等更新数据库的操作时,当前实体所关联的实体也会执⾏相应的操作。

2.inverse默认值为true, 表⽰让对⽅来维护关系。

设为false,⾃⼰维护关系。

inverse主要有两个作⽤:1)维护外键主控⽅保存时,是否⾃动update被控⽅的外键字段。

外键字段指向的就是当前保存的实体。

2)维护级联决定当前设置的级联是否有⽤,⾃⼰维护关系时,对⽅设置的级联就不会⽣效,对⽅保存时不会让本⽅也保存。

⽽对⽅维护关系,则与此相反。

@mappedBy注解1)mappedBy(name="对⽅标准代表当前实体的属性“)2)只存在于OneToOne,OneToMany,ManyToMany, 不能在ManyToOne中3)与joincolumn或jointable互斥。

Hibernate注解中CascadeType用法汇总

Hibernate注解中CascadeType用法汇总

Hibernate注解中CascadeType用法汇总在Hibernate中,CascadeType注解用来配置实体之间的级联操作。

级联操作是指在对一个实体进行持久化、更新、删除等操作时,同时也对关联的其他实体进行相应的操作。

CascadeType注解常用于一对一、一对多、多对多等关联关系中。

CascadeType注解的常用取值有以下几种:1. CascadeType.ALL:表示所有的级联操作,包括持久化、更新、删除等。

2. CascadeType.PERSIST:表示级联持久化操作,即当实体被持久化时,关联的其他实体也会被持久化。

3. CascadeType.MERGE:表示级联更新操作,即当实体被更新时,关联的其他实体也会被更新。

4. CascadeType.REMOVE:表示级联删除操作,即当实体被删除时,关联的其他实体也会被删除。

5. CascadeType.REFRESH:表示级联刷新操作,即当实体被刷新时,关联的其他实体也会被刷新。

6. CascadeType.DETACH:表示级联脱管操作,即当实体脱管时,关联的其他实体也会被脱管。

7. CascadeType.ALL_DELETE_ORPHAN:表示级联删除操作,并且会删除所有孤儿实体。

下面是对CascadeType注解的使用方法进行汇总:1.一对一关联关系:```private Address address;```上述代码表示当保存、更新或删除一个实体对象时,操作对应的address实体也会被保存、更新或删除。

2.一对多关联关系:```private List<Order> orders;```上述代码表示当保存、更新或删除一个用户对象时,操作对应的所有订单对象也会被保存、更新或删除。

3.多对多关联关系:```private List<Role> roles;```上述代码表示当保存、更新或删除一个用户对象时,操作对应的所有角色对象也会被保存、更新或删除。

07Mybatis的多表查询1----1对多和多对1---@Results注解用法总结

07Mybatis的多表查询1----1对多和多对1---@Results注解用法总结

07Mybatis的多表查询1----1对多和多对1---@Results注解⽤法总结1.表与表之间的关系及其举例表之间的关系有4种:⼀对多、多对⼀、⼀对⼀、多对多。

举例: (1)⽤户和订单就是⼀对多 ⼀个⽤户可以下多个订单 (2)订单和⽤户就是多对⼀ 多个订单属于同⼀个⽤户 (3)⼈和⾝份证号就是⼀对⼀ ⼀个⼈只能有⼀个⾝份证号 ⼀个⾝份证号只能属于⼀个⼈ (4)⽼师和学⽣之间就是多对多 ⼀个学⽣可以被多个⽼师教过 ⼀个⽼师可以交多个学⽣2.mybatis中的多表查询⽰例:⽤户和账户 ⼀个⽤户可以有多个账户 ⼀个账户只能属于⼀个⽤户(多个账户也可以属于同⼀个⽤户)步骤: 1、建⽴两张表:⽤户表,账户表 让⽤户表和账户表之间具备⼀对多的关系:需要使⽤外键在账户表中添加 2、建⽴两个实体类:⽤户实体类和账户实体类 让⽤户和账户的实体类能体现出来⼀对多的关系 3、建⽴两个配置⽂件 ⽤户的配置⽂件 账户的配置⽂件 4、实现配置: 当我们查询⽤户时,可以同时得到⽤户下所包含的账户信息 当我们查询账户时,可以同时得到账户的所属⽤户信息3.@Results注解⽤法总结:MyBatis中使⽤@Results注解来映射查询结果集到实体类属性。

(1)@Results的基本⽤法。

当数据库字段名与实体类对应的属性名不⼀致时,可以使⽤@Results映射来将其对应起来。

column为数据库字段名,porperty为实体类属性名,jdbcType为数据库字段数据类型,id为是否为主键。

@Select({"select id, name, class_id from my_student"})@Results({@Result(column="id", property="id", jdbcType=JdbcType.INTEGER, id=true),@Result(column="name", property="name", jdbcType=JdbcType.VARCHAR),@Result(column="class_id", property="classId", jdbcType=JdbcType.INTEGER)})List<Student> selectAll();如上所⽰的数据库字段名class_id与实体类属性名classId,就通过这种⽅式建⽴了映射关系。

hibernate核心,一对多,多对多映射讲解,看了就完全搞明白了

hibernate核心,一对多,多对多映射讲解,看了就完全搞明白了
• 增加山南区下属的三个街道:“和平路” 、“八一路”和“五四大道”
在many一方删除数据1
• 删除“五四大道”
inverse设为true,由many一方删除 从one一方去“删除”, Hibernate只是执行了 问题出在配置文件上 update语句。还是未删 没有配置set节点的inverse属性 除成功! 根本没有执行 Delete语句,数据 没有被删除!
– 配置Hibernate多对多关联,实现某OA系统项 目和人员对照关系的管理
本章目标
• 掌握单向many-to-one关联 • 掌握双向one-to-many关联 • 掌握many-to-many关联
实体间的关联
• 单向多对一
tblJd.getQx().getQxname();
• 单向一对多
TblJd jd = (TblJd)tblQx.getJds().get(0); jd.getJdname(); tblQx.getJds.add(jd);
小结
• 在租房系统中,房屋信息(Fwxx)与用户 (User)间也是多对一关系。如何配置映 射文件,使之可以通过下面的代码输出房 屋信息和发布该信息的用户名称? Fwxx fwxx = (Fwxx)super.get(Fwxx.class,1);
System.out.println( fwxx.getTitle() + "," + fwxx.getUser.getUname());
inverse是“反转”的意思,表示关联关系的控制权。 为true,表示由对方负责关联关系的添加和删除; 执行了delete语句, 为false,表示由自己负责维护关联关系。 删除成功
• 在many一方删除数据的正确做法:

Hibernate总结PPT教学课件

Hibernate总结PPT教学课件
Hibernate数据加载方式
1、即时加载 lazy=“false”; 2、延迟加载 lazy=“ture”; 特点:在需要使用时对数据进行加载,节约资源
HQL联表查询中fetch的使用 本地SQL查询
1、在实体映射文件中编写
2、在项目中进行调用
2020/12/11
9
第5章:Criteria查询
Hibernate学习总结
2020/12/11
1
第1章: Hibernate入门
数据持久化ORM 在项目中使用Hibernate
2020/12/11
2
数据持久化ORM
ORM(Object Relationship Mapping)
内存
Hibernate 项目
ORM
数据库
2020/12/11
3
2020/12/11
6
第3章: HQL实用技术
使用HQL语句的步骤:
1、得到Session 2、编写HQL语句 3、创建Query对象 4、执行查询
HQL中占位符的使用
1、使用‘?’占位符 为占位符设值 eq: query. setType(index,value); index从0开始 2、命名参数占位符 “:”后面必须为实体类的属性 设置值: QueryProperities qp = new QueryProperities();
Criteria查询
原理:根据实体类的类型进行查询 Criteria查询时条件设置:使用add()方法 1、 使用Restriction
Restriction. le(“实体类对象属性”,值) //小于 Restriction. ge(“实体类对象属性”,值) //大于 2、使用Example(将对象中不为空的属性作为条件) 将条件封装到实体对象,在使用该对象查询 Example. create(实体类对象);

hibernate最精细总结 java

hibernate最精细总结 java

Hibernate总结注:重点讲解关联映射总结人:张焕邮箱:zhang343489603@欢迎交流讨论。

目录1)核心接口简介2)Hibernate版本更新情况3)Hibernate关联映射4)简单属性查询5)Hibernate与延迟加载6)hibernate 中Criteria 的使用介绍7) Hibernate程序性能优化Hibernate优点:1、封装了jdbc,简化了很多重复性代码。

2、简化了DAO层编码工作,使开发更对象化了。

3、移植性好,支持各种数据库,如果换个数据库只要在配置文件中变换配置就可以了,不用改变hibernate代码。

4、支持透明持久化,因为hibernate操作的是纯粹的(pojo)java类,没有实现任何接口,没有侵入性。

所以说它是一个轻量级框架。

Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。

Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web 应用中使用,最具革命意义的是,Hibernate可以在应用EJB的J2EE架构中取代CMP,完成数据持久化的重任。

1)核心接口简介:Hibernate的核心接口一共有6个,分别为:Session、SessionFactory、Transaction、Query、Criteria和Configuration。

这6个核心接口在任何开发中都会用到。

通过这些接口,不仅可以对持久化对象进行存取,还能够进行事务控制。

下面对这6个核心接口分别加以介绍。

Session接口Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流,包含了很多常见的SQL语句。

)。

但需要注意的是Session对象是非线程安全的。

同时,Hibernate的session不同于JSP应用中的HttpSession。

13-Hibernate关联关系映射:一对多孤儿删除

13-Hibernate关联关系映射:一对多孤儿删除

13-Hibernate关联关系映射:⼀对多孤⼉删除persist和merge是JPA提供的内容none是不使⽤级联,save-update是保存和更新的时候级联hibernate级联的取值none:不使⽤级联save-update:保存和更新时级联delete:删除的时候级联all:delete-orphan:孤⼉删除,孤⼦删除*仅限于⼀对多,只有⼀对多的时候才有类似⽗⼦关系的存在,才有⽗⼦表的存在。

认为⼀的⼀⽅是⽗⽅。

因为⼀个⽗亲是可以有多个孩⼦的。

多的⼀⽅是⼦的⼀⽅。

*当⼀个客户与某个订单解除关系,其实就是将外键置为null,如果你的订单没有所属的客户,那你的订单还有意义吗?订单没有了所属客户,就相当于⼀个孩⼦没有了⽗亲,将这种记录就删除了,这就叫做孤⼉删除。

*但是这只有在⼀对多的情况下才存在。

多对多的情况哪有这种关系,多对多就是多个⽗亲多个⼉⼦,这就不合理了。

⼀的⼀⽅是⽗⽅,多的⼀⽅是⼦⽅。

All-delete-orphan:我们现在想让1号客户和1号订单解除关系:⼀个部门可以有多个员⼯,⼀个员⼯只能属于⼀个部门。

解除关系就是把外键置为空了,就是把外键置为null了。

Hibernate:selectcustomer0_.cid as cid0_0_,customer0_.cname as cname0_0_fromcustomer customer0_wherecustomer0_.cid=?Hibernate:selectorder0_.oid as oid1_0_,order0_.addr as addr1_0_,order0_.cno as cno1_0_fromorders order0_whereorder0_.oid=?Hibernate:selectorders0_.cno as cno0_1_,orders0_.oid as oid1_,orders0_.oid as oid1_0_,orders0_.addr as addr1_0_,orders0_.cno as cno1_0_fromorders orders0_whereorders0_.cno=?Hibernate:updateorderssetcno=nullwherecno=?这个时候我们再看客户和订单都还在。

关系映射

关系映射
单向关联Person----->IdCard
T_person --------------------------------------Id name --------------------------------------1 张三 2 李四 T_idCard --------------------------------------Id cardNo --------------------------------------1 1234567890 2 2345678901
One2One fk1
<class name="com.sinoest.hibernate.IdCard" table="t_idCard"> <id name="id"> <generator class="native"/> </id> <property name="cardNo"/> </class>
many2one
public class User { private int id; private String name; private String name; private Group group; public int getId() { return id; } …. } } public int getId() { return id; } public void setId(int id) { this.id = id; } …. Public class Group{ prlass Classes { private int id; private String name; private Set students; public int getId() { return id; } public void setId(int id) { this.id = id; } ……. public class Student { private int id; private String name; public int getId() { return id; } public void setId(int id) { this.id = id; }

一对多,多对一关系映射

一对多,多对一关系映射

⼀对多,多对⼀关系映射 ⼀对多,多对⼀关系映射 现实⽣活中有很多1对多(多对1)的关系模型。

⽐如,⼀个⼈可以有0到多套房⼦,0到多辆汽车;⼀个⽗亲有0到多个孩⼦等等。

这种关系被称作1对多关系。

反过来,房⼦与⼈,汽车与⼈的关系,以及孩⼦与⽗亲的关系就是多对⼀的关系。

这⾥需要注意⼀点的是,多对⼀关系的⼀个前提是:⼀套确定的房⼦只能属于某个确定的⼈(不能属于多⼈);⼀个确定的孩⼦也只能属于某个确定的⽗亲。

下⾯我们就拿最简单的⽗亲和孩⼦的关系来说明1对多(多对1)模型的映射。

关系模型:⽗亲 vs 孩⼦(Father vs Son)。

关系映射:one-to-many反过来,关系模型:孩⼦ vs ⽗亲(Son vs Father)。

关系映射:many-to-one 很多初学者往往有这样的疑问,我什么时候需要定义映射关系呢? 答案很简单:按需求来确定。

就是说你需要哪种关系的时候就定义哪种映射,不需要的时候就可以不定义它们的关系映射了。

还是以上⾯的例⼦来说明。

如果你需要在取得孩⼦(Son)的时候,同时需要知道该孩⼦的⽗亲(Father)是谁,你就可以在孩⼦的实体类⾥定义孩⼦跟⽗亲的关系映射: @ManyToOne 。

同样,如果需要知道某⽗亲的所有孩⼦,就可以在⽗亲的实体类⾥定义⽗亲跟孩⼦的关系映射: @OneToMany 。

1.ManyToOne(多对⼀) 单向:不产⽣中间表,但可以⽤@Joincolumn(name=" ")来指定⽣成外键的名字,外键在多的⼀⽅表中产⽣!2.OneToMany(⼀对多) 单向:会产⽣中间表,此时可以⽤@onetoMany @Joincolumn(name=" ")避免产⽣中间表,并且指定了外键的名字(别看 @joincolumn在⼀中写着,但它存在在多的那个表中)3.OneToMany ,ManyToOne 双向( 两个注解⼀起⽤的):如果不在 @OneToMany 中加mappedy属性就会产⽣中间表,此时通常在 @ManyToOne 的注解下再添上注解 @Joincolumn(name=" ") 来指定外键的名字(说明:多的⼀⽅为关系维护端,关系维护端负责外键记录的更新,关系被维护端没有权利更新外键记录)!( @OneToMany(mappedBy="⼀对多中,多中⼀的属性") 出现mapby为被维护端|||默认为延迟加载)⽤例:1 @ManyToOne(fetch=ZY)2 @JoinColumn(name="child_id")3private OrderChild orderChild;45 @OneToMany(mappedBy="orderChild",fetch=ZY,cascade={CascadeType.MERGE})6 @NotFound(action=NotFoundAction.IGNORE)//代表可以为空,允许为null7private List<OrderChildGoods> goodsList; hibernate中@ManyToOne默认是⽴即加载,@OneToMany默认是懒加载但是如果加上了@NotFound之后设置的fetch=ZY是不起作⽤的,也就是设置@NotFound后变为了⽴即加载eager 下⾯举例详细说明⼀下@ManyToOne  @ManyToOne注解的这端,是多端 1.在注释@ManyToOne(cascade=CascadeType.REFRESH,optional=true)中将属性optional设置为true,这可以使得即使外键为空时仍可以向表中添加数据。

javaee一对一,一对多,多对多的心得

javaee一对一,一对多,多对多的心得

JavaEE是一种用于开发企业级应用程序的技术评台,它构建在Java评台之上,提供了一系列的API和功能,从而使开发人员能够更加便利地构建出可靠、可扩展和安全的应用程序。

在JavaEE中,常见的关系模型有一对一、一对多和多对多,这三种关系模型在实际开发中具有重要的作用。

本文将深入探讨这三种关系模型在JavaEE中的应用,并结合实际开发经验,共享一些心得体会。

一、一对一关系1.1. 一对一关系概述在JavaEE中,一对一关系指的是两个实体之间的一对一映射关系,即一个实体实例只对应另一个实体实例。

这种关系模型在数据库设计和应用程序开发中经常会遇到,例如学生和唯一识别信息号码之间的关系就是一对一关系。

在JavaEE中,一对一关系通常通过OneToOne注解来进行表示。

1.2. 一对一关系的实际应用在实际开发中,一对一关系常常用于处理一些固定的关联关系,例如用户和用户详细信息、公司和公司详情等。

通过一对一关系的映射,可以方便地进行数据查询和管理,提高了系统的可维护性和可扩展性。

1.3. 一对一关系的心得体会在处理一对一关系时,需要注意合理设计数据库表结构和Entity对象之间的映射关系,避免出现冗余或不必要的数据。

还需要考虑数据查询的性能和效率,避免因为关联关系过多导致数据查询变慢。

一对一关系在JavaEE开发中具有重要的作用,需要合理使用和灵活运用。

二、一对多关系2.1. 一对多关系概述一对多关系指的是一个实体实例对应多个实体实例的关系模型,例如一个班级对应多个学生,一个订单对应多个商品等。

在JavaEE中,一对多关系通常通过OneToMany注解来进行表示。

2.2. 一对多关系的实际应用一对多关系在实际开发中非常常见,例如新闻和评论之间的关系、部门和员工之间的关系等。

通过一对多关系的映射,可以方便地进行数据操作和管理,提高了系统的灵活性和扩展性。

2.3. 一对多关系的心得体会在处理一对多关系时,需要注意数据的一致性和完整性,避免因为关联关系过于复杂而导致数据操作的困难和混乱。

java学习经验Hibernate总结

java学习经验Hibernate总结

Hibernate工作原理及为什么要用?一原理:1.读取并解析配置文件2.读取并解析映射信息,创建SessionFactory3.打开Sesssion4.创建事务Transaction5.持久化操作6.提交事务7.关闭Session。

8.关闭SessionFactory为什么要用:1. 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码。

2. Hibernate是一个基于JDBC的主流持久化框架,是一个优秀的ORM实现。

他很大程度的简化DAO层的编码工作3. hibernate使用Java反射机制,而不是字节码增强程序来实现透明性。

4. hibernate的性能非常好,因为它是个轻量级框架。

映射的灵活性很出色。

它支持各种关系数据库,从一对一到多对多的各种复杂关系。

二Hibernate 的核心接口及其作用1 Configuration类:配置Hibernate启动Hibernate创建SessionFactory对象2 SessionFactory:初始化Hibernate创建Session对象线程安全—同一实例被多个线程共享重量级:代表一个数据库内部维护一个连接池2.1 openSession():总是创建新的session,需要手动close()2.2 getCurrentSession() : 必须在hibernate.cfg.xml设置session 上下文事务自动提交并且自动关闭session.从上下文环境中获得session,如果当时环境中不存就创建新的.如果环境中存在就使用环境中的,而且每次得到的都是同一个session (在session提交之前,提交之后就是新的了) 应用在一个session中有多个不同DAO操作处于一个事务时3 Session:负责保存、更新、删除、加载和查询对象轻量级--可以经常创建或销毁3.1 Load与get方法的区别:简单理解:load是懒加载,get是立即加载.load方法当使用查出来的对象时并且session未关闭,才会向数据库发sql, get会立即向数据库发sql返回对象3.3 merge(); 合并对象更新前会先select 再更新3.4clear()清空缓存,flush()将session中的数据同步到数据库两者组合使用于批量数据处理3.4Transaction commit() rollback()JPA: java persistence API 提供了一组操作实体bean的注解和API规范SchemaExporthiberante的生成数据库表(及其他ddl)的工具类可以通过这个工具类完成一些ddl四Hibernate查询查询语言主要有:HQL 、QBC (Query By Criteria条件查询) 、 Native SQLHql:1、属性查询2、参数查询、命名参数查询3、关联查询4、分页查询5、统计函数五优化抓取策略连接抓取(Join fetching)使用 OUTER JOIN(外连接)来获得对象的关联实例或者关联集合查询抓取(Select fetching)另外发送一条 SELECT 语句抓取当前对象的关联实体或集合另外可以配置hibernate抓取数量限制批量抓取(Batch fetching)另外可以通过集合过滤来限制集合中的数据量使用session.createFilter(topic.getReplies(),queryString).list();检索策略延迟检索和立即检索(优先考虑延迟检索)N+1问题指hibernate在查询当前对象时查询相关联的对象查询一端时会查询关联的多端集合对象解决方案:延迟加载连接抓取策略二级缓存集合过滤 BatchSize限制记录数量映射建议使用双向一对多关联,不使用单向一对多灵活使用单向一对多关联不用一对一,用多对一取代配置对象缓存,不使用集合缓存一对多集合使用Bag,多对多集合使用Set继承类使用显式多态表字段要少,表关联不要怕多,有二级缓存撑腰Hibernbate缓存机制性能提升的主要手段Hibernate进行查询时总是先在缓存中进行查询,如缓存中没有所需数据才进行数据库的查询.Hibernbate缓存:一级缓存 (Session级别)二级缓存(SessionFactory级别)查询缓存 (基于二级缓存存储相同参数的sql查询结果集)一级缓存(session缓存)Session缓存可以理解为session中的一个map成员, key为OID ,value为持久化对象的引用在session关闭前,如果要获取记录,hiberntae先在session缓存中查找,找到后直接返回,缓存中没有才向数据库发送sql三种状态的区别在于:对象在内存、数据库、session缓存三者中是否有OID临时状态内存中的对象没有OID, 缓存中没有OID,数据库中也没有OID 执行new或delete()后持久化状态内存中的对象有OID, 缓存中有OID,数据库中有OIDsave() load() get() update() saveOrUpdate() Query对象返回的集合游离(脱管)状态内存中的对象有OID, 缓存中没有OID,数据库中可能有OIDflush() close()后使用session缓存涉及三个操作:1将数据放入缓存2从缓存中获取数据3缓存的数据清理4二级缓存SessionFactory级别SessionFactory级别的缓存,它允许多个Session间共享缓存一般需要使用第三方的缓存组件,如: Ehcache Oscache、JbossCache等二级缓存的工作原理:在执行各种条件查询时,如果所获得的结果集为实体对象的集合,那么就会把所有的数据对象根据OID放入到二级缓存中。

Hibernate注解

Hibernate注解

Hibernate注解常用的hibernate annotation标签如下:@Entity--注释声明该类为持久类。

@Table(name="promotion_info")--持久性映射的表(表名="promotion_info)。

@Column(name=”DESC”,nullable=false,length=512)--用于指定持久属性或字段的映射列。

@Id--注释可以表明哪种属性是该类中的独特标识符(即相当于数据表的主键)。

@GeneratedValue--定义自动增长的主键的生成策略。

@Transient--将忽略这些字段和属性,不用持久化到数据库。

@Temporal(TemporalType.TIMESTAMP)--声明时间格式。

@Enumerated--声明枚举@Version--声明添加对乐观锁定的支持@OneToOne--可以建立实体bean之间的一对一的关联@OneToMany--可以建立实体bean之间的一对多的关联@ManyToOne--可以建立实体bean之间的多对一的关联@ManyToMany--可以建立实体bean之间的多对多的关联@Formula--一个SQL表达式,这种属性是只读的,不在数据库生成属性(可以使用sum、average、max等)@OrderBy--Many端某个字段排序(List)下面是对以上常用Hibernate注解标签的详细介绍与举例:@Entity--注释声明该类为持久类。

将一个Javabean类声明为一个实体的数据库表映射类,最好实现序列化.此时,默认情况下,所有的类属性都为映射到数据表的持久性字段.若在类中,添加另外属性,而非映射来数据库的, 要用下面的Transient来注解.@Table(name="promotion_info")--持久性映射的表(表名="promotion_info).@T able是类一级的注解,定义在@Entity下,为实体bean映射表,目录和schema的名字,默认为实体bean的类名,不带包名.示例:@Entity@T able(name="CUST", schema="RECORDS")public class Customer { ... }@Column(name=”DESC”,nullable=false,length=512)--用于指定持久属性或字段的映射列。

Hibernate注释大全

Hibernate注释大全
inverseJoinColumns = @JoinColumn( name="monkey_id")
)
public Set<Monkey> getTrainedMonkeys() {
...
}
@Entity
public class Monkey {
... //no bidir
用 cascading 实现传播持久化(Transitive persistence)
cascade 属性接受值为 CascadeType 数组,其类型如下:
? CascadeType.PERSIST: cascades the persist (create) operation to associated entities persist() is called or if the entity is managed 如果一个实体是受管状态,或者当 persist() 函数被调用时,触发级联创建(create)操作。
@SecondaryTable(name="Cat2", uniqueConstraints={
@UniqueConstraint(columnNames={"storyPart2"})})
})
public class Cat implements Serializable {
...
}
public class MyDao {
doStuff() {
Query q = s.getNamedQuery("night.moreRecentThan");
q.setDate( "date", aMonthAgo );

Hibernate基础知识详解

Hibernate基础知识详解

Hibernate基础知识详解<hibernate-mapping><class name="*.*.*" table="t_customer" catalog="***"><id name="id" column="c_id"><generator class="identity"/></id><property name="name" column="c_name" length="20"/><set name="orders" inverse="false" cascade="save-update"><key column="c_customer_id"/></set></class></hibernate-mapping>(1)统⼀声明包名,这样在<class>中就不需要写类的全名。

(2)关于<class>标签配置name 属性:类的全名称table 表的名称,可以省略,这时表的名称就与类名⼀致catalog 属性:数据库名称可以省略.如果省略,参考核⼼配置⽂件中 url 路径中的库名称(3)关于<id>标签,<id>是⽤于建⽴类中的属性与表中的主键映射。

name 类中的属性名称column 表中的主键名称 column 它也可以省略,这时列名就与类中属性名称⼀致length 字段长度type 属性指定类型<generator>它主要是描述主键⽣成策略。

学习笔记-Mybatis(三)--XML方式的一对多,多对一,多对多关系

学习笔记-Mybatis(三)--XML方式的一对多,多对一,多对多关系

学习笔记-Mybatis(三)--XML⽅式的⼀对多,多对⼀,多对多关系1.⼀对多:(分类–产品)1、数据库建表,填数据。

2、新建⼀个普通的⼀个pojo Product实体类public class Product {private int id;private String name;private float price;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public float getPrice() {return price;}public void setPrice(float price) {this.price = price;}@Overridepublic String toString() {// TODO Auto-generated method stubreturn "Product [id=" + id + ",name=" + name + ",price=" + price;}}3.修改Category实体类在Category类中增加:List<Product> products;public List<Product> getProducts() {return products;}public void setProducts(List<Product> products) {this.products = products;}4.修改Category.xml通过left join关联查询,对Category和Product表进⾏关联查询。

Hibernate(V)——一对多与多对多关联关系映射(xml与注解)总结

Hibernate(V)——一对多与多对多关联关系映射(xml与注解)总结

Hibernate(V)——一对多与多对多关联关系映射(xml与注解)总结引言简要介绍Hibernate框架以及关联关系映射在数据库设计中的重要性。

Hibernate关联关系映射概述关联关系的重要性讨论在现实世界中对象间关系的重要性以及如何在数据库中表示这些关系。

Hibernate关联关系类型列举Hibernate支持的关联关系类型,包括一对一、一对多、多对一和多对多。

一对多关联关系映射概念解释解释一对多关联关系的概念,例如一个部门拥有多个员工。

XML映射方式详细描述如何在XML映射文件中配置一对多关联关系。

实体类定义展示一对多关系中实体类的Java代码示例。

XML映射文件提供一对多关系映射的XML配置示例。

注解映射方式详细描述如何使用注解配置一对多关联关系。

实体类定义展示使用注解的一对多关系中实体类的Java代码示例。

注解配置提供一对多关系映射的注解配置示例。

多对多关联关系映射概念解释解释多对多关联关系的概念,例如学生和课程之间的关联。

XML映射方式详细描述如何在XML映射文件中配置多对多关联关系。

实体类定义展示多对多关系中实体类的Java代码示例。

XML映射文件提供多对多关系映射的XML配置示例。

注解映射方式详细描述如何使用注解配置多对多关联关系。

实体类定义展示使用注解的多对多关系中实体类的Java代码示例。

注解配置提供多对多关系映射的注解配置示例。

关联关系映射的高级特性级联操作讨论级联保存、更新和删除的概念及其配置。

双向关系管理解释如何管理双向关联关系,确保数据的一致性。

延迟加载与即时加载讨论延迟加载和即时加载的概念及其在关联关系中的应用。

实践案例分析一对多关联关系案例通过一个具体的一对多关联关系案例,展示映射配置和数据操作。

多对多关联关系案例通过一个具体的多对多关联关系案例,展示映射配置和数据操作。

常见问题与解决方案一对多关联关系常见问题列举一对多关联关系映射中可能遇到的问题及其解决方案。

hibernate的manytoone和onetomany用例 -回复

hibernate的manytoone和onetomany用例 -回复

hibernate的manytoone和onetomany用例-回复Hibernate是一个Java的持久化框架,常用于开发数据访问层的代码。

它提供了一种简化数据库操作的方法,可以通过对象和关系数据库进行交互。

在Hibernate中,常用的关系映射包括many-to-one和one-to-many。

本文将通过详细讲解这两种关系映射的用例来帮助读者更好地理解和使用Hibernate。

首先,我们来了解一下many-to-one关系映射。

这种映射关系表示一个实体对象(通常是较"多"的一方)可以与另一个实体对象(通常是较"一"的一方)建立多对一的关系。

在关系数据库中,这种关系通过外键实现。

在Hibernate中,我们可以通过注解或XML配置来映射这种关系。

假设我们要建立一个简单的图书和作者的many-to-one关系映射。

一个作者可以写多本图书,而一本图书只能由一个作者所写。

我们先创建一个Author类和一个Book类。

Author类包含作者的姓名、年龄等属性,并与多个Book对象建立关联,通过"books"字段来表示与图书的关系。

Book 类包含图书的名字、出版日期等属性,并通过"author"字段与一个Author 对象建立关联,表示与作者的关系。

javapublic class Author {private Long id;private String name;private int age;private List<Book> books;省略getter和setter方法}public class Book {private Long id;private String name;private LocalDate publishDate;private Author author;省略getter和setter方法}在Author类中,我们可以使用OneToMany注解来建立与Book对象的关联,并通过设置cascade属性来实现级联操作。

Hibernate注解用法总结

Hibernate注解用法总结

1.类级别注解@Entity 映射实体类@Table 映射数句库表@Entity(name="tableName") - 必须,注解将一个类声明为一个实体bean。

属性:name - 可选,对应数据库中的一个表。

若表名与实体类名相同,则可以省略。

@Table(name="",catalog="",schema="") - 可选,通常和@Entity配合使用,只能标注在实体的class 定义处,表示实体对应的数据库表的信息。

属性:name - 可选,表示表的名称,默认地,表名和实体名称一致,只有在不一致的情况下才需要指定表名catalog - 可选,表示Catalog名称,默认为Catalog("").schema- 可选, 表示Schema 名称, 默认为Schema("").2.属性级别注解@Id 映射生成主键@Version 定义乐观锁@Column 映射表的列@Transient 定义暂态属性2.1 与主键相关注解@Id - 必须,定义了映射到数据库表的主键的属性,一个实体只能有一个属性被映射为主键,置于getXxxx() 前。

@GeneratedV alue(strategy=GenerationType,generator="") - 可选,用于定义主键生成策略。

属性:Strategy - 表示主键生成策略,取值有:GenerationType.AUTO- 根据底层数据库自动选择(默认),若数据库支持自动增长类型,则为自动增长。

GenerationType.I NDENTITY- 根据数据库的Identity字段生成,支持DB2、MySQL、MS、SQL Server、SyBase与HyperanoicSQL数据库的Identity类型主键。

GenerationType.SEQUENCE -使用Sequence来决定主键的取值,适合Oracle、DB2等支持Sequence的数据库,一般结合@SequenceGenerator使用。

hibernate注解简介

hibernate注解简介
在最近发布的几个Hibernate版本中,出现了一种基于 Java 5 注释的更为巧妙的新方法。借助新的 Hibernate Annotation 库,即可一次性地分配所有旧映射文件——一切都会按照您的想法来定义——注释直接嵌入到您的 Java 类中,并提供一种强大及灵活的方法来声明持久性映射。籍由自动代码完成和语法突出显示功能,最近发布的Java IDE也为其提供了有力的支持。
@Entity
@Table(name="T_MODEL_PLANE")
public class ModelPlane {
private Long id;
private String name;
@Id
@Column(name="PLANE_ID")
传统上,Hibernate的配置依赖于外部 XML 文件:数据库映射被定义为一组 XML 映射文件,并且在启动时进行加载。创建这些映射有很多方法,可以从已有数据库模式或Java类模型中自动创建,也可以手工创建。无论如何,您最终将获得大量的 Hibernate 映射文件。此外,还可以使用工具,通过javadoc样式的注释生成映射文件,尽管这样会给您的构建过程增加一个步骤。
...
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate</artifactId>
<version>3.2.1.ga</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>

java hibernate面试题

java hibernate面试题

java hibernate面试题1. 介绍Hibernate框架Hibernate是一个开源的对象关系映射(ORM)框架,用于在Java应用程序和数据库之间建立映射关系。

它提供了一种面向对象的编程模型,将Java对象与数据库表之间进行映射,从而使开发人员可以直接使用Java对象进行数据库操作。

Hibernate直接通过简单的配置,实现了对底层数据库的统一访问,大大简化了数据库操作代码。

2. Hibernate框架的特点和优势- 透明性: Hibernate隐藏了底层数据库的细节,使开发人员能够专注于业务逻辑而不用关心数据库操作。

- 高度可定制性: Hibernate提供了丰富的配置选项和灵活的映射策略,可以根据项目需求进行定制。

- 数据库无关性: Hibernate支持多种数据库,使用统一的API进行开发,使得应用程序可以无缝切换数据库。

- 缓存管理: Hibernate提供了缓存机制,可以提高应用程序的性能和扩展性。

- 对象关系映射: Hibernate将Java对象与数据库表之间建立映射关系,简化了数据库操作的代码编写。

- 事务管理: Hibernate支持事务管理,可以保证数据的一致性和完整性。

3. Hibernate中的持久化状态在Hibernate中,实体对象可以存在三种状态:瞬时态、持久态和脱管态。

- 瞬时态(Transient): 对象在内存中创建,但没有与会话关联。

对该对象进行更改不会影响数据库。

- 持久态(Persistent): 对象与会话关联,并且Hibernate会自动跟踪该对象的变化,并在事务提交时同步到数据库中。

- 脱管态(Detached): 对象与会话分离,再次与会话关联时需要手动进行合并或者更新操作。

4. Hibernate中的对象关系映射Hibernate通过注解或者XML文件来描述Java对象与数据库表之间的映射关系。

常用的映射关系有以下几种:- 一对一(One-to-one): 一个对象与另一个对象之间存在唯一对应关系。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

Hibernate(6)——一对多和多对多关联关系映射(xml和注解)总结涉及的知识点总结如下:∙One to Many 映射关系o多对一单向外键关联(XML/Annotation)o一对多单向外键关联(XML/Annotation)o懒加载和积极加载o一对多双向外键关联(XML/Annotation)∙Many to Many 映射关系o多对多单向外键关联(XML/Annotation)o多对多双向外键关联(XML/Annotation)o set的inverse元素详解∙问题小结∙关联关系的优缺点多对一单向外键关联关系注意多对一关联是多方持有一方的引用。

看一个例子,去淘宝购物,那么一个淘宝用户可以对应多个购物订单,如图所示:多的一方是Orders,持有一方的引用,也就是Users,而在Users中无需作任何定义,从订单到用户的关系是单向多对一关联。

对应数据库就是:还有比如说学生和班级的关系,多个学生可以属于同一个班级,这就是从学生到班级也是典型的单向多对一关系,看代码实现:基于注解的多对一单向外键关联:单向多对一关联中,多方需要持有一方的引用,那么多方(学生类)需要额外配置,需要对持有的一方引用使用注解@ManyToOne (cascade={CascadeType.ALL}, fetch=FetchType.EAGER),设置为级联操作和饥渴的抓取策略,@JoinColumn(name="cid"),而一方(教室类)无需做任何多方的定义。

注意;多方必须保留一个不带参数的构造器!importjavax.persistence.Entity;importjavax.persistence.GeneratedValue;importjavax.persistence.Id;//班级类,在多对一关系中属于一的方,不持有其他多余的配置,反而是被多方持有@Entitypublic class ClassRoom {private intcid;//班级编号private String cname;//班级名称// 自动增长的主键@Id@GeneratedValuepublicintgetCid() {returncid;}public void setCid(intcid) {this.cid = cid;}public String getCname() {returncname;}public void setCname(String cname) {ame = cname;}}View Code一方——班级类无需做多余的定义,下面是多方——学生实体和配置:importjavax.persistence.CascadeType;importjavax.persistence.Entity;importjavax.persistence.FetchType;importjavax.persistence.GeneratedValue;importjavax.persistence.Id;importjavax.persistence.JoinColumn;importjavax.persistence.ManyToOne;//学生实体类,属于多对一的多方,持有班级(一方)的引用@Entitypublic class Students {private intsid; //编号private String sname; //姓名private ClassRoom classroom;//学生班级//注意:多方一定要显式的定义不带参数的构造方法public Students() {}public Students(String sname){this.sname = sname;}// 多方使用注解:@ManyToOne// fetch=FetchType.EAGER,急加载,加载一个实体时,定义急加载的属性会立即从数据库中加载。

// 全部级联操作,referencedColumnName显式设置数据库字段名cid,不写默认就是和name一样的。

@ManyToOne (cascade={CascadeType.ALL}, fetch=FetchType.EAGER)@JoinColumn(name="cid",referencedColumnName="cid") publicClassRoomgetClassroom() {return classroom;}public void setClassroom(ClassRoom classroom) {this.classroom = classroom;}// 自动增长主键@Id@GeneratedValuepublicintgetSid() {returnsid;}public void setSid(intsid) {this.sid = sid;}public String getSname() {returnsname;}public void setSname(String sname) {this.sname = sname;}}View Code下面测试:先生成数据库脚本,再进行学生对象的插入public class TestStudentsByAnno {private static SessionFactorysessionFactory;@Beforepublic void setUp() throws Exception {System.out.println("setUp()...");sessionFactory = newAnnotationConfiguration().configure().buildSessionFactory(); }@Afterpublic void tearDown() throws Exception {System.out.println("tearDown()...");sessionFactory.close();}@Testpublic void testSave() {Session session = sessionFactory.getCurrentSession(); Transaction tx = session.beginTransaction();try {ClassRoom c = new ClassRoom();c.setCname("computer001");Students s = new Students("zhangsan");s.setClassroom(c);session.save(s);mit();} catch(Exception ex) {ex.printStackTrace();tx.rollback();}}@Test@Ignorepublic void testSchemaExport() {SchemaExport se = new SchemaExport(newAnnotationConfiguration().configure());se.create(true, true);}}View Code反向创建表的数据库脚本如下:create table ClassRoom (cid integer not null auto_increment, cnamevarchar(255), primary key (cid))create table Students (sid integer not null auto_increment, snamevarchar(255), cid integer, primary key (sid))插入一个学生对象,会自动生成如下语句:ClassRoom c = new ClassRoom();c.setCname("computer001");Students s = new Students("zhangsan");s.setClassroom(c);session.save(s);mit();View CodeHibernate: insert into ClassRoom (cname) values (?)Hibernate: insert into Students (cid, sname) values (?, ?)插入成功:基于xml配置实现多对一单向外键关联<hibernate-mapping><class name="net.nw.vo.fk.mto.ClassRoom" table="classroom"><id name="cid" column="cid" type="int"><generator class="native"/></id><property name="cname" column="cname" type="string"/></class></hibernate-mapping>View Code一方(教室类)无需做任何多方的定义。

只需要维护好自己的属性配置即可。

而多方只需要加上<many-to-one name="" column=“"/>就ok。

<hibernate-mapping><class name="net.nw.vo.fk.mto.Students" table="students"><id name="sid" column="sid" type="int"><generator class="native"/></id><property name="sname" column="sname" type="string"/><many-to-one name="classroom" column="cid"/></class></hibernate-mapping>View Codehibernate.cfg.xml里加上<mapping resource="net/nw/vo/fk/mto/ClassRoom.hbm.xml" /><mapping resource="net/nw/vo/fk/mto/Students.hbm.xml" />View Code注意:如果没有设置级联ALL,那么需要在保存的时候先保存班级,在保存学生,否则出错: object references an unsaved transient instance - save the transient instance before flushing:ClassRoomclassRoom = new ClassRoom();classRoom.setCname("CS");Students students = new Students("111");students.setClassroom(classRoom);session.save(classRoom);session.save(students);mit();View Code小结:使用<many-to-one>元素进行多对一关联关系配置,name属性指定类的属性名,column 属性指定库表字段名,class属性指定类属性类型(加上姓,即包名),not-null属性指定属性是否允许为空,cascade属性指定是否级联保存和更新:save-update、delete、all、none。

相关文档
最新文档