@JoinColumn 详解

ゞ浴缸里的玫瑰 2021-11-18 00:34 748阅读 0赞

# 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.     \}  
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_u010588262_article_details_76667283]

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

[https_blog.csdn.net_u010588262_article_details_76667283]: https://blog.csdn.net/u010588262/article/details/76667283