estou tentando fazer uma consulta do tipo FindById. Porém ao solicitar a consulta uma lista deveria ser gerada. Esta apesar de estar no bd, nada aparece somente um json com a lista vazia. O que poderia ser? Seguem os códigos:

Entidade Residencial

testeconsultas.manytomany.entity;

import. jakarta.persistence.*;
import lombok.Data;

import java.util.HashSet;
import java.util.Set;

@Data
@Entity
@Table(name = "tb_residencial")
public class Residencial {

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

    @ManyToMany(fetch = FetchType.LAZY, cascade = {CascadeType.DETACH, CascadeType.MERGE, CascadeType.REFRESH })
    @JoinTable(
            name = "tb_residencial_lazer",
            joinColumns = @JoinColumn(name = "residencial_id"),
            inverseJoinColumns = @JoinColumn(name = "lazer_id")
    )
    private Set<Lazer> lazeres = new HashSet<>();

    public Residencial(){}

    public Residencial(Long id, String nome) {
        this.id = id;
        this.nome = nome;
    }

    public Set<Lazer> getLazeres() {
        return lazeres;
    }

}

Entidade lazer

package testeconsultas.manytomany.entity;

import jakarta.persistence.*;
import lombok.Data;

import java.util.HashSet;
import java.util.Set;


@Data
@Entity
@Table(name = "tb_lazer")
public class Lazer {

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

    @ManyToMany(mappedBy = "lazeres")
    private Set<Residencial> residenciais = new HashSet<>();

    public Lazer(){}

    public Lazer(Long id, String tipo) {
        this.id = id;
        this.tipo = tipo;
    }

    public Set<Residencial> getResidenciais() {
        return residenciais;
    }
}

ResidencialDTO

package testeconsultas.manytomany.dto;

import jakarta.persistence.*;
import lombok.Data;
import testeconsultas.manytomany.entity.Lazer;
import testeconsultas.manytomany.entity.Residencial;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

@Data
public class ResidencialDTO {

    private Long id;
    private String nome;
    private List<LazerDTO> lazeres = new ArrayList<>();

    public ResidencialDTO() {}

    public ResidencialDTO(Long id, String nome) {
        this.id = id;
        this.nome = nome;

    }

    public ResidencialDTO(Residencial entidade) {
        this.id = entidade.getId();
        this.nome = entidade.getNome();

    }

    public ResidencialDTO(Residencial residencial, Set<Lazer> lazeres) {
        this(residencial);
        lazeres.forEach(lazer -> this.lazeres.add(new LazerDTO(lazer)));
    }

    public List<LazerDTO> getLazeres() {
        return lazeres;
    }


}

LazerDTO

package testeconsultas.manytomany.dto;

import lombok.Data;
import testeconsultas.manytomany.entity.Lazer;
import testeconsultas.manytomany.entity.Residencial;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

@Data
public class LazerDTO {

    private Long id;
    private String tipo;

    //private List<ResidencialDTO> residenciais = new ArrayList<>();

    public LazerDTO(){}

    public LazerDTO(Long id, String tipo) {
        this.id = id;
        this.tipo = tipo;
    }

    public LazerDTO(Lazer lazer) {
        this.id = lazer.getId();
        this.tipo = lazer.getTipo();
    }

}

Service – Residencial

package testeconsultas.manytomany.service;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import testeconsultas.manytomany.dto.LazerDTO;
import testeconsultas.manytomany.dto.ResidencialDTO;
import testeconsultas.manytomany.entity.Lazer;
import testeconsultas.manytomany.entity.Residencial;
import testeconsultas.manytomany.exception.service.ControllerNotFoundException;
import testeconsultas.manytomany.repository.ILazerRepository;
import testeconsultas.manytomany.repository.IResidencialRepository;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

@Service
public class ResidencialService {

    private final IResidencialRepository residencialRepository;
    private final ILazerRepository lazerRepository;

    public ResidencialService(IResidencialRepository residencialRepository, ILazerRepository lazerRepository) {
        this.residencialRepository = residencialRepository;
        this.lazerRepository = lazerRepository;
    }

    @Transactional(readOnly = true)
    public Page<ResidencialDTO> findAll(PageRequest pagina){
        var residenciais = residencialRepository.findAll(pagina);
        return residenciais.map(x ->  new ResidencialDTO(x, x.getLazeres()));
    }

    @Transactional(readOnly = true)
    public ResidencialDTO findById(Long id) {
        var residencial = residencialRepository.findById(id)
                .orElseThrow(() -> new ControllerNotFoundException("Produto não encontrado"));
        return new ResidencialDTO(residencial, residencial.getLazeres());
    }

    @Transactional
    public ResidencialDTO saveResidencial(ResidencialDTO residencialDTO){
        var entity = new Residencial();
        mapperDTOtoEntity(residencialDTO, entity);
        var residencialSaved = residencialRepository.save(entity);

        return new ResidencialDTO(residencialSaved, residencialSaved.getLazeres());
    }

    private void mapperDTOtoEntity(ResidencialDTO dto, Residencial entity){
        entity.setNome(dto.getNome());

        for(LazerDTO lazerDTO: dto.getLazeres()){
            Lazer lazer = lazerRepository.getOne(lazerDTO.getId());
            entity.getLazeres().add(lazer);
        }

    }

}

Controller

package testeconsultas.manytomany.controller;

import jakarta.validation.Valid;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import testeconsultas.manytomany.dto.ResidencialDTO;
import testeconsultas.manytomany.service.ResidencialService;
import org.springframework.web.servlet.support.ServletUriComponentsBuilder;

import java.net.URI;
import java.util.UUID;

@RestController
@RequestMapping("/residencial-teste")
public class ResidencialController {

    private final ResidencialService residencialService;

    public ResidencialController(ResidencialService residencialService) {
        this.residencialService = residencialService;
    }

    @GetMapping
    public ResponseEntity<Page<ResidencialDTO>> findAll(
            @RequestParam(value = "pagina", defaultValue = "0") Integer pagina,
            @RequestParam(value = "tamanho", defaultValue = "10") Integer tamanho
    ) {
        PageRequest pageRequest = PageRequest.of(pagina, tamanho);
        var residenciais = residencialService.findAll(pageRequest);
        return ResponseEntity.ok(residenciais);
    }

    @GetMapping("/{id}")
    public ResponseEntity<ResidencialDTO> findById(@PathVariable Long id) {
        var residencial = residencialService.findById(id);
        return ResponseEntity.ok(residencial);
    }

    @PostMapping
    public ResponseEntity<ResidencialDTO> saveResidencial(
            @Valid
            @RequestBody ResidencialDTO dto
    ){
        ResidencialDTO residencialDTO =residencialService.saveResidencial(dto);
        URI uri = ServletUriComponentsBuilder.fromCurrentRequest().path("/{id}").buildAndExpand((residencialDTO.getId())).toUri();
        return ResponseEntity.created(uri).body(residencialDTO);
    }

}

Repository

package testeconsultas.manytomany.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import testeconsultas.manytomany.entity.Residencial;

@Repository
public interface IResidencialRepository extends JpaRepository<Residencial, Long> {
}

A ideia é ao consultar um Residencial venha junto todos os lazeres.