Aucun sérialiseur trouvé pour la classe org.hibernate.proxy.pojo.javassist.Javassist?

Je travaille sur SpringMVC, Hibernateet JSONmais je reçois cette erreur.

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) ) 

Veuillez vérifier mon entité ci-dessous

    @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;
    }

    }

Comment puis-je resoudre ceci?

J'ai eu un problème similaire avec le chargement paresseux via l'objet proxy d'hibernation. Contournez-le en annotant la classe ayant des propriétés privées chargées paresseusement avec:

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

Je suppose que vous pouvez ajouter les propriétés de votre objet proxy qui interrompent la sérialisation JSON à cette annotation.

Le problème est que les entités sont chargées paresseusement et que la sérialisation se produit avant qu'elles ne soient complètement chargées.

Hibernate.initialize(<your getter method>);

Juste pour ajouter cela, j'ai rencontré le même problème, mais les réponses fournies n'ont pas fonctionné. Je l'ai corrigé en prenant la suggestion de l'exception et en l'ajoutant au fichier application.properties ...

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

J'utilise Spring Boot v1.3 avec Hibernate 4.3

Il sérialise désormais l'objet entier et les objets imbriqués.

MODIFIER: 2018

Comme cela reçoit encore des commentaires, je vais clarifier ici. Cela ne cache absolument que l'erreur. Les implications sur les performances sont là. À l'époque, j'avais besoin de quelque chose pour livrer et travailler dessus plus tard (ce que j'ai fait en n'utilisant plus de ressort). Alors oui, écoutez quelqu'un d'autre si vous voulez vraiment résoudre le problème. Si vous voulez juste qu'il disparaisse pour le moment, utilisez cette réponse. C'est une idée terrible, mais diable, pourrait fonctionner pour vous. Pour mémoire, je n'ai plus jamais eu de crash ou de problème après cela. Mais c'est probablement la source de ce qui a fini par être un cauchemar de performances SQL.

Comme il est correctement suggéré dans les réponses précédentes, le chargement différé signifie que lorsque vous récupérez votre objet de la base de données, les objets imbriqués ne sont pas récupérés (et peuvent être récupérés plus tard si nécessaire).

Maintenant, Jackson tente de sérialiser l'objet imbriqué (== en faire du JSON), mais échoue car il trouve JavassistLazyInitializer au lieu de l'objet normal. C'est l'erreur que vous voyez. Maintenant, comment le résoudre?

Comme suggéré précédemment par CP510, une option est de supprimer l'erreur par cette ligne de configuration:

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

Mais cela concerne les symptômes, pas la cause . Pour le résoudre avec élégance, vous devez décider si vous avez besoin de cet objet en JSON ou non?

1. Si vous avez besoin de l'objet dans JSON, supprimez l' FetchType.LAZYoption du champ qui le provoque (il peut également s'agir d'un champ dans un objet imbriqué, pas seulement dans l'entité racine que vous récupérez).

2. Si vous n'avez pas besoin de l'objet en JSON, annotez le getter de ce champ (ou le champ lui-même, si vous n'avez pas besoin d'accepter les valeurs entrantes non plus) avec @JsonIgnore, par exemple:

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

Si vous avez des besoins plus complexes (par exemple des règles différentes pour différents contrôleurs REST utilisant la même entité), vous pouvez utiliser les vues ou le filtrage jackson ou pour un cas d'utilisation très simple, récupérer les objets imbriqués séparément.

Vous pouvez utiliser le module complémentaire pour Jackson qui gère le chargement paresseux d'Hibernate.

Plus d'informations sur https://github.com/FasterXML/jackson-datatype-hibernate qui prend en charge les hibernates 3 et 4 séparément.

Je pense que le problème est la façon dont vous récupérez l'entité.

Peut-être que vous faites quelque chose comme ça:

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

Essayez d'utiliser la méthode getau lieu deload

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

Le problème est qu'avec la méthode de chargement, vous obtenez juste un proxy mais pas le vrai objet. L'objet proxy n'a pas les propriétés déjà chargées, donc lorsque la sérialisation se produit, il n'y a aucune propriété à sérialiser. Avec la méthode get, vous obtenez réellement l'objet réel, cet objet pourrait en fait être sérialisé.

ça marche pour moi

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

par exemple

@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;

}

Il existe deux façons de résoudre le problème.

Voie 1 :

Ajouter spring.jackson.serialization.fail-on-empty-beans=falsedans application.properties

Voie 2 :

Utilisez join fetchdans la requête JPQL pour récupérer les données de l'objet parent, voir ci-dessous:

@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); 

Ajoutez cette annotation à la classe d'entité (modèle) qui fonctionne pour moi, cela provoque un chargement paresseux via l'objet proxy d'hibernation.

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

Cette exception

org.springframework.http.converter.HttpMessageNotWritableException

obtenir parce que, je l'espère, vous envoyez une sortie de réponse en tant qu'objet sérialisable.
C'est un problème qui se produit au printemps. Pour résoudre ce problème, envoyez un objet POJO comme sortie de réponse.

Exemple :

    @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

Dans le contrôleur, convertissez les champs d'objet sérialisables en champs de classe POJO et retournez la classe pojo en sortie.

         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.

Dans Hibernate 5.2 et supérieur, vous pouvez supprimer le proxy d'hibernation comme ci-dessous, il vous donnera l'objet réel afin que vous puissiez le sérialiser correctement:

Object unproxiedEntity = Hibernate.unproxy( proxy );

Pour Hibernate, vous pouvez utiliser le projet jackson-datatype-hibernate pour gérer la sérialisation / désérialisation JSON avec des objets à chargement différé.

Par exemple,

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 solution est inspirée de la solution ci-dessous par @marco. J'ai également mis à jour sa réponse avec ces datails.

Le problème ici concerne le chargement paresseux des sous-objets, où Jackson ne trouve que des proxys d'hibernation, au lieu d'objets complets.

Il nous reste donc deux options: supprimer l'exception, comme ci-dessus dans la réponse la plus votée ici, ou s'assurer que les objets LazyLoad sont chargés.

Si vous choisissez d'utiliser la dernière option, la solution serait d'utiliser la bibliothèque jackson-datatype et de configurer la bibliothèque pour initialiser les dépendances de chargement différé avant la sérialisation.

J'ai ajouté une nouvelle classe de configuration pour ce faire.

@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;
}

}

@Primarys'assure qu'aucune autre configuration Jackson n'est utilisée pour initialiser d'autres beans. @Beanest comme d'habitude. module.enable(Hibernate5Module.Feature.FORCE_LAZY_LOADING);consiste à activer le chargement différé des dépendances.

Attention - Veuillez surveiller son impact sur les performances. Parfois, EAGER fetch aide, mais même si vous le rendez impatient, vous aurez toujours besoin de ce code, car les objets proxy existent toujours pour tous les autres mappages sauf@OneToOne

PS: Comme commentaire général, je découragerais la pratique de renvoyer l'objet de données entier dans la réponse Json. On devrait utiliser des Dto pour cette communication, et utiliser un mappeur comme mapstruct pour les mapper. Cela vous évite les failles de sécurité accidentelles, ainsi que l'exception ci-dessus.

J'ai le même problème en ce moment. vérifiez si vous corrigez la récupération paresseux avec un @jsonIQgnore

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

Supprimez simplement le "(fetch = ...)" ou l'annotation "@jsonIgnore" et cela fonctionnera

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

Ou vous pouvez configurer le mappeur comme:

// configuration personnalisée pour le chargement paresseux

public static class HibernateLazyInitializerSerializer extends JsonSerializer<JavassistLazyInitializer> {

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

et configurez le mappeur:

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

Cela pourrait être votre relation d'entité Hibernate à l'origine du problème ... arrêtez simplement le chargement paresseux de cette entité associée ... par exemple ... J'ai résolu ci-dessous en définissant lazy = "false" pour 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>

J'ai changé (dans la classe de modèle Annotation)

fetch = FetchType.LAZY

à

fetch = FetchType.EAGER

et a bien fonctionné ...

Aimer.

C'est un problème avec Jackson. Pour éviter cela, demandez à Jackson de ne pas sérialiser la relation imbriquée ou la classe imbriquée.

Regardez l'exemple suivant. Classe d' adresses mappée aux classes Ville , État et Pays et l'État lui-même pointe vers Pays et Pays pointant vers Région. Lorsque vous obtenez des valeurs d'adresse via l'API REST Spring Boot, vous obtiendrez l'erreur ci-dessus. Pour éviter cela, sérialisez simplement la classe mappée (qui reflète le JSON de niveau un) et ignorez les relations imbriquées avec @JsonIgnoreProperties(value = {"state"}), @JsonIgnoreProperties(value = {"country"})et @JsonIgnoreProperties(value = {"region"})

Cela empêchera l'exception Lazyload avec l'erreur ci-dessus. Utilisez le code ci-dessous comme exemple et modifiez vos classes de modèle.

Address.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;

}

Ville.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;
}

Essayer

implements interface Serializable