class Article
{
    private $id;
    private $content;

    public function getId()
    {
        return $this->id;
    }

    public function getContent()
    {
        return $this->content;
    }

    public function setContent($content)
    {
        $this->content = $content;

        return $this;
    }
}

class Article
{
    private $id;
    private $content;

    public function __construct(string $content)
    {
        $this->content = $content;
    }

    public function getId()
    {
        return $this->id;
    }

    public function getContent()
    {
        return $this->content;
    }
}

class Article
{
    private $id;
    private $content;

    public function __construct(string $content)
    {
        if (empty($content)) {
            throw new ArticleHasNoContent();
        }
        $this->content = $content;
    }

    public function getId(): int
    {
        return $this->id;
    }

    public function getContent(): string
    {
        return $this->content;
    }
}

class ArticleContent
{
    private $content;

    public function __construct(string $content)
    {
        if (empty($content)) {
            throw new ArticleHasNoContent();
        }
        $this->content = $content;
    }
}

use App\Domain\Article\Article;
use App\Domain\Article\ArticleContent;
use App\Domain\Article\ArticleTitle;

new Article(
  new ArticleTitle('my title'),
  new ArticleContent('This is a very short but nice article'),
  new \DateTimeImmutable(),
);

class Article
{
    public static function createFromNative(string $title, string $content): self
    {
        return new self(
          new ArticleTitle($title),
          new ArticleContent($content),
          new \DateTimeImmutable()
        );
    }
}

use Doctrine\DBAL\Types\Type;

final class ArticleContentType extends Type
{
    public function convertToPHPValue($value, AbstractPlatform $platform): ArticleContent
    {
        return new ArticleContent($value);
    }

    public function convertToDatabaseValue($value, AbstractPlatform $platform): string
    {
        return (string) $value;
    }

    public function getName()
    {
        return 'article_content';
    }
}

# config/packages/doctrine.yaml
doctrine:
    dbal:
        types:
            article_content:  App\Infrastructure\Persistence\ArticleContentType

use Doctrine\ORM\Annotation as ORM;

class Article
{
    private $uuid;

    /** @ORM\Embedded(class = "ArticleContent") */
    private $articleContent;

    public function __construct(ArticleContent $articleContent)
    {
        $this->uuid = Uuid::generate();
        $this->articleContent = $articleContent;
    }
}

/** @ORM\Embeddable() **/
class ArticleContent
{
    /** @ORM\Column() **/
    private $content;

    /** @ORM\Column() **/
    private $lastModification;
}

use Doctrine\ORM\Annotation as ORM;

class Article
{
    private $uuid;

    /** @ORM\Embedded(class = "ArticleContent", nullable=true) */
    private $articleContent;
}

class ArticleRepository extends ServiceEntityRepository
{
    public function __construct(RegistryInterface $registry)
    {
        parent::__construct($registry, Article::class);
    }

    // your methods
}

final class DoctrineArticleRepository implements ArticleRepository, ServiceEntityRepositoryInterface
{
    private $entityManager;

    public function __construct(ManagerRegistry $registry)
    {
        $this->entityManager = $registry->getManagerForClass(Article::class);
    }

    // your methods…
}

// Récupère votre repository d'article custom !
$repository = $entityManager->getRepository(Article::class);

interface ArticleRepository
{
    public function latestArticles(int size): iterable;
    public function mostReadArticles(int size): iterable;
    public function mostCommentedArticles(int size): iterable;
    public function byTopic(ArticleTopic $topic): iterable;
    public function findRelated(Article $article): iterable;

    // more and more methods…
}

final class DoctrineGetLatestArticles implements GetLatestArticles
{
    public function __construct(EntityManagerInterface $entityManager)
    {
        $this->entityManager = $entityManager;
    }

    public function __invoke(int $size): iterable
    {
        $this->entityManager->createQueryBuilder()
          ->select('a.*')
          ->from(Article::class)
          ->orderBy('a.createdAt', 'DESC')
          ->setMaxResults($size)
          ->getQuery()
          ->getResults();
    }
}

services:
    App\Domain\Article\GetLatestArticles:
        '@App\Infrastructure\Article\DoctrineGetLatestArticles'

class Article
{
    private $comments;

    public function __construct()
    {
        $this->comments = [];
    }

    public function getComments(): iterable
    {
        return $this->comments;
    }
}

$queryBuilder
  ->select('a.*')
  ->from(Article::class)
  ->innerJoin(Comment::class, 'c', Expr\Join::WITH, 'c.article_id = a.id')
  ->where("c.content LIKE '%Doctrine%'")
  ->getQuery()
  ->getResults();

$rsm = new ResultSetMappingBuilder($entityManager);

$rsm->addRootEntityFromClassMetadata(Comment::class, 'c');

$rsm->addJoinedEntityFromClassMetadata(
  Article::class,
  'a',
  'c',
  'article',
  ['uuid' => 'article_uuid']
);

$query = $entityManager->createNativeQuery(
<<<'SQL'
    SELECT *, a.uuid AS article_uuid, c.uuid AS comment_uuid
    FROM comment c
    INNER JOIN article ON c.article_uuid = a.uuid
    WHERE article_uuid = ?
SQL
, $rsm);
$query->setParameter(1, $article->getUuid());

// Comment instances
$comments = $query->getResult();

doctrine:
    orm:
        resolve_target_entities:
            Lib\Address\UserInterface: My\Project\Model\User