为什么需要PostPersist设置oneToOne子实体的ID？

时间：2019-08-18 19:51:36

标签： spring-boot jpa eclipselink

我正在尝试实现双向OneToOne映射，并从父实体（Project.java）插入子实体（ProjectDetails.java）。但是，实体管理器试图插入null作为子实体（ProjectDetails）的ID。

错误日志：

package com.example.playground.domain.dbo;

import com.example.playground.jsonviews.BasicView;
import com.example.playground.jsonviews.ProjectView;
import com.fasterxml.jackson.annotation.JsonView;
import lombok.Data;
import lombok.ToString;
import org.eclipse.persistence.annotations.JoinFetch;
import org.eclipse.persistence.annotations.JoinFetchType;

import javax.persistence.*;

@JsonView(BasicView.class)
@Data
@Entity
@Table(name = "project")
public class Project {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="project_id")
    private Integer projectId;

    @Column(name="name")
    private String name;

    @ToString.Exclude
    @JsonView(ProjectView.class)
    @OneToOne(mappedBy = "project", cascade = CascadeType.ALL, optional = false)
    private ProjectDetails projectDetails;

}

我尝试通过从@OneToOne中删除insertable = false和updatable = false的方法，但是这给了我一个错误，即同一列不能被两次引用。

我有以下实体类。

课程：项目

package com.example.playground.domain.dbo;

import com.example.playground.jsonviews.BasicView;
import com.example.playground.jsonviews.ProjectDetailsView;
import com.fasterxml.jackson.annotation.JsonView;
import lombok.Data;
import lombok.ToString;

import javax.persistence.*;

@JsonView(BasicView.class)
@Data
@Entity
@Table(name = "project_details")
public class ProjectDetails {

    @Id
    @Column(name = "project_id")
    private Integer projectId;

    @ToString.Exclude
    @JsonView(ProjectDetailsView.class)
    @OneToOne
    @JoinColumn(name = "project_id", nullable = false, insertable = false, updatable = false)
    private Project project;

    @Column(name = "details")
    private String details;


}

Class：ProjectDetails 

package com.example.playground.web;

import com.example.playground.domain.dbo.Project;
import com.example.playground.jsonviews.ProjectView;
import com.example.playground.service.ProjectService;
import com.fasterxml.jackson.annotation.JsonView;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/projects")
public class ProjectController {

    @Autowired
    private ProjectService projectService;

    @GetMapping("/{projectId}")
    @JsonView(ProjectView.class)
    public ResponseEntity<Project> getProject(@PathVariable Integer projectId){
        Project project = projectService.getProject(projectId);
        return ResponseEntity.ok(project);
    }

    @PostMapping
    @JsonView(ProjectView.class)
    public ResponseEntity<Project> createProject(@RequestBody Project projectDTO){
        Project project =  projectService.createProject(projectDTO);
        return ResponseEntity.ok(project);
    }


}

类：ProjectController 

package com.example.playground.service;

import com.example.playground.domain.dbo.Project;

public interface ProjectService {
    Project createProject(Project projectDTO);

    Project getProject(Integer projectId);
}

ProjectService类

package com.example.playground.impl.service;

import com.example.playground.domain.dbo.Project;
import com.example.playground.repository.ProjectRepository;
import com.example.playground.service.ProjectService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class ProjectServiceImpl implements ProjectService {

    @Autowired
    private ProjectRepository projectRepository;

    @Transactional
    @Override
    public Project createProject(Project projectDTO) {
        projectDTO.getProjectDetails().setProject(projectDTO);
        return projectRepository.saveAndFlush(projectDTO);
    }

    @Override
    public Project getProject(Integer projectId) {
        return projectRepository.findById(projectId).get();
    }
}

ProjectServiceImpl

类 
package com.example.playground.config;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.AdviceMode;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.EclipseLinkJpaVendorAdapter;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

@Configuration
@EnableTransactionManagement(mode= AdviceMode.ASPECTJ)
public class JPAConfig{

    @Bean("dataSource")
    @ConfigurationProperties(prefix = "db1")
    public DataSource getDataSource(){
        return DataSourceBuilder.create().build();
    }

    @Bean("entityManagerFactory")
    public LocalContainerEntityManagerFactoryBean getEntityManager(@Qualifier("dataSource") DataSource dataSource){
        EclipseLinkJpaVendorAdapter adapter = new EclipseLinkJpaVendorAdapter();
        LocalContainerEntityManagerFactoryBean em =  new LocalContainerEntityManagerFactoryBean();
        em.setPackagesToScan("com.example.playground.domain.dbo");
        em.setDataSource(dataSource);
        em.setJpaVendorAdapter(adapter);
        em.setPersistenceUnitName("persistenceUnit");
        em.setJpaPropertyMap(getVendorProperties());
        return em;
    }

    @Bean(name = "transactionManager")
    public JpaTransactionManager
    transactionManager(@Qualifier("entityManagerFactory") EntityManagerFactory entityManagerFactory)
    {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(entityManagerFactory);
        return transactionManager;
    }

    protected Map<String, Object> getVendorProperties()
    {
        HashMap<String, Object> map = new HashMap<String, Object>();
        map.put("eclipselink.ddl-generation", "none");
        map.put("eclipselink.ddl-generation.output-mode", "database");
        map.put("eclipselink.weaving", "static");
        map.put("eclipselink.logging.level.sql", "FINE");
        map.put("eclipselink.logging.parameters", "true");
        map.put(
                "eclipselink.target-database",
                "org.eclipse.persistence.platform.database.SQLServerPlatform");
        return map;
    }

}

JPAConfig 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>playground</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Java-Spring-Boot-Playground</name>
    <description>Java playground.</description>

    <properties>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-devtools -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>


        <!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-jpa -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>2.1.9.RELEASE</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>

        <dependency>
            <groupId>org.eclipse.persistence</groupId>
            <artifactId>org.eclipse.persistence.jpa</artifactId>
            <version>2.7.4</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.tomcat/tomcat-jdbc -->
        <dependency>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-jdbc</artifactId>
            <version>9.0.21</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

和pom.xml 

  @PostPersist
    public void fillIds(){
        projectDetails.setProjectId(this.projectId);
    }

编辑：可以正常运行，但仍在寻找解释

如果将以下代码添加到我的Project类中，它将按预期工作。

template <typename... Args>
void debug(Args&&... args,
           const std::source_location& loc = std::source_location::current());

购买为什么需要postPersist？如果将关系标记为oneToOne，JPA是否不应该自动填充这些值？有什么更好的方法吗？

1 个答案:

答案 0 :(得分：0)

JPA正在按照您的指示执行操作：您有两个到“ project_id”的映射，一个带有值的OneToOne是只读的。这意味着JPA必须从您保留为null的基本ID映射“ projectId”中提取值，从而使其在字段中插入null。

这是一个常见问题，JPA中有许多解决方案。首先应该将@ID映射标记为只读（insertable / updatable = false），然后让关系映射控制该值。

JPA 2.0引入了其他解决方案。 对于相同的设置，您可以使用@MapsId批注标记关系。这告诉JPA，关系外键值将在指定的ID映射中使用，并且将完全按照您的期望为您设置它，而无需postPersist方法。

JPA 2.0中的另一种替代方法是，您可以仅将OneToOne标记为ID映射，然后从类中删除projectId属性。 here

显示了更复杂的示例
相关问题
最新问题