笔记:Hibernate 持久化类标注示例-双向1-N关系映射

  • 1-N关系的1端持久化类

    package org.drsoft.hibernate.model.oneToMany;

    ?
    ?

    import java.util.Date;

    import java.util.Set;

    ?
    ?

    import javax.persistence.*;

    ?
    ?

    @Entity

    @Table(name = "OneToMany_One")

    public class OneToManyForOneModel {

    @Id

    @Column(name = "Record_ID")

    @GeneratedValue(strategy = GenerationType.IDENTITY)

    private int recordID;

    ?
    ?

    @Column(name = "Total_Trade_Amt")

    private long totalTradeAmt;

    ?
    ?

    @Column(name = "Modify_Time")

    private Date modifyTime;

    ?
    ?

    @Column(name = "Create_Time", insertable = false, updatable = false)

    private Date createTime;

    ?
    ?

    @OneToMany(cascade = {

    CascadeType.PERSIST }, fetch = FetchType.LAZY, targetEntity = OneToManyForManyModel.class, orphanRemoval = false,mappedBy="oneToManyForOneModel")

    private Set<OneToManyForManyModel> details;

    ?
    ?

    省略setter和getter

    }

?
?

  • 1-N关系的N端持久化类

    package org.drsoft.hibernate.model.oneToMany;

    ?
    ?

    import java.util.Date;

    ?
    ?

    import javax.persistence.*;

    ?
    ?

    @Entity

    @Table(name = "OneToMany_Many")

    public class OneToManyForManyModel {

    ?
    ?

    @Id

    @Column(name = "Detail_ID")

    @GeneratedValue(strategy = GenerationType.IDENTITY)

    private int detailID;

    ?
    ?

    @Column(name = "Trade_Amt")

    private long tradeAmt;

    ?
    ?

    @Column(name = "Create_Time", insertable = false, updatable = false)

    private Date createTime;

    ?
    ?

    @ManyToOne

    @JoinColumn(name = "Ref_Record_ID", referencedColumnName = "Record_ID")

    private OneToManyForOneModel oneToManyForOneModel;

    ?
    ?

    省略setter和getter

    }

    ?
    ?

  • 测试调用

    package org.drsoft.hibernate.manager.oneToMany;

    ?
    ?

    import java.util.*;

    ?
    ?

    import org.drsoft.hibernate.model.oneToMany.*;

    import org.drsoft.utils.hibernateUtils;

    import org.hibernate.Session;

    import org.hibernate.Transaction;

    ?
    ?

    public class OneToManyManager {

    public static void main(String[] args) {

    Session curSession = hibernateUtils.openSession();

    Transaction curTransaction = null;

    Calendar calendar = Calendar.getInstance(Locale.CHINA);

    try {

    System.out.println("#1 创建 One 和 Many数据");

    // #1 创建 One 和 Many数据

    OneToManyForOneModel oneToManyForOneModel = new OneToManyForOneModel();

    ?
    ?

    long totalTradeAmt = 0;

    for (int i = 0; i < 5; i++) {

    OneToManyForManyModel oneToManyForManyModel = new OneToManyForManyModel();

    oneToManyForManyModel.setTradeAmt(calendar.get(Calendar.SECOND) + i);

    totalTradeAmt = totalTradeAmt + oneToManyForManyModel.getTradeAmt();

    if (oneToManyForOneModel.getDetails() == null) {

    oneToManyForOneModel.setDetails(new HashSet<OneToManyForManyModel>());

    System.out.println("创建 HashSet<OneToManyForManyModel>()");

    }

    oneToManyForOneModel.getDetails().add(oneToManyForManyModel);

    }

    ?
    ?

    oneToManyForOneModel.setTotalTradeAmt(totalTradeAmt);

    oneToManyForOneModel.setModifyTime(new Date());

    ?
    ?

    curTransaction = hibernateUtils.beginTransaction(curSession);

    curSession.persist(oneToManyForOneModel);

    curTransaction.commit();

    ?
    ?

    System.out.println("#2 查询 One 数据");

    // #2 查询 One 数据

    oneToManyForOneModel = (OneToManyForOneModel) curSession.load(OneToManyForOneModel.class, new Integer(1));

    System.out.println("OneToManyForOneModel RecordID=" + oneToManyForOneModel.getRecordID()

    + "\tTotalTradeAmt=" + oneToManyForOneModel.getTotalTradeAmt());

    ?
    ?

    Set<OneToManyForManyModel> details = oneToManyForOneModel.getDetails();

    Iterator<OneToManyForManyModel> it = details.iterator();

    while (it.hasNext()) {

    OneToManyForManyModel obj = it.next();

    System.out.println(

    "OneToManyForManyModel DetailID=" + obj.getDetailID() + "\tTradeAmt=" + obj.getTradeAmt());

    }

    } catch (Exception e) {

    if (curTransaction != null && curTransaction.isActive()) {

    curTransaction.rollback();

    }

    ?
    ?

    throw e;

    } finally {

    if (curSession != null) {

    curSession.close();

    }

    }

    }

    }

    ?
    ?

?
?

时间: 2024-12-24 13:43:49

笔记:Hibernate 持久化类标注示例-双向1-N关系映射的相关文章

笔记:Hibernate 持久化类标注说明

持久化类标注 标注 @Entity:注解声明该类是一个Hibernate的持久化类 标注 @Table:指定该类映射的表 参数 name:指定映射数据库表的名称 参数 uniqueConstraints:为持久化类所映射的表设置唯一约束,该属性的值是 @UniqueConstraint 标注数组 参数 indexes:为持久化类说映射的表设置索引,该属性的值是 @Index 标注数组 参数 catalog:设置持久化类说映射的表放入指定的 catalog 中,没有指定则放入默认 catalog

(转) Hibernate持久化类与主键生成策略

http://blog.csdn.net/yerenyuan_pku/article/details/65462930 Hibernate持久化类 什么是持久化类呢?在Hibernate中持久化类的英文名称是Persistent Object(简称PO),PO=POJO+hbm映射配置文件. 对于Hibernate中的PO,有如下编写规则: 必须提供一个无参数的public构造方法. 所有属性要用private修饰,对外提供public的get/set方法. 在PO类必须提供一个标识属性,让它与

Hibernate框架(三)框架中的关系映射

在设计数据库时我们会考虑,表与表之间的关系,例如我们前边经常提到的一对一,一对多,多对多关系,在数据库中我们通过外键,第三张表等来实现这些关系.而Hibernate时间实体类和数据库中的表进行的映射,这些关系如何映射呢?这里简单总结一下: 一,一对多,多对一关系映射,这里拿学生和班级进行简单演示: 1,学生的类和对应的映射文件的编写: [java] view plaincopyprint? private int sid ; private String sname ; private Clas

Hibernate持久化类属性映射

Hibernate充当应用程序和数据库之间的中间件,实现二者之间的交互操作,他对JDBC进行了封装,以完全面向对象的方式来操作数据. 适用于有多个数据源的情况下,不必去考虑不同数据源的操作差异. Hibernate将类型对象与数据库表建立映射关系,把类的属性映射称为数据库表的字段,Hibernate属性映射可分为简单属性映射.集合属性 映射.复合属性映射及派生属性映射.下面分别以实例介绍这几个映射及其对应的映射文件表示方式. 1.简单属性 假设有个User类,对应数据库中的User表 User类

3.1 hibernate持久化类及一级缓存

1.持久化类编写规则 Hibernate是持久化层的ORM映射框架,专注于数据的持久化工作. 持久化:所谓的持久化就是讲内存中的数据永久保存到关系型数据库中. 持久化类:其实所谓的持久化类指的是一个Java类与数据库表建立了映射关系,那么这个类称为是持久化类.其实,你可以简单的理解为就是一个Java类,该类通过一个映射文件与数据库的表建立了关系.持久化类的编写规则如下: 1.持久化类提供无参数构造:因为在hibernate的底层需要使用反射生成类的实例: 2.成员变量私有,提供共有get/set

Hibernate持久化类规则

注意事项: 提供无参的构造方法,因为在hibernate需要使用反射生成类的实例 提供私有属性,并对这些属性提供公共的setting和getting方法,因为在hibernate底层会将查询到的数据进行封装 尽量使用封装类,因为包装类和基本数据类型的默认值不一样,包装类的类型语义更加清晰,而基本数据类型不容易描述 提供唯一一个oid,与数据库表的主键对应:因为hibernate需要使用oid来判断在内存中是否存在同一个持久化类,而在Java中是通过地址来区分的是否是同一条记录 不要用final修

Hibernate学习笔记(四) — session的产生方式 与 一对多关系映射

一.session的创建 Session是由SessionFactory负责创建的,而SessionFactory的实现是线程安全的,多个并发的线程可以同时访问一个SessionFactory并从中获取Session实例,但Session不是线程安全的. 每次openSession,产生的都是一个新的session,相当于创建一个新的连接.但是有很多时候,并不希望这样.比如在淘宝购物,在付账的一瞬间,至少有三件事情发生,转账,仓库数据变化,购物历史记录.而这三件事有必须在同一事务下.自然我们会联

--------Hibernate框架之双向多对多关系映射

今天跟大家分享下在Hibernate中双向的多对多的映射关系 这次我们以项目和员工举个栗子,因为大家可以想象得到,在真实的环境下,一个项目肯定是对应着多个员工的,这毫无疑问, 那么同时,一个比较牛员工也能同时参与多个项目的开发,这就体现了双向多对多的关系. 首先呢,我们得弄清楚在底层数据库中表与表之间的关系,我们创建一个员工表(Employee)和项目表(Project)毫无疑问,那么我们要怎么体现出多对多的关系呢? 当然有很多种方法,这里我以单独提出一张关系表为例,也就是说,我单独创建一张表来

Hibernate -- xxx.hbm.xml ORM元数据 表对象关系映射文件

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <!-- ORM元数据 表对象关系映射文件 p