关系映射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、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 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端不必也不能再定义任何物理映射。