@JoinColumn 详解

最新推荐文章于 2022-04-28 17:19:15 发布

zzhongcy

最新推荐文章于 2022-04-28 17:19:15 发布

阅读量1.4w

点赞数 9

分类专栏： Java

本文链接：https://blog.csdn.net/zzhongcy/article/details/97907295

版权

Java 专栏收录该内容

108 篇文章 9 订阅

订阅专栏

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. 保存外键

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

public class OrderItem extends AbstractNsSimpleModel {
private static final long serialVersionUID = -7120458190166247286L;
@Column(name = "ORDER_ID", insertable = false, updatable = false, nullable = false)
private Long orderId;
@ManyToOne(fetch = FetchType.EAGER, optional = false)
@JoinColumn(name = "ORDER_ID", referencedColumnName = "ID")
private Order order;
public Long getOrderId() {
return orderId;
}
public void setOrderId(Long orderId) {
this.orderId = orderId;
}
public Order getOrder() {
return order;
}
public void setOrder(Order order) {
this.order = order;
}
}

参考：

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

zzhongcy

关注

9
点赞
踩
55

收藏

觉得还不错? 一键收藏
6
评论
@JoinColumn 详解

1. 一对一现假设有Person表和Address表，是一对一的关系，在Person中有一个指向Address表主键的字段addressID，所以主控方一定是Person，所谓主控方就是能改变关联关系的一方，Person只要改变addressID就改变了关联关系，所以Person是主控方，所以@JoinColumn写在Person类中@OneToOne(cascade=CascadeTy...
复制链接

扫一扫