`

hibernate annotation 双向一对多 List映射

    博客分类:
  • Java
阅读更多

        hibernate一对多双向映射通常通过“多”的一端负责维护关系。但是对于list, 因为list保存关于“顺序”的信息,而多的一端没有这样的信息,所以只能由“一”的一端维护关系。

用在线图书馆举个例子。书和评论之间是一对多的关系。

book代码:

   1: package org.emoticon.library.model;
   2:  
   3: import java.util.ArrayList;
   4: import java.util.Date;
   5: import java.util.List;
   6:  
   7: import javax.persistence.CascadeType;
   8: import javax.persistence.Entity;
   9: import javax.persistence.FetchType;
  10: import javax.persistence.GeneratedValue;
  11: import javax.persistence.Id;
  12: import javax.persistence.JoinColumn;
  13: import javax.persistence.OneToMany;
  14:  
  15: @Entity
  16: public class Book {
  17:     
  18: private Integer id;
  19: private String title;
  20: private String author;
  21: private String description;
  22: private String publisher;
  23: private int pageNumber;
  24: private Date publishTime;
  25: private String isbn;
  26: private List<Comment> comments = new ArrayList<Comment>();
  27:  
  28:  
  29: public void addComment(Comment comment){
  30:     comment.setBook(this);
  31:     comments.add(comment);
  32: }
  33:  
  34: @Id
  35: @GeneratedValue
  36: public Integer getId() {
  37:     return id;
  38: }
  39: public void setId(Integer id) {
  40:     this.id = id;
  41: }
  42: public String getTitle() {
  43:     return title;
  44: }
  45: public void setTitle(String title) {
  46:     this.title = title;
  47: }
  48: public String getAuthor() {
  49:     return author;
  50: }
  51: public void setAuthor(String author) {
  52:     this.author = author;
  53: }
  54: public String getDescription() {
  55:     return description;
  56: }
  57: public void setDescription(String description) {
  58:     this.description = description;
  59: }
  60: public String getPublisher() {
  61:     return publisher;
  62: }
  63: public void setPublisher(String publisher) {
  64:     this.publisher = publisher;
  65: }
  66: public int getPageNumber() {
  67:     return pageNumber;
  68: }
  69: public void setPageNumber(int pageNumber) {
  70:     this.pageNumber = pageNumber;
  71: }
  72: public Date getPublishTime() {
  73:     return publishTime;
  74: }
  75: public void setPublishTime(Date publishTime) {
  76:     this.publishTime = publishTime;
  77: }
  78: public String getIsbn() {
  79:     return isbn;
  80: }
  81: public void setIsbn(String isbn) {
  82:     this.isbn = isbn;
  83: }
  84:  
  85: @OneToMany(fetch = FetchType.EAGER,
  86:         cascade = {CascadeType.ALL})
  87: @JoinColumn (name = "book_id",
  88:         nullable = false)
  89: @org.hibernate.annotations.IndexColumn(name = "comment_position",
  90:         nullable = false,
  91:         base = 1)
  92: public List<Comment> getComments() {
  93:     return comments;
  94: }
  95:  
  96: public void setComments(List<Comment> comments) {
  97:     this.comments = comments;
  98: }
  99: }

 

comment代码:

   1: package org.emoticon.library.model;
<!--CRLF-->
   2:  
<!--CRLF-->
   3: import javax.persistence.CascadeType;
<!--CRLF-->
   4: import javax.persistence.Entity;
<!--CRLF-->
   5: import javax.persistence.GeneratedValue;
<!--CRLF-->
   6: import javax.persistence.Id;
<!--CRLF-->
   7: import javax.persistence.JoinColumn;
<!--CRLF-->
   8: import javax.persistence.ManyToOne;
<!--CRLF-->
   9:  
<!--CRLF-->
  10: import junit.framework.Assert;
<!--CRLF-->
  11:  
<!--CRLF-->
  12: @Entity
<!--CRLF-->
  13: public class Comment {
<!--CRLF-->
  14: private Integer id;
<!--CRLF-->
  15: private int rate;
<!--CRLF-->
  16: private String title;
<!--CRLF-->
  17: private String content;
<!--CRLF-->
  18: private Book book;
<!--CRLF-->
  19:  
<!--CRLF-->
  20: @Id
<!--CRLF-->
  21: @GeneratedValue
<!--CRLF-->
  22: public Integer getId() {
<!--CRLF-->
  23:     return id;
<!--CRLF-->
  24: }
<!--CRLF-->
  25: public void setId(Integer id) {
<!--CRLF-->
  26:     this.id = id;
<!--CRLF-->
  27: }
<!--CRLF-->
  28: public int getRate() {
<!--CRLF-->
  29:     return rate;
<!--CRLF-->
  30: }
<!--CRLF-->
  31:  
<!--CRLF-->
  32: public void setRate(int rate) {
<!--CRLF-->
  33:     Assert.assertTrue(rate > 0 && rate < 6);
<!--CRLF-->
  34:     this.rate = rate;
<!--CRLF-->
  35: }
<!--CRLF-->
  36:  
<!--CRLF-->
  37: public String getTitle() {
<!--CRLF-->
  38:     return title;
<!--CRLF-->
  39: }
<!--CRLF-->
  40:  
<!--CRLF-->
  41: public void setTitle(String title) {
<!--CRLF-->
  42:     this.title = title;
<!--CRLF-->
  43: }
<!--CRLF-->
  44:  
<!--CRLF-->
  45: public String getContent() {
<!--CRLF-->
  46:     return content;
<!--CRLF-->
  47: }
<!--CRLF-->
  48: public void setContent(String content) {
<!--CRLF-->
  49:     this.content = content;
<!--CRLF-->
  50: }
<!--CRLF-->
  51:  
<!--CRLF-->
  52: @ManyToOne(cascade = {CascadeType.ALL})
<!--CRLF-->
  53: @JoinColumn(name="book_id",
<!--CRLF-->
  54:         nullable = false,
<!--CRLF-->
  55:         updatable = false,
<!--CRLF-->
  56:         insertable = false)
<!--CRLF-->
  57: public Book getBook() {
<!--CRLF-->
  58:     return book;
<!--CRLF-->
  59: }
<!--CRLF-->
  60:  
<!--CRLF-->
  61: public void setBook(Book book) {
<!--CRLF-->
  62:     this.book = book;
<!--CRLF-->
  63: }
<!--CRLF-->
  64:  
<!--CRLF-->
  65: }
<!--CRLF-->

测试代码:

  1: package org.emoticon.library.manager;
   2:  
   3: import org.emoticon.core.test.DaoTestCase;
   4: import org.emoticon.library.model.Book;
   5: import org.emoticon.library.model.Comment;
   6:  
   7: public class BookManagerTest extends DaoTestCase {
   8:     private BookManager manager;
   9:     
  10:     private static final String commentTitle = "a good book";
  11:     
  12:     public void setManager(BookManager manager) {
  13:         this.manager = manager;
  14:     }
  15:     
  16:     public void testSave(){
  17:         Book entity = new Book();
  18:         entity.setTitle("thinking in java");
  19:         entity.setDescription("for newbie");
  20:         
  21:         Comment comment = new Comment();
  22:         comment.setTitle(commentTitle);
  23:         comment.setContent("I like it.");
  24:         comment.setRate(5);
  25:         
  26:         Comment comment2 = new Comment();
  27:         comment2.setTitle(commentTitle + "2");
  28:         comment2.setContent("I like it2.");
  29:         comment2.setRate(4);
  30:  
  31:         entity.addComment(comment);
  32:         entity.addComment(comment2);
  33:         
  34:         manager.save(entity);
  35:         assertNotNull(entity.getId());
  36:         entity = manager.get(entity.getId());
  37:         //assertEquals(entity.getComments().get(0).getTitle(), commentTitle);
  38:         assertNotNull(entity);
  39:         this.setComplete();
  40:     }
  41: }

这里需要注意:很多时候你在一对多list关联的时候,不真的需要indexcolumn来维护顺序。比如在线图书馆,如果没有indexcolumn也没问题。因为comment总是一条一条加的,那么indexcolumn那一列其实总不变。只有一下添加多个comment的时候,如上面代码,indexcolumn才会增加。comment的id本身就可以用来排序。

在线图书馆其实用不上indexcolumn, 实现的时候想错了,既然已经调通了,就记下来以后也许用得上。

分享到:
评论

相关推荐

    Hibernate annotation JPA 一对多,多对多

    在本主题中,我们将深入探讨使用Hibernate注解来实现JPA的一对多、多对多和多对一的关系映射。 1. **一对多关系**: 在现实世界中,一个老师可以教多个学生,或者一个班级可以包含多个学生,这就是典型的一对多...

    Hibernate Annotation 基于外键的一对多双向关联

    本文将深入探讨如何使用Hibernate注解实现基于外键的一对多双向关联。我们将通过具体实例来解析这个主题,并结合源码分析其工作原理。 首先,我们要明白一对多关联意味着一个实体可以拥有多个关联的实体。在数据库...

    最全的Hibernate Annotation API文档

    在Hibernate中,注解(Annotation)是一种声明式的方法,用于配置实体类、属性以及它们与数据库表之间的映射关系。本文将深入探讨“最全的Hibernate Annotation API文档”中的关键知识点。 一、实体类(Entity) 在...

    Hibernate一对多(多对一)双向关联(annotation/xml)

    在Java的持久化框架Hibernate中,一对多(Many-to-One)和多对一(One-to-Many)的关系映射是数据库关系模型中的常见关联类型。本文将深入探讨这两种关联方式在使用Hibernate时的配置,包括基于注解(Annotation)和...

    hibernate-annotation

    6. `@OneToMany`, `@ManyToOne`, `@OneToOne`, `@ManyToMany`:这些注解用于描述多对一、一对多、一对一和多对多的关联关系。例如,一个用户可以有多个订单: ```java @Entity public class User { @Id private ...

    hibernate4.3.8的annotation及xml的一对多的双向案例

    在Java的持久化框架中,Hibernate是一个非常重要的工具,它提供了强大的对象关系映射(ORM)功能,使得开发者...此外,由于多对多关系可以转换为两个一对多关系,因此这个案例对于理解多对多关系的处理也有一定帮助。

    hibernate anotation 处理一对多关系

    本文将以一个实例为依托,深入解析如何使用注解来设置一对多关系以及多对一关系的映射。 在Hibernate中,处理一对多关系主要使用`@OneToMany`和`@ManyToOne`注解。一个简单的例子通常包括两个实体类:一个“父”类...

    Hibernate Annotation 基于连接表的单向一对多关联

    本篇文章将详细讲解如何利用Hibernate的注解实现基于连接表的单向一对多关联。 首先,理解一对多关联:在数据库设计中,一对多关联意味着一个实体(表)可以与多个其他实体(表)相对应。例如,一个学生可以有多个...

    hibernate-annotation-3.4.0.GA

    2. @ManyToOne:多对一关系 3. @OneToMany:一对多关系 4. @ManyToMany:多对多关系 这些注解用于处理不同类型的关联关系。例如,一个用户可以拥有多个角色,我们可以这样表示: ```java @Entity @Table(name = ...

    Hibernate Annotation应用

    4. **关联映射**:在Java对象中,关系(如一对一、一对多、多对多)可以通过`@OneToOne`、`@OneToMany`、`@ManyToOne`和`@ManyToMany`注解来定义。例如,一个用户可能有多个订单,可以用以下方式表示: ```java @...

    Hibernate_Annotation参考文档

    - 使用`@ManyToOne`注解进行多对一映射配置。 - **一对多映射**: - 使用`@OneToMany`注解进行一对多映射配置。 - **多对多映射**: - 使用`@ManyToMany`注解进行多对多映射配置。 - **次级表映射**: - 使用`...

    Hibernate一对多映射配置详解

    在Java持久化框架Hibernate中,一对多映射是常见的实体关系映射类型,它表示一个实体(例如User)可以与多个其他实体(例如Account)相关联。以下是对Hibernate一对多映射配置的详解: 一、XML文件配置 1. 单向...

    Hibernate关联关系的CRUD和集合映射(annotation)

    集合映射是处理一对多或多对多关联关系的重要手段。常见的集合类型有`List`、`Set`、`Map`等。通过以下注解可以进行配置: 1. **@ElementCollection**:用于非关联的简单元素集合,如字符串列表或枚举集。 2. **@...

    Hibernate多对多双向关联(annotation/xml)

    本主题将深入探讨使用Hibernate进行多对多双向关联的实现,既可以通过注解(Annotation)方式,也可以通过XML配置文件来完成。 首先,我们来看多对多关联的基本概念。在数据库设计中,当两个实体之间存在多个实例...

    hibernate annotation

    在Hibernate中,注解(Annotation)是用于替代传统XML配置的一种方式,使得对象模型与数据库表的映射关系更加直观和简洁。本文将深入探讨Hibernate注解的相关知识点,并通过实例来阐述其用法。 ### 1. Hibernate...

    hibernate_annotation

    3.1 OneToMany、ManyToOne:表示一对多和多对一的关系,如用户与订单的关系: ```java // 在User类中 @OneToMany(mappedBy = "user") private List&lt;Order&gt; orders; // 在Order类中 @ManyToOne @JoinColumn(name = ...

    Hibernate一对多单向关联(annotation/xml)

    在Java的持久化框架Hibernate中,一对多关系是常见的实体关联类型,表示一个实体可以与多个其他实体相关联。在本教程中,我们将探讨如何使用注解和XML配置实现Hibernate的一对多单向关联。 首先,让我们理解一对多...

    hibernate中用annotation的demo

    4. **关系注解**:Hibernate支持多种关系映射,如一对一(@OneToOne)、一对多(@OneToMany)、多对一(@ManyToOne)和多对多(@ManyToMany)。这些注解用于定义实体之间的关系。例如,一个用户可以有多个订单,可以...

    hibernate-annotation-3.2.1

    `@OneToOne`,`@OneToMany`,`@ManyToOne`,`@ManyToMany`这四个注解分别用于表示一对一、一对多、多对一和多对多的关系。例如,用户和角色的一对多关系可以这样表示: ```java @Entity public class User { @...

    Hibernate annotation

    3. @ManyToOne:多对一关系,通常配合@JoinColumn使用。 4. @ManyToMany:多对多关系,需要通过中间表进行关联,使用@JoinTable定义中间表和关联字段。 四、其他注解 1. @Temporal:用于日期和时间类型的映射,...

Global site tag (gtag.js) - Google Analytics