Php $em->；上的未定义索引错误；Symfony2中的clear（）

我已经编写了一个Symfony命令来从API导入一些数据。它可以工作，但问题是当我在数据库中插入一个大的JSON时，我的PHP内存使用量增加了。每次导入活动后，我的单位工时将增加“2”

我已经取消设置了所有使用过的对象，并且我已经阅读了Symfony2的文档，您需要执行大规模批处理：

但是当我使用

$em->clear（）

时，我的实体管理器会出现以下错误：

注意：未定义的索引：00000000 7B56EA7100000000E366C259，路径为application\vendor\doctrine\lib\doctrine\ORM\UnitOfWork.php第2228行

这是我的完整代码：

 /**
 * @see Command
 */
protected function configure() {
  $this
    ->setName('ks:user:runkeepersync')
    ->setDescription('Synchroniser les activités d\'un utilisateur runkeeper')
    ->setDefinition(array(
      new InputArgument('access_token', InputArgument::REQUIRED, 'Access token'),
    ))
}

/**
 * @see Command
 */
protected function execute(InputInterface $input, OutputInterface $output) {
  $accessToken = $input->getArgument('access_token');
  $em = $this->getContainer()->get('doctrine')->getEntityManager();
  $UserHasServices = $em->getRepository('KsUserBundle:UserHasServices')->findOneByToken($accessToken);
  if (!is_object($UserHasServices) ) {
    echo "Impossible de trouver l'utilisateur qui possède le jeton ".$accessToken."";
  }
  $user    = $UserHasServices->getUser();
  $service = $UserHasServices->getService();
  echo "avant de requérir l'api : ".memory_get_usage()."\n";
  try {
    $rkApi = $this->getContainer()->get('ks_user.runkeeper');
    $rkApi->setAccessToken($accessToken);
    $activities  = $rkApi->getFitnessActivities(0,25);
    $nbParPages  = 25;
    $nomberActivitites = $activities->size;
    $aActivities = $activities->items;
    $nbPages =  floor ($nomberActivitites/$nbParPages);
    $aEndurance = array("Running", "Cycling", "Mountain Biking", "Walking", "Hiking", "Downhill Skiing", "Cross-Country Skiing", "Snowboarding", "Skating","Wheelchair", "Rowing", "Elliptical", "Other");
    $aEnduranceUnderWater = array("Swimming");
    $enduranceOnEarthType = $em->getRepository('KsActivityBundle:SportType')->findOneByLabel("endurance");
    if (!is_object($enduranceOnEarthType) ) {
      echo "Impossible de trouver le type de sport d'endurance";
    }
    $enduranceUnderWaterType = $em->getRepository('KsActivityBundle:SportType')->findOneByLabel("endurance_under_water");
    if (!is_object($enduranceUnderWaterType) ) {
      echo "Impossible de trouver le type de sport d'endurance sous l'eau ";
    }
    echo "Après avoir récupéré 25 activités : ".memory_get_usage()."\n";
    $a = 0;
    for($i=0;$i<=$nbPages;$i++){
      if($i!=0){
        $activities  = $rkApi->getFitnessActivities($i,25);
        $aActivities = $activities->items;
      }
      foreach ($aActivities as $activity) {
        $a = $a+1;
        $codeSport = $this->formatNameSport($activity->type);
        $sport = $em->getRepository('KsActivityBundle:Sport')->findOneByCodeSport($codeSport);
        if (!is_object($sport) ) {
          $sport = new \Ks\ActivityBundle\Entity\Sport();
          $sport->setLabel($codeSport);
          $sport->setCodeSport($codeSport);
          $sport->setSportType($enduranceOnEarthType);
          $em->persist($sport);
          $em->flush();
        }
        $activityDetail = json_decode($rkApi->requestJSONHealthGraph($activity->uri));
        if(in_array($activity->type, $aEndurance)){
          $urlActivitieDetail = $activityDetail->activity;
          $ActivitySessionEnduranceOnEarth = new \Ks\ActivityBundle\Entity\ActivitySessionEnduranceOnEarth($user);
          isset($activity->total_distance)? $ActivitySessionEnduranceOnEarth->setDistance($activity->total_distance) : "";
          isset($activity->duration)? $ActivitySessionEnduranceOnEarth->setDuration($this->secondesToTimeDuration($activity->duration)) : "";
          isset($activity->start_time)?  $ActivitySessionEnduranceOnEarth->setIssuedAt(new \DateTime($activity->start_time)) : "";
          $ActivitySessionEnduranceOnEarth->setModifiedAt(new \DateTime('Now'));
          $ActivitySessionEnduranceOnEarth->setSport($sport);
          isset($activityDetail->total_calories)?  $ActivitySessionEnduranceOnEarth->setCalories($activityDetail->total_calories) : "";
          isset($activityDetail->climb)?  $ActivitySessionEnduranceOnEarth->setElevationGain($activityDetail->climb) : "";
          $maxElevation = 0;
          $minElevation = 10000;
          if(isset($activityDetail->path)){
            foreach($activityDetail->path as $gpsPoint){
              if($gpsPoint->altitude > $maxElevation){
                $maxElevation = $gpsPoint->altitude;
              }
              if($gpsPoint->altitude < $minElevation){
                $minElevation = $gpsPoint->altitude;
              }
            }
            $ActivitySessionEnduranceOnEarth->setElevationMin($minElevation);
            $ActivitySessionEnduranceOnEarth->setElevationMax($maxElevation);
          }
          $em->persist($ActivitySessionEnduranceOnEarth);
          $em->flush();
          //Pour chaque activité on a un identifiant relatif au service qu'on synchronise
          $ActivityComeFromService = new \Ks\ActivityBundle\Entity\ActivityComeFromService();
          $ActivityComeFromService->setActivity($ActivitySessionEnduranceOnEarth);
          $ActivityComeFromService->setService($service);
          $ActivityComeFromService->setIdWebsiteActivityService($activity->uri);
          $ActivityComeFromService->setSourceDetailsActivity($rkApi->requestJSONHealthGraph($activity->uri));
          $ActivityComeFromService->setTypeSource("JSON");
          $em->persist($ActivityComeFromService);
          $em->flush();
          echo "Import de l'activite num ".$a." type :".$activity->type." effectue avec success \n";
          unset($ActivitySessionEnduranceOnEarth);
          unset($ActivityComeFromService);
          echo "UnitOFWOrk -> ".$em->getUnitOfWork()->size()."\n";
        }
        if(in_array($activity->type, $aEnduranceUnderWater)){
          $ActivitySessionEnduranceUnderWater = new \Ks\ActivityBundle\Entity\ActivitySessionEnduranceUnderWater($user);
          isset($activity->total_distance)? $ActivitySessionEnduranceUnderWater->setDistance($activity->total_distance) : "";
          isset($activity->duration)? $ActivitySessionEnduranceUnderWater->setDuration($this->secondesToTimeDuration($activity->duration)) : "";
          isset($activity->start_time) && !empty($activity->start_time)?  $ActivitySessionEnduranceUnderWater->setIssuedAt(new \DateTime($activity->start_time)) : "";
          $ActivitySessionEnduranceUnderWater->setModifiedAt(new \DateTime('Now'));
          $ActivitySessionEnduranceUnderWater->setSport($sport);
          isset($activityDetail->total_calories)?  $ActivitySessionEnduranceUnderWater->setCalories($activityDetail->total_calories) : "";
          isset($activityDetail->notes)?  $ActivitySessionEnduranceUnderWater->setDescription($activityDetail->notes) : "";
          $em->persist($ActivitySessionEnduranceUnderWater);
          $em->flush();
          $ActivityComeFromService = new \Ks\ActivityBundle\Entity\ActivityComeFromService();
          $ActivityComeFromService->setActivity($ActivitySessionEnduranceUnderWater);
          $ActivityComeFromService->setService($service);
          $ActivityComeFromService->setIdWebsiteActivityService($activity->uri);
          $ActivityComeFromService->setSourceDetailsActivity($rkApi->requestJSONHealthGraph($activity->uri));
          $ActivityComeFromService->setTypeSource("JSON");
          $em->persist($ActivityComeFromService);
          $em->flush();
          echo "Import de l'activité num ".$a." type :".$activity->type." effectué avec succès\n";
          unset($ActivitySessionEnduranceUnderWater);
          unset($ActivityComeFromService);
        }
        echo "Après chaque activité : ".memory_get_usage()."\n";
        unset($sport);
        unset($activityDetail);
        $em->clear();
      }
    }
  } catch (\Exception $e) {
    throw $e;
  }
}

/**
*@see命令
*/
受保护的函数配置（）{
美元这个
->setName（'ks:user:runkeepersync'）
->setDescription（'同步器未使用我们的runkeeper'）
->集合定义（数组）(
新的InputArgument（'access_token'，InputArgument:：REQUIRED'，access token'），
))
}
/**
*@see命令
*/
受保护的函数执行（InputInterface$input，OutputInterface$output）{
$accessToken=$input->getArgument（'access_token'）；
$em=$this->getContainer（）->get（'doctrine'）->getEntityManager（）；
$UserHasServices=$em->getRepository（'KsUserBundle:UserHasServices'）->findOneByToken（$accessToken）；
如果（！is_对象（$UserHasServices））{
回音“不可能的利用率”$accessToken“；
}
$user=$UserHasServices->getUser（）；
$service=$UserHasServices->getService（）；
echo“avant de requérir l'api:”.memory_get_usage（）。“\n”；
试一试{
$rkApi=$this->getContainer（）->get（'ks_user.runkeeper'）；
$rkApi->setAccessToken（$accessToken）；
$activities=$rkApi->getFitnessActivities（0,25）；
$nbParPages=25；
$NomberActivities=$activities->size；
$aaActivities=$activities->items；
$nbPages=底价（$nomberavitites/$nbParPages）；
$aEndurance=数组（“跑步”、“骑自行车”、“山地自行车”、“步行”、“徒步”、“下坡滑雪”、“越野滑雪”、“滑雪板”、“滑冰”、“轮椅”、“划船”、“椭圆机”、“其他”）；
$aEnduranceUnderWater=阵列（“游泳”）；
$enduranceOnEarthType=$em->getRepository（'KsActivityBundle:SportType'）->findOneByLabel（“耐力”）；
如果（！is_对象（$enduranceOnEarthType））{
呼应“不可能的运动耐力”；
}
$enduranceUnderWaterType=$em->getRepository（'KsActivityBundle:SportType'）->findOneByLabel（“水下耐力”）；
如果（！是_对象（$enduranceUnderWaterType））{
呼应“不可能的耐力运动”；
}
echo“Après avoir récupéré25活动：”.memory_get_usage（）。“\n”；
$a=0；
对于（$i=0；$igetFitnessActivities（$i，25）；
$aaActivities=$activities->items；
}
foreach（$A活动作为$activity）{
$a=$a+1；
$codeSport=$this->formatNameSport（$activity->type）；
$sport=$em->getRepository（'KsActivityBundle:sport'）->findOneByCodeSport（$codeSport）；
如果（！is_object（$sport））{
$sport=new\Ks\ActivityBundle\Entity\sport（）；
$sport->setLabel（$codeSport）；
$sport->setCodeSport（$codeSport）；
$sport->setSportType（$enduranceOnEarthType）；
$em->persist（$sport）；
$em->flush（）；
}
$activityDetail=json_decode（$rkApi->requestJSONHealthGraph（$activity->uri））；
if（在数组中（$activity->type，$aEndurance））{
$URLRActivityDetail=$activityDetail->activity；
$ActivitySessionEnduranceOnEarth=new\Ks\ActivityBundle\Entity\ActivitySessionEnduranceOnEarth（$user）；
isset（$activity->total_distance）？$ActivitySessionEnduranceOneEarth->setDistance（$activity->total_distance）：“”；
isset（$activity->duration）？$ActivitySessionEnduranceOneEarth->setDuration（$this->secondesToTimeDuration（$activity->duration））：“”；
isset（$activity->start_time）？$ActivitySessionEnduranceOnEarth->setIssuedAt（new\DateTime（$activity->start_time））：“”；
$ActivitySessionEnduranceOnEarth->setModifiedAt（new\DateTime（'Now'））；
$ActivitySessionEnduranceOnEarth->setSport（$sport）；
isset（$activityDetail->total_Carries）？$ActivitySessionEnduranceOneEarth->SetCarries（$activityDetail->total_Carries）：“”；
isset（$activityDetail->Gramb）？$ActivitySessionEnduranceOneEarth->setElevationGain（$activityDetail->Gramb）：“”；
$maxElevation=0；
$minElevation=10000；
如果（设置（$activityDetail->path））{
foreach（$activityDetail->path as$gpsPoint）{
如果（$gpsPoint->高度>$maxElevation）{
$maxElevation=$gpsPoint->高度；
}
如果（$gpsPoint->高度<$minElevation）{
$minElevation=$gpsPoint->高度；
}
}
$ActivitySessionEnduranceOneEarth->setElevationMin（$minElevation）；
$ActivitySessionEnduranceOnEarth->setElevationMax（$maxElevation）；
}
$em->persist（$ActivitySessionEnduranceOneEarth）；
$em->flush（）；
//在联合国身份证上开展活动，并提供同步服务
$ActivityComeFromService=new\Ks\ActivityBundle\Entity\ActivityComeFromService（）；
$ActivityComeFromService->setActivity（$ActivitySessionEnduranceOnEarth）；
$ActivityComeFromService->setService（$service）；
$ActivityComeFromService->setIdWebsiteActivityService（$activity->uri）；
$ActivityComeFromService->setSourceDetailsActivity（$rkApi->requestJSONHealthGraph（$activity->uri））；
$ActivityComeFromService->setTypeSource（“JSON”）；
$em->persist（$ActivityComeFromService）；
$em->flush（）；
echo“Import de l'activite num.$a.”类型：“$activity->type.“effectue avec success\n”；
取消设置（$ActivitySessionEnduranceOneEarth）；
未设置（$ActivityComeFromService）；
$this->getContainer()->get('doctrine')->resetEntityManager();

$em = $this->getContainer()->get('doctrine')->getEntityManager();

// disable logger
$em->getConnection()->getConfiguration()->setSQLLogger(null);

// remove all listeners
foreach ($em->getEventManager()->getListeners() as $event => $listeners) {
    foreach ($listeners as $listener) {
        $em->getEventManager()->removeEventListener($event, $listener);
    }
}

// save and clear
$em->flush();
$em->getUnitOfWork()->clear();

// collect 100 entities and then save them
if (($i % 100) == 0) {
    $em->flush();
    $em->getUnitOfWork()->clear();
}