Symfony查询结果转关联数组技巧

在文章实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《Symfony 查询结果转为关联数组方法》，聊聊，希望可以帮助到正在努力赚钱的你。

使用 getArrayResult() 可直接将 Doctrine 查询结果转为关联数组；2. 手动遍历实体并构建数组可自定义结构；3. Serializer 组件适用于复杂转换，如处理关联关系；4. 自定义 DQL 查询可控制返回字段；5. getArrayResult() 返回空数组通常因无匹配数据或配置问题，需检查查询条件、实体映射、数据库连接、缓存及 DQL 语法；6. 处理关联关系推荐使用 Serializer 配合 @Groups 注解；7. 性能优化包括使用 getArrayResult()、DQL 查询指定字段、分页、缓存及避免 N+1 查询。正确选择方法可高效实现查询结果到关联数组的转换并提升性能。

将 Symfony 查询结果转换为关联数组，实际上是在处理 Doctrine ORM 返回的数据。核心在于理解 Doctrine 返回的数据结构，并利用 PHP 的数组操作进行转换。

解决方案：

Symfony 中，当你使用 Doctrine 查询数据库时，通常会得到一个对象数组。要将这些对象转换为关联数组，有几种方法可以选择，取决于你的具体需求和查询方式。

1. 使用 getArrayResult() 方法：

   这是最直接的方法，如果你的查询目的是获取数组形式的结果，那么在 QueryBuilder 对象上调用 getArrayResult() 就可以直接得到关联数组。

   $entityManager = $this->getDoctrine()->getManager();
   
   $query = $entityManager->createQueryBuilder()
       ->select('u')
       ->from('App\Entity\User', 'u')
       ->getQuery();
   
   $users = $query->getArrayResult();
   
   // $users 现在就是一个关联数组，可以直接使用

   这个方法会将每个实体转换为一个关联数组，数组的键对应实体类的属性名。

2. 手动遍历和转换：

   如果需要更精细的控制，或者需要在转换过程中进行一些额外的处理，可以手动遍历查询结果，并将每个对象转换为关联数组。

   $entityManager = $this->getDoctrine()->getManager();
   
   $users = $entityManager->getRepository(User::class)->findAll();
   
   $userArrays = [];
   foreach ($users as $user) {
       $userArrays[] = [
           'id' => $user->getId(),
           'name' => $user->getName(),
           'email' => $user->getEmail(),
           // 其他属性
       ];
   }
   
   // $userArrays 现在是一个关联数组

   这种方式的优点是可以自定义数组的结构，只选择需要的属性，并进行格式化。

3. 使用 Serializer 组件：

   Symfony 的 Serializer 组件可以将对象序列化为各种格式，包括数组。这在需要更复杂的转换，例如处理关联关系时非常有用。

   首先，你需要安装 Serializer 组件：

   composer require symfony/serializer
   composer require symfony/property-access

   然后，可以使用以下代码将对象转换为数组：

   use Symfony\Component\Serializer\Serializer;
   use Symfony\Component\Serializer\Encoder\JsonEncoder;
   use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
   
   $encoders = [new JsonEncoder()];
   $normalizers = [new ObjectNormalizer()];
   
   $serializer = new Serializer($normalizers, $encoders);
   
   $entityManager = $this->getDoctrine()->getManager();
   $users = $entityManager->getRepository(User::class)->findAll();
   
   $userArrays = [];
   foreach ($users as $user) {
       $userArrays[] = $serializer->normalize($user, 'json');
   }
   
   // $userArrays 现在是一个关联数组

   需要注意的是，使用 Serializer 组件需要配置 Normalizer，才能正确地将对象转换为数组。

4. 自定义 DQL 查询：

   有时候，直接使用 DQL 查询可以更方便地获取所需的数据结构。例如，可以直接在 DQL 中指定需要查询的字段，并使用 getResult() 方法获取数组结果。

   $entityManager = $this->getDoctrine()->getManager();
   
   $query = $entityManager->createQuery('
       SELECT u.id, u.name, u.email
       FROM App\Entity\User u
   ');
   
   $users = $query->getResult(\Doctrine\ORM\Query::HYDRATE_ARRAY);
   
   // $users 现在是一个关联数组

   这种方式的优点是可以直接控制查询结果的结构，避免了不必要的对象创建和转换。

为什么 getArrayResult() 有时会返回空数组？

getArrayResult() 返回空数组，通常意味着查询没有找到任何匹配的记录。但也可能是一些配置问题，例如缓存或者数据库连接问题。

1. 检查查询条件：

   首先，确保你的查询条件是正确的，并且数据库中存在满足条件的记录。可以使用 dump() 函数或者 Symfony 的 Profiler 来查看生成的 SQL 语句，并手动在数据库中执行，以验证查询结果。

   $query = $entityManager->createQueryBuilder()
       ->select('u')
       ->from('App\Entity\User', 'u')
       ->where('u.email = :email')
       ->setParameter('email', 'test@example.com')
       ->getQuery();
   
   dump($query->getSQL()); // 查看 SQL 语句
   dump($query->getParameters()); // 查看参数
   
   $users = $query->getArrayResult();
   
   dump($users); // 查看结果

2. 检查实体映射：

   确保你的实体类的属性和数据库表的字段映射是正确的。如果属性名和字段名不一致，或者缺少映射关系，Doctrine 可能无法正确地将数据填充到对象中。

   可以在实体类中使用 @ORM\Column 注解来定义属性和字段的映射关系。

   use Doctrine\ORM\Mapping as ORM;
   
   /**
    * @ORM\Entity
    * @ORM\Table(name="users")
    */
   class User
   {
       /**
        * @ORM\Id
        * @ORM\GeneratedValue
        * @ORM\Column(type="integer")
        */
       private $id;
   
       /**
        * @ORM\Column(type="string", length=255)
        */
       private $name;
   
       /**
        * @ORM\Column(type="string", length=255, unique=true)
        */
       private $email;
   
       // ...
   }

3. 检查数据库连接：

   确保你的数据库连接配置是正确的，并且数据库服务器正在运行。可以在 .env 文件中或者 config/packages/doctrine.yaml 文件中查看数据库连接配置。

   doctrine:
       dbal:
           default_connection: default
           connections:
               default:
                   driver: 'pdo_mysql'
                   url: '%env(DATABASE_URL)%'

4. 清除缓存：

   Doctrine 会缓存查询结果，有时缓存可能会导致 getArrayResult() 返回空数组。可以尝试清除 Doctrine 的查询缓存和结果缓存。

   php bin/console doctrine:cache:clear-metadata
   php bin/console doctrine:cache:clear-query
   php bin/console doctrine:cache:clear-result

5. 检查 DQL 语句：

   如果使用了自定义 DQL 查询，确保 DQL 语句的语法是正确的，并且查询的字段是存在的。可以使用 Doctrine 的 validate 命令来验证 DQL 语句的语法。

   php bin/console doctrine:query:dql "SELECT u FROM App\Entity\User u WHERE u.email = 'test@example.com'" --hydrate=array

如何处理关联关系数据？

处理关联关系数据，例如一对多或多对多关系，需要更复杂的转换逻辑。Serializer 组件在这里会非常有用。

1. 配置 Serializer：

   首先，确保 Serializer 组件已经安装并配置好。需要在实体类中使用 @Groups 注解来定义哪些属性需要被序列化。

   use Doctrine\ORM\Mapping as ORM;
   use Symfony\Component\Serializer\Annotation\Groups;
   
   /**
    * @ORM\Entity
    * @ORM\Table(name="users")
    */
   class User
   {
       /**
        * @ORM\Id
        * @ORM\GeneratedValue
        * @ORM\Column(type="integer")
        * @Groups("user")
        */
       private $id;
   
       /**
        * @ORM\Column(type="string", length=255)
        * @Groups("user")
        */
       private $name;
   
       /**
        * @ORM\Column(type="string", length=255, unique=true)
        * @Groups("user")
        */
       private $email;
   
       /**
        * @ORM\OneToMany(targetEntity="App\Entity\Post", mappedBy="user")
        * @Groups("user")
        */
       private $posts;
   
       // ...
   }
   
   /**
    * @ORM\Entity
    * @ORM\Table(name="posts")
    */
   class Post
   {
       /**
        * @ORM\Id
        * @ORM\GeneratedValue
        * @ORM\Column(type="integer")
        * @Groups("post")
        */
       private $id;
   
       /**
        * @ORM\Column(type="string", length=255)
        * @Groups("post")
        */
       private $title;
   
       /**
        * @ORM\ManyToOne(targetEntity="App\Entity\User", inversedBy="posts")
        * @ORM\JoinColumn(name="user_id", referencedColumnName="id")
        */
       private $user;
   
       // ...
   }

2. 使用 Serializer 序列化对象：

   然后，可以使用 Serializer 组件将对象序列化为数组。

   use Symfony\Component\Serializer\Serializer;
   use Symfony\Component\Serializer\Encoder\JsonEncoder;
   use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
   use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
   
   $encoders = [new JsonEncoder()];
   $normalizers = [new ObjectNormalizer()];
   
   $serializer = new Serializer($normalizers, $encoders);
   
   $entityManager = $this->getDoctrine()->getManager();
   $users = $entityManager->getRepository(User::class)->findAll();
   
   $userArrays = [];
   foreach ($users as $user) {
       $userArrays[] = $serializer->normalize($user, 'json', [AbstractNormalizer::GROUPS => 'user']);
   }
   
   // $userArrays 现在是一个包含关联关系数据的关联数组

   在 normalize 方法中，使用 AbstractNormalizer::GROUPS 选项来指定需要序列化的属性分组。

3. 自定义 Normalizer：

   如果需要更复杂的转换逻辑，可以自定义 Normalizer。可以创建一个类，实现 Symfony\Component\Serializer\Normalizer\NormalizerInterface 和 Symfony\Component\Serializer\Normalizer\DenormalizerInterface 接口，并在其中实现自定义的序列化和反序列化逻辑。

   这允许你完全控制对象转换为数组的过程，并处理各种复杂的关联关系。

性能优化建议

将查询结果转换为关联数组可能会影响性能，特别是当处理大量数据时。以下是一些性能优化建议：

1. 使用 getArrayResult()：

   如果只需要数组形式的结果，并且不需要进行额外的处理，尽量使用 getArrayResult() 方法。这是最快的方法，因为它避免了创建不必要的对象。

2. 使用 DQL 查询：

   使用 DQL 查询可以直接控制查询结果的结构，避免了不必要的对象创建和转换。只查询需要的字段，可以减少数据传输量和内存消耗。

3. 使用分页：

   如果需要处理大量数据，可以使用分页来减少每次查询的数据量。可以使用 Doctrine 的 Paginator 组件来实现分页。

   use Doctrine\ORM\Tools\Pagination\Paginator;
   
   $entityManager = $this->getDoctrine()->getManager();
   
   $query = $entityManager->createQueryBuilder()
       ->select('u')
       ->from('App\Entity\User', 'u')
       ->getQuery();
   
   $paginator = new Paginator($query, $fetchJoinCollection = true);
   
   $totalItems = count($paginator);
   $page = 1; // 当前页码
   $pageSize = 10; // 每页显示的数量
   $iterator = $paginator->getIterator();
   $iterator->seek(($page - 1) * $pageSize);
   
   $users = array();
   for ($i = 0; $i < $pageSize && $iterator->valid(); $i++, $iterator->next()) {
       $users[] = $iterator->current();
   }
   
   // $users 现在是当前页的关联数组

4. 使用缓存：

   可以使用 Doctrine 的查询缓存和结果缓存来缓存查询结果，减少数据库的访问次数。

   doctrine:
       orm:
           metadata_cache_driver:
               type: pool
               pool: doctrine.system.cache_pool
           query_cache_driver:
               type: pool
               pool: doctrine.system.cache_pool
           result_cache_driver:
               type: pool
               pool: doctrine.result.cache_pool
   
   framework:
       cache:
           pools:
               doctrine.result.cache_pool:
                   adapter: cache.app

5. 避免 N+1 查询问题：

   当处理关联关系数据时，可能会出现 N+1 查询问题。可以使用 Doctrine 的 fetch join 或者 EXTRA_LAZY 关联来避免 N+1 查询问题。

   $query = $entityManager->createQueryBuilder()
       ->select('u', 'p')
       ->from('App\Entity\User', 'u')
       ->leftJoin('u.posts', 'p')
       ->getQuery();

   或者，在实体类中使用 EXTRA_LAZY 关联：

   /**
    * @ORM\OneToMany(targetEntity="App\Entity\Post", mappedBy="user", fetch="EXTRA_LAZY")
    */
   private $posts;

通过以上方法，你可以灵活地将 Symfony 查询结果转换为关联数组，并根据具体需求进行优化。记住，选择合适的方法取决于你的具体场景和性能要求。

今天带大家了解了的相关知识，希望对你有所帮助；关于文章的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~