hibernate继承映射| 耗时:0.215秒|14969条结果

Hibernate继承映射

【前言】     不知道大家是否还记得UML中的四种关系?自己回想了一下,还是没有忘记的,分别是继承、实现、依赖和关联。     怎么突然会想到这样一个问题?是因为在学习完Hibernate关联映射之后,紧接着又来了一个继承映射。关联和继承,都属于
http://www.itnose.net/detail/6649406.html 2016-10-01 17:19   [Hibernate]

(14)Hibernate继承映射

人们总是在失去时,才了解到事情的本质 需求:动物、猫、猴子 1、简单继承映射 Animal.java package com.rk.hibernate.n_inheritance1; public abstract class Animal
http://www.itnose.net/detail/6532225.html 2016-07-15 05:48   [Hibernate]

hibernate 继承映射(二)

每个子类映射成一张表: 每个具体类映射成一张表:
http://www.itnose.net/detail/6368720.html 2015-09-10 18:24   [Hibernate]

hibernate 继承映射(一)

每棵继承映射成一张表 测试代码: public void testSave1() {         Session session = null
http://www.itnose.net/detail/6368509.html 2015-09-10 16:51   [Hibernate]

JPA Hibernate 继承映射

 在面向对象的程序领域中,类与类之间是有继承关系的,例如Java世界中只需要extends关键字就可以确定这两个类的父子关系,但是在关系数据库中,有的知识关联关系。为了将继承映射到关系数据库中,Hibernate提供了3中方式  整个的继承体系就用一张表(single_table)注解
http://www.itnose.net/detail/6210216.html 2015-02-12 16:09   [Hibernate]

Hibernate 继承映射

的关系,并没有继承关系,不能说一张表继承另一张表,它们之间的关系只能是关联,那么如何将这种继承关系的表映射到我们的数据库当中呢?Hibernate提供了三种基本实现策略。 例如:有如下表继承结构体系:   一、  每棵类继承树基树一张表 该种方案,是将不同的种类动物都放在
http://www.itnose.net/detail/6139741.html 2014-10-29 19:13   [Hibernate]

hibernate 继承映射

对于面向对象的程序设计语言而言,继承和多态是两个最基本的概念。Hibernate继承映射可以理解持久化类之间的继承关系。例如:人和学生之间的关系。学生继承了人,可以认为学生是一个特殊的人,如果对人进行查询,学生的实例也将被得到。 Hibernate支持三种继承映射策略: 使用
http://www.itnose.net/detail/6052235.html 2014-06-01 15:02   [Hibernate]

hibernate继承映射

{ } hibernateTemplate保存S的实例时,只发送S里的属性,也就是说他没有帮我从F里的属性也保存进去,我的表中的字段是对应F和S里的所有属性的,我的F只是作为一个普通共用属性对象而已,请问怎么配置可以让他帮我连父类的属性也一起添加进去 回复讨论(解决方案) 问题已解决 在超类使用
http://www.itnose.net/detail/845379.html 2014-02-21 20:49   [J2EE]

hibernate 继承映射

有谁能帮忙解决一下吗, 回复讨论(解决方案) 分三种: 1。每个实体类一个映射表,比较简单,就是对应有几个数据表就有几个实体类; 2。每个类架构一个映射表,稍微麻烦点,    举例说明:继承User类的DefaultUser及PowerUser
http://www.itnose.net/detail/760958.html 2014-02-20 18:08   [JavaEclipse]

Hibernate 简化继承映射

概述 Hibernate 是一个纯 Java 的对象关系映射和持久性框架,它允许您用 XML 配置文件把普通 Java 对象映射到关系数据库表。使用 Hibernate 能够节约大量项目开发时间,因为整个 JDBC 层都由这个框架管理。这意味着您的应用程序的数据访问层位于 Hibernate 之上
http://www.itnose.net/detail/505771.html 2014-01-25 16:13   [Hibernate]

Hibernate继承映射

三种实现策略: ① 每棵继承映射成一张表 ② 每个子类映射成一张表 ③ 每个具体类映射成一张表    每棵继承映射成一张表  1、理解如何映射  因为类继承树肯定是对应多个类,要把多个类的信息存放在一张表中,必须有某种机制来区分哪些记录是属于哪个类的
http://www.itnose.net/detail/498829.html 2014-01-24 19:53   [Hibernate]

Hibernate(十)继承结构映射

Hibernate继承结构映射有三种实现方式: 使用一张表(映射文件名与超类相同) 每个类一张表(抽象类也对应表。每个表中只有当前类中的属性) 每个具体类对应一张表(抽象类不对应表。每个表中都有全部的信息,包括继承过来的信息) 这里以论坛帖子和回复为例。 使用一张表 超类
http://www.itnose.net/detail/6321995.html 2015-07-19 21:00   [Hibernate]

Hibernate继承映射-多态关联

address,16 null as EXPRESS_NUMBER,17 POSTCODE,18 PARCEL_NUMBER,19 null as EXPRESS_COMPANY,20 1 as clazz_ 21 from22 POST_DELIVERY 23 union24 select25 ID,26 phone,27 address,28 EXPRESS_NUMBER,29 POSTCODE,30 null as PARCEL_NUMBER,31 EXPRESS_COMPANY,32 2 as clazz_ 33 from34 EXPRESS_DELIVERY 35 ) delivery0_36 北京西街15号37 苏州通信大楼2F 可见Hibernate把两个子类对应的表的字段合并起来,执行效率低。建议用于父类将来不会修改且不需要多态查询的情况。 (3)父类子类各有一表,用外键关联,子类表的主键为外键引用父类表的主键 1 /*mysql*/ 2 create table delivery 3 ( 4 id int primary key auto_increment, 5 phone varchar(20), 6 address varchar(200) not null, 7 postcode varchar(20) 8 ); 9 create table post_delivery10 (11 id int primary key,12 parcel_number varchar(20),13 foreign key(id) references delivery(id)14 );15 16 create table express_delivery17 (18 id int primary key,19 express_company varchar(20),20 express_number varchar(20),21 foreign key(id) references delivery(id)22 ); 例子1:单独子类操作 1 PostDelivery pDelivery=new PostDelivery();2 pDelivery.setPhone("13526356485");3 pDelivery.setAddress("北京西街15号");4 pDelivery.setPostcode("100080");5 pDelivery.setParcelNumber("8578");6 session.save(pDelivery); 输出: 1 Hibernate: 2 insert 3 into 4 DELIVERY 5 (phone, address, POSTCODE) 6 values 7 (?, ?, ?) 8 Hibernate: 9 insert 10 into11 POST_DELIVERY12 (PARCEL_NUMBER, id) 13 values14 (?, ?) 例子2:多态查询 1 Hibernate: 2 select 3 delivery0_.ID as ID8_, 4 delivery0_.phone as phone8_, 5 delivery0_.address as address8_, 6 delivery0_.POSTCODE as POSTCODE8_, 7 delivery0_1_.PARCEL_NUMBER as PARCEL2_9_, 8 delivery0_2_.EXPRESS_COMPANY as EXPRESS2_10_, 9 delivery0_2_.EXPRESS_NUMBER as EXPRESS3_10_,10 case 11 when delivery0_1_.id is not null then 1 12 when delivery0_2_.id is not null then 2 13 when delivery0_.ID is not null then 0 14 end as clazz_ 15 from16 DELIVERY delivery0_ 17 left outer join18 POST_DELIVERY delivery0_1_ 19 on delivery0_.ID=delivery0_1_.id 20 left outer join21 EXPRESS_DELIVERY delivery0_2_ 22 on delivery0_.ID=delivery0_2_.id23 北京西街15号24 苏州通信大楼2F 符合数据模型的常规设计规则,类与表的映射匹配更合理。缺点是复杂的类继承下新增数据需要同时操作多个表,查询时通过多个表连接。适用于需要多态查询,同时子类相对来说有较多的新增属性。
http://www.itnose.net/detail/527499.html 2014-02-07 14:48   [Hibernate]

解读Hibernate继承映射策略

Hibernate继承映射的英文是Inheritance Mappings,Hibernate继承映射有三种策略,下文对Hibernate继承映射策略具体理解。 Hibernate继承映射的英文是Inheritance Mappings,Hibernate继承映射有三种策略,下文对Hibernate继承映射策略具体理解。Hibernate支持三种基本的继承映射策略: ◆每个类分层结构一张表(table per class hierarchy) ◆每个子类一张表(table per subclass) ◆每个具体类一张表(table per concrete class) 此外,Hibernate还支持第四种稍有不同的多态映射策略: 隐式多态(implicit polymorphism) 对于同一个继承层次内的不同分支,可以采用不同的映射策略,然后用隐式多 态来完成跨越整个层次的多态。但是在同一个<class>根元素 下,Hibernate不支持混合了元素<subclass>、 <joined-subclass>和<union-subclass> 的映射。在同一个<class>元素下,可以混合使用 “每个类分层结构一张表”(table per hierarchy) 和“每个子类一张表”(table per subclass) 这两种映射策略,这是通过结合元素<subclass>和 <join>来实现的(见后)。 1. 每个类分层结构一张表(Table per class hierarchy) 假设我们有接口Payment和它的几个实现类: CreditCardPayment, CashPayment, 和ChequePayment。则“每个类分层结构一张表”(Table per class hierarchy)的映射代码如下所示: <class name="Payment" table="PAYMENT">      <id name="id" type="long" column="PAYMENT_ID">          <generator class="native"/>      </id>      <discriminator column="PAYMENT_TYPE" type="string"/>      <property name="amount" column="AMOUNT"/>      ...       <subclass name="CreditCardPayment" discriminator-value="CREDIT">          <property name="creditCardType" column="CCTYPE"/>          ...       </subclass>      <subclass name="CashPayment" discriminator-value="CASH">          ...       </subclass>      <subclass name="ChequePayment" discriminator-value="CHEQUE">          ...       </subclass>  </class>  采用这种策略只需要一张表即可。它有一个很大的限制:要求那些由子类定义的字段, 如CCTYPE,不能有非空(NOT NULL)约束。 2. 每个子类一张表(Table per subclass) 对于上例中的几个类而言,采用“每个子类一张表”的映射策略,代码如下所示: <class name="Payment" table="PAYMENT">      <id name="id" type="long" column="PAYMENT_ID">          <generator class="native"/>      </id>      <property name="amount" column="AMOUNT"/>      ...       <joined-subclass name="CreditCardPayment" table="CREDIT_PAYMENT">          <key column="PAYMENT_ID"/>          ...       </joined-subclass>      <joined-subclass name="CashPayment" table="CASH_PAYMENT">          <key column="PAYMENT_ID"/>          <property name="creditCardType" column="CCTYPE"/>          ...       </joined-subclass>      <joined-subclass name="ChequePayment" table="CHEQUE_PAYMENT">          <key column="PAYMENT_ID"/>          ...       </joined-subclass>  </class>  需要四张表。三个子类表通过主键关联到超类表(因而关系模型实际上是一对一关联)。 3. 每个子类一张表(Table per subclass),使用辨别标志(Discriminator) 注意,对“每个子类一张表”的映射策略,Hibernate的实现不需要辨别字段,而其他 的对象/关系映射工具使用了一种不同于Hibernate的实现方法,该方法要求在超类 表中有一个类型辨别字段(type discriminator column)。Hibernate采用的方法更 难实现,但从关系(数据库)这点上来看,按理说它更正确。若你愿意使用带有辨别字 段的“每个子类一张表”的策略,你可以结合使用<subclass> 与<join>,如下所示: <class name="Payment" table="PAYMENT">      <id name="id" type="long" column="PAYMENT_ID">          <generator class="native"/>      </id>      <discriminator column="PAYMENT_TYPE" type="string"/>      <property name="amount" column="AMOUNT"/>      ...       <subclass name="CreditCardPayment" discriminator-value="CREDIT">          <join table="CREDIT_PAYMENT">              <property name="creditCardType" column="CCTYPE"/>              ...           </join>      </subclass>      <subclass name="CashPayment" discriminator-value="CASH">          <join table="CASH_PAYMENT">              ...           </join>      </subclass>      <subclass name="ChequePayment" discriminator-value="CHEQUE">          <join table="CHEQUE_PAYMENT" fetch="select">              ...           </join>      </subclass>  </class>  可选的声明fetch="select",是用来告诉Hibernate,在查询超类时, 不要使用外部连接(outer join)来抓取子类ChequePayment的数据。 4. 混合使用“每个类分层结构一张表”和“每个子类一张表” 你甚至可以采取如下方法混和使用“每个类分层结构一张表”和“每个子类一张表”这两种策略: <class name="Payment" table="PAYMENT">      <id name="id" type="long" column="PAYMENT_ID">          <generator class="native"/>      </id>      <discriminator column="PAYMENT_TYPE" type="string"/>      <property name="amount" column="AMOUNT"/>      ...       <subclass name="CreditCardPayment" discriminator-value="CREDIT">          <join table="CREDIT_PAYMENT">              <property name="creditCardType" column="CCTYPE"/>              ...           </join>      </subclass>      <subclass name="CashPayment" discriminator-value="CASH">          ...       </subclass>      <subclass name="ChequePayment" discriminator-value="CHEQUE">          ...       </subclass>  </class>  对上述任何一种映射策略而言,指向根类Payment的 关联是使用<many-to-one>进行映射的。 <many-to-one name="payment" column="PAYMENT_ID" class="Payment"/>  5. 每个具体类一张表(Table per concrete class) 对于“每个具体类一张表”的映射策略,可以采用两种方法。第一种方法是使用 <union-subclass>。 <class name="Payment">      <id name="id" type="long" column="PAYMENT_ID">          <generator class="sequence"/>      </id>      <property name="amount" column="AMOUNT"/>      ...       <union-subclass name="CreditCardPayment" table="CREDIT_PAYMENT">          <property name="creditCardType" column="CCTYPE"/>          ...       </union-subclass>      <union-subclass name="CashPayment" table="CASH_PAYMENT">          ...       </union-subclass>      <union-subclass name="ChequePayment" table="CHEQUE_PAYMENT">          ...       </union-subclass>  </class>  这里涉及三张表。每张表为对应类的所有属性(包括从超类继承的属性)定义相应字段。 这种方式的局限在于,如果一个属性在超类中做了映射,其字段名必须与所有子类 表中定义的相同。(我们可能会在Hibernate的后续发布版本中放宽此限制。) 不允许在联合子类(union subclass)的继承层次中使用标识生成器策略(identity generator strategy), 实际上, 主键的种子(primary key seed)不得不为同一继承层次中的全部被联合子类所共用. 6. Table per concrete class, using implicit polymorphism另一种可供选择的方法是采用隐式多态: <class name="CreditCardPayment" table="CREDIT_PAYMENT">      <id name="id" type="long" column="CREDIT_PAYMENT_ID">          <generator class="native"/>      </id>      <property name="amount" column="CREDIT_AMOUNT"/>      ...   </class>    <class name="CashPayment" table="CASH_PAYMENT">      <id name="id" type="long" column="CASH_PAYMENT_ID">          <generator class="native"/>      </id>      <property name="amount" column="CASH_AMOUNT"/>      ...   </class>    <class name="ChequePayment" table="CHEQUE_PAYMENT">      <id name="id" type="long" column="CHEQUE_PAYMENT_ID">          <generator class="native"/>      </id>      <property name="amount" column="CHEQUE_AMOUNT"/>      ...   </class>  注意,我们没有在任何地方明确的提及接口Payment。同时注意 Payment的属性在每个子类中都进行了映射。如果你想避免重复, 可以考虑使用XML实体(例如:位于DOCTYPE声明内的 [ <!ENTITY allproperties SYSTEM "allproperties.xml"> ] 和映射中的&allproperties;)。 这种方法的缺陷在于,在Hibernate执行多态查询时(polymorphic queries)无法生成带 UNION的SQL语句。 对于这种映射策略而言,通常用<any>来实现到 Payment的多态关联映射。 <any name="payment" meta-type="string" id-type="long">      <meta-value value="CREDIT" class="CreditCardPayment"/>      <meta-value value="CASH" class="CashPayment"/>      <meta-value value="CHEQUE" class="ChequePayment"/>      <column name="PAYMENT_CLASS"/>      <column name="PAYMENT_ID"/>  </any>  7. 隐式多态和其他继承映射混合使用 对这一映射还有一点需要注意。因为每个子类都在各自独立的元素<class> 中映射(并且Payment只是一个接口),每个子类可以很容易的成为另一 个继承体系中的一部分!(你仍然可以对接口Payment使用多态查询。) <class name="CreditCardPayment" table="CREDIT_PAYMENT">      <id name="id" type="long" column="CREDIT_PAYMENT_ID">          <generator class="native"/>      </id>      <discriminator column="CREDIT_CARD" type="string"/>      <property name="amount" column="CREDIT_AMOUNT"/>      ...       <subclass name="MasterCardPayment" discriminator-value="MDC"/>      <subclass name="VisaPayment" discriminator-value="VISA"/>  </class>    <class name="NonelectronicTransaction" table="NONELECTRONIC_TXN">      <id name="id" type="long" column="TXN_ID">          <generator class="native"/>      </id>      ...       <joined-subclass name="CashPayment" table="CASH_PAYMENT">          <key column="PAYMENT_ID"/>          <property name="amount" column="CASH_AMOUNT"/>          ...       </joined-subclass>      <joined-subclass name="ChequePayment" table="CHEQUE_PAYMENT">          <key column="PAYMENT_ID"/>          <property name="amount" column="CHEQUE_AMOUNT"/>          ...       </joined-subclass>  </class>  我们还是没有明确的提到Payment。 如果我们针对接口Payment执行查询 ??如from Payment?? Hibernate 自动返回CreditCardPayment(和它的子类,因为 它们也实现了接口Payment)、 CashPayment和Chequepayment的实例, 但不返回NonelectronicTransaction的实例。
http://www.itnose.net/detail/523357.html 2014-02-06 12:37   [Hibernate]

  1  2  3  4  5 下一页>