带有额外列的 JPA 2.0 多对多

Question

我正在尝试在 JPA 2.0 (JBoss 7.1.1) 中建立一个多对多关系，并在该关系中添加一个额外的列（下面用粗体表示），例如：

Employer           EmployerDeliveryAgent             DeliveryAgent
(id,...)   (employer_id, deliveryAgent_id, **ref**)  (id,...)

我不想有重复的属性，所以我想应用http://giannigar.wordpress.com/2009/09/04/mapping-a-many-to-many-join-table-with-extra-column-using-jpa/ 中提出的第二种解决方案。但我无法让它工作，我收到几个错误，例如：

1. 嵌入式 ID 类不应包含关系映射（实际上规范是这样说的）；
2. 在属性“employerDeliveryAgent”中，“映射者”值“pk.deliveryAgent”无法解析为目标实体上的属性；
3. 在属性“employerDeliveryAgent”中，“映射者”值“pk.employer”无法解析为目标实体上的属性；
4. 无法解析持久类型的覆盖属性“pk.deliveryAgent”；
5. 无法解析持久类型的覆盖属性“pk.employer”；

该链接上的许多人都说它工作正常，所以我想我的环境有些不同，可能是 JPA 或 Hibernate 版本。所以我的问题是：如何使用 JPA 2.0（Jboss 7.1.1 / 使用 Hibernate 作为 JPA 实现）实现这种场景？为了补充这个问题：我应该避免使用复合键，而是使用普通生成的 id 和唯一约束吗？

提前致谢。

Obs.：我没有在这里复制我的源代码，因为它本质上是上面链接中的源代码的副本，只是具有不同的类和属性名称，所以我想没有必要。

Answer 1

Eric Lucio 和 Renan 的两个答案都有帮助，但他们在关联表中使用 id 是多余的。您在类中同时拥有关联的实体和它们的 id。这不是必需的。您可以简单地将关联类中的关联实体与关联实体字段上的@Id 进行映射。

@Entity
public class Employer {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @OneToMany(mappedBy = "employer")
    private List<EmployerDeliveryAgent> deliveryAgentAssoc;

    // other properties and getters and setters
}

@Entity
public class DeliveryAgent {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @OneToMany(mappedBy = "deliveryAgent")
    private List<EmployerDeliveryAgent> employerAssoc;

    // other properties and getters and setters
}

关联类

@Entity
@Table(name = "employer_delivery_agent")
@IdClass(EmployerDeliveryAgentId.class)
public class EmployerDeliveryAgent {
    
    @Id
    @ManyToOne
    @JoinColumn(name = "employer_id", referencedColumnName = "id")
    private Employer employer;
    
    @Id
    @ManyToOne
    @JoinColumn(name = "delivery_agent_id", referencedColumnName = "id")
    private DeliveryAgent deliveryAgent;
    
    @Column(name = "is_project_lead")
    private boolean isProjectLead;
}

还需要关联PK类。请注意，字段名称应与关联类中的字段名称完全对应，但类型应为关联类型中 id 的类型。

public class EmployerDeliveryAgentId implements Serializable {
    
    private int employer;
    private int deliveryAgent;

    // getters/setters and most importantly equals() and hashCode()
}

Answer 2

首先你需要生成一个EmployerDeliveryAgentPK类，因为它有多个PK：

@Embeddable
public class EmployerDeliveryAgentPK implements Serializable {

    @Column(name = "EMPLOYER_ID")
    private Long employer_id;

    @Column(name = "DELIVERY_AGENT_ID")
    private Long deliveryAgent_id;
}

接下来，您需要创建一个EmployerDeliveryAgent 类。这个类代表Employer和DeliveryAgent之间的多对多关系：

@Entity
@Table(name = "EmployerDeliveryAgent")
public class EmployerDeliveryAgent implements Serializable {

    @EmbeddedId
    private EmployerDeliveryAgentPK id;

    @ManyToOne
    @MapsId("employer_id") //This is the name of attr in EmployerDeliveryAgentPK class
    @JoinColumn(name = "EMPLOYER_ID")
    private Employer employer;

    @ManyToOne
    @MapsId("deliveryAgent_id")
    @JoinColumn(name = "DELIVERY_AGENT_ID")
    private DeliveryAgent deliveryAgent;    
}

之后，在Employer类中你需要添加：

    @OneToMany(mappedBy = "deliveryAgent")
    private Set<EmployerDeliveryAgent> employerDeliveryAgent = new HashSet<EmployerDeliveryAgent>();

并且在DeliveryAgent类中你需要添加：

    @OneToMany(mappedBy = "employer")
    private Set<EmployerDeliveryAgent> employer = new HashSet<EmployerDeliveryAgent>();

这就是全部！祝你好运！！

Answer 3

好的，我根据提供的解决方案让它工作了

http://en.wikibooks.org/wiki/Java_Persistence/ManyToMany#Mapping_a_Join_Table_with_Additional_Columns.

此解决方案不会在数据库上生成重复的属性，但它会在我的 JPA 实体中生成重复的属性（这是非常可接受的，因为您可以将额外的工作传递给构造函数或方法 - 它最终是透明的）。数据库中生成的主键和外键100%正确。

如链接所述，我不能使用 @PrimaryKeyJoinColumn 而是使用 @JoinColumn(name = "projectId", updatable = false, insertable = false, referencedColumnName = "id")。另一件值得一提的事情：我必须使用 EntityManager.persist(association)，这在链接的示例中是缺失的。

所以我的最终解决方案是：

@Entity
public class Employee {
  @Id
  private long id;
  ...
  @OneToMany(mappedBy="employee")
  private List<ProjectAssociation> projects;
  ...
}

@Entity
public class Project {

  @PersistenceContext
  EntityManager em;

  @Id
  private long id;
  ...
  @OneToMany(mappedBy="project")
  private List<ProjectAssociation> employees;
  ...
  // Add an employee to the project.
  // Create an association object for the relationship and set its data.
  public void addEmployee(Employee employee, boolean teamLead) {
    ProjectAssociation association = new ProjectAssociation();
    association.setEmployee(employee);
    association.setProject(this);
    association.setEmployeeId(employee.getId());
    association.setProjectId(this.getId());
    association.setIsTeamLead(teamLead);
    em.persist(association);

    this.employees.add(association);
    // Also add the association object to the employee.
    employee.getProjects().add(association);
  }
}

@Entity
@Table(name="PROJ_EMP")
@IdClass(ProjectAssociationId.class)
public class ProjectAssociation {
  @Id
  private long employeeId;
  @Id
  private long projectId;
  @Column(name="IS_PROJECT_LEAD")
  private boolean isProjectLead;
  @ManyToOne
  @JoinColumn(name = "employeeId", updatable = false, insertable = false,
          referencedColumnName = "id")

  private Employee employee;
  @ManyToOne
  @JoinColumn(name = "projectId", updatable = false, insertable = false,
          referencedColumnName = "id")

  private Project project;
  ...
}

public class ProjectAssociationId implements Serializable {

  private long employeeId;

  private long projectId;
  ...

  public int hashCode() {
    return (int)(employeeId + projectId);
  }

  public boolean equals(Object object) {
    if (object instanceof ProjectAssociationId) {
      ProjectAssociationId otherId = (ProjectAssociationId) object;
      return (otherId.employeeId == this.employeeId) 
              && (otherId.projectId == this.projectId);
    }
    return false;
  }

}