@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 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 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 orderItems = new HashSet();  
5.     public Set getOrderItems() {  
6.         return orderItems;  
7.     }  
8.     public void setOrderItems(Set orderItems) {  
9.         this.orderItems = orderItems;  
10.     }  
11. } 

 

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