`
endual
  • 浏览: 3544679 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

JPA 多对一单向

    博客分类:
  • JPA
 
阅读更多

 

http://ningnian169.blog.51cto.com/2417825/452825

 

 

自己做了一个单向多对一的例子。

     主贴类(1)-----回帖类(m)

     Topic(1)------Feedback(m)

      persistence.xml

  1. <?xml version="1.0" encoding="UTF-8"?> 
  2. <persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"> 
  3.     <persistence-unit name="JpaTest" transaction-type="RESOURCE_LOCAL"> 
  4.     <provider>org.hibernate.ejb.HibernatePersistence</provider> 
  5.     <class>com.entity.Topic</class> 
  6.     <class>com.entity.Feedback</class> 
  7.     <exclude-unlisted-classes>true</exclude-unlisted-classes> 
  8.     <properties> 
  9.         <property name="hibernate.connection.driver_class" value="oracle.jdbc.driver.OracleDriver"/> 
  10.         <property name="hibernate.connection.url" value="jdbc:oracle:thin:@localhost:1521:orcl"/> 
  11.         <property name="hibernate.connection.username" value="ningnian"/> 
  12.         <property name="hibernate.connection.password" value="ningningx"/> 
  13.         <property name="hibernate.dialect" value="org.hibernate.dialect.Oracle10gDialect"/> 
  14.         <property name="hibernate.show_sql" value="true" /> 
  15.         <property name="hibernate.hbm2ddl.auto" value="update"/>          
  16.     </properties> 
  17.     </persistence-unit> 
  18. </persistence> 

TopicEntity

 

  1. package com.entity;  
  2.  
  3. import java.io.Serializable;  
  4.  
  5. import javax.persistence.Column;  
  6. import javax.persistence.Entity;  
  7. import javax.persistence.GeneratedValue;  
  8. import javax.persistence.GenerationType;  
  9. import javax.persistence.Id;  
  10. import javax.persistence.Table;  
  11.  
  12. @Entity 
  13. @Table 
  14. public class Topic implements Serializable {  
  15.  
  16.     /**  
  17.      *   
  18.      */ 
  19.     private static final long serialVersionUID = 1L;  
  20.  
  21.     private int id;  
  22.     private String author;  
  23.     private String title;  
  24.     private String context;  
  25.  
  26.     @Id 
  27.     @Column 
  28.     @GeneratedValue(strategy = GenerationType.AUTO)  
  29.     public int getId() {  
  30.         return id;  
  31.     }  
  32.  
  33.     public void setId(int id) {  
  34.         this.id = id;  
  35.     }  
  36.  
  37.     @Column(length = 20)  
  38.     public String getAuthor() {  
  39.         return author;  
  40.     }  
  41.  
  42.     public void setAuthor(String author) {  
  43.         this.author = author;  
  44.     }  
  45.  
  46.     @Column(length = 20)  
  47.     public String getTitle() {  
  48.         return title;  
  49.     }  
  50.  
  51.     public void setTitle(String title) {  
  52.         this.title = title;  
  53.     }  
  54.  
  55.     @Column(length = 20)  
  56.     public String getContext() {  
  57.         return context;  
  58.     }  
  59.  
  60.     public void setContext(String context) {  
  61.         this.context = context;  
  62.     }  
  63.  
  64. }  

Feedback

 

  1. package com.entity;  
  2.  
  3. import java.io.Serializable;  
  4.  
  5. import javax.persistence.CascadeType;  
  6. import javax.persistence.Column;  
  7. import javax.persistence.Entity;  
  8. import javax.persistence.FetchType;  
  9. import javax.persistence.GeneratedValue;  
  10. import javax.persistence.GenerationType;  
  11. import javax.persistence.Id;  
  12. import javax.persistence.JoinColumn;  
  13. import javax.persistence.ManyToOne;  
  14.  
  15. @Entity 
  16. public class Feedback implements Serializable {  
  17.  
  18.     /**  
  19.      *   
  20.      */ 
  21.     private static final long serialVersionUID = 1L;  
  22.  
  23.     private int id;  
  24.     private String author;  
  25.     private String context;  
  26.     private Topic topics;  
  27.  
  28.     @Id 
  29.     @Column 
  30.     @GeneratedValue(strategy = GenerationType.AUTO)  
  31.     public int getId() {  
  32.         return id;  
  33.     }  
  34.  
  35.     public void setId(int id) {  
  36.         this.id = id;  
  37.     }  
  38.  
  39.     @Column 
  40.     public String getAuthor() {  
  41.         return author;  
  42.     }  
  43.  
  44.     public void setAuthor(String author) {  
  45.         this.author = author;  
  46.     }  
  47.  
  48.     @Column 
  49.     public String getContext() {  
  50.         return context;  
  51.     }  
  52.  
  53.     public void setContext(String context) {  
  54.         this.context = context;  
  55.     }  
  56.  
  57.     /**  
  58.      * cascade = CascadeType.MERGE--级联更新 cascade=CascadeType.PERSIST--级联持久  
  59.      * cascade=CascadeType.REMOVE--级联删除 cascade=CascadeType.REFRESH--  
  60.      * 级联刷新--在业务逻辑中可能对象进行修改,但是读取出来并不是最新的数据。 如果需要最新的数据,这时就得需要级联刷新 fetch =  
  61.      * FetchType.LAZY--开启延迟加载。 fetch = FetchType.EAGER--即时加载 optional--boolean  
  62.      * 在数据中,这个字段是否为空 optional=false,这个选项不可以空  
  63.      */ 
  64.     @ManyToOne(cascade = CascadeType.REFRESH, fetch = FetchType.LAZY, optional = false)  
  65.     /**  
  66.      * @JoinColumn(name = "top_id") 指定外键  
  67.      */ 
  68.     @JoinColumn(name = "top_id")  
  69.     public Topic getTopics() {  
  70.         return topics;  
  71.     }  
  72.  
  73.     public void setTopics(Topic topics) {  
  74.         this.topics = topics;  
  75.     }  
  76.  
  77. }  

测试类

 

  1. @Test 
  2.     public void testFeedback() {  
  3.         EntityManagerFactory factory = Persistence  
  4.                 .createEntityManagerFactory("JpaTest");  
  5.         EntityManager manager = factory.createEntityManager();  
  6.  
  7.         Topic topic = new Topic();  
  8.         topic.setTitle("test");  
  9.         topic.setContext("this is test");  
  10.         topic.setAuthor("ning");  
  11.  
  12.         Feedback fk = new Feedback();  
  13.         fk.setAuthor("nian");  
  14.         fk.setContext("________");  
  15.         fk.setTopics(topic);  
  16.  
  17.         manager.getTransaction().begin();  
  18.         manager.persist(fk);  
  19.         manager.getTransaction().commit();  
  20.  
  21.     } 
分享到:
评论

相关推荐

    jpa--9.单向多对一

    在Java Persistence API (JPA) 中,"单向多对一"关系是一种常见的对象关系映射(ORM)设计模式,用于表示实体之间的关联。在这个模式中,一个实体("多"端)可以引用另一个实体("一"端),但被引用的实体并不持有对...

    jpa--10.单向一对多

    在Java Persistence API (JPA) 中,"单向一对多"是一种常见的关系映射类型,它代表了数据库中两个实体间的一种关联。这种关联意味着一个实体(“一方”)可以与多个其他实体(“多方”)相关联,而反过来,多方并不...

    JPA 一对一实例配置

    总结来说,JPA的一对一实例配置是通过`@OneToOne`注解实现的,可以方便地管理两个实体之间的单向或双向一对一关系。理解并熟练运用这一特性,有助于我们在Java应用中更有效地处理数据持久化,提高开发效率。

    13_jpa多对多双向关联实体定义与注解

    4. **注解细节**:`@JoinColumn`用于单向一对一或一对多关系,而在多对多关系中,通常使用`@JoinTable`来指定中间表的信息,包括表名、连接列等。 5. **操作关联**:在JPA中,可以通过添加或移除对象到集合属性来...

    hibernate多对一单向关联关系实现源码

    对于单向多对一关联,通常是在多方(拥有多个实体)的类中添加一个对单方(拥有单一实体)的引用。 例如,我们可以创建两个实体类:`Employee`(员工)和`Department`(部门)。在`Employee`类中,我们将有一个`...

    14_传智播客JPA详解_JPA中的多对多双向关联的各项关系操作

    在JPA中,多对多(Many-to-Many)关联是一种常见的关系类型,适用于描述两个实体之间复杂的关系。本教程将深入探讨JPA中多对多双向关联的各个方面及其操作。 在数据库中,多对多关联意味着一个实体可以与多个其他...

    尚硅谷JPA视频教程

    JPA视频_映射单向一对多的关联关系 · 14. JPA视频_映射双向一对多的关联关系 · 15. JPA视频_映射双向一对一的关联关系 · 16. JPA视频_映射双向多对多的关联关系 · 17. JPA视频_二级缓存 · 18. JPA视频_...

    jpa的实体映射关系7种

    1. **单向一对一**: 在这种关系中,一个实体只有一个对应实体与之关联,且只在一个方向上有引用。通常通过`@OneToOne`注解来实现,可以设置`mappedBy`属性来指定对方实体中的关联字段。 2. **双向一对一**: ...

    JPA-4 映射关联关系

    JPA 提供了多种方式来处理不同类型的关联关系,包括单向多对一、单向一对多、双向一对一、双向多对一和双向多对多。下面我们将详细探讨这些关联关系的实现方法。 1. **单向多对一关联关系(SingleManyToOne)** 在...

    13_JPA详解_JPA中的多对多双向关联实体定义与注解设置.zip

    本资料“13_JPA详解_JPA中的多对多双向关联实体定义与注解设置”专注于讲解JPA如何处理多对多双向关联关系,这是数据库设计中常见的一种复杂关联类型。下面我们将详细探讨这一主题。 首先,我们需要理解多对多关联...

    一对多单向关联关系实现元源码

    // @ManyToOne注解表示这个字段是一个多对一的关系,对应Parent实体 // cascade属性可以设置成CascadeType.ALL,以处理级联操作,如保存、删除等 @ManyToOne(cascade = CascadeType.ALL) private Parent parent;...

    Hibernate 一对一外键单向关联

    本篇文章将深入探讨Hibernate中的一对一外键单向关联。 首先,一对一外键关联指的是一个实体通过外键直接引用另一个实体的主键。在单向关联中,只有其中一个实体知道另一个实体的存在,而另一个实体则无感知。这种...

    hibernate 单向多对多关联映射练习

    本练习主要关注的是Hibernate中的单向多对多关联映射,这是一种常见的关系数据库设计模式,用于表示两个实体间复杂的关系。 在多对多关联中,两个实体类可以相互拥有多个实例,但只在一个方向上建立关联。例如,...

    jpa--11.双向一多

    - 在另一方实体中,我们使用`@ManyToOne`注解来表示多对一的关系。这个注解会定义一个字段,该字段保存了对一方实体的引用。 3. **示例代码** 假设我们有`Department`(部门)和`Employee`(员工)两个实体,部门...

    使用jpa映射关联和继承

    3. **多对一(ManyToOne)映射**:多个子对象对应一个父对象,与一对一相反,通过`@ManyToOne`注解实现。同样可设置`fetch`策略和`@JoinColumn`来定义外键。 4. **多对多(ManyToMany)映射**:一个实体可以与多个...

    JPA教程详解,这是个word文档,需要的可以拿走

    - **多对一映射**:使用`@ManyToOne`注解定义,多个实体的实例可与另一个实体的单个实例相关联。 - **多对多映射**:使用`@ManyToMany`注解表示,支持任意一方成为所有者。 #### JPA实体 - **实体定义**:在JPA中...

    JPA关联关系

    本文将深入探讨JPA中的四种主要关联关系:一对一(OneToOne)、一对多(OneToMany)、多对一(ManyToOne)和多对多(ManyToMany)。 1. **一对一关联(OneToOne)** 在一对一关联中,一个实体实例对应数据库中的唯...

    JPA.rar_jpa

    3. **实体关系(Entity Relationships)**:JPA支持多种关系映射,如一对一(OneToOne)、一对多(OneToMany)、多对一(ManyToOne)和多对多(ManyToMany),这些关系可以是单向或双向的。 4. **持久化上下文...

Global site tag (gtag.js) - Google Analytics