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. 清除缓存：

   

   蓝心千询

   蓝心千询是vivo推出的一个多功能AI智能助手

   34

   查看详情

   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 查询结果转换为关联数组，并根据具体需求进行优化。记住，选择合适的方法取决于你的具体场景和性能要求。

以上就是Symfony 如何将查询结果转为关联数组的详细内容，更多请关注php中文网其它相关文章！