@JoinColumn 详解

1. 一对一

现假设有Person表和Address表,是一对一的关系,在Person中有一个指向Address表主键的字段addressID,所以主控方一定是Person,所谓主控方就是能改变关联关系的一方,Person只要改变addressID就改变了关联关系,所以Person是主控方,所以@JoinColumn写在Person类中

@OneToOne(cascade=CascadeType.ALL,optional=true)
@JoinColumn(name="addressID")//注释本表中指向另一个表的外键。
public Address getAddress() {
    return address;
}

我们也可以不写@JoinColumn,Hibernate会自动在Person表生成关联字段,名称是被控方类名_被控方主键,如address_id

如果两张表是以主键关联的,比如Person表主键是id,Address表主键是address_id,则运用如下注释:

@OneToOne(cascade={CascadeType.ALL})
@PrimaryKeyJoinColumn(name = "id", referencedColumnName="address_id")
public Address getAddress( ) {
    return homeAddress;
}

2.一对多单向

假如现在有Person表和Country表,那么一定是Person表中有country_id字段

由于我们是一对多的关系,所以站在一的角度,也就是Country的角度,在Country类中加入@JoinColumn:

@OneToMany(cascade=CascadeType.ALL)
@JoinColumn(name="country_id")//注释的是另一个表指向本表的外键。
public List<Person> getPersons() {
    return persons;
}

      在一对多单向关系中,多的一方(Person)没有注解,一的一方(Country)有注解,如果一的一方不加@JoinColumn指定外键字段的话,Hibernate会自动生成一张中间表Country_PERSON来对Person和Country进行绑定。

3.多对一单向

还是沿用一对多单向的例子,只是反过来,将Country中的注解去掉,挪到Person类中:

@ManyToOne
@JoinColumn(name="country_id")
public Country getCountry() {
    return country;
}

      与一对多单向不同的是,此时若不用@JoinColumn指定外键字段的话,不会生成中间表,而是在Person表中生成一列指向Country的外键。

      如果记不清这类关系的话,最好自己把表都设计好,通过注解将关系全部指定,不要让Hibernate代劳。使用中间表关联的注解:

@JoinTable(name = "Person_Country",
    joinColumns = {@JoinColumn(name = "person_id")},
    inverseJoinColumns = {@JoinColumn(name = "country_id")})

      joinColumns指定中间表中关联自己ID的字段,inverseJoinColumns表示中间表中关联对方ID的字段,在Country类中使用这个注解把它们对调一下即可。
 

4.一对多双向

单向关系的缺点还是比较明显的,比如一对多单向,多的那一方没有任何关于另一方的信息,如果我们通过person_id取得一个单独的Person对象,我们没办法知道它属于哪个Country,因为Person类中没有Country对象,多对一单向则是反之。所以正常使用时,一对多双向是最常用的,双方都有彼此的信息。单向变双向,只需在单向的基础上,在Person类中加入多对一的注解:

@ManyToOne(cascade = CascadeType.ALL, optional = false)
@JoinColumn(name="country_id")
private Country country;

5.多对多单向

一般多对多的关系都是用中间表来维护的,假设现在有Person表,Project表,Person_Project表,Person类中的注解:
 

@ManyToMany(cascade = CascadeType.ALL)
@JoinTable(name = "Person_Project",
    joinColumns = {@JoinColumn(name = "person_id")},
    inverseJoinColumns = {@JoinColumn(name = "project_id")})
public List<Project> getProjects() {
    return project;
}

6.referencedColumnName属性

 @JoinColumn与@Column标记一样,是用于注释表中的字段的。它的属性与@Column属性有很多相同之处,这里就不详细讲述。请读者参阅5.2.2小节中有关@Column属性的部分。 

l  @JoinColumn与@Column相区别的是:@JoinColumn注释的是保存表与表之间关系的字段,它要标注在实体属性上。而@Column标注的是表中不包含表关系的字段。 

l 与@Column标记一样,name属性是用来标识表中所对应的字段的名称。例如customer表中存在字段addr_id,标识的代码如下所示。 

@OneToOne 
@JoinColumn(name = "addr_id") 
public AddressEO getAddress() { 
    return address; 
} 

若此时,不设置name的值,则在默认情况下,name的取值遵循以下规则: 

name=关联表的名称+“_”+ 关联表主键的字段名 


      例如,CustomerEO实体中,如果不指定name的值,默认将对应name=address_id;因为@JoinColumn注释在实体 AddressEO属性上,实体AddressEO对应的表名为“address”;表address的主键是“id”,所以此时对应的默认的字段名称为 “address_id”。 

提示:此规则只适用于与@OneToOne标记同时使用时。若与@ManyToOne或@ManyToMany标记同时使用时,将遵循其他的规则。 

l   默认情况下,关联的实体的主键一般是用来做外键的。但如果此时不想主键作为外键,则需要设置referencedColumnName属性。例如,将address表中增加一个字段“ref_id”,address表的建表SQL变为以下所示。 

CREATE TABLE address ( 
    id int(20) NOT NULL auto_increment, 
    ref_id int int(20) NOT NULL, 
    province varchar(50) , 
    city varchar(50) , 
    postcode varchar(50) , 
    detail varchar(50) , 
    PRIMARY KEY (id) 
) 

    此时,通过customer表中的“address_id”字段关联的是address表中的“ref_id”,而“ref_id”并不是address表中的主键,则实体中标注如代码下所示。 

@OneToOne 
@JoinColumn(name = "address_id",referencedColumnName="ref_id") 
public AddressEO getAddress() { 
    return address; 
} 

属性referencedColumnName标注的是所关联表中的字段名,若不指定则使用的所关联表的主键字段名作为外键。 

l JoinColumn标记不仅能够与@OneToOne使用,也可以@ManyToOne或@ManyToMany标记同时使用,它们所表示的含义不同,这些内容将在下文详细讲述。

 

7.另外问题:DuplicateMappingException: Table [xx] contains physical column name referred to by multiple

报错如题:

Caused by: org.hibernate.DuplicateMappingException: Table [xxx] contains physical column name [comment] referred to by multiple physical column names: [comment], [auditComment]
    at org.hibernate.boot.internal.InFlightMetadataCollectorImpl$TableColumnNameBinding.bindPhysicalToLogical(InFlightMetadataCollectorImpl.java:922)
    at org.hibernate.boot.internal.InFlightMetadataCollectorImpl$TableColumnNameBinding.addBinding(InFlightMetadataCollectorImpl.java:891)
    at org.hibernate.boot.internal.InFlightMetadataCollectorImpl.addColumnNameBinding(InFlightMetadataCollectorImpl.java:961)
    at org.hibernate.boot.internal.InFlightMetadataCollectorImpl.addColumnNameBinding(InFlightMetadataCollectorImpl.java:942)
    at ... ...


情况1. 项目用的 spring-data-jpa 。

原本对于表和本类的每个字段都有给注解 @Colum 来对应,其实不用给也可以。把这些注解 @Colum 注释掉工程就可以正常启动了

如下:
import org.codehaus.jackson.annotate.JsonIgnore;
import org.codehaus.jackson.annotate.JsonIgnoreProperties;
import org.codehaus.jackson.map.annotate.JsonSerialize;
 
import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;
 
/**
 * 解冻申请
 */
@Entity(name = "unfreeze")
@Table(name = "unfreeze_apply")
@JsonIgnoreProperties(ignoreUnknown = true)
public class UnfreezeApply implements Serializable {
 
    private static final long serialVersionUID = -1826761763082698565L;
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
 
    //@Column(name = "employee_no", nullable = false)
    private String employeeNo;
 
    @Transient
    private String employeeName; //员工名称
 
    @ManyToOne(fetch = FetchType.EAGER)
    @JsonIgnore
    //@JoinColumn(name="employee_no", referencedColumnName="usernumber", insertable=false, updatable=false)
    private User employee;
 
    //@Column(name = "reason", nullable = false)
    private String reason;
 
}
启动成功:

情况2. (网上的其它情况)

当有一个物理表映射两个或多个逻辑表名称时,会发生此异常。如 因为那里有多个@JoinColumns使用相同的列名(user_id)

为每个JoinColumns(在注释中的name参数中定义)设置一个不同的名称

@OneToOne
@JoinColumn(name = "local_user_id")
public User getUser() {
    return user;
}
 
@OneToOne
@JoinColumns({@JoinColumn(name = "userId", referencedColumnName = "userId"),
        @JoinColumn(name = "providerId", referencedColumnName = "providerId"),
        @JoinColumn(name = "providerUserId", referencedColumnName = "providerUserId")}
)
public UserConnection getUserConnection() {
    return userConnection;
}

 

情况3.  保存外键

  1. public class Order extends AbstractNsSimpleModel {  
  2.     private static final long serialVersionUID = -3227571634593243399L;  
  3.     @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "order", orphanRemoval = true)  
  4.     private Set<OrderItem> orderItems = new HashSet<OrderItem>();  
  5.     public Set<OrderItem> getOrderItems() {  
  6.         return orderItems;  
  7.     }  
  8.     public void setOrderItems(Set<OrderItem> orderItems) {  
  9.         this.orderItems = orderItems;  
  10.     }  

 

  1. public class OrderItem extends AbstractNsSimpleModel {  
  2.     private static final long serialVersionUID = -7120458190166247286L;  
  3.     @Column(name = "ORDER_ID", insertable = false, updatable = false, nullable = false)  
  4.     private Long orderId;  
  5.       
  6.     @ManyToOne(fetch = FetchType.EAGER, optional = false)  
  7.     @JoinColumn(name = "ORDER_ID", referencedColumnName = "ID")  
  8.     private Order order;  
  9.   
  10.     public Long getOrderId() {  
  11.         return orderId;  
  12.     }  
  13.   
  14.     public void setOrderId(Long orderId) {  
  15.         this.orderId = orderId;  
  16.     }  
  17.   
  18.     public Order getOrder() {  
  19.         return order;  
  20.     }  
  21.   
  22.     public void setOrder(Order order) {  
  23.         this.order = order;  
  24.     }  
  25. }  

 

参考:

http://mussatto.github.io/java/hibernate/error/fix/mapping/2016/11/14/hibernate-error-multiple-physical-columns.html

https://blog.csdn.net/u010588262/article/details/76667283

https://blog.csdn.net/jiangyu1013/article/details/80844949 

评论 7
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值