文章/答案/技术大牛

发布

社区首页 >问答首页 >Hibernate复合主键

问Hibernate复合主键
EN

Stack Overflow用户

提问于 2012-11-21 13:42:37

回答 1查看 7.2K关注 0票数 2

我在使用带有复合主键的hibernate实体集时遇到了问题。

我们的应用程序中有一个概念"Target“。目标id应该是其他三个表(实体)主id的组合。Target也有一个int标记。员工应该有一个目标集合。SQL如下所示：

CREATE TABLE IF NOT EXISTS `target` (
  `role_id` bigint(20) NOT NULL,
  `ApplicationPeriod_id` bigint(20) NOT NULL,
  `project_class_id` bigint(20) NOT NULL,
  `target` int(11) NOT NULL,
  PRIMARY KEY (`role_id`,`ApplicationPeriod_id`,`project_class_id`),
  KEY `fk_role_id` (`role_id`),
  KEY `fk_ApplicationPeriod_id` (`ApplicationPeriod_id`),
  KEY `fk_project_class_id` (`project_class_id`),
  KEY `FKCB7E71918717386C` (`project_class_id`),
  KEY `FKCB7E7191BEC322C1` (`ApplicationPeriod_id`),
  KEY `FKCB7E71917B617197` (`role_id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

这个SQL运行得很好，只要应用程序周期和项目分类不同，它就允许我为每个role_id (员工)创建多个目标。

这是targetID类

@Embeddable
public class TargetId implements Serializable {

    @ManyToOne
    private Employee employee;

    @ManyToOne
    private ApplicationPeriod applicationPeriod;

    @ManyToOne
    private ProjectClass projectClass;


    public Employee getEmployee() {
        return employee;
    }

    public void setEmployee(Employee employee) {
        this.employee = employee;
    }

    public ApplicationPeriod getApplicationPeriod() {
        return applicationPeriod;
    }

    public void setApplicationPeriod(ApplicationPeriod applicationPeriod) {
        this.applicationPeriod = applicationPeriod;
    }

    public ProjectClass getProjectClass() {
        return projectClass;
    }

    public void setProjectClass(ProjectClass projectClass) {
        this.projectClass = projectClass;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof TargetId)) return false;

        TargetId that = (TargetId) o;

        if (applicationPeriod != null ? !applicationPeriod.equals(that.applicationPeriod) : that.applicationPeriod != null)
            return false;
        if (employee != null ? !employee.equals(that.employee) : that.employee != null) return false;
        if (projectClass != null ? !projectClass.equals(that.projectClass) : that.projectClass != null) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = employee != null ? employee.hashCode() : 0;
        result = 31 * result + (applicationPeriod != null ? applicationPeriod.hashCode() : 0);
        result = 31 * result + (projectClass != null ? projectClass.hashCode() : 0);
        return result;
    }
}

这是目标类

@Entity
@Table(name = "target")
@AssociationOverrides({
        @AssociationOverride(name = "targetId.employee",
            joinColumns = @JoinColumn(name = "role_id")),
        @AssociationOverride(name = "targetId.applicationPeriod",
            joinColumns = @JoinColumn(name = "ApplicationPeriod_id")),
        @AssociationOverride(name = "targetId.projectClass",
                joinColumns = @JoinColumn(name = "project_class_id"))
})
public class Target implements Serializable {

    @EmbeddedId
    private TargetId targetId;

    private int target;

    public TargetId getTargetId() {
        return targetId;
    }

    public void setTargetId(TargetId targetId) {
        this.targetId = targetId;
    }

    public int getTarget() {
        return target;
    }

    public void setTarget(int target) {
        this.target = target;
    }

    public Target() {
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Target)) return false;

        Target target = (Target) o;

        if (this.target != target.target) return false;
        if (targetId != null ? !targetId.equals(target.targetId) : target.targetId != null)
            return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = targetId != null ? targetId.hashCode() : 0;
        result = 31 * result + target;
        return result;
    }
}

这是employee类，我希望在其中为每个员工存储一组目标。

@Entity
@Cacheable(true)
@Cache(usage= CacheConcurrencyStrategy.NONSTRICT_READ_WRITE) //Hibernate specific
public class Employee {

    ...

    @OneToMany(fetch = FetchType.LAZY, mappedBy = "targetId.employee", cascade=CascadeType.ALL, orphanRemoval=true)
    private Set<Target> targets = new HashSet<Target>();

    public Set<Target> getTargets() {
        return targets;
    }

    public void setTargets(Set<Target> targets) {
        this.targets = targets;
    }

    ...

}

通过hibernate创建和存储目标是可行的，并且数据库中的所有内容看起来都很好。问题是，即使数据库允许每个员工存储多个目标，只要应用程序周期和项目类不同，Hibernate就不会为每个员工存储多个目标，无论应用程序周期和项目类是否不同。我做错了什么？如何让Hibernate让我为每个员工存储多个目标？

composite-primary-key

java

hibernate

回答 1

Stack Overflow用户

回答已采纳

发布于 2012-11-22 10:27:56

好了，我想通了。问题似乎是TargetID类不能使用实体属性，而应该使用Longs来指向有问题的实体的in。然后使用SQL在数据库中设置正确的约束和列之间的连接。

SQL：

CREATE TABLE IF NOT EXISTS `target` (
  `applicationPeriodId` bigint(20) NOT NULL,
  `employeeId` bigint(20) NOT NULL,
  `projectClassId` bigint(20) NOT NULL,
  `target` int(11) NOT NULL,
  PRIMARY KEY (`applicationPeriodId`,`employeeId`,`projectClassId`),
  KEY `FKCB7E71913353DC5C` (`employeeId`),
  KEY `FKCB7E7191A520201E` (`projectClassId`),
  KEY `FKCB7E7191790761A4` (`applicationPeriodId`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

--
-- Constraints for table `target`
--
ALTER TABLE `target`
  ADD CONSTRAINT `FKCB7E7191790761A4` FOREIGN KEY (`applicationPeriodId`) REFERENCES `ApplicationPeriod` (`id`),
  ADD CONSTRAINT `FKCB7E71913353DC5C` FOREIGN KEY (`employeeId`) REFERENCES `role` (`id`),
  ADD CONSTRAINT `FKCB7E7191A520201E` FOREIGN KEY (`projectClassId`) REFERENCES `project_class` (`id`);

复合ID类：

@Embeddable
public class TargetId implements Serializable {

    @Basic
    private Long employeeId;

    @Basic
    private Long applicationPeriodId;

    @Basic
    private Long projectClassId;

    public Long getEmployeeId() {
        return employeeId;
    }

    public void setEmployeeId(Long employeeId) {
        this.employeeId = employeeId;
    }

    public Long getApplicationPeriodId() {
        return applicationPeriodId;
    }

    public void setApplicationPeriodId(Long applicationPeriodId) {
        this.applicationPeriodId = applicationPeriodId;
    }

    public Long getProjectClassId() {
        return projectClassId;
    }

    public void setProjectClassId(Long projectClassId) {
        this.projectClassId = projectClassId;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof TargetId)) return false;

        TargetId targetId = (TargetId) o;

        if (applicationPeriodId != null ? !applicationPeriodId.equals(targetId.applicationPeriodId) : targetId.applicationPeriodId != null)
            return false;
        if (employeeId != null ? !employeeId.equals(targetId.employeeId) : targetId.employeeId != null) return false;
        if (projectClassId != null ? !projectClassId.equals(targetId.projectClassId) : targetId.projectClassId != null)
            return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = employeeId != null ? employeeId.hashCode() : 0;
        result = 31 * result + (applicationPeriodId != null ? applicationPeriodId.hashCode() : 0);
        result = 31 * result + (projectClassId != null ? projectClassId.hashCode() : 0);
        return result;
    }
}

目标实体：

@Entity
@Table(name = "target")
@AssociationOverrides({
        @AssociationOverride(name = "targetId.employeeId",
            joinColumns = @JoinColumn(name = "role_id")),
        @AssociationOverride(name = "targetId.applicationPeriodId",
            joinColumns = @JoinColumn(name = "ApplicationPeriod_id")),
        @AssociationOverride(name = "targetId.projectClassId",
                joinColumns = @JoinColumn(name = "project_class_id"))
})
public class Target implements Serializable {

    @EmbeddedId
    private TargetId targetId;

    private int target;

    public TargetId getTargetId() {
        return targetId;
    }

    public void setTargetId(TargetId targetId) {
        this.targetId = targetId;
    }

    public int getTarget() {
        return target;
    }

    public void setTarget(int target) {
        this.target = target;
    }

    public Target() {
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Target)) return false;

        Target target = (Target) o;

        if (this.target != target.target) return false;
        if (targetId != null ? !targetId.equals(target.targetId) : target.targetId != null)
            return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = targetId != null ? targetId.hashCode() : 0;
        result = 31 * result + target;
        return result;
    }
}

Employee实体，它包含一组目标：

@Entity
@Cacheable(true)
@Cache(usage= CacheConcurrencyStrategy.NONSTRICT_READ_WRITE) //Hibernate specific
public class Employee extends ProjectTeamMember {
    ...
    public Set<Language> getLanguages() {
        return languages;
    }

    public void setLanguages(Set<Language> languages) {
        this.languages = languages;
    }

    @OneToMany(fetch = FetchType.LAZY, mappedBy = "targetId.employeeId", cascade=CascadeType.ALL, orphanRemoval=true)
    private Set<Target> targets = new HashSet<Target>();

    public Set<Target> getTargets() {
        return targets;
    }

    public void setTargets(Set<Target> targets) {
        this.targets = targets;
    }    
    ...
}

票数 5

页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持

原文链接：

https://stackoverflow.com/questions/13487070

复制

相似问题

问Hibernate复合主键
EN

回答 1

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Hibernate复合主键EN

回答 1

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Hibernate复合主键
EN