我们有一个后端组件，通过 JPA 将数据库 (PostgreSQL) 数据公开给 RESTful API。
问题是当发送一个 JPA 实体作为 REST 响应时，我可以看到 Jackson 触发了所有 Lazy JPA 关系。
代码示例(简化):
import org.springframework.hateoas.ResourceSupport;
import com.fasterxml.jackson.annotation.JsonIdentityInfo;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;
import org.springframework.transaction.annotation.Transactional;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
@Entity
@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "id")//for resolving this bidirectional relationship, otherwise StackOverFlow due to infinite recursion
public class Parent extends ResourceSupport implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue
private Long id;
//we actually use Set and override hashcode&equals
@OneToMany(mappedBy = "parent", cascade = CascadeType.ALL)
private List<Child> children = new ArrayList<>();
@Transactional
public void addChild(Child child) {
child.setParent(this);
children.add(child);
}
@Transactional
public void removeChild(Child child) {
child.setParent(null);
children.remove(child);
}
public Long getId() {
return id;
}
@Transactional
public List<Child> getReadOnlyChildren() {
return Collections.unmodifiableList(children);
}
}
import com.fasterxml.jackson.annotation.JsonIdentityInfo;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import java.io.Serializable;
@Entity
@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "id")
public class Child implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue
private Long id;
@ManyToOne
@JoinColumn(name = "id")
private Parent parent;
public Long getId() {
return id;
}
public Parent getParent() {
return parent;
}
/**
* Only for usage in {@link Parent}
*/
void setParent(final Parent parent) {
this.parent = parent;
}
}
import org.springframework.data.repository.CrudRepository;
public interface ParentRepository extends CrudRepository<Parent, Long> {}
import com.avaya.adw.db.repo.ParentRepository;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.hateoas.Link;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
@RestController
@RequestMapping("/api/v1.0/parents")
public class ParentController {
private final String hostPath;
private final ParentRepository parentRepository;
public ParentController(@Value("${app.hostPath}") final String hostPath,
final ParentRepository parentRepository) {
// in application.properties: app.hostPath=/api/v1.0/
this.hostPath = hostPath;
this.parentRepository = parentRepository;
}
@CrossOrigin(origins = "*")
@GetMapping("/{id}")
public ResponseEntity<?> getParent(@PathVariable(value = "id") long id) {
final Parent parent = parentRepository.findOne(id);
if (parent == null) {
return new ResponseEntity<>(new HttpHeaders(), HttpStatus.NOT_FOUND);
}
Link selfLink = linkTo(Parent.class)
.slash(hostPath + "parents")
.slash(parent.getId()).withRel("self");
Link updateLink = linkTo(Parent.class)
.slash(hostPath + "parents")
.slash(parent.getId()).withRel("update");
Link deleteLink = linkTo(Parent.class)
.slash(hostPath + "parents")
.slash(parent.getId()).withRel("delete");
Link syncLink = linkTo(Parent.class)
.slash(hostPath + "parents")
.slash(parent.getId())
.slash("sync").withRel("sync");
parent.add(selfLink);
parent.add(updateLink);
parent.add(deleteLink);
parent.add(syncLink);
return new ResponseEntity<>(adDataSource, new HttpHeaders(), HttpStatus.OK);
}
}
所以，如果我发送 GET .../api/v1.0/parents/1，响应如下:
{
"id": 1,
"children": [
{
"id": 1,
"parent": 1
},
{
"id": 2,
"parent": 1
},
{
"id": 3,
"parent": 1
}
],
"links": [
{
"rel": "self",
"href": "http://.../api/v1.0/parents/1"
},
{
"rel": "update",
"href": "http://.../api/v1.0/parents/1"
},
{
"rel": "delete",
"href": "http://.../api/v1.0/parents/1"
},
{
"rel": "sync",
"href": "http://.../api/v1.0/parents/1/sync"
}
]
}
但我希望它不包含 children 或将其包含为空数组或 null -- 不从数据库中获取实际值。
该组件具有以下值得注意的 maven 依赖项:
- Spring Boot Starter 1.5.7.RELEASE - Spring Boot Starter Web 1.5.7.RELEASE (version from parent) - Spring HATEOAS 0.23.0.RELEASE - Jackson Databind 2.8.8 (it's 2.8.1 in web starter, I don't know why we overrode that) - Spring Boot Started Data JPA 1.5.7.RELEASE (version from parent) -- hibernate-core 5.0.12.Final
Tried so far
Debugging showed that there is one select on Parent at parentRepository.findOne(id) and another one on Parent.children during serialization.
At first, I tried applying @JsonIgnore to lazy collections, but that ignores the collection even if it actually contains something (has already been fetched).
I found out about jackson-datatype-hibernate project that claims to
build Jackson module (jar) to support JSON serialization and deserialization of Hibernate (http://hibernate.org) specific datatypes and properties; especially lazy-loading aspects.
The idea of this is to register Hibernate5Module (if version 5 of hibernate is used) to the ObjectMapper and that should do it as the module has a setting FORCE_LAZY_LOADING set to false by default.
So, I included this dependency jackson-datatype-hibernate5, version 2.8.10 (from parent). And googled a way to enable it in Spring Boot (I also found other sources but they mostly refer to this).
1. Straightforward add module (Spring Boot specific):
import com.fasterxml.jackson.databind.Module;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.hibernate5.Hibernate5Module;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class HibernateConfiguration {
@Bean
public Module disableForceLazyFetching() {
return new Hibernate5Module();
}
}
调试显示，Spring 在返回 Parent 时调用的 ObjectMapper 包含此模块，并且按预期将强制延迟设置设置为 false。但它仍然会获取 children。
进一步调试显示:com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields 遍历属性(com.fasterxml.jackson.databind.ser.BeanPropertyWriter) 并调用他们的方法serializeAsField，其中第一行是:final Object value = (_accessorMethod == null) ? _field.get(bean) : _accessorMethod.invoke(bean); 触发延迟加载。我找不到代码真正关心该 hibernate 模块的任何地方。
upd 还尝试启用 SERIALIZE_IDENTIFIER_FOR_LAZY_NOT_LOADED_OBJECTS 应该包含惰性属性的实际 ID，而不是 null(这是默认设置)。
@Bean
public Module disableForceLazyFetching() {
Hibernate5Module module = new Hibernate5Module();
module.enable(Hibernate5Module.Feature.SERIALIZE_IDENTIFIER_FOR_LAZY_NOT_LOADED_OBJECTS);
return module;
}
调试显示该选项已启用，但仍然无效。
<强>2。指示 Spring MVC 添加模块:
import com.fasterxml.jackson.datatype.hibernate5.Hibernate5Module;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import java.util.List;
@Configuration
@EnableWebMvc
public class HibernateConfiguration extends WebMvcConfigurerAdapter {
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder()
.modulesToInstall(new Hibernate5Module());
converters.add(new MappingJackson2HttpMessageConverter(builder.build()));
}
}
这也成功地将模块添加到正在调用的 ObjectMapper 中，但在我的情况下它仍然没有效果。
3.将 ObjectMapper 完全替换为新的:
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.hibernate5.Hibernate5Module;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
@Configuration
public class HibernateConfiguration {
@Primary
@Bean(name = "objectMapper")
public ObjectMapper hibernateAwareObjectMapper(){
ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new Hibernate5Module());
return mapper;
}
}
再次，我可以看到模块已添加，但这对我没有任何影响。
还有其他方法可以添加此模块，但我没有失败，因为添加了模块。
最佳答案
作为一种可能的解决方案，Vlad Mihalcea建议我不要打扰 jackson-datatype-hibernate project 并简单地构建一个 DTO。我一直试图强制 jackson 做我想做的事，持续 3 天，每次 10-15 小时，但我放弃了。
在阅读了 Vlad 关于如何 EAGER fetching is bad 的博文后，我从另一个方面研究了获取原理一般来说——我现在明白了，尝试为整个应用程序定义要获取的属性和不获取的属性是一个坏主意(即在使用 fetch 注释属性的实体内部@Basic 或 @OneToMany 或 @ManyToMany)。在某些情况下，这将导致额外的延迟获取或在其他情况下不必要的急切获取受到惩罚。也就是说，我们需要创建一个自定义查询 and a DTO对于每个 GET 端点。对于 DTO，我们不会遇到任何与 JPA 相关的问题，这也将让我们移除数据类型依赖。
还有更多要讨论的内容:正如您在代码示例中所见，为了方便起见，我们将 JPA 和 HATEOAS 耦合在一起。虽然总体上并没有那么糟糕，但考虑到前面关于“最终属性获取选择”的段落以及我们为每个 GET 创建一个 DTO，我们可能会将 HATEOAS 移至该 DTO。此外，从扩展 ResourseSupport 类中释放 JPA 实体可以扩展与业务逻辑实际相关的父级。
关于java - Jackson 在序列化时触发 JPA Lazy Fetching，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47989857/