Hibernate关系映射

最新推荐文章于 2021-01-08 15:45:48 发布
最新推荐文章于 2021-01-08 15:45:48 发布
阅读量714 收藏
点赞数
分类专栏： ssh 文章标签： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/brucehome/article/details/23839981
版权

用 Annotation 讲解

一、一对一单向外键关联

一对一关联的注解是 @OneToOne，同时我们还可以在 @OneToOne 注解下面指定 @JoinColumn(name="xx") 来指定外键的名称：

   1:  @OneToOne
   2:  @JoinColumn(name="fk")
   3:  private Husband husband;

可以通过下面的语句来查看 SQL 语句：

   1:  new SchemaExport(new Configuration().configure()).create(true,true);

二、一对一双向外键关联

一对一双向外键关联还是使用 @OneToOne 注解，需要在双向关联的一方为 @OneToOne 指定属性 mappedBy="xx"：

Husband.java：

   1:  @OneToOne
   2:  private Wife wife;

Wife.java：

   1:  @OneToOne(mappedBy="wife")
   2:  private Husband husband;

三、一对一单向主键关联

一对一单向主键关联使用 @OneToOne 注解，并且在此注解下加 @PrimaryKeyJoinColumn 即可：

   1:  @OneToOne
   2:  @PrimaryKeyJoinColumn
   3:  private Husband husband;

四、一对一双向主键关联

在双向关联的双方声明 @OneToOne 和 @PrimaryKeyJoinColumn 注解即可：

Wife.java：

   1:  @OneToOne
   2:  @PrimaryKeyJoinColumn
   3:  private Husband husband;

Husband.java：

   1:  @OneToOne
   2:  @PrimaryKeyJoinColumn
   3:  private Wife wife;

五、一对一单向联合主键关联

联合主键，这需要单独创建一个主键类 WifePk.java，内容如下：

   1:  public class WifePk implements Serializable{
   2:      private int id;
   3:      private String name;
   4:  //Getters,setters,equals and hashCode methods omitted here...
   5:  }

在 Wife.java 中使用联合主键：

   1:  @Entity
   2:  @IdClass(value=WifePk.class)
   3:  public class Wife {
   4:      @Id
   5:      private int id;
   6:      @Id
   7:      private String name;
   8:      private double salary;
   9:  //Codes omitted here...
  10:  }

在 Husband.java 中使用 Wife 关联：

   1:  @Entity
   2:  public class Husband {
   3:      @Id
   4:      private int id;
   5:      private String name;
   6:      private double salary;
   7:      @OneToOne
   8:      @JoinColumns({ 
   9:              @JoinColumn(name = "WifeId", referencedColumnName = "id"),
  10:              @JoinColumn(name = "WifeName", referencedColumnName = "name") 
  11:              })
  12:      private Wife wife;
  13:  //Codes omitted here...
  14:  }
@JoinColumns 注解的作用是指定生成的外键的名称的，参数是 @JoinColumn 数组。省去不写则会由 hibernate 自动生成外键名称。

六、组件映射

主键映射意思是把一个对象当做另一个对象的一部分存在同一张表中，就像联合主键一样，但是不是作为主键而已。比方说 Wife 是 Husband 的一部分，需要映射在同一张表中，需要这样做：

Wife.java 不需要独立映射成为一张表，所有不需要 @Entity 注解和 @Id 注解了，而且，因为 Wife  和 Husband 会被映射到同一张表中，所以两个类中不能出现相同的字段，Wife 也不再需要主键 Id 字段了：

Wife.java：

   1:  public class Wife {
   2:      private String wifeName;
   3:      private double wifeSalary;
   4:  //Getters and setters omitted here...
   5:  }

在 Husband.java 中需要使用 @Embedded 注解说明 Wife 是作为一个组件映射的：

   1:  @Entity
   2:  public class Husband {
   3:      @Id
   4:      private int id;
   5:      private String name;
   6:      private double salary;
   7:      @Embedded
   8:      private Wife wife;
   9:  //Getters and setters omitted here...
  10:  }

七、多对一单向关联

以 Group 和 User 类为例，一个 Group 可以有多个 User ，而一个 User 只能属于一个 Group ，是典型的多对一关联。多对一使用的是 @ManyToOne 注解：

Group.java：

   1:  @Entity
   2:  @Table(name="mygroup")
   3:  public class Group {
   4:      @Id
   5:      @GeneratedValue
   6:      private int id;
   7:      private String name;
   8:  //Getters and setters omitted here...
   9:  }

因为 group 是 MySQL 的关键字，所以使用 @Table 注解更改表名为 mygroup。

User.java：

   1:  @Entity
   2:  public class User {
   3:      @Id
   4:      @GeneratedValue
   5:      private int id;
   6:      private String name;
   7:      @ManyToOne
   8:      private Group group;
   9:  //Setters and getters omitted here...
  10:  }

因为每个 User 只属于一个 Group ，所以在 User 中定义一个 Group 域，并使用 @ManyToOne 注解。

八、一对多单向关联

还是以 Group 和 User 为例，现在是 Group 里面有多个 User：

Group.java：

   1:  @Entity
   2:  @Table(name="mygroup")
   3:  public class Group {
   4:      @Id
   5:      @GeneratedValue
   6:      private int id;
   7:      private String name;
   8:      @OneToMany
   9:      @JoinColumn(name="GroupId")
  10:      private Set users = new HashSet();
  11:  //Getters and setters omitted here...
  12:  }

如果不加注 @JoinColumn 注解，Hibernate 会生成三张表，也就是单做多对多处理。所以加注 @JoinColumn 注解是必要的。

User.java：

   1:  @Entity
   2:  public class User {
   3:      @Id
   4:      @GeneratedValue
   5:      private int id;
   6:      private String name;
   7:  //Getters and setters omitted here...
   8:  }

九、一对多（多对一）双向关联

只要是双向关联就一定要加 mappedBy 属性：

Group.java：

   1:  @Entity
   2:  @Table(name="mygroup")
   3:  public class Group {
   4:      @Id
   5:      @GeneratedValue
   6:      private int id;
   7:      private String name;
   8:      @OneToMany(mappedBy="group")
   9:      private Set
  
  
   
    users = 
   
   new HashSet
   
   
    
    ();
   
   
  
  
  10:  //Getters and setters omitted here...
  11:  }

User.java：

   1:  @Entity
   2:  public class User {
   3:      @Id
   4:      @GeneratedValue
   5:      private int id;
   6:      private String name;
   7:      @ManyToOne
   8:      private Group group;
   9:  //Getters and setters omitted here...
  10:  }

mappedBy 属性之所以要加在 Group.java 中，因为这符合数据库表设计原则，而且在 @ManyToOne 注解中还没有 mappedBy 属性。

十、多对多单向关联

多对多关联就像一个 Teacher 会有多个 Student，而一个 Student 也可以被多个 Teacher 教，符合多对多关联：

Teacher.java：

   1:  @Entity
   2:  public class Teacher {
   3:      @Id
   4:      private int id;
   5:      private String name;
   6:      @ManyToMany
   7:      @JoinTable(name="s_t_table",
   8:              joinColumns={@JoinColumn(name="t_id")},
   9:              inverseJoinColumns={@JoinColumn(name="s_id")}
  10:      )
  11:      private Set
  
  
   
    students = 
   
   new HashSet
   
   
    
    ();
   
   
  
  
  12:  //Getters and setters omitted here...
  13:  }

@JoinTable 是用于指定生成的第三方表的名称以及里面对应的字段的名称，joinColumns 属性定义的是本类的主键在第三方表的字段名称，inverseJoinColumns 属性定义的是另一个类中的主键在第三方表中对应的名称。可以省去 @JoinTable 注解使用 HIbernate 自动生成的表名和字段名。

Student.java：

   1:  @Entity
   2:  public class Student {
   3:      @Id
   4:      private int id;
   5:      private String name;
   6:  //Getters and setters omitted here...
   7:  }

十一、多对多双向关联

又是双向关联，所以一定要记得 mappedBy 属性：

Teacher.java：

沿用多对多单向关联的 Teacher.java。

Student.java：

   1:  @Entity
   2:  public class Student {
   3:      @Id
   4:      private int id;
   5:      private String name;
   6:      @ManyToMany(mappedBy="students")
   7:      private Set
  
  
   
    teachers = 
   
   new HashSet
   
   
    
    ();
   
   
  
  
   8:  //Getters and setters omitted here...
   9:  }
 
 
转：http://blog.csdn.net/mzule/article/details/6194186
 


                

        

        

    




    

      

        

            

              
                
                  宁静致远NC
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
@JoinColumn

				
			

			

				

					Crack The World
				

				

					10-15
					
					4万+
					
				

			

		

		

			
				
@OneToOne注释只能确定实体与实体的关系是一对一的关系，不能指定数据库表中的保存的关联字段。所以此时要结合@JoinColumn标记来指定保存实体关系的配置。


@JoinColumn与本书上一章讲述的@Column注释类似，它的定义如下代码所示。 

@Tar

			
		

	



                

              
                



	

		

			

				
					
Hibernate @JoinColumn 注解的用法

				
			

			

				

					Forever Young
				

				

					08-08
					
					2925
					
				

			

		

		

			
				
1、一对一单项外键
（比如实体People和实体IDCard，一个人对应一个身份证号）
@OneToOne（cascade=CAscadeType.ALL）全级联关系
@JoinColumn（name=“pid”,unique=true）被控类的外键写到主控类中，且唯一

注意：保存时应该先保存主表对象，再保存外键对象，这是因为数据库外键约束的原因。删除时则相反，应该先删除该人的身份证号，再删除该人，或者将该人和身份证号一起删除。

2、一对一双向外键
主控方配置不变
被控方添加
@OneToOne（map

			
		

	



                


  
              

                


	

		

			

				
					
Hibernate @JoinColumn 注解

				
			

			

				

					妖怪的博客
				

				

					12-11
					
					1225
					
				

			

		

		

			
				
@JoinColumn支持的属性:





属性
是否必须
说明




columnDefinition
否
指定Hibernate使用该属性值指定的SQL片段来创建外键列


name
否
指定该外键列的列名


insertable
否
指定该列是否包含在Hibernate生成的insert语句的列表中。默认值: true


updatable
否
指定该列是否包含在Hibernate...

			
		

	





	

		

			

				
					
Hibernate @JoinColumn介绍

				
			

			

				

					MaBanSheng的博客
				

				

					11-28
					
					3065
					
				

			

		

		

			
				
在address中没有特殊的注解。 
在Person中对应到数据库里面就有一个指向Address的外键. 
我们也可以增加注释指定外键的列的名字,如下: 
@OneToOne(cascade=CascadeType.ALL,optional=true) 
@JoinColumn(name=”addressID”)//注释本表中指向另一个表的外键。 
    public Address getAdd

			
		

	



		

			
		



	

		

			

				
					
Hibernate 关联关系

				
			

			

				

					MZULE CSDN
				

				

					02-09
					
					1223
					
				

			

		

		

			
				
用 Annotation 讲解    一、一对一单向外键关联  一对一关联的注解是 @OneToOne，同时我们还可以在 @OneToOne 注解下面指定 @JoinColumn(name="xx") 来指定外键的名称：        1:  @OneToOne

     2:  @JoinColumn(name="fk")

     3:  private Husband husband;

















.csharpcode, .csh

			
		

	





	

		

			

				
					
hibernate关系映射

				
			

			

				

					03-24
				

			

		

		

			
				
NULL 博文链接：https://daishuanglong.iteye.com/blog/1119793

			
		

	





	

		

			

				
					
Hibernate中mappedBy和@JoinColumn二者的使用心得

				
			

			

				

					xukai0110的博客
				

				

					07-16
					
					2478
					
				

			

		

		

			
				
在单向关系中没有mappedBy，因此使用@JoinColumn建立外键关联，建立外键的一端即主控端，主控方相当于拥有指向另一方的外键的一方。
1、一对一和多对一的@JoinColumn注解的都是在“主控方”，都是本表指向外表的外键名称。
2、一对多的@JoinColumn注解在“被控方”，即一的一方，指的是外表中指向本表的外键名称，一般只有单向关系才在“被控方”中使用@JoinColumn，

			
		

	





	

		

			

				
					
JPA/hibernate @joincolumns 联合主键关联

				
			

			

				

					u013275741的专栏
				

				

					03-05
					
					1万+
					
				

			

		

		

			
				
直接上代码，最后解释。


这里我有2个entity，用过id1 + id2 映射


首先JPA 要求联合主键必须注册一个PK 类,自己override hashcode/equal方法
doc
Class ProjectId {
    int departmentId;
    long projectId;
}
然后在entity中引用pk
@Entity @IdCla

			
		

	





	

		

			

				
					
Hibernate里的mappedBy和注解@JoinColumn

				
			

			

				

					qq_41386447的博客
				

				

					06-18
					
					237
					
				

			

		

		

			
				
一对多
@JoinColumn（name=“FK_name”）
在多的一方的作用是为了指定外键字段的名称，就算没有ManyToOne也会自己创建外键
在一的一方是为了指定外表指向本表的外键，如果没有该注解，会创建一张中间表来维系关系

以下内容装载自[http://www.cnblogs.com/ShawnYuki/p/6363547.html](http://www.cnblogs.com/ShawnYuki/p/6363547.html)
mappedBy

我们知道，mappedBy用于指定具...

			
		

	





	

		

			

				
					
hibernate常用注解

				
			

			

				

					09-18
				

			

		

		

			
				
hibernate注解的方法的详解

			
		

	





	

		

			

				
					
hibernate注解之@Onetomany、@Manytoone、@JoinColumn

				
			

			

				

					weixin_30236595的博客
				

				

					11-14
					
					308
					
				

			

		

		

			
				
@Onetomany用于实体类与数据库表映射中少的一方，请看下面的例子。
假设一个用户只有一种角色，用户和角色是onetomany的关系
用户实体


@Entity
@Table(name="user")
public class UserEntity implements Serializable{
    
    @Id
    @Generic...

			
		

	





	

		

			

				
					
hibernate注解（二）

					
热门推荐

				
			

			

				

					鹏霄万里展雄飞
				

				

					03-31
					
					1万+
					
				

			

		

		

			
				
本篇将向大家介绍表关联的注解方式。
1. 一对一(One-to-one)
使用@OneToOne注解可以建立实体bean之间的一对一的关联.一对一关联有三种情况：一是关联的实体都共享同样的主键,二是其中一个实体通过外键关联到另一个实体的主键(注意要模拟一对一关联必须在外键列上添加唯一约束).三是通过关联表来保存两个实体之间的连接关系(注意要模拟一对一关联必须在每一个外键上添加唯一约束).
首

			
		

	





	

		

			

				
					
Hibernate 多表联查

				
			

			

				

					Memory166的博客
				

				

					01-08
					
					1329
					
				

			

		

		

			
				
@ManyToOne
ManyToOne 表示为此实体多对一，如学生对老师
使用@ManyToOne-----关联非主键列
	@ManyToOne(cascade = CascadeType.MERGE)
    @JoinColumn(name="CASECODE", referencedColumnName="CASENO")
    private CaseInfoModel caseInfo;            

CASECODE 表示当前实体类对应数据库表中的列名称。
CASENO 表示关联

			
		

	





	

		

			

				
					
hibernate 注解@joinColumn,@mappedBy详解

				
			

			

				

					u014624659的博客
				

				

					01-21
					
					521
					
				

			

		

		

			
				

【转】http://xiaoruanjian.iteye.com/blog/1094253
class Card{Person getPerson(){}mappedBy 单向关系不需要设置该属性，双向关系必须设置，避免双方都建立外键字段把关系的维护交给多方对象的属性去维护关系a) 只有OneToOne,OneToMany,ManyToMany上才有mappedBy属性，ManyToOne不存...

			
		

	





	

		

			

				
					
Hibernate基础之八：一对一单/双向，主/外键关联 @OneToOne@JoinColumn

				
			

			

				

					thewebcode
				

				

					11-06
					
					583
					
				

			

		

		

			
				

1：一对一，单向，外键关联
Student和stusentIDCard两张表是一对一的关系，即一个学生只有一个学生证，一个学生证只对应一个学生
Stuent表里有个外键要参考StudentIDCard
表现类上就是Student实例里聚合一个stusentIDCard

@Entity
public class Student 
{
	private int id;
	private...

			
		

	





	

		

			

				
					
hibernate5(13)注解映射[5]一对一共享主键关联

				
			

			

				

					weixin_33682719的博客
				

				

					04-10
					
					120
					
				

			

		

		

			
				
一对一共享主键

下面我们直接通过实例来讲解共享主键配置： 
主键主控方：Article



package com.zeng2.model;

@Table(name = "t_article2")
@Entity
public class Article {
    @Id
    @GeneratedValue(strategy...

			
		

	





	

		

			

				
					
Hibernate中的一对一关联技术

				
			

			

				

					Nicholas_GUB的博客
				

				

					05-19
					
					419
					
				

			

		

		

			
				
Hibernate中的一对一关联技术
加入现在有一个用户的注册功能，这个功能可能要涉及到10个字段的填写，那么这个时候如果上来就填写10个信息，那么可能注册的人就少了。现在的开发往往都会提供一个快速注册和一个信息维护。那么这种情况就可以用一对一关系来描述。
【定义数据库的创建脚本】
DROP TABLE IF EXISTS member_details;
DROP TABLE IF EXISTS member_login;

CREATE TABLE member_login(
   mid        

			
		

	





	

		

			

				
					
Hibernate4一对一关系映射（共享主键方式）

				
			

			

				

					xyjikl
				

				

					03-21
					
					1177
					
				

			

		

		

			
				
示例：一个人（person） 住一个地址（address），一个地址有一个人。
 


Java代码  


public class Person {        private Integer id;      private String name;        private Address address;        //getter and setter  }  

			
		

	





	

		

			

				
					
hibernate框架关联关系映射操作

					
最新发布

				
			

			

				

					05-14
				

			

		

		

			
				
Hibernate框架提供了对象关系映射（ORM）功能，可以将Java对象映射到数据库表中，并且可以使用关联关系映射来描述对象之间的关系。下面是一些常见的Hibernate关联关系映射操作：  1. 一对一映射：在一个实体中定义一...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值