Swoft 框架运行分析（二） —— AnnotationProcessor模块分析

protected function processors(): array
    {
        return [
            new EnvProcessor($this),
            new ConfigProcessor($this),
            new AnnotationProcessor($this),
            new BeanProcessor($this),
            new EventProcessor($this),
            new ConsoleProcessor($this),
        ];
    }

<?php declare(strict_types=1);

namespace Swoft\Processor;

use Exception;
use Swoft\Annotation\AnnotationRegister;
use Swoft\Log\Helper\CLog;

/**
 * Annotation processor
 * @since 2.0
 */
class AnnotationProcessor extends Processor
{
    /**
     * Handle annotation
     *
     * @return bool
     * @throws Exception
     */
    public function handle(): bool
    {
        if (!$this->application->beforeAnnotation()) {
            CLog::warning('Stop annotation processor by beforeAnnotation return false');
            return false;
        }

        $app = $this->application;

        // Find AutoLoader classes. Parse and collect annotations.
        AnnotationRegister::load([
            'inPhar'               => \IN_PHAR,
            'basePath'             => $app->getBasePath(),
            'notifyHandler'        => [$this, 'notifyHandler'],
            'disabledAutoLoaders'  => $app->getDisabledAutoLoaders(),
            'disabledPsr4Prefixes' => $app->getDisabledPsr4Prefixes(),
        ]);

        $stats = AnnotationRegister::getClassStats();

        CLog::info(
            'Annotations is scanned(autoloader %d, annotation %d, parser %d)',
            $stats['autoloader'],
            $stats['annotation'],
            $stats['parser']
        );

        return $this->application->afterAnnotation();
    }

    /**
     * @param string $type
     * @param string $target
     * @see \Swoft\Annotation\Resource\AnnotationResource::load()
     */
    public function notifyHandler(string $type, $target): void
    {
        switch ($type) {
            case 'excludeNs':
                CLog::debug('Exclude namespace %s', $target);
                break;
            case 'noLoaderFile':
                CLog::debug('No autoloader on %s', $target);
                break;
            case 'noLoaderClass':
                CLog::debug('Autoloader class not exist %s', $target);
                break;
            case 'findLoaderClass':
                CLog::debug('Find autoloader %s', $target);
                break;
            case 'addLoaderClass':
                CLog::debug('Parse autoloader %s', $target);
                break;
            case 'noExistClass':
                CLog::debug('Skip interface or trait %s', $target);
                break;
        }
    }
}

/**
    * Load annotation class
    *
    * @param array $config
    *
    * @throws AnnotationException
    * @throws ReflectionException
    */
public static function load(array $config = []): void
{
    $resource = new AnnotationResource($config);
    $resource->load();
}

/**
    * Load annotation resource by find ClassLoader
    *
    * @throws AnnotationException
    * @throws ReflectionException
    */
public function load(): void
{
    $prefixDirsPsr4 = $this->classLoader->getPrefixesPsr4();

    foreach ($prefixDirsPsr4 as $ns => $paths) {
        // Only scan namespaces
        if ($this->onlyNamespaces && !in_array($ns, $this->onlyNamespaces, true)) {
            $this->notify('excludeNs', $ns);
            continue;
        }

        // It is excluded psr4 prefix
        if ($this->isExcludedPsr4Prefix($ns)) {
            AnnotationRegister::registerExcludeNs($ns);
            $this->notify('excludeNs', $ns);
            continue;
        }

        // Find package/component loader class
        foreach ($paths as $path) {
            $loaderFile = $this->getAnnotationClassLoaderFile($path);
            if (!file_exists($loaderFile)) {
                $this->notify('noLoaderFile', $this->clearBasePath($path), $loaderFile);
                continue;
            }

            $loaderClass = $this->getAnnotationLoaderClassName($ns);
            if (!class_exists($loaderClass)) {
                $this->notify('noLoaderClass', $loaderClass);
                continue;
            }

            $loaderObject = new $loaderClass();
            if (!$loaderObject instanceof LoaderInterface) {
                $this->notify('invalidLoader', $loaderFile);
                continue;
            }

            $this->notify('findLoaderClass', $this->clearBasePath($loaderFile));

            // If is disable, will skip scan annotation classes
            if (!isset($this->disabledAutoLoaders[$loaderClass])) {
                AnnotationRegister::registerAutoLoaderFile($loaderFile);
                $this->notify('addLoaderClass', $loaderClass);
                $this->loadAnnotation($loaderObject);
            }

            // Storage auto loader to register
            AnnotationRegister::addAutoLoader($ns, $loaderObject);
        }
    }
}

/**
    * Load annotations from an component loader config.
    *
    * @param LoaderInterface $loader
    *
    * @throws AnnotationException
    * @throws ReflectionException
    */
private function loadAnnotation(LoaderInterface $loader): void
{
    $nsPaths = $loader->getPrefixDirs();

    foreach ($nsPaths as $ns => $path) {
        $iterator = DirectoryHelper::recursiveIterator($path);

        /* @var SplFileInfo $splFileInfo */
        foreach ($iterator as $splFileInfo) {
            $filePath = $splFileInfo->getPathname();
            // $splFileInfo->isDir();
            if (is_dir($filePath)) {
                continue;
            }

            $fileName  = $splFileInfo->getFilename();
            $extension = $splFileInfo->getExtension();

            if ($this->loaderClassSuffix !== $extension || strpos($fileName, '.') === 0) {
                continue;
            }

            // It is exclude filename
            if (isset($this->excludedFilenames[$fileName])) {
                AnnotationRegister::registerExcludeFilename($fileName);
                continue;
            }

            $suffix    = sprintf('.%s', $this->loaderClassSuffix);
            $pathName  = str_replace([$path, '/', $suffix], ['', '\\', ''], $filePath);
            $className = sprintf('%s%s', $ns, $pathName);

            // Fix repeat included file bug
            $autoload = in_array($filePath, $this->includedFiles, true);

            // Will filtering: interfaces and traits
            if (!class_exists($className, !$autoload)) {
                $this->notify('noExistClass', $className);
                continue;
            }

            // Parse annotation
            $this->parseAnnotation($ns, $className);
        }
    }
}

/**
    * Parser annotation
    *
    * @param string $namespace
    * @param string $className
    *
    * @throws AnnotationException
    * @throws ReflectionException
    */
private function parseAnnotation(string $namespace, string $className): void
{
    // Annotation reader
    $reflectionClass = new ReflectionClass($className);

    // Fix ignore abstract
    if ($reflectionClass->isAbstract()) {
        return;
    }
    $oneClassAnnotation = $this->parseOneClassAnnotation($reflectionClass);

    if (!empty($oneClassAnnotation)) {
        AnnotationRegister::registerAnnotation($namespace, $className, $oneClassAnnotation);
    }
}

/**
    * Parse an class annotation
    *
    * @param ReflectionClass $reflectionClass
    *
    * @return array
    * @throws AnnotationException
    * @throws ReflectionException
    */
private function parseOneClassAnnotation(ReflectionClass $reflectionClass): array
{
    // Annotation reader
    $reader    = new AnnotationReader();
    $className = $reflectionClass->getName();

    $oneClassAnnotation = [];
    $classAnnotations   = $reader->getClassAnnotations($reflectionClass);

    // Register annotation parser
    foreach ($classAnnotations as $classAnnotation) {
        if ($classAnnotation instanceof AnnotationParser) {
            $this->registerParser($className, $classAnnotation);

            return [];
        }
    }

    // Class annotation
    if (!empty($classAnnotations)) {
        $oneClassAnnotation['annotation'] = $classAnnotations;
        $oneClassAnnotation['reflection'] = $reflectionClass;
    }

    // Property annotation
    $reflectionProperties = $reflectionClass->getProperties();
    foreach ($reflectionProperties as $reflectionProperty) {
        $propertyName        = $reflectionProperty->getName();
        $propertyAnnotations = $reader->getPropertyAnnotations($reflectionProperty);

        if (!empty($propertyAnnotations)) {
            $oneClassAnnotation['properties'][$propertyName]['annotation'] = $propertyAnnotations;
            $oneClassAnnotation['properties'][$propertyName]['reflection'] = $reflectionProperty;
        }
    }

    // Method annotation
    $reflectionMethods = $reflectionClass->getMethods();
    foreach ($reflectionMethods as $reflectionMethod) {
        $methodName        = $reflectionMethod->getName();
        $methodAnnotations = $reader->getMethodAnnotations($reflectionMethod);

        if (!empty($methodAnnotations)) {
            $oneClassAnnotation['methods'][$methodName]['annotation'] = $methodAnnotations;
            $oneClassAnnotation['methods'][$methodName]['reflection'] = $reflectionMethod;
        }
    }

    $parentReflectionClass = $reflectionClass->getParentClass();
    if ($parentReflectionClass !== false) {
        $parentClassAnnotation = $this->parseOneClassAnnotation($parentReflectionClass);
        if (!empty($parentClassAnnotation)) {
            $oneClassAnnotation['parent'] = $parentClassAnnotation;
        }
    }

    return $oneClassAnnotation;
}

// Register annotation parser
foreach ($classAnnotations as $classAnnotation) {
    if ($classAnnotation instanceof AnnotationParser) {
        $this->registerParser($className, $classAnnotation);

        return [];
    }
}

/**
    * @param string $annotationClass
    * @param string $parserClassName
    */
public static function registerParser(string $annotationClass, string $parserClassName): void
{
    self::$classStats['parser']++;
    self::$parsers[$annotationClass] = $parserClassName;
}

/**
    * @param string $loadNamespace
    * @param string $className
    * @param array  $classAnnotation
    */
public static function registerAnnotation(string $loadNamespace, string $className, array $classAnnotation): void
{
    self::$classStats['annotation']++;
    self::$annotations[$loadNamespace][$className] = $classAnnotation;
}