PHP Exception::getPrevious方法代码示例

 /**
  * handle errors
  *
  * @param \Exception                                       $error  the error stack
  * @param Symfony\Component\Console\Output\OutputInterface $output the ooutput interface
  * @param string                                           $prefix the prefix to indent the text
  */
 protected function displayError(\Exception $error, OutputInterface $output, $prefix = '')
 {
     $output->writeln('<error>' . $prefix . $error->getMessage() . '</error>');
     if ($error->getPrevious()) {
         $this->displayError($error->getPrevious(), $output, "\t - ");
     }
 }

 public static function getFilteredStackTrace(Exception $e, $asString = true)
 {
     $stackTrace = $asString ? '' : array();
     $trace = $e->getPrevious() ? $e->getPrevious()->getTrace() : $e->getTrace();
     if ($e instanceof \PHPUnit_Framework_ExceptionWrapper) {
         $trace = $e->getSerializableTrace();
     }
     foreach ($trace as $step) {
         if (self::classIsFiltered($step)) {
             continue;
         }
         if (self::fileIsFiltered($step)) {
             continue;
         }
         if (!$asString) {
             $stackTrace[] = $step;
             continue;
         }
         if (!isset($step['file'])) {
             continue;
         }
         $stackTrace .= $step['file'] . ':' . $step['line'] . "\n";
     }
     return $stackTrace;
 }

 public static function exceptionToArray(\Exception $e)
 {
     $a = array('code' => $e->getCode(), 'message' => $e->getMessage());
     if ($e->getPrevious() !== null) {
         $a['previous'] = self::exceptionToArray($e->getPrevious());
     }
     return $a;
 }

 /**
  * Format exception
  *
  * @param Exception $e Exception
  * @return array
  */
 private function _formatException(Exception $e)
 {
     $result = ['message' => $e->getMessage(), 'code' => $e->getCode(), 'trace' => $e->getTrace()];
     if ($previous = $e->getPrevious()) {
         $result['previous'] = $this->_formatException($e->getPrevious());
     }
     return $result;
 }

function displayError(Exception $error)
{
    echo $error->getMessage() . "\n";
    if ($error->getPrevious()) {
        echo ' Underlying error: ';
        displayError($error->getPrevious());
    }
}

 /**
  * Returns an Inspector for a previous Exception, if any.
  *
  * @return Inspector
  */
 public function getPreviousExceptionInspector()
 {
     if ($this->previousExceptionInspector === null) {
         $previousException = $this->exception->getPrevious();
         if ($previousException) {
             $this->previousExceptionInspector = new Inspector($previousException);
         }
     }
     return $this->previousExceptionInspector;
 }

 public static function findCodeDb(Exception $e)
 {
     if (isset($e->errorInfo)) {
         return $e->errorInfo;
     }
     if ($e->getPrevious()) {
         return self::findCodeDb($e->getPrevious());
     } else {
         return false;
     }
 }

 /**
  * @param \Exception $exception
  *
  * @return array
  */
 protected function buildError(\Exception $exception)
 {
     $result = ['code' => $exception->getCode(), 'message' => $exception->getMessage(), 'previous' => null, 'data' => null];
     if ($exception->getPrevious() !== null) {
         $result['previous'] = $this->buildError($exception->getPrevious());
     }
     if ($exception instanceof ExceptionInterface) {
         $result['data'] = $exception->getMetaData();
     }
     return $result;
 }

 /**
  * @param \Exception $exception
  * @return string
  */
 private static function serializeException(\Exception $exception)
 {
     $appendix = '';
     $info = array_merge($exception->getMessage() ? array(self::serialize($exception->getMessage())) : array(), $exception->getCode() ? array(self::serialize($exception->getCode())) : array());
     if ($info) {
         $appendix = '(' . implode(', ', $info) . ')';
     }
     if ($exception->getPrevious()) {
         $appendix .= ' <- ' . self::serializeException($exception->getPrevious());
     }
     return self::serializeObject($exception, $appendix);
 }

 /**
  * Create Serializable exception from real exception
  * @param \Exception $exception
  */
 public function __construct(\Exception $exception)
 {
     $this->message = $exception->getMessage();
     $this->traceString = $exception->getTraceAsString();
     $this->code = $exception->getCode();
     $this->file = $exception->getFile();
     $this->line = $exception->getLine();
     if ($exception->getPrevious() instanceof \Exception) {
         $this->previous = new SerializableException($exception->getPrevious());
     }
     $this->trace = $exception->getTrace();
     $this->cleanupTrace();
 }

 /**
  * {@inheritdoc}
  */
 public function handle(\Exception $exception)
 {
     if (null !== ($preEx = $exception->getPrevious())) {
         throw $preEx;
     }
     throw $exception;
 }

function displayExceptionObject(Exception $e)
{
    echo "\$e = >{$e}<\n";
    // calls __toString
    echo "getMessage:       >" . $e->getMessage() . "<\n";
    echo "getCode:          >" . $e->getCode() . "<\n";
    echo "getPrevious:      >" . $e->getPrevious() . "<\n";
    echo "getFile:          >" . $e->getFile() . "<\n";
    echo "getLine:          >" . $e->getLine() . "<\n";
    echo "getTraceAsString: >" . $e->getTraceAsString() . "<\n";
    $traceInfo = $e->getTrace();
    var_dump($traceInfo);
    echo "Trace Info:" . (count($traceInfo) == 0 ? " none\n" : "\n");
    foreach ($traceInfo as $traceInfoKey => $traceLevel) {
        echo "Key[{$traceInfoKey}]:\n";
        foreach ($traceLevel as $levelKey => $levelVal) {
            if ($levelKey != "args") {
                echo "  Key[{$levelKey}] => >{$levelVal}<\n";
            } else {
                echo "  Key[{$levelKey}]:\n";
                foreach ($levelVal as $argKey => $argVal) {
                    echo "    Key[{$argKey}] => >{$argVal}<\n";
                }
            }
        }
    }
}

 /**
  * Handles a thrown exception.  Will also log extra information if the exception happens to by a MySql deadlock.
  *
  * @param \Exception $exception The exception captured.
  *
  * @return null
  */
 protected function handleException($exception)
 {
     // Log MySQL deadlocks
     if ($exception instanceof \CDbException && strpos($exception->getMessage(), 'Deadlock') !== false) {
         $data = craft()->db->createCommand('SHOW ENGINE INNODB STATUS')->query();
         $info = $data->read();
         $info = serialize($info);
         Craft::log('Deadlock error, innodb status: ' . $info, LogLevel::Error, 'system.db.CDbCommand');
     }
     // If this is a Twig Runtime exception, use the previous one instead
     if ($exception instanceof \Twig_Error_Runtime) {
         if ($previousException = $exception->getPrevious()) {
             $exception = $previousException;
         }
     }
     // Special handling for Twig syntax errors
     if ($exception instanceof \Twig_Error) {
         $this->handleTwigError($exception);
     } else {
         if ($exception instanceof DbConnectException) {
             $this->handleDbConnectionError($exception);
         } else {
             parent::handleException($exception);
         }
     }
 }

 /**
  * Outputs the error popup, or a plain message, depending on the response content type.
  *
  * @param \Exception|\Error      $exception Note: can't be type hinted, for PHP7 compat.
  * @param ResponseInterface|null $response  If null, it outputs directly to the client. Otherwise, it assumes the
  *                                          object is a new blank response.
  * @return ResponseInterface|null
  */
 static function display($exception, ResponseInterface $response = null)
 {
     // For HTML pages, output the error popup
     if (strpos(get($_SERVER, 'HTTP_ACCEPT'), 'text/html') !== false) {
         ob_start();
         ErrorConsoleRenderer::renderStyles();
         $stackTrace = self::getStackTrace($exception->getPrevious() ?: $exception);
         ErrorConsoleRenderer::renderPopup($exception, self::$appName, $stackTrace);
         $popup = ob_get_clean();
         // PSR-7 output
         if ($response) {
             $response->getBody()->write($popup);
             return $response->withStatus(500);
         }
         // Direct output
         echo $popup;
     } else {
         // PSR-7 output
         if ($response) {
             $response->getBody()->write($exception->getMessage());
             if (self::$devEnv) {
                 $response->getBody()->write("\n\nStack trace:\n" . $exception->getTraceAsString());
             }
             return $response->withoutHeader('Content-Type')->withHeader('Content-Type', 'text-plain')->withStatus(500);
         }
         // Direct output
         header("Content-Type: text/plain");
         http_response_code(500);
         echo $exception->getMessage();
         if (self::$devEnv) {
             echo "\n\nStack trace:\n" . $exception->getTraceAsString();
         }
     }
     return null;
 }

 public static function handle(\Exception $ex)
 {
     if ($ex->getPrevious() instanceof ConsoleException) {
         Console::error($ex->getMessage());
         return;
     }
     $handles = Settings::load('exception');
     if (isset($handles) && !empty($handles)) {
         foreach ($handles as $key => $value) {
             if (self::recursive($ex, $key)) {
                 if (is_callable($value)) {
                     call_user_func($value, $ex);
                     return;
                 } else {
                     /** @var ExceptionHandle $handle */
                     $handle = DI::get($value);
                     if (isset($handle)) {
                         $handle->handle();
                         return;
                     }
                 }
             }
         }
     }
     throw $ex;
 }