$fields = [
    SomeEntity::class => [
        'id' => 'id',
        'public_serialized_name' => 'classFieldName',
    ],
    OtherEntity::class => ['id' => 'id', 'name' => 'name']
]

# src/Entity/Book.php

namespace App\Tests\Entity;

use Doctrine\ORM\Mapping as ORM;
use Maldoinc\Doctrine\Filter\Annotation\Expose as FilterExpose;

/**
 * @ORM\Entity
 */
class Book
{
    /**
     * @ORM\Id
     * @ORM\GeneratedValue
     * @ORM\Column(type="integer")
     * @FilterExpose
     */
    public $id;

    /**
     * @ORM\Column(name="name", type="string", length=255)
     * @FilterExpose
     */
    public $name;

    /**
     * @ORM\Column(type="json")
     */
    public $notMappedForFiltering;

    /**
     * @ORM\Column(type="datetime")
     * @FilterExpose(serializedName="published_at")
     */
    public $publishedAt;
}

# src/Service/FilteredQueryBuilder.php

namespace App\Service;

use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\Common\Annotations\CachedReader;
use Doctrine\Common\Cache\FilesystemCache;
use Doctrine\ORM\QueryBuilder;
use Maldoinc\Doctrine\Filter\DoctrineFilter;
use Maldoinc\Doctrine\Filter\ExposedFieldsReader;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\RequestStack;

class FilteredQueryBuilder
{
    public function __construct(private RequestStack $requestStack,
                                private string $cacheDir,
                                private bool $isDebug)
    {
    }

    public function createEntityJsonResponse(QueryBuilder $queryBuilder): JsonResponse
    {
        // Create a cached annotation reader in order to read the @Expose annotations
        // from the entities appearing in the query builder
        $reader = new CachedReader(
            new AnnotationReader(),
            // Example uses Filesystem cache but feel free to adapt
            // to any of the supported doctrine caching mechanisms
            new FilesystemCache($this->cacheDir),
            $this->isDebug
        );

        // Use the built-in reader based on the doctrine annotations reader.
        // You are free however to use something else if annotations
        // are not appropriate for your project.
        $fieldReader = new ExposedFieldsReader($reader);

        $filter = new DoctrineFilter($queryBuilder, $fieldReader->readExposedFields($queryBuilder));
        $filter->applyFromArray($this->requestStack->getCurrentRequest()->query->all());

        return new JsonResponse(['data' => $queryBuilder->getQuery()->getResult()]);
    }
}

# src/Controller/BookController.php

class BookController extends Controller
{
    #[Route("/book")]
    public function getList(BookRepository $repository, FilteredQueryBuilder $filteredQueryBuilder)
    { 
        // All that there's left to do is create a query builder based on the current
        //resource or entity being exposed and pass it to the service we just created.
        
        // Create a new query builder or otherwise call a method that returns one
        // from the entity repository
        $qb = $repository->createQueryBuilder('b');
        
        return $filteredQueryBuilder->createEntityJsonResponse($qb);
    }
}