hibernate实现继承

最新推荐文章于 2018-11-07 23:29:58 发布
最新推荐文章于 2018-11-07 23:29:58 发布
阅读量1.4k 收藏 1
点赞数
文章标签： hibernate payment string null table class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wzff2154/article/details/1622693
版权

1.hibernate中子类继承的表实现
 三种策略:
 一个表:优点......需要多态,子类属性比较少的时候实用.
        缺点......有空字段.需要标志位.
 二张表:优点......没有多态时候,操作针对单表,不需要映射查询的时候很实用.简单易用.
        缺点......父类信息在子类分别体现,浪费.修改父类的时候子类信息所这被修改.
 三张表:优点......充分体现多态,修改的时候只需要修改一个表不需要修改其他的表. 
        缺点......复杂查询慢,维护难.
        一个类写一张表,需要多态,并且子类属性较多的时候实用.
2.三个类.
3.配置文件
  一种策略针对一个配置文件
  一张表:
   一个类里面有子类;每个子类后面需要标志位,来说明是那个子类.<subcalss/>
  二张表:
   父类信息在每一张表内.
   配置文件一个类.<union-class/>
  三张表:
   要关联的,用外键.
   配置文件一个类.<joined-subclass/>
                  一个额外的ID.
4.业务.
5.Hibernate的sql语句.
  select  from 类全名 别名 where 别名.类属性=:变量名
  updata  类全名 set 类属性=:变量名 where 属性名=:变量名
6.hibernate里的标签学习
  <set name="" inverse=""|控制权限
               cascade=""级联
                       -|none
                       -|save-updata
                       -|delete
                       -|all
                       -|persist
                       -|......                      
7.hibernate里面的隔离级别.
  1  读未提交的数据
  2  读已提交的数据
  4  可重复读
  8  可串行化
 <property name="hibernate.connection.isolation">1|2|4|8</property>
 引起的原因:并发事务
 解决的方法:加锁
            -|读锁
            -|         
           hibernate悲观锁,认为别人一定来读.行锁,表锁-效率低.
                    乐观锁,认为别人不会来读.-|加时间戳,检查来修改的人的时间戳是否一样,如果还没有释放则不让改.
                                                也有问题.                     
                                            -|默认字段,比较安全......        
8.下面看继承在hibernate里面的实现
在这例子里面实用的是建立三张表,这样对应三个类
实现基本的对对象操作作用到数据库的数据上.
在业务上有弊端,应注意.
  -|.1.首先建数据库
create database bank;
create table payment(
pid int primary key AUTO_INCREMENT,
name char(32) not null,
amount double not null
);
create table cardpayment(
currency char(16) not null,
pid int primary key,
constraint k foreign key(pid)  references payment(pid)
);
create table cashpayment(
pid int primary key,
bank varchar(32) not null,
owner varchar(64) not null,
constraint kk foreign key(pid) references payment(pid)
);
    -|.2.写出三个类
父类Payment.java
package com;
public class Payment {
   private int pid;
   private String name;
   private double amount;
   private CardPayment cardP;
   private CashPayment cashP;
public CardPayment getCardP() {
 return cardP;
}
public void setCardP(CardPayment cardP) {
 this.cardP = cardP;
}
public CashPayment getCashP() {
 return cashP;
}
public void setCashP(CashPayment cashP) {
 this.cashP = cashP;
}
public Payment(int pid, String name, double amount) {
 super();
 this.pid = pid;
 this.name = name;
 this.amount = amount;
}
public Payment() {
 super();

}
public double getAmount() {
 return amount;
}
public void setAmount(double amount) {
 this.amount = amount;
}
public String getName() {
 return name;
}
public void setName(String name) {
 this.name = name;
}
public int getPid() {
 return pid;
}
public void setPid(int pid) {
 this.pid = pid;
}
}
子类CardPayment.java
package com;
public class CardPayment extends Payment {
   private int pid;
   private String currency;
   private Payment p;
public Payment getP() {
 return p;
}
public void setP(Payment p) {
 this.p = p;
}
public String getCurrency() {
 return currency;
}
public void setCurrency(String currency) {
 this.currency = currency;
}
public int getPid() {
 return pid;
}
public void setPid(int pid) {
 this.pid = pid;
}
public CardPayment() {
   super();
}
public CardPayment(int pid, String currency) {
 super();
 this.pid = pid;
 this.currency = currency;
}
}
子类CashPayment.java
package com;
public class CashPayment extends Payment{
  private int pid;
  private String bank;
  private String owner;
public CashPayment() {
 super();
}
public CashPayment(int id, String bank, String owner) {
 super();
 this.pid = id;
 this.bank = bank;
 this.owner = owner;
}
public String getBank() {
 return bank;
}
public void setBank(String bank) {
 this.bank = bank;
}
public int getPid() {
 return pid;
}
public void setPid(int pid) {
 this.pid = pid;
}
public String getOwner() {
 return owner;
}
public void setOwner(String owner) {
 this.owner = owner;
}
}
   -|.3.几个实用类
Util.java
package util;
import org.hibernate.*;
import org.hibernate.cfg.Configuration;
public  class Util {
 static Configuration cfg=new Configuration().configure();
 static SessionFactory sf=cfg.buildSessionFactory();
 public static Session config(){
   
    Session s=sf.openSession();
    return s;
   }
  /* public static void clear(){
    sf.close();     
   }*/ 
}
一个接口
package util;
public interface UtilADO {
    public boolean insertCardPayment();//实现在卡上输入钱,在数据库里显示
    public boolean insertCashPayment();//实现在存着上输入钱,在数据库里显示
    public void query();//查询所有的内容
}
主要实现类
package util;
import java.util.*;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.*;
public class ManageUtilADO implements UtilADO{
 public boolean insertCardPayment() {
 /* Session s=Util.config();
  Transaction tr=s.beginTransaction();
  CardPayment cardP=new CardPayment();
  //CashPanyment cashP=new CashPanyment();
  cardP.setName("yutao");
  cardP.setAmount(10000);
  cardP.setCurrency("123");
  //p.setCardP(cardP);
   
  try {
   s.save(cardP);  
   tr.commit();
   return true;
  } catch (HibernateException e) {
   e.printStackTrace();
   return false;
  }*/
  return true;
  
 }
 public boolean insertCashPayment() {
  /*Session s=Util.config();
  Transaction tr=s.beginTransaction();
  //CardPanyment cardP=new CardPanyment();
  CashPayment cashP=new CashPayment();
  cashP.setName("yu");
  cashP.setAmount(10000);
  cashP.setBank("People");
  cashP.setOwner("tao");
  
  try {
   s.save(cashP);  
   tr.commit();
   return true;
  } catch (HibernateException e) {
   e.printStackTrace();
   return false;
  }*/
  return true;
 }
 public void query() {//查询出一张表的所有内容,相当与查询一个类里面的所有对象映射数据
  Session s=Util.config();
  Transaction tr=s.beginTransaction();
  Query q=s.createQuery("from Payment");
  Iterator i = q.list().iterator();
  System.out.println("打印出总表信息");
  System.out.println("ID" + "/t" + "Name" + "/t" + "Amount");
  while(i.hasNext()){
   Payment p = (Payment)i.next();
   System.out.println(""+ p.getPid() + "/t"
     + p.getName() + "/t"
     + p.getAmount() + "/t"
     );
  }
  tr.commit();
 }
 public void quaryCard(){  
  Session s=Util.config();
  Transaction tr=s.beginTransaction();
  Query cardP=s.createQuery("from CardPayment");
    Iterator i=cardP.list().iterator();
    System.out.println("打印出card信息");
    System.out.println("PID"+"/t"+"name"+"/t"+"amount"+"/t"+"current");
    while(i.hasNext()){
     CardPayment cp=(CardPayment)i.next();
          System.out.println(""+ cp.getPid() + "/t"
      + cp.getName() + "/t"
      + cp.getAmount() + "/t"
      +cp.getCurrency()
      );
    }
    tr.commit();
  }
 public void quaryCard(String name){  
  Session s=Util.config();
  Transaction tr=s.beginTransaction();
  Query cardP=s.createQuery("from CardPayment cp where cp.name='"+name+"'");
    Iterator i=cardP.list().iterator();
    System.out.println("按条件查询打印出card信息");
    System.out.println("PID"+"/t"+"name"+"/t"+"amount"+"/t"+"current");
    while(i.hasNext()){
     CardPayment cp=(CardPayment)i.next();
          System.out.println(""+ cp.getPid() + "/t"
      + cp.getName() + "/t"
      + cp.getAmount() + "/t"
      +cp.getCurrency()
      );
    }
    tr.commit();
  }
}
   -|.4.main函数类
package cn;
import util.*;
public class Manage {
    public static void main(String[] args) {
  boolean b;
  ManageUtilADO m=new ManageUtilADO();
  b=m.insertCardPayment();
  if(b){
   System.out.println("成功");
  }else{
   System.out.println("失败");
  }//实现对子类card的操作,及插入数据,同时实现了对父类的操作,把相关数据插入到父类对应的表里面
  ManageUtilADO m1=new ManageUtilADO();
  b=m1.insertCashPayment();
  if(b){
   System.out.println("成功");
  }else{
   System.out.println("失败");
  }
  //m.query();
  m.quaryCard();
  m.quaryCard("yutao");
}  
}
 -|.5.配置文件
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com">
 <class name="Payment" table="PAYMENT">
  <id name="pid" unsaved-value="null">
   <generator class="native">
     <!--<param name="table">pk_table</param>
     <param name="column">id_value</param>
    --></generator>
  </id>
  <property name="name"></property>
  <property name="amount"></property>
  <joined-subclass name="CardPayment" table="CARDPAYMENT">
   <key column="pid"/>
   <property name="currency"></property>
  </joined-subclass>
  <joined-subclass name="CashPayment" table="CASHPAYMENT">
   <key column="pid"/>
   <property name="owner"/>
   <property name="bank"></property>
  </joined-subclass>
  
 </class>
</hibernate-mapping>
............................
         注意
............................
写这些的目的是要今后用到时不会找不到参考.
以上代码均能够实现,希望今后再看的时候感觉不同.
.......yu........
    一张表策略
create table payment_hierarchy(
 id int primary key,
 name varchar(32) not null,
 amount double not null,
 currency varchar(16),
 owner varchar(64),
 bank varchar(32),
 payment_type varchar(16)
);                                             
关键在这里配置文件:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="inheritance">
 <class name="Payment" table="PAYMENT_HIERARCHY">
  <id name="id" unsaved-value="null">
   <generator class="hilo">
     <param name="table">pk_table</param>
     <param name="column">id_value</param>
    </generator>
  </id>
  <discriminator column="payment_type" type="string"></discriminator>
  <property name="name"></property>
  <property name="amount"></property>
  <subclass name="CashPayment" discriminator-value="cash">
   <property name="currency"></property>
  </subclass>
  <subclass name="CardPayment" discriminator-value="card">
   <property name="owner"/>
   <property name="bank"></property>
  </subclass>
 </class>
 <query name="queryWithParam"><![CDATA[from Payment cp where cp.amount > :ma]]></query>
</hibernate-mapping>   
.........yu.........
两张表策略
create table cashpayment_concrete(
 id int primary key,
 name varchar(32) not null,
 amount double not null,
 currency varchar(16)
);
create table cardpayment_concrete(
 id int primary key,
 name varchar(32) not null,
 amount double not null,
 bank varchar(32) not null,
 owner varchar(64) not null
);     
关键在这里.
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="inheritance">
 <class name="Payment">
  <id name="id" unsaved-value="null">
   <generator class="hilo">
     <param name="table">pk_table</param>
     <param name="column">id_value</param>
    </generator>
  </id>
  <property name="name"></property>
  <property name="amount"></property>
  <union-subclass name="CashPayment" table="CASHPAYMENT_CONCRETE">
   <property name="currency"></property>
  </union-subclass>
  <union-subclass name="CardPayment" table="CARDPAYMENT_CONCRETE">
   <property name="owner"></property>
   <property name="bank"></property>
  </union-subclass>
 </class>
</hibernate-mapping>                                          
                                             
                                             
                                           
                                         

wzff2154
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
用Hibernate映射继承关系
11-19
讲解了Hibernate的关联映射包括一对一，一对多，多对多
Hibernate实体对象继承的三种方法
10-19
本篇文章将详细阐述Hibernate中的三种实体继承策略：单表继承（Single Table）、类表继承（Table Per Class）和联合继承（ Joined Subclass）。 1. 单表继承（Single Table） 单表继承策略，如其名，意味着所有继承...
Hibernate继承映射
alva88888888的博客
01-26 156
Hibernate继承映射 　　在面向对象的程序领域中，类与类之间是有继承关系的，例如Java世界中只需要extends关键字就可以确定这两个类的父子关系，但是在关系数据库的世界中，表与表之间没有任何关键字可以明确指明这两张表的父子关系，表与表是没有继承关系这样的说法的。为了将程序领域中的继承关系反映到数据中，Hibernate为我们提供了3中方案： 第一种方案：一个子类对应一张表。...
Hibernate 继承
bluethirdbank的博客
11-29 171
  在域模型中，类与类之间除了关联关系和聚集关系，还可以存在继承关系，在下图所示的域模型中，Deparment类和Employee类之间为一对多的 双向关联关系，Employee类有两个子 类：Skiller类和Sales类。由于Java只允许一个类最多有一个直接的父类，因此Employee类、 Skiller类和Sales类构成了一棵继承关系树。 在 面向对象的范畴中，还存在多态的概念，多态建...
Hibernate继承
HotSunMoon的专栏
08-17 407
每棵类继承树一张表 因为类继承树肯定是对应多个类，要把多个类的信息存放在一张表中， 必须有某种机制来区分哪些记录是属于哪个类的。这种机制就是，在表中添加一个字段， 用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤： 父类用普通的标签定义 在父类中定义一个discriminator，即指定这个区分的字段的名称和类型 如： 子类使用标签定义，在定义subcla
Hibernate继承映射详解
鹏霄万里展雄飞
02-21 2372
在面向对象的程序领域中，类与类之间是有继承关系的，例如Java世界中只需要extends关键字就可以确定这两个类的父子关系，但是在关系数据库的世界中，表与表之间没有任何关键字可以明确指明这两张表的父子关系，表与表是没有继承关系这样的说法的。为了将程序领域中的继承关系反映到数据中，Hibernate为我们提供了3中方案： 第一种方案：一个子类对应一张表。 第二种方案：使用一张表表示所有继承体系下
Hibernate继承类的实现.docx
06-19
本例中，我们探讨了如何使用Hibernate处理继承类的映射问题，特别是涉及到论坛系统中的文章（Article）、主题（Topic）和回复（Reply）这类具有继承关系的实体。 首先，论坛系统中的文章（Article）可以分为两种...
jpa/hibernate继承注解
03-22
若希望实现懒加载，可以在继承关系中使用`@OneToMany`或`@ManyToOne`注解并设置`fetch = FetchType.LAZY`。 7. **性能考虑** 不同的继承策略对数据库性能和设计有不同影响。STI可能导致表膨胀，而TPC可能导致更多...
Java的Hibernate框架中的继承映射学习教程
09-02
在Java的Hibernate框架中，继承映射是一个重要的概念，它允许我们将面向对象编程中的类继承关系映射到关系数据库的...通过理解和应用继承映射，开发者可以更好地利用OOP的优势，同时在数据库层面上实现高效的数据管理。
Hibernate继承映射代码
05-08
在"javaII-8"这个压缩包文件中，很可能包含了实现Hibernate继承映射和C3P0连接池配置的源代码示例。这些代码可能包括实体类定义、映射文件（如.hbm.xml或使用注解的类）、Hibernate配置文件（hibernate.cfg.xml）...
hibernate映射继承关系（每个类都对应一张表）
11-28
hibernate实现继承关系映射的方式有三种，这种方式是将每个类都映射成一张表。
学习hibernate（六） -- hibernate继承
weixin_34148340的博客
04-07 116
2019独角兽企业重金招聘Python工程师标准>>> ...
hibernate之继承关系
刘杰 廊坊师范学院信息技术提高班十期
10-14 685
其每一种策略的具体区别如下： 1、放到一张表中     2、每个类一张表   3、每个具体类一张表
Hibernate继承关系
05-14 111
1、整个继承树映射到一张表 在一个论坛中有用户（User）这个实体类，其中User这个实体中有分为普通用户，管理员与游客这3种身份，而这3种现在身份的用户就只有一个字段（即类型）不相同，可以考虑用Hibernate中的Table per class hierarchy策略   对象模型(Java类结构) 表结构 User代码: package org.hibernate.domain...
Hibernate 继承关系（泛化关系）
m0_38068812的博客
11-07 249
一、介绍    one-table映射继承的优劣势:       优点:非常简单;多态查询非常快;       缺点:表及其不稳定;数据分布不好;空值较多;没法实现一些非空的约束;     1,在hibernate中,继承只需要映射一个类就可以了,映射是整个继承体系的根类;     2,使用一张表完成继承映射,我们把这种映射方式称为ONE-TABLE;     3,子类都是使用&lt;subc...
Hibernate的继承映射
馍馍菜的博客
05-30 300
继承映射共有3种方式，具体表现如下：1.共一张表父类@inheritance(strategy=InheritanceType.SINGLE_TABLE)class BaseBean{ //主键 private int pk; //创建人 priate String creator; //创建时间 private String creatime; ...
请教大家一个关于hibernate继承的问题
chuqiang1101的博客
03-08 168
父类： Animal package com.qchu.hiber.pojo; public class Animal { private int id; private String name; private String age; //getter setter } 第一个子类：Dog package com.qchu.hiber.pojo; ...
Hibernate继承映射策略解析
"这篇文档介绍了Hibernate框架中关于对象继承关系如何映射到关系数据库的三种策略，主要包括每个继承层次一张表、每个具体类一张表和每个类一张表的方法。通过这些策略，开发者可以将面向对象的继承特性转换为适合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值