Nessun serializzatore trovato per la classe org.hibernate.proxy.pojo.javassist.Javassist?

Sto lavorando su SpringMVC, Hibernatee JSONma sto ottenendo questo errore.

HTTP Status 500 - Could not write JSON: No serializer found for class org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationConfig.SerializationFeature.FAIL_ON_EMPTY_BEANS) ) 

Si prega di controllare la mia entità di seguito

    @Entity
@Table(name="USERS")
public class User {

    @Id
    @GeneratedValue
    @Column(name="USER_ID")
    private Integer userId;

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

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


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

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

    @Column(name="USER_PHONE_NO")
    private Integer phoneNo;

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

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

    @Transient
    private String token;

    @Column(name="USER_CREATED_ON")
    private Date createdOn;

    @OneToMany(fetch=FetchType.EAGER,cascade=CascadeType.ALL)
    @Fetch(value = FetchMode.SUBSELECT)
    @JoinTable(name = "USER_ROLES", joinColumns = { @JoinColumn(name = "USER_ID") }, inverseJoinColumns = { @JoinColumn(name = "ROLE_ID") })
    private List<ActifioRoles> userRole = new ArrayList<ActifioRoles>();


    @OneToMany(fetch=FetchType.EAGER,cascade=CascadeType.ALL,mappedBy="userDetails")
    @Fetch(value = FetchMode.SUBSELECT)
    private List<com.actifio.domain.Address> userAddress = new ArrayList<com.actifio.domain.Address>();

    @OneToOne(cascade=CascadeType.ALL)
    private Tenant tenantDetails;


    public Integer getUserId() {
        return userId;
    }
    public void setUserId(Integer userId) {
        this.userId = userId;
    }
    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    public String getEmailId() {
        return emailId;
    }
    public void setEmailId(String emailId) {
        this.emailId = emailId;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getConfPassword() {
        return confPassword;
    }
    public void setConfPassword(String confPassword) {
        this.confPassword = confPassword;
    }
    public Date getCreatedOn() {
        return createdOn;
    }
    public void setCreatedOn(Date createdOn) {
        this.createdOn = createdOn;
    }

    public List<ActifioRoles> getUserRole() {
        return userRole;
    }

    public void setUserRole(List<ActifioRoles> userRole) {
        this.userRole = userRole;
    }
    public String getMiddleName() {
        return middleName;
    }
    public void setMiddleName(String middleName) {
        this.middleName = middleName;
    }
    public Integer getPhoneNo() {
        return phoneNo;
    }
    public void setPhoneNo(Integer phoneNo) {
        this.phoneNo = phoneNo;
    }

    public List<com.actifio.domain.Address> getUserAddress() {
        return userAddress;
    }
    public void setUserAddress(List<com.actifio.domain.Address> userAddress) {
        this.userAddress = userAddress;
    }
    public Tenant getTenantDetails() {
        return tenantDetails;
    }
    public void setTenantDetails(Tenant tenantDetails) {
        this.tenantDetails = tenantDetails;
    }
    public String getToken() {
        return token;
    }
    public void setToken(String token) {
        this.token = token;
    }

    }

Come posso risolvere questo?

Ho avuto un problema simile con il caricamento lento tramite l'oggetto proxy di ibernazione. Ho aggirato il problema annotando la classe con proprietà private caricate in modo pigro con:

@JsonIgnoreProperties({"hibernateLazyInitializer", "handler"})

Presumo che tu possa aggiungere le proprietà sul tuo oggetto proxy che interrompe la serializzazione JSON a quell'annotazione.

Il problema è che le entità vengono caricate lentamente e la serializzazione avviene prima che vengano caricate completamente.

Hibernate.initialize(<your getter method>);

Solo per aggiungere questo, mi sono imbattuto in questo stesso problema, ma le risposte fornite non hanno funzionato. L'ho risolto prendendo il suggerimento dell'eccezione e aggiungendo al file application.properties ...

spring.jackson.serialization.fail-on-empty-beans=false

Sto usando Spring Boot v1.3 con Hibernate 4.3

Ora serializza l'intero oggetto e gli oggetti nidificati.

EDIT: 2018

Poiché questo riceve ancora commenti, chiarirò qui. Questo nasconde assolutamente solo l'errore. Le implicazioni sulle prestazioni ci sono. A quel tempo, avevo bisogno di qualcosa da consegnare e lavorarci su in seguito (cosa che ho fatto non usando più la molla). Quindi sì, ascolta qualcun altro se vuoi davvero risolvere il problema. Se vuoi solo che finisca per ora, vai avanti e usa questa risposta. È un'idea terribile, ma diamine, potrebbe funzionare per te. Per la cronaca, non si è più verificato un arresto anomalo o un problema dopo questo. Ma probabilmente è la fonte di quello che è finito per essere un incubo di prestazioni SQL.

Come è stato correttamente suggerito nelle risposte precedenti, il caricamento lento significa che quando si recupera il proprio oggetto dal database, gli oggetti nidificati non vengono recuperati (e possono essere recuperati in seguito, se necessario).

Ora Jackson prova a serializzare l'oggetto annidato (== ne ricava JSON), ma fallisce poiché trova JavassistLazyInitializer invece del normale oggetto. Questo è l'errore che vedi. Ora, come risolverlo?

Come suggerito in precedenza dal CP510, un'opzione è sopprimere l'errore con questa riga di configurazione:

spring.jackson.serialization.fail-on-empty-beans=false

Ma si tratta dei sintomi, non della causa . Per risolverlo elegantemente, devi decidere se hai bisogno di questo oggetto in JSON o no?

1. Se hai bisogno dell'oggetto in JSON, rimuovi l' FetchType.LAZYopzione dal campo che lo causa (potrebbe anche essere un campo in qualche oggetto nidificato, non solo nell'entità radice che stai recuperando).

2. Se non è necessario l'oggetto in JSON, annota il getter di questo campo (o il campo stesso, se non è necessario accettare i valori in entrata) con @JsonIgnore, ad esempio:

   // this field will not be serialized to/from JSON @JsonIgnore private NestedType secret;

Se si hanno esigenze più complesse (ad esempio regole diverse per controller REST diversi che utilizzano la stessa entità), è possibile utilizzare visualizzazioni jackson o filtri o, per casi d'uso molto semplici, recuperare oggetti annidati separatamente.

Potresti usare il modulo aggiuntivo per Jackson che gestisce il caricamento lento di Hibernate.

Maggiori informazioni su https://github.com/FasterXML/jackson-datatype-hibernate che supporta l'ibernazione 3 e 4 separatamente.

Penso che il problema sia il modo in cui recuperi l'entità.

Forse stai facendo qualcosa del genere:

Person p = (Person) session.load(Person.class, new Integer(id));

Prova a usare il metodo getinvece diload

Person p = (Person) session.get(Person.class, new Integer(id));

Il problema è che con il metodo di caricamento ottieni solo un proxy ma non l'oggetto reale. L'oggetto proxy non ha le proprietà già caricate, quindi quando avviene la serializzazione non ci sono proprietà da serializzare. Con il metodo get si ottiene effettivamente l'oggetto reale, questo oggetto potrebbe infatti essere serializzato.

per me funziona

@JsonIgnoreProperties({"hibernateLazyInitializer","handler"})

per esempio

@Entity
@Table(name = "user")
@Data
@NoArgsConstructor
@JsonIgnoreProperties({"hibernateLazyInitializer","handler"})
public class User {

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

    private String name;

    private Date created;

}

Esistono due modi per risolvere il problema.

Modo 1 :

Aggiungi spring.jackson.serialization.fail-on-empty-beans=falsein application.properties

Modo 2 :

Utilizzare join fetchnella query JPQL per recuperare i dati dell'oggetto padre, vedere di seguito:

@Query(value = "select child from Child child join fetch child.parent Parent ",
           countQuery = "select count(*) from Child child join child.parent parent ")
public Page<Parent> findAll(Pageable pageable); 

Aggiungi questa annotazione alla classe di entità (modello) che funziona per me, questo causa il caricamento lento tramite l'oggetto proxy di ibernazione.

@JsonIgnoreProperties ({"hibernateLazyInitializer", "handler"})

Questa eccezione

org.springframework.http.converter.HttpMessageNotWritableException

ottenendo perché, spero di sì, stai inviando l'output della risposta come oggetto Serializable.
Questo è un problema che si verifica in primavera. Per superare questo problema, inviare l'oggetto POJO come output della risposta.

Esempio :

    @Entity
    @Table(name="user_details")
    public class User implements Serializable{

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

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

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

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

//setter and getters

Classe POJO:

public class UserVO {

    private int Id;
    private String userName;
    private String emailId;
    private String phone;
    private Integer active;

//setter and getters

Nel controller converte i campi oggetto personalizzabili in campi di classe POJO e restituite la classe pojo come output.

         User u= userService.getdetials(); // get data from database

        UserVO userVo= new UserVO();  // created pojo class object

        userVo.setId(u.getId());
        userVo.setEmailId(u.getEmailId());
        userVo.setActive(u.getActive());
        userVo.setPhone(u.getPhone());
        userVo.setUserName(u.getUserName());
       retunr userVo;  //finally send pojo object as output.

In Hibernate 5.2 e versioni successive, puoi rimuovere il proxy di ibernazione come di seguito, ti darà l'oggetto effettivo in modo da poterlo serializzare correttamente:

Object unproxiedEntity = Hibernate.unproxy( proxy );

Per Hibernate puoi usare il progetto jackson-datatype-hibernate per adattare la serializzazione / deserializzazione JSON con oggetti a caricamento lento.

Per esempio,

import com.fasterxml.jackson.databind.Module;
import com.fasterxml.jackson.datatype.hibernate5.Hibernate5Module;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class JacksonDatatypeHibernate5Configuration {

    // Register Jackson Hibernate5 Module to handle JSON serialization of lazy-loaded entities
    // Any beans of type com.fasterxml.jackson.databind.Module are automatically
    // registered with the auto-configured Jackson2ObjectMapperBuilder
    // https://docs.spring.io/spring-boot/docs/current/reference/html/howto-spring-mvc.html#howto-customize-the-jackson-objectmapper
    @Bean
    public Module hibernate5Module() {
        Hibernate5Module hibernate5Module = new Hibernate5Module();
        hibernate5Module.enable( Hibernate5Module.Feature.FORCE_LAZY_LOADING );
        hibernate5Module.disable( Hibernate5Module.Feature.USE_TRANSIENT_ANNOTATION );
        return hibernate5Module;
    }
}

La soluzione si ispira alla soluzione sottostante di @marco. Ho anche aggiornato la sua risposta con questi dati.

Il problema qui riguarda il caricamento lento dei sottooggetti, dove Jackson trova solo proxy ibernati, invece di oggetti in piena regola.

Quindi ci rimangono due opzioni: Sopprimi l'eccezione, come fatto sopra nella risposta più votata qui, o assicurati che gli oggetti LazyLoad siano caricati.

Se scegli di utilizzare quest'ultima opzione, la soluzione sarebbe utilizzare jackson-datatype libreria e configurare la libreria per inizializzare le dipendenze di caricamento lento prima della serializzazione.

Ho aggiunto una nuova classe di configurazione per farlo.

@Configuration
public class JacksonConfig extends WebMvcConfigurerAdapter {

@Bean
@Primary
public MappingJackson2HttpMessageConverter jacksonMessageConverter(){
    MappingJackson2HttpMessageConverter messageConverter = new MappingJackson2HttpMessageConverter();
    ObjectMapper mapper = new ObjectMapper();
    Hibernate5Module module = new Hibernate5Module();
    module.enable(Hibernate5Module.Feature.FORCE_LAZY_LOADING);
    mapper.registerModule(module);
    messageConverter.setObjectMapper(mapper);
    return messageConverter;
}

}

@Primarysi assicura che nessun'altra configurazione di Jackson venga utilizzata per inizializzare altri bean. @Beanè come al solito.module.enable(Hibernate5Module.Feature.FORCE_LAZY_LOADING);è abilitare il caricamento lento delle dipendenze.

Attenzione: prestare attenzione al suo impatto sulle prestazioni. a volte EAGER fetch aiuta, ma anche se lo rendi desideroso, avrai comunque bisogno di questo codice, perché gli oggetti proxy esistono ancora per tutti gli altri mapping tranne@OneToOne

PS: Come commento generale, scoraggerei la pratica di inviare l'intero oggetto dati nella risposta Json, uno dovrebbe usare Dto per questa comunicazione e usare un mappatore come mapstruct per mapparli. Questo ti salva da scappatoie accidentali di sicurezza, così come dalle eccezioni di cui sopra.

Ho lo stesso problema adesso. controlla se aggiusti fetch in lazy con @jsonIQgnore

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name="teachers")
@JsonIgnoreProperties("course")
Teacher teach;

Basta eliminare "(fetch = ...)" o l'annotazione "@jsonIgnore" e funzionerà

@ManyToOne
@JoinColumn(name="teachers")
@JsonIgnoreProperties("course")
Teacher teach;

Oppure puoi configurare il mapper come:

// configurazione personalizzata per il caricamento lento

public static class HibernateLazyInitializerSerializer extends JsonSerializer<JavassistLazyInitializer> {

    @Override
    public void serialize(JavassistLazyInitializer initializer, JsonGenerator jsonGenerator,
            SerializerProvider serializerProvider)
            throws IOException, JsonProcessingException {
        jsonGenerator.writeNull();
    }
}

e configura mappatore:

    mapper = new JacksonMapper();
    SimpleModule simpleModule = new SimpleModule(
            "SimpleModule", new Version(1,0,0,null)
    );
    simpleModule.addSerializer(
            JavassistLazyInitializer.class,
            new HibernateLazyInitializerSerializer()
    );
    mapper.registerModule(simpleModule);

Potrebbe essere la tua relazione di entità Hibernate a causare il problema ... semplicemente interrompi il caricamento lento di quell'entità correlata ... per esempio ... Ho risolto di seguito impostando lazy = "false" per customerType.

<class name="Customer" table="CUSTOMER">
        <id name="custId" type="long">
            <column name="CUSTID" />
            <generator class="assigned" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="phone" type="java.lang.String">
            <column name="PHONE" />
        </property>
        <property name="pan" type="java.lang.String">
            <column name="PAN" />
        </property>

        <many-to-one name="customerType" not-null="true" lazy="false"></many-to-one>
    </class>
</hibernate-mapping>

Ho cambiato (nella classe del modello di annotazione)

fetch = FetchType.LAZY

per

fetch = FetchType.EAGER

e ha funzionato in modo carino ...

Lo adoro.

Questo è un problema con Jackson. Per evitare ciò, istruire Jackson a non serializzare la relazione nidificata o la classe nidificata.

Guarda il seguente esempio. Classe indirizzo mappata alle classi Città , Stato e Paese e lo Stato stesso punta a Paese e Paese che punta a Regione. Quando si ottengono i valori dell'indirizzo tramite l'API REST di Spring boot, verrà visualizzato l'errore precedente. Per evitare che, di classe appena serialize mappata (che riflette un livello di JSON) e ignorare le relazioni nidificate con @JsonIgnoreProperties(value = {"state"}), @JsonIgnoreProperties(value = {"country"})e @JsonIgnoreProperties(value = {"region"})

Ciò impedirà l'eccezione Lazyload insieme all'errore precedente. Usa il codice seguente come esempio e modifica le classi del modello.

Indirizzo.java

@Entity
public class Address extends AbstractAuditingEntity
{
    private static final long serialVersionUID = 4203344613880544060L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;

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

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

    @ManyToOne
    @JoinColumn(name = "city_id")
    @JsonIgnoreProperties(value = {"state"})
    private City city;

    @ManyToOne
    @JoinColumn(name = "state_id")
    @JsonIgnoreProperties(value = {"country"})
    private State state;

    @ManyToOne
    @JoinColumn(name = "country_id")
    @JsonIgnoreProperties(value = {"region"})
    private Country country;

    @ManyToOne
    @JoinColumn(name = "region_id")
    private Region region;

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

    @ManyToOne
    @JoinColumn(name = "address_type_id", referencedColumnName = "id")
    private AddressType addressType;

}

City.java

@EqualsAndHashCode(callSuper = true)
@Entity
@Table(name = "city")
@Cache(region = "cityCache",usage = CacheConcurrencyStrategy.READ_WRITE)
@Data
public class City extends AbstractAuditingEntity
{
    private static final long serialVersionUID = -8825045541258851493L;

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name")
    //@Length(max = 100,min = 2)
    private String name;


    @ManyToOne
    @JoinColumn(name = "state_id")
    private State state;
}

State.java

@Entity
@Table(name = "state")
@Data
@EqualsAndHashCode(callSuper = true)
public class State extends AbstractAuditingEntity
{
    private static final long serialVersionUID = 5553856435782266275L;

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

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

    @Column(name = "name")
    @Length(max = 200, min = 2)
    private String name;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "country_id")
    private Country country;

}

Country.java

@Entity
@Table(name = "country")
@Data
@EqualsAndHashCode(callSuper = true)
public class Country extends AbstractAuditingEntity
{
    private static final long serialVersionUID = 6396100319470393108L;

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name")
    @Length(max = 200, min = 2)
    private String name;

    @Column(name = "code")
    @Length(max = 3, min = 2)
    private String code;

    @Column(name = "iso_code")
    @Length(max = 3, min = 2)
    private String isoCode;

    @ManyToOne
    @JoinColumn(name = "region_id")
    private Region region;
}

Provare

implements interface Serializable