设置“持久化”时忽略级联类型合并

Question

Hy全部

我很难解决次年Spring的jpa问题。假设我有以下简单的数据模型（两个实体之间有单向关系）

@Accessors(chain = true) @Getter @Setter  @NoArgsConstructor @AllArgsConstructor
@MappedSuperclass
public class AbstractEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @Version
    private Long version;
}

@Accessors(chain = true) @Getter @Setter  @NoArgsConstructor @AllArgsConstructor
@Entity
public class Entity1 extends AbstractEntity {

    private String name;    
}

@Accessors(chain = true) @Getter @Setter  @NoArgsConstructor @AllArgsConstructor
@Entity
public class Entity2 extends AbstractEntity {

    private String name;
    
    @ManyToOne(cascade={ALL})
    private Entity1 entity1;
}

和下面的管道来存储它们

public interface Entity1Dao extends JpaRepository< Entity1, Long >, JpaSpecificationExecutor< Entity1 > {
    
    Entity1 findByName(String name);
}

public interface Entity2Dao extends JpaRepository< Entity2, Long >, JpaSpecificationExecutor< Entity2 > {
    
    Entity2 findByName(String name);    
}

@Service
public class StoreService {

    @Autowired
    Entity1Dao dao1;
    
    @Autowired
    Entity2Dao dao2;
    
    @Transactional
    public Entity1 saveEntity1(Entity1 e) {
        return dao1.save(e);
    }

    @Transactional
    public Entity2 saveEntity2(Entity2 e) {
        return dao2.save(e);
    }

    public Entity1 loadEntity1ByName(String name) {
        return dao1.findByName(name);
    }
}

@SpringBootApplication
public class JpaDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(JpaDemoApplication.class, args);
    }
}

下面的测试

@SpringBootTest
@TestMethodOrder(value = MethodOrderer.OrderAnnotation.class)
class JpaDemoApplicationTests {

    @Autowired
    StoreService store;
    
    @Test
    @Order(1)
    void contextLoads() {
        assertThat(store).isNotNull();
    }

    @Test
    @Order(2)
    void insertEntity1() {
        store.saveEntity1(new Entity1("test entity1"));
        Entity1 saved = store.loadEntity1ByName("test entity1");
        assertThat(saved).isNotNull().hasNoNullFieldsOrProperties();
    }
    
    @Test
    @Order(4)
    void insertEntity2WithNewEntity1() {
        store.saveEntity2(new Entity2("with new entity1", new Entity1("new entity1")));
    }
    
    @Test
    @Order(5)
    void insertEntity2WithExistingEntity1() {
        store.saveEntity2(new Entity2("with saved entity1", store.loadEntity1ByName("test entity1")));
    }
}

最后一次测试（即insertEntity2WithExistingEntity1）失败，出现以下异常

组织。冬眠PersistentObjectException:传递给persist:com的分离实体。实例杰帕德莫。实体1

如果我将Entity2中的CascadeType更改为MERGE，则该测试通过，但insertEntity2WithNewEntity1失败，出现以下异常

org.hibernate.瞬态属性：对象引用未保存的瞬态实例-在刷新之前保存瞬态实例：com.example.jpa演示。Entity2.entity1-

我尝试了多种级联类型的组合，但似乎只要使用PERSIST，最后的测试就会失败（所有测试都包括PERSIST）。

我本以为如果设置了MERGE和PERSIST，它们都会处于活动状态，但从测试来看，设置PERSIST时似乎忽略了MERGE。有什么线索，提示，暗示我做错了什么，这样两个测试都可以运行吗？？？

编辑

这些测试被认为是模仿REST服务endpoint的行为，转发和保存实体的json rerenentation 1。

第三次测试的json是

{ name: "with new entity1", entity1: { name: "new entity1"}}

第四个的json是

{ name: "with new entity1", entity1: { id: 1, version: 0, name: "test entity1"}}

JPA应该在第三个测试中保留entity1，因为它的id是null，但是应该在第四个测试中合并一个，因为它的id不是null。

然而，我不能两者兼而有之，不是一个就是另一个。

编辑2

我稍微修改了Entity1，以引用与其关联的Entity2列表，并使用@OneToMany和Entity2中相同的级联类型对其进行注释，其行为与Entity2相同。

当我将级联类型设置为MERGE并且仅设置Merge时，我能够保存具有对现有实体的引用的新实体，但不能保存具有对新实体的引用的新实体。

当我将级联类型设置为PERSIST（即PERSIST本身、PERSIST和MERGE或ALL）时，它是相反的；我可以通过引用另一个新实体来保存一个新实体，但我不能通过引用已经存在的新实体来保存一个新实体一。

因此，当设置PERSIST时，它似乎覆盖了MERGE的行为。对我来说，这是一个错误。不是吗？

我已经将源代码上传到github，以防您想亲自进行实验或查看。https://github.com/willix71/persistVsMerge.git

Answer 1

我不确定这是否相关，但下面的代码正如我所期望的那样工作。删除“cascade=CascadeType.PERSIST”将使持久化测试失败，“对象引用了一个未保存的瞬态实例”。

我还注意到，在您的github repo中，您正在尝试从父级到子级以及子级到父级进行级联。我认为这是你问题的根本原因。

实体：

@Entity
@Table(name = "users")
@Getter
@Setter
@NoArgsConstructor
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    UUID id;

    @ManyToOne(cascade = CascadeType.PERSIST)
    Address address;
}

@Entity
@Getter
@Setter
@NoArgsConstructor
public class Address {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    Long id;

    @OneToMany(mappedBy = "address")
    List<User> user;
}

存储库：

public interface UserRepository extends JpaRepository<User, UUID> {
}

public interface AddressRepository extends JpaRepository<Address, UUID> {
}

测验：

@DataJpaTest
@Import(DataSourceConfig.class)
class UserRepositoryTest {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private AddressRepository addressRepository;

    @Test
    void testMerge() {
        var address = new Address();
        addressRepository.save(address);

        var user = new User();
        user.setAddress(address);
        userRepository.save(user);

        assertThat(userRepository.findAll()).contains(user);
        assertThat(addressRepository.findAll()).contains(address);
    }  

    @Test
    void testPersist() {
        var address = new Address();

        var user = new User();
        user.setAddress(address);
        userRepository.save(user);

        assertThat(userRepository.findAll()).contains(user);
        assertThat(addressRepository.findAll()).contains(address);
    }
 }

Answer 2

您需要在上次测试中添加@Transactional。加载的实体是分离的，因为没有外部事务，您不能持久化它。

@Test
@Order(5)
@Transactional
void insertEntity2WithExistingEntity1() {
    store.saveEntity2(new Entity2("with saved entity1", store.loadEntity1ByName("test entity1")));
}