关系映射annotation
Java中的注解(Annotation)

Java中的注解(Annotation)⽬录结构:contents structure [+]1.2.3.1.2.4.1.2.1.什么是注解⽤⼀个词就可以描述注解,那就是元数据,即⼀种描述数据的数据。
所以,可以说注解就是源代码的元数据。
⽐如,下⾯这段代码:@Overridepublic String toString() {return "This is String Representation of current object.";}上⾯的代码中,我重写了toString()⽅法并使⽤了@Override注解。
但是,即使我不使⽤@Override注解标记代码,程序也能够正常执⾏。
那么,该注解表⽰什么?这么写有什么好处吗?事实上,@Override告诉编译器这个⽅法是⼀个重写⽅法(描述⽅法的元数据),如果⽗类中不存在该⽅法,编译器便会报错,提⽰该⽅法没有重写⽗类中的⽅法。
如果我不⼩⼼拼写错误,例如将toString()写成了toStrring(){double r},⽽且我也没有使⽤@Override注解,那程序依然能编译运⾏。
但运⾏结果会和我期望的⼤不相同。
现在我们了解了什么是注解,并且使⽤注解有助于阅读程序。
Annotation是⼀种应⽤于类、⽅法、参数、变量、构造器及包声明中的特殊修饰符。
它是⼀种由JSR-175标准选择⽤来描述元数据的⼀种⼯具。
2.为什么要使⽤注解使⽤Annotation之前(甚⾄在使⽤之后),XML被⼴泛的应⽤于描述元数据。
不知何时开始⼀些应⽤开发⼈员和架构师发现XML的维护越来越糟糕了。
他们希望使⽤⼀些和代码紧耦合的东西,⽽不是像XML那样和代码是松耦合的(在某些情况下甚⾄是完全分离的)代码描述。
假如你想为应⽤设置很多的常量或参数,这种情况下,XML是⼀个很好的选择,因为它不会同特定的代码相连。
如果你想把某个⽅法声明为服务,那么使⽤Annotation会更好⼀些,因为这种情况下需要注解和⽅法紧密耦合起来,开发⼈员也必须认识到这点。
软件系统数据库设计中的对象关系映射(OR Mapping)设计

由于对象之间的关系反映了具体的商业规则,因此将对 象映射到关系数据库时,必须保证对象之间的关系。
(2)在关系数据库中实现关联关系的基本思路 在关系数据库中主要是通过使用外键来实现关联关系。外 键允许将表中的某一行与其它表中的行相关联。 实现一对一或一对多关系,仅仅需要在表中加入另一个表 的主键
在ORMapping技术中不仅要解决对象在纵向方面的继承关 系需要被映射至数据库,对象之间在横向的的关联关系也需 要映射至数据库
(2)对象之间的关系总的可以分为
继承(Inheritance) 关联(association) 依赖(Dependency) 聚集(aggregation) 组合(composition)
8、将整个类层次映射为单个数据库表的示例
(1)该方法的优点:实现简单并且支持多态--对象角色发生变 化,或存在多重角色时;报表操作实现简单,因为表中包含 了所有信息。 详细内容请见文档 (2)该方法的缺点 中的说明 增加类层次中的耦合,类层次中任何类的属性的增加会导 致表的变更 如果在某个子类属性的修改错误会影响到整个层次结构, 而不仅仅是该子类;同时也会浪费了大量的数据库空间。
12、各种关联关系的实现示例—请见文档 (1)“1对1”关联关系
(2)“1对多”关联关系
(3)“多对多”关联关 系
本讲的简要回顾
1、子曰:“学而不思则罔,思而不学则殆。” “学而时习之”
2、子曰:“知之者不如好之者,好之者不如乐之者”
3、子曰:“三人行,必有我师焉”
4、子曰:“我非生而知之者,好古,敏以求之者也”
9、每个具体子类映射成单个数据库表
(1)优点:报表操作实现简单,因为 表中包含了具体子类的所有信息。 (2)缺点 类的修改会导致相对应的表及其 子类所对应表的更改 角色的更改会造成 ID 的重新赋值 (因为不同子类的ID可能重复) 难以在支持多重角色时,保持数 据的完整性
Annotation入门

同时,annotation运行存在两种方式:运行时、编译时。
上文中讨论的都是在运行时的annotation应用,但在编译时的annotation应用还没有涉及,一、为什么使用Annotation:在JAVA应用中,我们常遇到一些需要使用模版代码。
例如,为了编写一个JAX-RPC web service,我们必须提供一对接口和实现作为模版代码。
如果使用annotation对远程访问的方法代码进行修饰的话,这个模版就能够使用工具自动生成。
另外,一些API需要使用与程序代码同时维护的附属文件。
例如,JavaBeans需要一个BeanInfo Class与一个Bean同时使用/维护,而EJB则同样需要一个部署描述符。
此时在程序中使用anno tation来维护这些附属文件的信息将十分便利而且减少了错误。
二、Annotation工作方式:在5.0 版之前的Java平台已经具有了一些ad hoc annotation 机制。
比如,使用transient修饰符来标识一个成员变量在序列化子系统中应被忽略。
而@deprecated这个javadoc tag也是一个ad h oc annotation用来说明一个方法已过时。
从Java5.0版发布以来,5. 0平台提供了一个正式的annotation功能:允许开发者定义、使用自己的annoatation类型。
此功能由一个定义annotation类型的语法和一个描述annotation声明的语法,读取annotaion 的API,一个使用annotation修饰的class文件,一个annotation处理工具(apt)组成。
annotation并不直接影响代码语义,但是它能够工作的方式被看作类似程序的工具或者类库,它会反过来对正在运行的程序语义有所影响。
annotation可以从源文件、class文件或者以在运行时反射的多种方式被读取。
当然annotation在某种程度上使javadoc tag更加完整。
hibernate关系映射总结

5.2.2.3、一对一主键关系映射(非延迟抓取) 配置 1(UserModel.hbm.xml) Java 代码 1. <one-to-one name="userGeneral" cascade="all"/>
配置 2(UserGeneralModel.hbm.xml) Java 代码 1. 2. 3. 4. 5. 6. 7. 8. 关联的对象所对应的数据库表之间,通过一个外键引用对主键进行约束。 <id name="uuid"> <generator class="foreign"> <param name="property">user</param> </generator> </id> <one-to-one name="user" class="erModel"/>
四、如何把数据库关系表示为面向对象中的关系: 1、关联:将数据库表之间的关系转化为对象之间的关系;在 Hibernate 中总指实体之间的关系。 2、映射:完成 java 对象到数据库表的双向转换。 3、级联(可选):将数据库中的级联转化为对象中的级联(两者(对象和数据库表)没关系)。 4、Hibernate 的表和对象的映射: 1、实体类型映射: 4.1.1、主键之间的映射
5.2.2、实体关联关系映射: 5.2.2.1、单向关联关系映射,不演示。 5.2.2.2、双向关联关系映射
Java 代码 1. 2. 3. 4. 5. 6. 单向 定义:不知道另一端什么情况,获取一端另一端自动获取,因为单向,你不知道另一侧是什么。 如 class A{ B b;} class B{ } 只能从 A 导航到 B,不能从 B 导航到 A 关系维护:另一端维护,如 B 维护
将对象映射到关系数据库

________________________________________
满江红翻译团队:
-5-
图 3. 在一个类图里包含"shadow 信息"
我还没有讨论的一种 shadow 信息是用一个 boolean 类型的标志来表示当前一个 对象是否存在于数据库中。这里的问题是当你把数据保存到一个关系型数据中, 如果原先的对象是从数据库中获取出来的,你需要使用一个 SQL update 语句来 保存数据,否则应该使用 SQL insert 语句。一个普通的解决方法是为每个类实 现一个 isPersistent 的 boolean 型信号标志(图 3 里没有显示),当数据是从 数据库里面读取的时候把它的值设置成 true,如果对象是新创建的话则设置为 false。
最简单的映射就是把一个属性映射到一个字段。当双方拥有一样的基本类型的时 候,这甚至可以变得更简单。例如,双方都是 date 类型,或者属性是 string 类型而字段是 char 型,或者属性是 number 类型而字段是 float 类型。
映射术语
映射 (动词). 指的是如何把对象和对象之间的关系持久化到永久存储设备(这在里是关系 型数据库)中的行为。
将对象映射到关系数据库:对象/ 关系映射(O/R Mapping)详解
大多数现代商业应用开发项目使用面向对象技术,比如采用Java或者C#来创建应 用软件,同时使用关系型数据库来存储数据。但这并不是要说你没有其它选择, 也有许多应用程序是使用面向过程的语言开发,比如COBOL,而且也有许多系统 使用对象型数据库或者XML数据库来存储数据。然而,因为面向对象和关系数据 库技术到目前为止已经成为一种事实上的标准,在本章节中我假设你正在使用这 些技术。如果你采用其它的存储技术,本文里的许多概念仍然适用,只需要做一 点点修改(不必担心,Realistic XML总括了对象与XML映射的相关问题)。
java getdeclaredannotation用法-概述说明以及解释

java getdeclaredannotation用法-概述说明以及解释1. 引言1.1 概述在Java编程语言中,注解(Annotation)是一种元数据(metadata)机制,它可以用来给程序中的元素(类、方法、字段等)添加额外的信息,以完成特定的行为或性质。
注解在Java领域中被广泛应用,比如在类的映射关系、测试框架、日志记录等方面。
其中,`getDeclaredAnnotation()`方法是Java反射机制中的一个重要方法,它被用于获取指定元素上的注解信息。
通过该方法,我们可以在运行时动态地获取类、方法、字段上的注解信息,从而灵活地进行处理和判断,满足不同的编程需求。
本文将详细介绍`getDeclaredAnnotation()`方法的使用方式和注意事项,帮助读者更好地理解和应用该方法。
1.2 文章结构本文分为三个部分:引言、正文和结论。
在引言部分,我们将对本文要探讨的主题进行概述,介绍getDeclaredAnnotation方法的作用和重要性,并说明本文的结构和目的。
在正文部分,我们将详细介绍getDeclaredAnnotation()方法的使用方式和用法。
首先,我们将对getDeclaredAnnotation()方法进行简单介绍,包括它的定义和功能。
然后,我们将通过具体的示例和代码演示,详细说明如何使用getDeclaredAnnotation()方法获取注解信息。
我们将讨论getDeclaredAnnotation()方法的参数和返回值,以及如何正确地使用它来获取注解的各种信息。
在结论部分,我们将对getDeclaredAnnotation()方法的用法进行总结,并指出一些可能存在的局限性。
我们将强调getDeclaredAnnotation()方法的重要性和灵活性,但也要提醒读者注意它的一些限制和使用注意事项。
我们希望通过本文的介绍,读者能够充分理解和掌握getDeclaredAnnotation()方法的用法,并能在实际开发中正确地应用它。
关系映射

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,这可以使得即使外键为空时仍可以向表中添加数据。
数据和对象的映射关系

数据和对象的映射关系1.引言1.1 概述数据和对象的映射关系是计算机科学领域的一个重要概念。
在计算机编程和数据库管理中,数据和对象的映射关系指的是将数据转化为对象,或将对象转化为数据的过程。
这种映射关系的存在使得我们能够更加灵活地处理数据,并且方便地对其进行操作和管理。
在计算机编程中,数据是指程序使用的输入、输出或中间结果等信息,而对象则是指程序中的实体,具有数据和对数据进行操作的方法。
数据和对象的映射关系可以将数据表示为对象的属性,从而使得我们能够更好地理解和操作这些数据。
同时,在面向对象编程中,对象的定义可以帮助我们创建和管理多个实例,从而提高了代码的重用性和可维护性。
在数据库管理中,数据和对象的映射关系变得尤为重要。
数据库是一种专门用于存储和管理数据的软件系统。
在数据库系统中,数据被组织成了一种结构化的形式,可以通过对象的方式来进行操作和管理。
通过数据和对象的映射关系,我们可以更加方便地对数据库中的数据进行增删改查操作,并且可以更好地利用数据库的功能进行数据分析和数据挖掘。
总的来说,数据和对象的映射关系在计算机科学领域发挥着重要的作用。
通过将数据表示为对象的属性或通过对象的方式来操作数据,我们能够更加方便地处理和管理数据,提高程序的可维护性和代码的重用性。
在数据库管理中,数据和对象的映射关系使得我们能够更加便捷地对数据进行操作和分析。
因此,深入理解和掌握数据和对象的映射关系对于计算机科学的研究和应用具有重要意义。
1.2 文章结构文章结构部分的内容应包括以下信息:文章结构的目的是为了向读者介绍整篇文章的组织结构,使读者能够清楚地了解文章的各个部分以及它们之间的关系。
本文主要分为三个部分:引言、正文和结论。
引言部分包括三个小节:概述、文章结构和目的。
在概述部分,我们将介绍数据和对象的映射关系的背景和重要性。
在文章结构部分,我们将详细介绍整篇文章的结构和各个部分的内容。
在目的部分,我们将阐述本文的主要目的和意义。
关系映射反演原则的应用

x 统),其中包含着待确定的原象 。令M表示一种映射
(一一对应法则),通过它的作用假定原象结构系统R
x 被映成映象关系结构R * ,其中自然包括未知原象 的映 x 象x * ,如果有办法把x * 确定下来, 则通过反演即送映
射I M1 也就相应地把 确定下来。
在原像 满f 足 f (0)的限0制下,映射D是一一对应,其反演
是
1:g D1gxg(t)d.t 0
因此S(x的) 反演便给出了原像表达式
x
S (x ) 0lo 1 g t)d (( t1 x )lo 1 g x ) x (.
RMI原则与几何问题
思想方法可用框图表示如下:
几何关系问题
课题目的 确定某种 几何关系
逆映射 1具有某种能行性,即能将目标原像的某 种所需要的性状经有限步确定下来者,则称该系 统为可解结构系统,简记为 (S,S*;).
数学手续——凡是由数值计算、代数计算、 解析计算(包括极限手续等)、逻辑演算以及数 学论证等步骤作成的形式过程。
对于给定的一个具有目标原像x的关系结
构 S,如果有这样的一个可逆映射 ,它 S将
RMI原则与尺规作图 例2、分析古希腊三大难题尺规作图的不可能性, 三大难题即作出长度 、 3的2 线段和把任意角三等 分。
所谓尺规作图法,按行数对应的解析几何观点来看,无 非是利用直线与直线相交、直线与圆周相交、圆与圆相交 等截取交点的几种基本方式来进行的。尺规作图数量是联
结任意两个有理点经过多次五则运算+、-、 、、表示
映成映像关系结构S * ,在中通过某种形式的有
限多步数学手续,能把目标映像 x*(x)的某
种所需要的性状确定下来的话,那么就称 为
多值映射关系-概述说明以及解释

多值映射关系-概述说明以及解释1.引言1.1 概述概述多值映射关系是指在一对多的关系中,一个元素在源集合中可以对应多个元素在目标集合中的情况。
在现实生活中,我们经常会遇到这样的情况,例如一个学生可能选择了多门课程,一个作家可能被多家出版社出版了多本书籍等等。
多值映射关系在各个领域中都有着广泛的应用,如数据库管理、图像处理、自然语言处理等。
本文将对多值映射关系的定义、概念、应用领域、特点和挑战进行深入的探讨。
首先,我们将介绍多值映射关系的基本概念和定义,以及与其他相关概念的区别和联系。
其次,我们将探究多值映射关系在不同领域中的应用,包括数据库管理中的关系型数据库设计、图像处理中的像素映射、自然语言处理中的词频统计等。
然后,我们将分析多值映射关系的特点,包括灵活性、可扩展性和复杂性等,并讨论多值映射关系带来的挑战,如数据冗余、一致性维护和查询效率等。
最后,我们将总结多值映射关系的重要性,并展望其未来的发展。
多值映射关系在现代信息技术发展中扮演着重要的角色,不仅为企业和个人提供了便利的数据管理和信息检索方式,还为科学研究和技术创新提供了有力支持。
然而,随着数据量的不断增加和应用场景的不断扩展,多值映射关系也面临着更多的挑战和问题。
未来,我们需要进一步研究和探索多值映射关系的新理论、新方法和新技术,以应对不断变化的需求和挑战。
在本文的结尾,我们将给出对多值映射关系的总结,并强调其在实际应用中的重要性。
多值映射关系的研究和应用将继续推动信息技术的发展和应用创新,为我们的生活和工作带来更多的便利和可能性。
通过深入研究多值映射关系的定义、概念、应用领域、特点和挑战,我们将更好地理解并应用这一重要概念,为相关领域的进一步发展做出贡献。
文章结构部分的内容如下:1.2 文章结构本文将按照以下结构进行展开讨论:1. 引言:首先介绍多值映射关系的概念和定义,以及本文的目的和意义。
2. 正文:2.1 多值映射关系的定义和概念:详细解释多值映射关系的概念,并介绍其在计算机科学和其他领域的相关研究成果。
hibernate annotation 双向 one-to-one 注解

环境:Hibernate 3.3.1Maven 3.0.4MySQL 5.5.13Myeclipse 8.6.1建表语句:DROP TABLE IF EXISTS `t_card`;CREATE TABLE `t_card` (`cardId` int(10) unsigned NOT NULL AUTO_INCREMENT,`cardNumber` char(18) NOT NULL,PRIMARY KEY (`cardId`)) ENGINE=InnoDB AUTO_INCREMENT=2DEFAULT CHARSET=gb2312; INSERT INTO `t_card` VALUES ('1', '440911************');DROP TABLE IF EXISTS `t_person`;CREATE TABLE `t_person` (`personId` int(10) unsigned NOT NULL AUTO_INCREMENT,`personName` varchar(15) NOT NULL,`cid` int(10) unsigned NOT NULL,PRIMARY KEY (`personId`)) ENGINE=InnoDB AUTO_INCREMENT=2DEFAULT CHARSET=gb2312; INSERT INTO `t_person` VALUES ('1', 'fancy', '1');Person.javapackage com.fancy.po;import javax.persistence.CascadeType;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;import javax.persistence.JoinColumn;import javax.persistence.OneToOne;import javax.persistence.Table;/*** -----------------------------------------* @文件: Person.java* @作者: fancy* @邮箱: fancyzero@* @时间: 2012-6-10* @描述: 实体类* -----------------------------------------*//*** @Entity 声明一个类为实体Bean* @Table(name = "xx")指定实体类映射的表,如果表名和实体类名一致,可以不指定*/@Entity@Table(name = "t_person")public class Person {private Integer personId;private String personName;private Card card;/*** @Id 映射主键属性,这里采用uuid的主键生成策略* @GeneratedValue ——注解声明了主键的生成策略。
hibernate关系映射注解配置

1. Hibernate Annotation关系映射有下面几种类型:1)一对一外键关联映射(单向)2)一对一外键关联映射(双向)3)一对一主键关联映射(不重要,有需要看下文档即可)在实际中很少用,使用注解@PrimaryKeyJoinColumn意思是说,我的主键去参考另外一张表中的主键,作为我的主键,但是在我测试使用注解一对一主键关联映射,在生成表的时候,数据库中并没有生成关联,使用XML映射可以生成。
Annotation注解一对一主键关联映,有些bug。
不过没空去研究它。
因为在实际开发中一对一很少用。
在实际开发中我机会没有用过,主键关联就更少了4)多对一关联映射(单向)5)一对多关联映射(单向)6)一对多关联映射(双向)7)多对多关联映射(单向)8)多对多关联映射(双向)2.介绍各种映射用法1)一对一外键关联映射(单向)Husband ---> Wifepublic class Husband{private Wife wife;@OneToOne(cascade=CascadeType.ALL)@JoinColumn(name="wife_id",unique=true)public Wife getWife(){…}…}public class Wife{}一对一外键关联,使用@OneToOne,并设置了级联操作@JoinColum设置了外键的名称为wife_id(数据库字段名),如果不设置,则默认为另一类的属性名+ _id外键的值是唯一的(unique),不可重复,与另一类的主键一致2)一对一外键关联映射(双向)Husband <---> Wifepublic class Husband{private Wife wife;@OneToOne(cascade=CascadeType.ALL)@JoinColumn(name="wife_id",unique=true)public Wife getWife(){…}...}public class Wife{private Husband husband;@OneToOne(mappedBy="wife",cascade=CascadeType.ALL)public Husband getHusband(){…}...}一对一双向关联关系,使用@OneToOne注意:需要加上mappedBy="wife",如果不加上的话,Wife也会生成一个外键(husband_id)。
映射关系——精选推荐

映射关系命名策略的例⼦public class MyNamingStrategy extends ImprovedNamingStrategy{public String classToTableName(String className){return StingHelper.unqualify(className).toUpperCase()+'S';}public String propertyToColumnName(String propertyName){return propertyName.toUpperCase();}public String tableName(String tableName){return tableName;}public String columnName(String columnName){return columnName;}public String propertyToTabTableName(String className, String propertyName){return classToTableName(classNmae)+'_'+propertyToColumnName(propertyName);}}设置类的包名<hibernate-mapping package="xxx"><class name="" >...</class></hibernate-mapping>把主键定义为⾃动增长标识符类型:auto-increment:⾃动递增(MySQL)identity(a,b):以a为起始,⾃动增加b个长度。
(MySQL)Sequence:创建⼀个单独的序列。
(Oracle)create sequence XX_ID_SEQ increment by 1 start with 1curval:返回序列的当前值nxtval:先增加序列值,然后返回增加后的序列值Hibernate允许在持久化类中把OID定义为以下整数类型:short:2个字节取值范围 -2^15~2^15-1int:4个字节取值范围 -2^31~2^31-1long:8个字节取值范围 -2^63~2^63-1为了持久化对象的OID的唯⼀性和不变形,通常由Hibernate或底层数据库来给OID赋值。
简述orm框架原理。

简述orm框架原理。
ORM(Object Relational Mapping)框架是一个实现了对象与关系数据库映射的工具,使得开发者能够使用面向对象的方式操作数据库,而不需要直接使用SQL语句。
ORM框架的原理是建立了对象模型和关系模型之间的映射关系,将面向对象的操作转换为对关系数据库的操作,从而简化了对数据库的操作。
ORM框架的主要原理是通过映射文件(Mapping File)或注解(Annotation)描述关系数据库中表与列的信息,并将它们转换为实体类与属性的信息。
ORM框架通过数据访问对象(DAO)将面向对象的操作映射为关系数据库中的操作,例如通过数据库连接(Connection)建立与数据库的连接,通过SQL语句执行数据库操作,获取ResultSet结果集等等。
ORM框架一般使用对象关系映射(Object Relational Mapping,ORM)技术建立对象与关系数据库之间的映射。
它首先以面向对象的方式描述关系数据库中的表和列,然后通过映射文件(Mapping File)或注解(Annotation)将它们转换为实体类与属性的信息。
通过这种方式,ORM框架将面向对象的操作转换为对关系数据库的操作,从而简化了对数据库的操作。
ORM框架的核心是ORM映射器(ORM Mapper),它是一个处理映射关系的组件,负责将实体对象映射到关系数据库中的表和列上,并且根据操作(CRUD)产生相应的SQL语句。
ORM框架一般有自己的语法、规则和数据类型,采用基于Class的方式操作数据,根据对象属性值的改变和触发条件执行自动SQL语句,包括生成INSERT、UPDATE、DELETE、SELECT等操作的SQL语句。
ORM框架通常支持的功能包括:1. 映射对象到表ORM框架将实体对象映射到关系数据库中的表和列上,从而实现面向对象的方式操作数据库。
2. 自动生成SQL语句ORM框架能够自动生成INSERT、UPDATE、DELETE、SELECT等操作的SQL语句,大大简化开发人员的工作。
6.关系映射(使用注解的方式表示)

6.关系映射(使⽤注解的⽅式表⽰)写在前⾯ 这⾥的关系是指:对象之间的关系,并不是数据库的关系 如:关系有单向和双向之分,但是在数据库中,单向关系和双向关系其实并没有什么区别, 这⾥的单双向指的是对象之间是否能够相互访问铁律: 1、凡是双向关联,必设mappedBy 因为根本都没必要在2个表中都存在⼀个外键关联,在数据库中只要定义⼀遍就可以了 mappedBy的意思就是“被映射”,即mappedBy这⽅不⽤管关联关系(即不⽣成外键字段),关联关系交给另⼀⽅处理 2、双向关系在程序中要设定双向关联存在以下关联关系 1.⼀对⼀ 有两种策略可以实现⼀对⼀的关联映射: 1.主键关联:即让两个对象具有相同的主键值,以表明它们之间的⼀⼀对应的关系; 数据库表不会有额外的字段来维护它们之间的关系,仅通过表的主键来关联 2.唯⼀外键关联:外键关联,本来是⽤于多对⼀的配置, 但是如果加上唯⼀的限制之后,也可以⽤来表⽰⼀对⼀关联关系 唯⼀外键关联(单向) @OneToOne 写在被引⽤对象的实体类中 @JoinColum 为数据库表中这个外键指定个字段名称1 @Entity2public class Husband {3private int id;4private String name;5private Wife wife;67 @OneToOne8 @JoinColumn(name="wifeID")9public Wife getWife() {10return wife;11 }12public void setWife(Wife wife) {13this.wife = wife;14 }15 @Id16 @GeneratedValue(strategy=GenerationType.AUTO)17public int getId() {18return id;19 }20public void setId(int id) {21this.id = id;22 }23public String getName() {24return name;25 }26public void setName(String name) { = name;28 }29 } 唯⼀外键关联(双向) mappedBy作⽤ 是指定这个⼀对⼀关联是被Husband类的 wife属性(准确说是getWife⽅法)做的映射 Wife这边不⽣成外键字段,⽽是交给 Husband去⽣成外键字段1 @Entity2public class Wife {3private int id;4private String name;5private Husband husband;6 @OneToOne(mappedBy="wife")7public Husband getHusband() {8return husband;9 }10public void setHusband(Husband husband) {11this.husband = husband;12 } 主键关联(单向) @PrimaryKeyJoinColumn 主键关联(双向) mappedBy 联合主键关联(参考的那张表的主键不唯⼀时会使⽤到) @JoinColumns 注解联合主键⼀对⼀联系,然后再使⽤@JoinColumn 来注解当前表中的外键字段名, 并指定关联哪个字段,使⽤referencedColumnName指定哪个字段的名称1 @OneToOne2 @JoinColumns(3 {4 @JoinColumn(name="wifeId", referencedColumnName="id"),5 @JoinColumn(name="wifeName", referencedColumnName="name")6 }7 )8public Wife getWife() {9return wife;10 } 2.多对⼀ @ManyToOne 3.⼀对多 @OneToMany 4.多对多 @ManyToMany1 @ManyToMany2 @JoinTable(name="t_s",3 joinColumns={@JoinColumn(name="teacher_id")}, //会⾃动参考teahcer的 ID4 inverseJoinColumns={@JoinColumn(name="student_id")} //会⾃动参考student的 ID5 )6public Set<Student> getStudents() {7return students;8 }9public void setStudents(Set<Student> students) {10this.students = students;11 }注:关联关系中的CRUD_Cascade_Fetch@OneToMany(mappedBy="group",cascade={CascadeType.ALL},fetch=FetchType.EAGER)1.设定cascade 可以设定在持久化时对于关联关系对象的操作(级联更新)(CUD ,R归Fetch管)2.cascade仅仅是帮助我们省了编程的⿇烦⽽已,不要把它的作⽤看的太⼤3.fetch(FetchType.EAGER,(会被关联⾃动查询出来)zy(不会⾃动关联查询出来,⽤到的时候才会去查询)) 如⽼师⾥⾯有学⽣集合,当⽼师被查询时,这个⽼师的学⽣集合被直接加载出来,不管是否学⽣有没有⽤到 EAGER 学⽣集合不会被直接加载,⽽是等到需要⽤到学⽣的时候,才会去加载学⽣集合 Lazy a) 铁律:双向不要两边设置Eager (会有多余的查询语句发出) b) 对多⽅设置fetch的时候要谨慎,结合具体应⽤,⼀般⽤Lazy 不⽤ eager, 特殊情况(多⽅数量不多的可以考虑,提⾼效率时可以考虑)4.如果想消除关联关系,先设定关系为null,再删除对应记录(如果不设定为null,就会级联删除), 如果不删除记录,该记录就变成垃圾数据 5.集合映射 1.Set 2.List a) @OrderBy("name ASC") //使⽤ @OrderBy注解List中使⽤哪个字段进⾏排序,可以组合排序,中间使⽤逗号分开 3.Map a) @MapKey(name="id") //注解使⽤哪个字段为key 6.继承关系(不重要) 使⽤@Inheritance 注解为继承映射,再使⽤strategy属性来指定继承映射的⽅式 strategy有三个值:InheritanceType.SINGLE_TABLE 单表继承 InheritanceType.TABLE_PER_CLASS 类表继承 InheritanceType.JOINED 具体表继承a)单表继承 SINGLE_TABLE把所有的属性都存储到⼀个表中,另外需要加⼊⼀个标识字段(表⽰哪个具体的⼦类)使⽤@DiscriminatorColumn 标识字段的字段名,及字段类型使⽤@DiscriminatorValue 来注解标识字段的值b)类表继承 TABLE_PER_CLASS每个具体类映射成⼀个表,⼦类之间的ID不能重复@TableGenerator来申明⼀个表主键⽣成策略@GeneratedValue(generator="t_gen", strategy=GenerationType.TABLE)来注解⽣成策略为表⽣成策略,并且指定表⽣成策略的名称c)具体表继承 JOINED每个类映射成⼀个表⽗类中包含了⼦类公共的⼀些字段,⽗类中⼀个ID对应⼀个⼦类只需要设置@Inheritance(strategy=InheritanceType.JOINED) 7.组件映射(值对象和实体对象) @Embeddable @Embedded //⽤于注解组件映射,表⽰嵌⼊对象的映射1 @Embedded2public Wife getWife() {3return wife;4 }5public void setWife(Wife wife) {6this.wife = wife;7 } /*Wife成了Husband的⼀部分,Wife中的这些字段,也会放到Husband中,Wife在这⾥只是⼀个对象,不需要任何注解*/。
hibernate注解处理映射关系

3 / 14
private int age; private ClassRoom room;
@ManyToOne(fetch=ZY) ---> ManyToOne 指定了多对一的关系,fetch=ZY 属性 表示在多的那一方通过延迟加载的方式加载对象(默认不是延迟加载)
return name; }
--->
指定了 OneToOne 的关联关系,mappedBy 同样指定由对方来进
5 / 14
public void setName(String name) {
= name; }
}
IDCard 类:
@Entity @Table(name="t_id_card") public class IDCard {
this.room = room; } @Id @GeneratedValue public int getId() {
return id; } public void setId(int id) {
this.id = id; } public String getName() {
return name; } public void setName(String name) {
@Entity @Table(name="t_person") public class Person {
private int id; private String name; private IDCard card;
@OneToOne(mappedBy="person") 行维护关联关系
关系映射表

(1)多对一的关联关系 (对象模型) Group User(能够识别group) 关系模型(2)一对多的关联关系(对象模型)Group (能够识别User) 关系模型 <key column ="group_id" ></key ><one-to-many class ="User"/></set >private Set users;(3)对于Group 来说是一对多,对于User 来说是多对一(对象模型) 关系模型 <key column ="group_id" ></key ><one-to-many class ="User"/></set >private Set users;<many-to-one name="group" column="group_id"/> private Group group;ExportDB.java一对一的关联关系(4)以主键为关联的一对一关联关系单向(对象模型)Person(能够识别IdCard) IdCard 关系模型<generator class="foreign"><param name="property">idCard</param></generator></id><property name="name"/><one-to-one name="idCard" constrained="true"/>private IdCard idCard;(5)以主键为关联的一对一关联关系双向(对象模型)关系模型<generator class="foreign"><param name="property">idCard</param></generator></id><property name="name"/><one-to-one name="idCard" constrained="true"/>private IdCard idCard;private Person person;<one-to-one name="person"/>(6)以外键为关联的一对一关联关系单向(对象模型)事实上多对一的一个特例<many-to-one name="idCard" column="idCard_id" unique="true"/> private IdCard idCard;(7)以外键为关联的一对一关联关系双向(对象模型)(8)多对多的关联关系(单向)user与role<key column="user_id"/><many-to-many class="Role" column="role_id"/> </set>private Set roles;(9)多对多的关联关系(双向)<set name="roles" table="t_user_role"><key column="user_id"/><many-to-many class="Role" column="role_id"/> </set>private Set roles;<set name="users" table="t_user_role"><key column="role_id"/><many-to-many class="User" column="user_id"/> </set>private Set users;继承映射(对象模型特有的)(10)关系模型:每棵继承树映射成一张表public class Pig extends Animal {private int weight;}public class Bird extends Animal {private int height;}extends.hbm.xml<class name="Animal" table="t_animal"lazy="false"> <id name="id"><generator class="native"/></id><discriminator column="type" type="string"/><property name="name"/><property name="sex"/><subclass name="Pig" discriminator-value="P"> <property name="weight"/></subclass><subclass name="Bird" discriminator-value="B"> <property name="height"/></subclass></class>(11)每个子类映射成一张表public class Pig extends Animal {private int weight;}public class Bird extends Animal {private int height;}extends.hbm.xml<joined-subclass name="Pig" table="t_pig"><key column="pid"/><property name="weight"/></joined-subclass><joined-subclass name="Bird" table="t_bird"><key column="bid"/><property name="height"/></joined-subclass>(12)类表继承。
数据表关联关系映射RelationshipMap

数据表关联关系映射RelationshipMap 数据表关联关系映射 Relationship Map在关系型数据库中,通常不会把所有数据都放在同⼀张表中,这样做会额外占⽤内存空间,在关系列数据库中通常⽤表关联来解决数据库。
⽤的表关联⽅式有三种: ⼀对⼀映射 如: ⼀个⾝份证对应⼀个⼈ ⼀对多映射 如: ⼀个班级可以有多个学⽣ 多对多映射 如: ⼀个学⽣可以报多个课程,⼀个课程可以有多个学⽣学习⼀⼀对⼀映射⼀对⼀是表⽰现实事物间存在的⼀对⼀的对应关系。
如:⼀个家庭只有⼀个户主,⼀个男⼈有⼀个妻⼦,⼀个⼈有⼀个唯⼀的指纹信息等1.语法:在关联的两个类中的任何⼀个类中:class A(model.Model):...class B(model.Model):属性 = models.OneToOneField(A)2.⽤法(1)创建作家和作家妻⼦类# file : xxxxxxxx/models.pyfrom django.db import modelsclass Author(models.Model):'''作家模型类'''name = models.CharField('作家', max_length=50)class Wife(models.Model):'''作家妻⼦模型类'''name = models.CharField("妻⼦", max_length=50)author = models.OneToOneField(Author) # 增加⼀对⼀属性(2)查询在 Wife 对象中,通过 author 属性找到对应的author对象在 Author 对象中,通过 wife 属性找到对应的wife对象(3)创始⼀对⼀的数据记录from . import modelsauthor1 = models.Author.objects.create(name='王⽼师')wife1 = models.Wife.objects.create(name='王夫⼈', author=author1) # 关联王⽼师author2 = models.Author.objects.create(name='张⽼师') # ⼀对⼀可以没有对应的数据(4)⼀对⼀数据的相互获取 1.正向查询 直接通过关联属性查询即可# 通过 wife 找 authorfrom . import modelswife = models.Wife.objects.get(name='王夫⼈')print(, '的⽼公是', ) 2.反向查询 通过反向引⽤属性查询 反向引⽤属性为实例对象,引⽤类名(⼩写),如作家的反向引⽤为作家对象.wife 当反向引⽤不存在时,则会触发异常# 通过 author.wife 引⽤属性找 wife,如果没有对应的wife刚触发异常author1 = models.Author.objects.get(name='王⽼师')print(, '的妻⼦是', )author2 = models.Author.objects.get(name='张⽼师')try:print(, '的妻⼦是', )except:print(, '还没有妻⼦')3.作⽤主要是解决常⽤数据不常⽤数据的存储问题,把经常加载的⼀个数据放在主表中,不常⽤数据放在另⼀个副表中,这样在访问主表数据时不需要加载副表中的数据以提⾼访问速度提⾼效率和节省内存空间,如经常把书的内容和书名建成两张表,因为在⽹站上经常访问书名等信息,但不需要得到书的内容。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
一对一(One-To-One)使用@OneToOne注解建立实体Bean之间的一对一关联。
一对一关联有三种情况:(1).关联的实体都共享同样的主键,(2).其中一个实体通过外键关联到另一个实体的主键(注意要模拟一对一关联必须在外键列上添加唯一约束),(3).通过关联表来保存两个实体之间的连接关系(要模拟一对一关联必须在每一个外键上添加唯一约束)。
1.共享主键的一对一关联映射:@Entity@Table(name="Test_Body")public class Body {private Integer id;private Heart heart;@Idpublic Integer getId() {return id;}public void setId(Integer id) {this.id = id;}@OneToOne@PrimaryKeyJoinColumnpublic Heart getHeart() {return heart;}public void setHeart(Heart heart) {this.heart = heart;}}@Entity@Table(name="Test_Heart")public class Heart {private Integer id;@Idpublic Integer getId() {return id;}public void setId(Integer id) {this.id = id;}}通过@PrimaryKeyJoinColumn批注定义了一对一关联2.使用外键进行实体一对一关联:@Entity@Table(name="Test_Trousers")public class Trousers {@Idpublic Integer id;@OneToOne@JoinColumn(name = "zip_id")public TrousersZip zip;}@Entity@Table(name="Test_TrousersZip")public class TrousersZip {@Idpublic Integer id;@OneToOne(mappedBy = "zip")public Trousers trousers;}上面的例子是指Trousers通过Trousers的外键列zip_id和TrousersZip关联,@JoinColumn批注定义了联接列,该批注和@Column批注有点类似,但是多了一个名为referencedColumnName的参数。
该参数定义了所关联目标实体中的联接列,注意,当referencedColumnName关联到非主键列的时候,关联的目标类必须实现Serializable,还要注意的是所映像的属性对应单个列(否则映射无效)一对一关联可能是双向的,在双向关联中,有且仅有一端作为主体(owner)端存在:主体端负责维护联接列(即更新),对于不需要维护这种关系的从表则通过mappedNy属性进行声明。
mappedBy的值指向主体的关联属性。
例子中,mappedBy的值为zip。
最后,不必也不能再在被关联端(ownedside)定义联接列了,因为已经在主体端声明了。
如果在主体没有声明@JoinColumn,系统自动进行处理:在主表(owner table)中将创建联接列,列名为:主体的关联属性名+下划线+被关联端的主键列名。
上面的例子中是zip_id,因为Trousers中的关联属性名为zip,TrousersZip的主键是id。
3.通过关联表定义一对一关联@Entity@Table(name="Test_People")public class People {@Idpublic Integer id;@OneToOne@JoinTable(name ="TestPeoplePassports",joinColumns=@JoinColumn(name="people_fk"),inverseJoinColumns=@JoinColumn(name="passport_fk"))public Passport passport;}@Entity@Table(name="Test_Passport")public class Passport {@Idpublic Integer id;@OneToOne(mappedBy = "passport")public People people;}People通过名为TestPeoplePassports的关联表和Passport关联。
该关联表拥有名为passport_fk的外键列,该外键指向Passport表,该信息定义为inverseJoinColoumns的属性值,而people_fk外键列指向People表,该信息定义为joinColumns的属性值。
这种关联可能是双向的,在双向关联中,有且仅有一端作为主体(owner)端存在:主体端负责维护联接列(即更新),对于不需要维护这种关系的从表则通过mappedNy属性进行声明。
mappedBy的值指向主体的关联属性。
例子中,mappedBy的值为passport。
最后,不必也不能再在被关联端(ownedside)定义联接列了,因为已经在主体端声明了。
以上是一对一关联的三种形式,下面介绍多对一关联。
多对一(Many-to-One)使用@ManyToOne批注来实现多对一关联。
@ManyToOne批注有一个名为targetEntity的参数,该参数定义了目标实体名,通常不需要定义该参数,因为在大部分情况下默认值 (表示关联关系的属性类型)就可以很好的满足需求了。
不过下面这种情况下这个参数就显得有意义了:使用接口作为返回值而不是常见的实体。
@ManyToOne(targetEntity=CompanyImpl.class)@JoinColoumn(name=”COPM_ID”)Public Company getCompany(){return company;}多对一的配置方式有两种:(1)通过@JoinColoumn映像(2)通过关联表的方式来映像(1) 通过@JoinColoumn映射SRD Framework中Company,Category例子:Company:@ManyToOne@JoinColumn(name = "CATEGORY_OPTION_ID")private Category category = null;Category:@DiscriminatorValue("Category")public class Category extends Option {}(2) 通过关联表映射通过@JoinTable批注定义关联表,该关联表包含了指回实体表的外键(通过@JoinTable.joinColoumns)以及指向目标实体表的外键(通过@JoinTable.inverseJoinColoumns)@Entity@Table(name="Test_TreeType")public class TreeType {private Integer id;private String name;private ForestType forestType;@ManyToOne(fetch = ZY)@JoinTable(name="Test_Tree_Forest",joinColumns = @JoinColumn(name="tree_id"),inverseJoinColumns = @JoinColumn(name="forest_id") )public ForestType getForestType() {// forestType的getter,setter方法必须在这里,否则会出错return forestType;}public void setForestType(ForestType forestType) {this.forestType = forestType;}@Id@GeneratedValuepublic Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}}@Entity@Table(name="Test_ForestType")public class ForestType {private Integer id;private String name;private Set<TreeType> trees;@OneToMany(mappedBy="forestType")public Set<TreeType> getTrees() {// trees的getter,setter方法必须在这里,否则会出错return trees;}public void setTrees(Set<TreeType> trees) {this.trees = trees;}@Id @GeneratedValuepublic Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}}一对多(One-to-Many)使用@OneToMany批注可定义一对多关联,一对多关联可以是双向关联。
在EJB3规范中多对一这端几乎总是双向关联中的主体(owner)端,而一对多这端关联批注为@OneToMany(mappedBy...)@EntityPublic class Troop{@OneToMany(mappedBy=”troop”)Public Set<Soldier> getSoldiers(){......}@EntityPublic class Soldier{@ManyToOne@JoinColumn(name=”troop_fk”)Public Troop getTroop(){......}Troop通过troop属性和Soldier建立一对多的双向关联,在mappedBy端不必也不能再定义任何物理映射。