相关疑难解决方法(0)

杰克逊抛出一个奇怪的例外,我不知道如何解决.我正在使用Spring,Hibernate和Jackson.

我已经考虑过延迟加载会导致问题,但我已采取措施告诉Jackson不要处理各种属性,如下所示:

@JsonIgnoreProperties({ "sentMessages", "receivedMessages", "educationFacility" })
public class Director extends UserAccount implements EducationFacilityUser {
   ....
}

我也为所有其他UserAccount子类做了同样的事情.

这是抛出的异常:

org.codehaus.jackson.map.JsonMappingException: No serializer found for class org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS) ) (through reference chain: java.util.ArrayList[46]->jobprep.domain.educationfacility.Director_$$_javassist_2["handler"])
    at org.codehaus.jackson.map.ser.StdSerializerProvider$1.serialize(StdSerializerProvider.java:62)
    at org.codehaus.jackson.map.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:268)
    at org.codehaus.jackson.map.ser.BeanSerializer.serializeFields(BeanSerializer.java:146)
    at org.codehaus.jackson.map.ser.BeanSerializer.serialize(BeanSerializer.java:118)
    at org.codehaus.jackson.map.ser.ContainerSerializers$IndexedListSerializer.serializeContents(ContainerSerializers.java:236)
    at org.codehaus.jackson.map.ser.ContainerSerializers$IndexedListSerializer.serializeContents(ContainerSerializers.java:189)
    at org.codehaus.jackson.map.ser.ContainerSerializers$AsArraySerializer.serialize(ContainerSerializers.java:111)
    at org.codehaus.jackson.map.ser.StdSerializerProvider._serializeValue(StdSerializerProvider.java:296)
    at org.codehaus.jackson.map.ser.StdSerializerProvider.serializeValue(StdSerializerProvider.java:224)
    at org.codehaus.jackson.map.ObjectMapper.writeValue(ObjectMapper.java:925)
    at org.springframework.http.converter.json.MappingJacksonHttpMessageConverter.writeInternal(MappingJacksonHttpMessageConverter.java:153)

有关如何获取更多信息以查看导致此问题的建议？谁知道怎么修它？

编辑:我发现代理对象上存在getHander()和其他get*()方法.GRR!有什么办法我可以告诉杰克逊不要在代理上处理任何事情,或者我是谁？这真的很奇怪,因为吐出JSON的方法只会在某些情况下崩溃,而不是一直崩溃.尽管如此,这是由于代理对象上的get*()方法.

旁白:代理是邪恶的.它们破坏了Jackson,equals()和常规Java编程的许多其他部分.我很想完全放弃Hibernate:/

这是关于JPA瞬态注释的以下问题的后续操作 为什么JPA有@Transient注释？

我有一个我不想持久的瞬态变量,它标有瞬态注释.但是,当我想从我的其余控制器生成JSON时,此瞬态变量在输出的JSON中不可用.

POJO PublicationVO是直接的,没有花哨的属性,只有一些私有属性(持久化)有getter和setter以及1个瞬态变量.

@RequestMapping(value = { "{publicationId}"}, method = RequestMethod.GET, produces = "application/json")
@ResponseBody public PublicationVO getPublicationDetailsJSON(@PathVariable(value = "publicationId") Integer publicationId) {
    LOG.info("Entered getPublicationDetailsJSON - publicationId: " + publicationId);

    //Call method to get the publicationVO based on publicationId
    PublicationVO publicationVO = publicationServices.getPublicationByIdForRestCalls(publicationId);       
    LOG.info("publicationVO:{}", publicationVO);

    LOG.info("Exiting getPublicationDetailsJSON");
    return publicationVO;
}

PublicationVO如下

    package com.trinity.domain.dao;

import java.util.Calendar;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.persistence.Transient;

import com.fasterxml.jackson.annotation.JsonInclude;

@Entity
@Table(name …

我正在构建一个使用和返回JSON的RESTful Web服务.当我尝试通过服务层从数据库中获取ESRBRating对象时,我遇到了以下堆栈跟踪.但是,当我将Spring Data JPA存储库直接注入控制器并使用它来获取ESRBRating ID时,它可以正常工作.但是,当通过服务层调用时,它不起作用.我在下面提供了堆栈跟踪和代码.有人可以向我解释为什么在通过服务层时会发生这种情况,而不是直接通过Spring Data JPA存储库时会发生这种情况吗？我该如何解决这个问题？

堆栈跟踪

Caused by: org.hibernate.LazyInitializationException: could not initialize proxy - no Session
    at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:165)
    at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:286)
    at org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer.invoke(JavassistLazyInitializer.java:185)
    at net.jkratz.igdb.model.ESRBRating_$$_jvst319_0.getId(ESRBRating_$$_jvst319_0.java)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:606)
    at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:466)
    at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:639)
    ... 76 more

调节器

@RestController
@RequestMapping(produces = "application/json", value="/esrbrating")
public class ESRBRatingController {

    @Inject
    ESRBRatingService esrbRatingService;

    @Inject
    ESRBRatingRepository esrbRatingRepository;

    private Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * Returns all ESRB ratings in database
     * 
     * @return List of ESRBRating objects
     * @see …

我有一个实体:

@Entity
public class Book {

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

    @Column
    private String title;

    @OneToMany(fetch = FetchType.LAZY, mappedBy = ("movie"),cascade = CascadeType.ALL)
    private List<Genre> genre;

}

然后我有一个控制器,其目的是检索书籍,我的问题是,类型字段被包含在我的控制器的json响应中.任何方式我可以排除那些杰克逊序列化对象时延迟加载的字段？

这是我的ObjectMapper的配置:

Hibernate4Module hm = new Hibernate4Module();
hm.configure(Hibernate4Module.Feature.FORCE_LAZY_LOADING, false);
registerModule(hm);
configure(SerializationFeature.INDENT_OUTPUT, true);

谢谢!

我无法将其标记为JsonIgnore,因为它将永远不在序列化框中.有时候我需要随书检索这些类型,然后我会在查询中使用"fetch join",这样它就不会为空.

我正在尝试用angularjs和springmvc构建一个应用程序.我有两个类省和Comunidad.:

@Entity(name="Provincia")
@Table(name="T_PROVINCIA")
public class Provincia implements Serializable{


private String idProvincia;
private String nombre;    
private Comunidad refComunidad;

public Provincia() {
}

@Id
@TableGenerator(name="provinciaGen",
                table="T_GENERATOR",
                pkColumnName="ID_GENERATOR",
                pkColumnValue="ID_PROVINCIA",
                valueColumnName="ID_VALUE")
@GeneratedValue(generator="provinciaGen",strategy=GenerationType.TABLE)
@Column(name="ID_PROVINCIA")
public String getIdProvincia() {
    return idProvincia;
}

@Column(name="NOMBRE")
public String getNombre() {
    return nombre;
}

@ManyToOne(targetEntity=Comunidad.class, fetch=FetchType.LAZY)
@JoinColumn(name="ID_COMUNIDAD")
public Comunidad getRefComunidad() {
    return refComunidad;
}
setters
.....
.....
}

@Entity(name="Comunidad")
@Table(name="T_COMUNIDAD")
public class Comunidad implements Serializable{

@Id   
@TableGenerator(name="comunidadGen",
                table="T_GENERATOR",
                pkColumnName="ID_GENERATOR",
                pkColumnValue="ID_COMUNIDAD",
                valueColumnName="ID_VALUE")
@GeneratedValue(generator="comunidadGen",strategy=GenerationType.TABLE)
@Column(name="ID_COMUNIDAD")
private String idComunidad;

@Column(name="NOMBRE")
private String nombre; …

我使用Spring并创建一个REST服务.

这是我的控制器的一部分:

@RequestMapping("/get")
public @ResponseBody Person getPerson() {
    Person person = personRepository.findOne(1L);
    //(1) person.setRoles(null);
    return person;
}

该人的角色是懒惰的初始化,当时不需要.当(1)被注释掉时,一切都会失败

org.springframework.http.converter.HttpMessageNotWritableException:无法编写JSON:懒得初始化角色集合:no.something.project.Person.roles,无法初始化代理 - 没有会话等

我可以通过执行(1),手动将其设置为null(或其他一些值)来解决这个问题,因此当Jackson尝试序列化我的对象时它不会失败.

然而,这很烦人,必须在不同的地方做很多次.我想要一些简单的解决方案,在未初始化时忽略那些延迟的初始化字段,或者只是将它们设置为null.

注意:@JsonIgnore对象的值不是解决方案,因为在其他情况下我希望包含这些值.

在 Spring Data Rest 项目中处理延迟加载代理时，使用 Jackson 的Hibernate4Module来处理序列化问题。

一般来说，它解决了 Jackson 尝试序列化未初始化代理的问题，但一个副作用是 JSON 输出不同：

直接获取：api/cases/5400

{
   "id": 5400,
   "practiceReference": "DWPYI9"
}

通过延迟加载的 @ManyToOne 获取：api/submissions/11901/parentCase

{
   "content": {
      "id": 5400,
      "practiceReference": "DWPYI9"
   }
}

通过非延迟加载的 @ManyToOne 获取：api/submissions/11901/parentCase

{
   "id": 5400,
   "practiceReference": "DWPYI9"
}

从上面可以看出，序列化惰性@ManyToOne关联时 JSON 表示有所不同：实体包装在content节点中。

如果关联是非惰性的，则无论路径如何，都会写入相同的表示形式。

这是否有原因，并且可以以某种方式阻止附加的“内容”节点吗？

2017 年 2 月更新：

我在这里找到了相同的（已删除的）问题：

/sf/ask/2323618811/ different-resulting-jsons-when-serializing-lazy-objects-and-simple-objects

这是从这个 github 问题中引用的。另外，这里报告了，所以似乎是一个已知问题：

我正在用java-hibernate-spring实现服务器REST，它返回一个json

我已经映射了多对多关系。

我会更好地解释，我有一个供应商，其中列出了成分清单，每种成分都有一个供应商清单。

我创建了表：

CREATE TABLE supplier_ingredient (
supplier_id BIGINT,
ingredient_id BIGINT
)


ALTER TABLE supplier_ingredient ADD CONSTRAINT supplier_ingredient_pkey 
PRIMARY KEY(supplier_id, ingredient_id);

ALTER TABLE supplier_ingredient ADD CONSTRAINT 
fk_supplier_ingredient_ingredient_id FOREIGN KEY (ingredient_id) 
REFERENCES ingredient(id);

ALTER TABLE supplier_ingredient ADD CONSTRAINT 
fk_supplier_ingredient_supplier_id FOREIGN KEY (supplier_id) REFERENCES 
supplier(id);

然后我有成分模型：

.....
.....
@ManyToMany(mappedBy = "ingredients")
@OrderBy("created DESC")
@BatchSize(size = 1000)
private List<Supplier> suppliers = new ArrayList<>();
....
....

然后我有供应商模型：

....
@ManyToMany
@JoinTable( name = "supplier_ingredient ", 
        joinColumns = @JoinColumn(name = "supplier_id", …

我目前正在运行一个spring-boot应用程序,其中端点返回存储在数据库中的特定对象的Page.为了我们的目的,我们称该对象为"x".在"x"中,有一个设置为延迟取出的对象列表.

@Entity
@DynamicUpdate
class x {

      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private Integer id;

      @JsonIgnore
      @OneToMany(mappedBy = "x", cascade = CascadeType.MERGE, fetch = FetchType.LAZY)
      private List<y> lazilyFetchedList;

      @Override
      public Integer getId() {
           return id;
      }

      public void setId(Integer id) {
           this.id = id;
      }

      @JsonIgnore
      public List<y> getLazilyFetchedList() {
           return lazilyFetchedList;
      }

      public void setLazilyFetchedList(List<y> lazilyFetchedList) {
           this.lazilyFetchedList = lazilyFetchedList;
      }
}

我在@JsonIgnore上面设置是因为我不希望lazilyFetchedList在GET呼叫时被发送到客户端.

我的问题是,尽管杰克逊作为查看JSON响应的客户端成功忽略了该字段.但是,当序列化Java对象"x"时,hibernate仍然会获取额外的查询lazilyFetchedList(即使jackson没有使用结果). …

类型异常报告

消息无法写入内容:无法初始化懒洋洋角色的集合:edu.waa.classified.dto.User.products,无法初始化代理 - 没有会话(通过参考链:java.util.ArrayList中的[0] - > EDU .waa.classified.dto.User [ "产品"]); 嵌套的例外是com.fasterxml.jackson.databind.JsonMappingException:无法初始化懒洋洋角色的集合:edu.waa.classified.dto.User.products,无法初始化代理 - 没有会话(通过参考链:java.util中. ArrayList的[0] - > edu.waa.classified.dto.User [ "产品"])

description服务器遇到内部错误,导致无法完成此请求.