您可以通过创建一个CustomJpaRepository一次性定义EntityManager，而不是在每个resource中定义EntityManager。参考
然后直接在每个存储库中使用EntityManager的refresh。
请参考以下示例：

自定义存储库接口

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.repository.NoRepositoryBean;

import java.io.Serializable;

@NoRepositoryBean
public interface CustomRepository<T, ID extends Serializable> extends JpaRepository<T, ID> {
  void refresh(T t);
}

自定义存储库实施

import org.springframework.data.jpa.repository.support.JpaEntityInformation;
import org.springframework.data.jpa.repository.support.SimpleJpaRepository;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.EntityManager;
import java.io.Serializable;

public class CustomRepositoryImpl<T, ID extends Serializable> extends SimpleJpaRepository<T, ID>
    implements CustomRepository<T, ID> {

  private final EntityManager entityManager;

  public CustomRepositoryImpl(JpaEntityInformation entityInformation, EntityManager entityManager) {
    super(entityInformation, entityManager);
    this.entityManager = entityManager;
  }

  @Override
  @Transactional
  public void refresh(T t) {
    entityManager.refresh(t);
  }
}

在Sping Boot 应用程序类中启用自定义JPARepository

@SpringBootApplication
@EnableJpaRepositories (repositoryBaseClass = CustomRepositoryImpl.class)
public class Application {
  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

您的信息库

public interface SomethingRepository extends CustomRepository<Something, Long> {

}

直接在SomethingResource中使用Refresh（假设Something是实体）

@RestController
@RequestMapping("/api")
@Transactional
public class SomethingResource {

    private final SomethingRepository somethingRepository;

    public SomethingResource(SomethingRepository somethingRepository) {
        this.somethingRepository = somethingRepository;
    }

    @PostMapping("/somethings")
    public Something createSomething(@RequestBody Something something) throws URISyntaxException {
        Something result = somethingRepository.save(something);
        somethingRepository.refresh(result);
        return result;
    }
}

这还不够：

Something result = somethingRepository.save(something);

您需要手动合并传入实体：

Something dbSomething = somethingRepository.findOne(
    Something.class, something.getId()
);
dbSomething.setName(something.getName());
dbSomething.setOwner(something.getOwner());

somethingRepository.save(dbSomething);

由于property属性使用默认的FetchType.EAGER，因此实体应初始化property属性。
但是，从REST控制器调用Repository两次是很奇怪的。你应该有一个服务层，它在@Transactional服务方法中完成所有这些工作。这样，你就不需要重新保存实体了，因为它已经被管理了。

@Transactional
public Something mergeSomething(Something something) {
    Something dbSomething = somethingRepository.findOne(
        Something.class, something.getId()
    );
    dbSomething.setName(something.getName());
    dbSomething.setOwner(something.getOwner());

    return dbSomething;
}

现在，您需要小心地合并发送的每个属性。在您的示例中，如果您发送null来替换property，则应该决定是否应该使@ManyToOne引用无效。因此，这取决于您当前的应用程序业务逻辑需求。

更新

如果您确保总是返回先前获取的相同实体，则可以使用merge。

em.merge(result);

但是您的property属性只是一个id，而不是一个实际的子实体，因此您必须在服务层中自己解决这个问题。

在Sping Boot JpaRepository中：
如果我们的修改查询更改了持久性上下文中包含的实体，则此上下文将过时。
以便从数据库中提取具有最新记录的实体。
修改时使用（自动清除= true）
@Modifying注解具有clearAutomatically属性，该属性定义是否应在执行修改查询后清除基础持久性上下文。
示例：

@Modifying(clearAutomatically = true)
@Query("UPDATE NetworkEntity n SET n.network_status = :network_status WHERE n.network_id = :network_id")
        int expireNetwork(@Param("network_id") Integer network_id,  @Param("network_status") String network_status);

我将用使用session.load生成的代理替换该属性

something.setProperty(session.load(Property.class, something.getProperty().getId()))
        Something result = somethingRepository.save(something);
        return result;

现在，结果将从数据库中加载整个属性对象

在持久化实体时，它将处于托管状态，因此，如果只调用something.getProperty();，它将从数据库加载并填充something实体的property值

public Something save(Something something) {
    em.persist(something);
    something.getProperty();
    return something;
}

所以通常当你有多对一的关系时，应该自动获取。如果没有调用实体中对象的getter，也会通过触发一个新的DBFind请求来填充它们。