No serializer found for class ByteBuddyInterceptor

Question

I kept getting this error while calling an API (under development) in my spring boot app:

java.base/java.lang.Thread.run(Thread.java:1623)
Caused by: com.fasterxml.jackson.databind.exc.InvalidDefinitionException: 
No serializer found for class 
org.hibernate.proxy.pojo.bytebuddy.ByteBuddyInterceptor 
and no properties discovered to create BeanSerializer 
(to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS) 
(through reference chain: com.example.service.model.Listing[\"project\"]-
>com.example.service.model.Project[\"user\"]->com.example.service.model.User$HibernateProxy$Nf8nVUyV[\"company\"]-
>com.example.service.model.Company$HibernateProxy$ulaPUlxC[\"hibernateLazyInitializer\"])

From my research, it looks like it's caused by Jackson not being able to serialize the object into json.

Here's my code exerpts:

Model:

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "listing")
public class Listing {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "id")
  private Long id;

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "project_id", referencedColumnName = "id")
  private Project project;

  @NotNull
  @Column(name = "limit")
  private Integer limit;

  ...
}

Controller:

@RestController
@AllArgsConstructor
@RequestMapping("/listing")
public class ListingController {
  private final ListingService listingService;

  @PostMapping
  public ResponseEntity<?> create(@Valid @RequestBody CreateListingRequest request) {
    Listing listing = listingService.create(request);
    return new ResponseEntity<>(listing,  HttpStatus.CREATED);
  }

I set the breakpoint on the return line in the controller while debugging and observed a valid object constructed before it was serialized, so everything up to the serialization step is working.

What I've tried:

• Turning off spring.jackson.serialization.FAIL_ON_EMPTY_BEANS through both application.properties file and via a custom bean:

  @Bean
  @Primary
  public ObjectMapper objectMapper() {
    return new ObjectMapper().disable(SerializationFeature.FAIL_ON_EMPTY_BEANS)
        .setVisibility(PropertyAccessor.FIELD, Visibility.ANY);
  }

• Setting visibility to "visible to all" (via the bean code above). But this shouldn't be necessary since Lombok does this already through annotations in the model;
• Setting FetchType from LAZY to EAGER;
• Adding @JoinColumn annotation for project field;
• Adding the @OneToMany counterpart in the Project class (with property listings);
• Adding @JsonIgnore for project property. This actually solves the problem, but this causes problem with deserialization - the project field becomes null during deserilization;

I'm looking for a way to make this work for both serialization and deserialization.

Answer 1

I think you are a victim of a bad design. You are exposing your database entity objects via REST controller, which is considered as antipattern. Apart from the bad architecture, it brings you the technical problems you are facing.

Ideally you should have three layers (repository/entities, domain/business logic, enpoint/data tranfser objects). Each layer should have their own objects, which should not mix, even if they look more or less the same.

The reason is, among others, that you are free to change (and free to keep stable) your API and your database model separately from each other. It also gives you free hands to design each layer's objects optimally for their purpose.

Mapping between the objects from different layers does not cost you much work, you may use a framework such as MapStruct.

If you omit the service layer, at least you should not expose your database entities via endpoints.

Create a separate ListingDto and ProjectDto and use a mapper to fill them with the data from your Listing and Project objects. The entity should be designed for the database, and DTO should be designed for JSON serialization/deserialization. Most probably if the DTOs are (Lombok-powered) POJOs tailored for you API, you will not even need any JSON annotations at all!

Database and REST API are two different worlds - do not mix them. <opinionated>Hibernate aka ORM is antipattern on its own</opinionated>, but mixing it with JSON serialization is a design disaster per se.

Thus you will give your program a proper design, and as an extra reward your Jackson will not have to bother with the hibernate crap and your problem will be solved for free.

ADDED: In case you have problems with Lombok + MapStruct, which sometimes do not cooperate well, there is a Maven config for it. See the aswers to MapStruct and Lombok not working together