modify

Annotation/Annotation.php

@@ -192,14 +192,9 @@ class Annotation extends Component
 	 * @param string|array $outPath
 	 * @throws Exception
 	 */
-	public function runtime(string $dir, string|array $outPath = '')
+	public function runtime(string $dir)
 	{
-		if (empty($outPath)) {
+		return $this->_loader->loadByDirectory($dir);
-			$outPath = [];
-		} else if (is_string($outPath)) {
-			$outPath = [$outPath];
-		}
-		$this->_loader->loadByDirectory($dir, $outPath);
 	}
 
 

Annotation/Loader.php

@@ -38,13 +38,6 @@ class Loader extends BaseObject
 
     private static array $_methods = [];
 
-    /**
-     * @return array
-     */
-    public function getDirectory(): array
-    {
-        return static::$_directory;
-    }
 
     /**
      * @param $path
@@ -56,16 +49,6 @@ class Loader extends BaseObject
         $this->_scanDir(new DirectoryIterator($path), $namespace);
     }
 
-
-    /**
-     * @return array
-     */
-    public function getClasses(): array
-    {
-        return static::$_classes;
-    }
-
-
     /**
      * @param string $class
      * @param string $property
@@ -121,16 +104,6 @@ class Loader extends BaseObject
     }
 
 
-    /**
-     * @param string $class
-     * @return array
-     */
-    public function getTarget(string $class): array
-    {
-        return static::$_classes[$class] ?? [];
-    }
-
-
     /**
      * @param DirectoryIterator $paths
      * @param $namespace
@@ -173,16 +146,7 @@ class Loader extends BaseObject
             }
             $this->appendFileToDirectory($path->getRealPath(), $replace->getName());
 
-            $_array['handler'] = $replace->newInstance();
+            static::$_classes[] = $replace->getName();
-            $_array['target'] = [];
-            $_array['methods'] = [];
-            $_array['property'] = [];
-
-            $_array = $this->_targets($replace, $_array);
-            $_array = $this->_methods($replace, $_array);
-            $_array = $this->_properties($replace, $_array);
-
-            static::$_classes[$replace->getName()] = $_array;
         } catch (Throwable $throwable) {
             $this->addError($throwable, 'throwable');
         }
@@ -202,75 +166,6 @@ class Loader extends BaseObject
     }
 
 
-    /**
-     * @param ReflectionClass $replace
-     * @param array $_array
-     * @return array
-     */
-    private function _targets(ReflectionClass $replace, array $_array): array
-    {
-        foreach ($replace->getAttributes() as $attribute) {
-            if ($attribute->getName() == Attribute::class) {
-                continue;
-            }
-            if ($attribute->getName() == Target::class) {
-                continue;
-            }
-            $_array['target'][] = $attribute->newInstance();
-        }
-        return $_array;
-    }
-
-
-    /**
-     * @param ReflectionClass $replace
-     * @param array $_array
-     * @return array
-     */
-    private function _methods(ReflectionClass $replace, array $_array): array
-    {
-        $methods = $replace->getMethods(ReflectionMethod::IS_PUBLIC);
-        foreach ($methods as $method) {
-            $_method = [];
-            foreach ($method->getAttributes() as $attribute) {
-                if (!class_exists($attribute->getName())) {
-                    continue;
-                }
-                $_method[] = $attribute->newInstance();
-            }
-            if (!empty($_method)) {
-                static::$_methods[$replace->getName()][$method->getName()] = $_method;
-            }
-        }
-        return $_array;
-    }
-
-
-    /**
-     * @param ReflectionClass $replace
-     * @param array $_array
-     * @return array
-     */
-    private function _properties(ReflectionClass $replace, array $_array): array
-    {
-        $methods = $replace->getProperties();
-        foreach ($methods as $method) {
-            $_property = [];
-            if ($method->isStatic()) continue;
-            foreach ($method->getAttributes() as $attribute) {
-                if (!class_exists($attribute->getName())) {
-                    continue;
-                }
-                $_property[] = $attribute->newInstance();
-            }
-            if (!empty($_property)) {
-                static::$_property[$replace->getName()][$method->getName()] = $_property;
-            }
-        }
-        return $_array;
-    }
-
-
     /**
      * @param string $path
      * @param string|array $outPath
@@ -280,15 +175,22 @@ class Loader extends BaseObject
     {
         try {
             $path = '/' . trim($path, '/');
+
+            $paths = [];
             foreach (static::$_directory as $key => $_path) {
                 $key = '/' . trim($key, '/');
                 if (!str_starts_with($key, $path) || in_array($key, $outPath)) {
                     continue;
                 }
-                $this->execute($_path);
+
+                foreach ($_path as $item) {
+                    $paths[] = $item;
                 }
+            }
+            return $paths;
         } catch (Throwable $exception) {
             $this->addError($exception, 'throwable');
+            return [];
         }
     }
 
@@ -326,38 +228,4 @@ class Loader extends BaseObject
     }
 
 
-    /**
-     * @param array $classes
-     * @throws Exception
-     */
-    private function execute(array $classes)
-    {
-        if (empty($classes)) {
-            return;
-        }
-        foreach ($classes as $className) {
-            if (!isset(static::$_methods[$className])) {
-                continue;
-            }
-            foreach (static::$_methods[$className] as $name => $attribute) {
-                $this->methods($attribute, $className, $name);
-            }
-        }
-    }
-
-
-    /**
-     * @param $attribute
-     * @param $annotation
-     * @param $className
-     * @param $name
-     */
-    private function methods($attribute, $className, $name)
-    {
-        $handler = static::$_classes[$className]['handler'];
-        foreach ($attribute as $value) {
-            $value->execute($handler, $name);
-        }
-    }
-
 }

Annotation/Model/Get.php

@@ -4,9 +4,7 @@
 namespace Annotation\Model;
 
 
-use Annotation\Annotation;
 use Attribute;
-use Database\ActiveRecord;
 use Exception;
 use Snowflake\Snowflake;
 

Annotation/Route/Interceptor.php

@@ -1,52 +0,0 @@
-<?php
-
-
-namespace Annotation\Route;
-
-
-use Annotation\Attribute;
-use JetBrains\PhpStorm\Pure;
-use Snowflake\Snowflake;
-
-/**
- * Class Interceptor
- * @package Annotation\Route
- */
-#[\Attribute(\Attribute::TARGET_METHOD)] class Interceptor extends Attribute
-{
-
-
-	/**
-	 * Interceptor constructor.
-	 * @param string|array $interceptor
-	 * @throws
-	 */
-	public function __construct(public string|array $interceptor)
-	{
-		if (is_string($this->interceptor)) {
-			$this->interceptor = [$this->interceptor];
-		}
-
-		foreach ($this->interceptor as $key => $value) {
-			$sn = Snowflake::createObject($value);
-
-			if (!($sn instanceof \HttpServer\IInterface\Interceptor)) {
-				continue;
-			}
-
-			$this->interceptor[$key] = [$sn, 'Interceptor'];
-		}
-	}
-
-
-	/**
-	 * @param mixed $class
-	 * @param mixed|null $method
-	 * @return Interceptor
-	 */
-    public function execute(mixed $class, mixed $method = null): static
-	{
-		return $this;
-	}
-
-}

Annotation/Route/Limits.php

@@ -1,52 +0,0 @@
-<?php
-
-
-namespace Annotation\Route;
-
-
-use Annotation\Attribute;
-use Snowflake\Snowflake;
-
-/**
- * Class Limits
- * @package Annotation\Route
- */
-#[\Attribute(\Attribute::TARGET_METHOD)] class Limits extends Attribute
-{
-
-
-	/**
-	 * Limits constructor.
-	 * @param string|array $limits
-	 * @throws
-	 */
-	public function __construct(public string|array $limits)
-	{
-		if (is_string($this->limits)) {
-			$this->limits = [$this->limits];
-		}
-
-		foreach ($this->limits as $key => $value) {
-			$sn = Snowflake::createObject($value);
-
-			if (!($sn instanceof \HttpServer\IInterface\Limits)) {
-				continue;
-			}
-
-			$this->limits[$key] = [$sn, 'next'];
-		}
-	}
-
-
-	/**
-	 * @param mixed $class
-	 * @param mixed|null $method
-	 * @return Limits
-	 */
-    public function execute(mixed $class, mixed $method = null): static
-	{
-		return $this;
-	}
-
-
-}

Annotation/Route/Middleware.php

@@ -5,6 +5,7 @@ namespace Annotation\Route;
 
 
 use Annotation\Attribute;
+use HttpServer\Route\Middlewares;
 use Snowflake\Snowflake;
 use HttpServer\IInterface\Middleware as IMiddleware;
 
@@ -28,7 +29,7 @@ use HttpServer\IInterface\Middleware as IMiddleware;
         }
 
         $array = [];
-		foreach ($this->middleware as $key => $value) {
+        foreach ($this->middleware as $value) {
             $sn = Snowflake::createObject($value);
             if (!($sn instanceof IMiddleware)) {
                 continue;
@@ -46,6 +47,8 @@ use HttpServer\IInterface\Middleware as IMiddleware;
      */
     public function execute(mixed $class, mixed $method = null): static
     {
+        $middleware = Snowflake::getDi()->get(Middlewares::class);
+        $middleware->addMiddlewares($class, $method, $this->middleware);
         return $this;
     }
 

Annotation/Route/Route.php

@@ -38,9 +38,16 @@ use Snowflake\Snowflake;
     {
         // TODO: Implement setHandler() method.
         $router = Snowflake::app()->getRouter();
-
+        $node = $router->addRoute($this->uri, [$class, $method], $this->method);
-		$router->addRoute($this->uri, [$class, $method], $this->method);
+        if ($node !== null) {
-
+            $attribute = Snowflake::getDi()->getMethodAttribute($class::class, $method);
+            foreach ($attribute as $item) {
+                if ($item instanceof Route) {
+                    continue;
+                }
+                $item->execute($class, $method);
+            }
+        }
         return $router;
     }
 

HttpServer/Route/Middlewares.php

@@ -0,0 +1,69 @@
+<?php
+
+
+namespace HttpServer\Route;
+
+
+use HttpServer\IInterface\Middleware;
+use Snowflake\Abstracts\BaseObject;
+
+
+/**
+ * Class Middlewares
+ * @package HttpServer\Route
+ */
+class Middlewares extends BaseObject
+{
+
+    private static array $_middlewares = [];
+
+
+    /**
+     * @param $class
+     * @param $method
+     * @param array|string $middlewares
+     */
+    public function addMiddlewares($class, $method, array|string $middlewares)
+    {
+        if (is_object($class)) {
+            $class = get_class($class);
+        }
+        if (!isset(static::$_middlewares[$class . '::' . $method])) {
+            static::$_middlewares[$class . '::' . $method] = [];
+        }
+
+        if (is_string($middlewares) && !in_array($middlewares, static::$_middlewares[$class . '::' . $method])) {
+            static::$_middlewares[$class . '::' . $method][] = $middlewares;
+            return;
+        }
+        foreach ($middlewares as $middleware) {
+            if (in_array($middlewares, static::$_middlewares[$class . '::' . $method])) {
+                continue;
+            }
+            static::$_middlewares[$class . '::' . $method][] = $middleware;
+        }
+    }
+
+
+    /**
+     * @param $class
+     * @param $method
+     * @param $caller
+     */
+    public function callerMiddlewares($class, $method, $caller)
+    {
+        $middlewares = static::$_middlewares[$class . '::' . $method] ?? [];
+        if (empty($middlewares)) {
+            return $caller;
+        }
+        return array_reduce(array_reverse($middlewares), function ($stack, $pipe) {
+            return function ($passable) use ($stack, $pipe) {
+                if ($pipe instanceof Middleware) {
+                    return $pipe->onHandler($passable, $stack);
+                }
+                return call_user_func($pipe, $passable, $stack);
+            };
+        }, $caller);
+    }
+
+}

HttpServer/Route/Node.php

@@ -5,15 +5,10 @@ declare(strict_types=1);
 namespace HttpServer\Route;
 
 
-use Annotation\Route\After;
-use Annotation\Route\Interceptor;
-use Annotation\Route\Limits;
-use Annotation\Route\Middleware;
 use Annotation\Route\RpcProducer;
 use Closure;
 use Exception;
 use HttpServer\Abstracts\HttpService;
-use HttpServer\Controller;
 use HttpServer\Http\Context;
 use HttpServer\Http\Request;
 use JetBrains\PhpStorm\Pure;
@@ -22,7 +17,6 @@ use Snowflake\Aop;
 use Snowflake\Core\Json;
 use Snowflake\Exception\NotFindClassException;
 use Snowflake\Snowflake;
-use Throwable;
 
 /**
  * Class Node
@@ -56,10 +50,6 @@ class Node extends HttpService
 
     private string $_alias = '';
 
-	private array $_interceptors = [];
-	private array $_after = [];
-	private array $_limits = [];
-
 
     /**
      * @param string $dataType
@@ -98,80 +88,50 @@ class Node extends HttpService
             if (!class_exists($controller) && !empty($this->namespace)) {
                 $controller = implode('\\', $this->namespace) . '\\' . $controller;
             }
-			$this->handler = $this->getReflect($controller, $action);
+            $this->handler = [Snowflake::getDi()->get($controller), $action];
         } else if ($handler != null && !is_callable($handler, true)) {
             $this->_error = 'Controller is con\'t exec.';
-		} else if ($handler instanceof Closure) {
-			$this->handler = $handler;
         } else {
-			[$controller, $action] = $this->handler = $handler;
+            $this->handler = $handler;
-			if (!($controller instanceof Controller)) {
-				return $this;
-			}
-			$this->annotationInject($controller::class, $action);
         }
         if (!empty($this->handler)) {
-			$this->callback = Reduce::reduce($this->createDispatch(), $this->annotation());
+            $this->callback = di(Middlewares::class)->callerMiddlewares(
-			$this->setAop();
+                $this->handler[0], $this->handler[1], $this->createDispatch()
+            );
         }
         return $this;
     }
 
-	private array $_aop;
-
-
-	/**
-	 * @return Closure
-	 * @throws Exception
-	 */
-	public function createDispatch(): Closure
-	{
-		$application = $this;
-		return static function () use ($application) {
-			$dispatchParam = Context::getContext('dispatch-param', [\request()]);
-			if (!empty($application->_aop)) {
-				return call_user_func($application->_aop[0], $application->_aop[1], $dispatchParam);
-			}
-			return call_user_func($application->handler, ...$dispatchParam);
-		};
-	}
-
 
     /**
      * @throws ReflectionException
      * @throws NotFindClassException
      * @throws Exception
      */
-	private function setAop()
+    private function createDispatch()
     {
+        $application = $this;
+
         /** @var Aop $aop */
         $aop = Snowflake::app()->get('aop');
         if (!is_array($this->handler) || !$aop->hasAop($this->handler)) {
-			return;
+            return static function () use ($application) {
+                $dispatchParam = Context::getContext('dispatch-param', [\request()]);
+
+                return call_user_func($application->handler, ...$dispatchParam);
+            };
         }
+
         $reflect = $aop->getAop($this->handler);
-		$this->_aop = [
+        $callback = [$reflect->getMethod('invoke'), 'invokeArgs'];
-			[$reflect->getMethod('invoke'), 'invokeArgs'],
-			$reflect->newInstance($this->handler)
-		];
-	}
 
+        return static function () use ($callback, $application, $reflect) {
+            $dispatchParam = Context::getContext('dispatch-param', [\request()]);
 
-	private bool $_hasBeforeAction = false;
+            $asp = $reflect->newInstance($this->handler);
 
-
+            call_user_func($callback, $asp, $dispatchParam);
-	/**
+        };
-	 * @return bool
-	 * @throws Exception
-	 */
-	public function beforeAction(): bool
-	{
-		if (!$this->_hasBeforeAction) return true;
-		[$controller, $action] = $this->handler;
-		if (!$controller->beforeAction(\request())) {
-			return false;
-		}
-		return true;
     }
 
 
@@ -180,116 +140,10 @@ class Node extends HttpService
      */
     #[Pure] protected function annotation(): array
     {
-		$middleWares = $this->getMiddleWares();
+        return $this->getMiddleWares();
-		$middleWares = $this->annotation_limit($this, $middleWares);
-		return $this->annotation_interceptor($this, $middleWares);
     }
 
 
-	/**
-	 * @param Node $node
-	 * @param array $middleWares
-	 * @return array
-	 */
-	#[Pure] protected function annotation_interceptor(Node $node, array $middleWares = []): array
-	{
-		if (!$node->hasInterceptor()) {
-			return $middleWares;
-		}
-		foreach ($node->getInterceptor() as $item) {
-			$middleWares[] = $item;
-		}
-		return $middleWares;
-	}
-
-
-	/**
-	 * @param Node $node
-	 * @param array $middleWares
-	 * @return array
-	 */
-	#[Pure] protected function annotation_limit(Node $node, array $middleWares = []): array
-	{
-		if (!$node->hasLimits()) {
-			return $middleWares;
-		}
-		foreach ($node->getLimits() as $item) {
-			$middleWares[] = $item;
-		}
-		return $middleWares;
-	}
-
-
-	/**
-	 * @return bool
-	 */
-	#[Pure] public function hasInterceptor(): bool
-	{
-		return count($this->_interceptors) > 0;
-	}
-
-
-	/**
-	 * @return bool
-	 */
-	#[Pure] public function hasLimits(): bool
-	{
-		return count($this->_limits) > 0;
-	}
-
-
-	/**
-	 * @param null $response
-	 * @return mixed
-	 * @throws Exception
-	 */
-	public function afterDispatch($response = null): mixed
-	{
-		if (is_object($this->_after[0])) {
-			return call_user_func($this->_after, \request(), $response);
-		}
-		foreach ($this->_after as $value) {
-			call_user_func($value, \request(), $response);
-		}
-		return $this->_after;
-	}
-
-
-	/**
-	 * @return array
-	 */
-	public function getInterceptor(): array
-	{
-		return $this->_interceptors;
-	}
-
-
-	/**
-	 * @return array
-	 */
-	public function getAfters(): array
-	{
-		return $this->_after;
-	}
-
-
-	/**
-	 * @return bool
-	 */
-	#[Pure] public function hasAfter(): bool
-	{
-		return count($this->_after) > 0;
-	}
-
-
-	/**
-	 * @return array
-	 */
-	public function getLimits(): array
-	{
-		return $this->_limits;
-	}
-
     /**
      * @param Request $request
      * @return bool
@@ -319,102 +173,6 @@ class Node extends HttpService
     }
 
 
-	/**
-	 * @param string $controller
-	 * @param string $action
-	 * @return null|array
-	 * @throws Exception
-	 */
-	private function getReflect(string $controller, string $action): ?array
-	{
-		try {
-			$reflect = Snowflake::getDi()->getReflect($controller);
-			if (empty($reflect)) {
-				throw new Exception($controller . ' Class is con\'t Instantiable.');
-			}
-			if (!empty($action) && !$reflect->hasMethod($action)) {
-				throw new Exception('method ' . $action . ' not exists at ' . $controller . '.');
-			}
-
-			$this->_hasBeforeAction = $reflect->hasMethod('beforeAction');
-
-			$this->annotationInject($reflect->getName(), $action);
-
-			return [$reflect->newInstance(), $action];
-		} catch (Throwable $exception) {
-			$this->_error = $exception->getMessage();
-			$this->addError($exception, 'router');
-			return null;
-		}
-	}
-
-
-	/**
-	 * @param Closure|array|string $handler
-	 * @throws Exception
-	 */
-	public function addInterceptor(Closure|string|array $handler)
-	{
-		if (!is_array($handler) || is_object($handler[0])) {
-			$handler = [$handler];
-		}
-		foreach ($handler as $closure) {
-			if (in_array($closure, $this->_interceptors)) {
-				continue;
-			}
-			$this->_interceptors[] = $closure;
-		}
-	}
-
-
-	/**
-	 * @param string $className
-	 * @param string $action
-	 * @return Node
-	 * @throws Exception
-	 */
-	public function annotationInject(string $className, string $action): Node
-	{
-		$annotation = annotation()->getMethods($className, $action);
-		if (empty($annotation)) {
-			return $this;
-		}
-		foreach ($annotation as $attribute) {
-			if ($attribute instanceof Interceptor) {
-				$this->addInterceptor($attribute->interceptor);
-			}
-			if ($attribute instanceof After) {
-				$this->addAfter($attribute->after);
-			}
-			if ($attribute instanceof Middleware) {
-				$this->addMiddleware($attribute->middleware);
-			}
-			if ($attribute instanceof Limits) {
-				$this->addLimits($attribute->limits);
-			}
-		}
-		return $this;
-	}
-
-
-	/**
-	 * @param Closure|array|string $handler
-	 * @throws Exception
-	 */
-	public function addAfter(Closure|string|array $handler)
-	{
-		if (!is_array($handler) || is_object($handler[0])) {
-			$handler = [$handler];
-		}
-		foreach ($handler as $closure) {
-			if (in_array($closure, $this->_after)) {
-				continue;
-			}
-			$this->_after[] = $closure;
-		}
-	}
-
-
     /**
      * @param Closure|array|string $handler
      * @throws Exception

HttpServer/Route/Reduce.php

@@ -19,52 +19,16 @@ class Reduce
      * @return mixed
      */
     public static function reduce($last, $middleWares): mixed
-    {
-        return array_reduce(array_reverse($middleWares), static::core(), $last);
-    }
-
-
-    /**
-     * @param $middleWares
-     * @return mixed
-     */
-    public static function after($middleWares): mixed
     {
         return array_reduce(array_reverse($middleWares), function ($stack, $pipe) {
-            return function ($request, $passable) use ($stack, $pipe) {
-                if (!($pipe instanceof After)) {
-                    return call_user_func($pipe, $request, $passable, $stack);
-                }
-                return $pipe->onHandler($request, $passable);
-            };
-        });
-    }
-
-
-    /**
-     * @return Closure
-     */
-    private static function core(): Closure
-    {
-        return function ($stack, $pipe) {
-            return static::passable($stack, $pipe);
-        };
-    }
-
-
-    /**
-     * @param $stack
-     * @param $pipe
-     * @return Closure
-     */
-    public static function passable($stack, $pipe): Closure
-    {
             return function ($passable) use ($stack, $pipe) {
                 if ($pipe instanceof Middleware) {
                     return $pipe->onHandler($passable, $stack);
                 }
                 return call_user_func($pipe, $passable, $stack);
             };
+        }, $last);
     }
 
+
 }

HttpServer/Route/Router.php

@@ -44,6 +44,9 @@ class Router extends HttpService implements RouterInterface
     public int $useTree = ROUTER_TREE;
 
 
+    private static array $controllers = [];
+
+
     public ?Response $response = null;
 
 
@@ -119,10 +122,6 @@ class Router extends HttpService implements RouterInterface
             $handler = Closure::bind($handler, new Controller());
         }
 
-//        if ($this->useTree === ROUTER_TREE) {
-//            return $this->tree($path, $handler, $method);
-//        }
-
         return $this->hash($path, $handler, $method);
     }
 
@@ -136,7 +135,6 @@ class Router extends HttpService implements RouterInterface
     private function hash($path, $handler, string $method = 'any'): ?Node
     {
         $path = $this->resolve($path);
-
         static::$nodes[$method][$path] = $this->NodeInstance($path, 0, $method);
 
         return static::$nodes[$method][$path]->bindHandler($handler);
@@ -343,11 +341,9 @@ class Router extends HttpService implements RouterInterface
         if ($this->middleware instanceof \Closure) {
             $node->addMiddleware([$this->middleware]);
         }
-
         if (is_array($name)) {
             $node->addMiddleware($this->resolve_middleware($name));
         }
-
         return $node;
     }
 
@@ -527,10 +523,7 @@ class Router extends HttpService implements RouterInterface
             $this->response->setFormat(Response::HTML);
             $this->response->send('<h1 style="text-align: center;">404</h1>');
         } else {
-            $this->response->send(($response = $node->dispatch()), 200);
+            $this->response->send($node->dispatch(), 200);
-            if ($node->hasAfter()) {
-                $node->afterDispatch($response);
-            }
         }
     }
 
@@ -637,6 +630,14 @@ class Router extends HttpService implements RouterInterface
     public function _loader()
     {
         $this->loadRouteDir(APP_PATH . 'routes');
+        $classes = Snowflake::getAnnotation()->runtime(CONTROLLER_PATH);
+        foreach ($classes as $class) {
+            $instance = Snowflake::getDi()->get($class);
+            $methods = Snowflake::getDi()->getMethodAttribute($class);
+            foreach ($methods as $method => $attribute) {
+                $attribute->execute($instance, $method);
+            }
+        }
     }
 
     /**

Server/Worker/ServerWorker.php

@@ -56,15 +56,10 @@ class ServerWorker extends \Server\Abstracts\Server
 
             echo sprintf("\033[36m[" . date('Y-m-d H:i:s') . "]\033[0m Worker[%d].%d start.", $server->worker_pid, $workerId) . PHP_EOL;
             $this->setProcessName(sprintf('Worker[%d].%d', $server->worker_pid, $workerId));
-
-            $annotation->runtime(CONTROLLER_PATH);
-            $annotation->runtime(MODEL_PATH);
         } else {
             echo sprintf("\033[36m[" . date('Y-m-d H:i:s') . "]\033[0m Tasker[%d].%d start.", $server->worker_pid, $workerId) . PHP_EOL;
 
             $this->setProcessName(sprintf('Tasker[%d].%d', $server->worker_pid, $workerId));
-
-            $annotation->runtime(APP_PATH, [CONTROLLER_PATH]);
         }
     }
 

System/Di/Container.php

@@ -9,13 +9,16 @@ declare(strict_types=1);
 
 namespace Snowflake\Di;
 
+use Annotation\Attribute;
 use Annotation\Inject;
+use Annotation\Target;
 use Exception;
 use ReflectionClass;
 use ReflectionException;
 use ReflectionMethod;
 use ReflectionProperty;
 use Snowflake\Abstracts\BaseObject;
+use Snowflake\Abstracts\Configure;
 use Snowflake\Exception\NotFindClassException;
 use Snowflake\Snowflake;
 
@@ -31,26 +34,58 @@ class Container extends BaseObject
      *
      * instance class by className
      */
-	private array $_singletons = [];
+    private static array $_singletons = [];
 
     /**
      * @var array
      *
      * class new instance construct parameter
      */
-	private array $_constructs = [];
+    private static array $_constructs = [];
 
     /**
      * @var array
      *
      * implements \ReflectClass
      */
-	private array $_reflection = [];
+    private static array $_reflection = [];
-
-	private array $_reflectionProperty = [];
 
 
-	private array $_property = [];
+    /**
+     * @var ReflectionProperty[]
+     */
+    private static array $_reflectionProperty = [];
+
+    /**
+     * @var ReflectionMethod[]
+     */
+    private static array $_reflectionMethod = [];
+
+    /**
+     * @var ReflectionClass[]
+     */
+    private static array $_reflectionClass = [];
+
+
+    /**
+     * @var array
+     */
+    private static array $_propertyAttributes = [];
+
+
+    /**
+     * @var array
+     */
+    private static array $_methodsAttributes = [];
+
+
+    /**
+     * @var array
+     */
+    private static array $_targetAttributes = [];
+
+
+    private static array $_attributeMaping = [];
 
 
     /**
@@ -58,7 +93,7 @@ class Container extends BaseObject
      *
      * The construct parameter
      */
-	private array $_param = [];
+    private static array $_param = [];
 
     /**
      * @param       $class
@@ -72,23 +107,23 @@ class Container extends BaseObject
      */
     public function get($class, array $constrict = [], array $config = []): mixed
     {
-		if (isset($this->_singletons[$class])) {
+        if (isset(static::$_singletons[$class])) {
-			return $this->_singletons[$class];
+            return static::$_singletons[$class];
-		} else if (!isset($this->_constructs[$class])) {
+        } else if (!isset(static::$_constructs[$class])) {
             return $this->resolve($class, $constrict, $config);
         }
 
-		$definition = $this->_constructs[$class];
+        $definition = static::$_constructs[$class];
         if (is_callable($definition, TRUE)) {
             return call_user_func($definition, $this, $constrict, $config);
         } else if (is_array($definition)) {
             $object = $this->resolveDefinition($definition, $class, $config, $constrict);
         } else if (is_object($definition)) {
-			return $this->_singletons[$class] = $definition;
+            return static::$_singletons[$class] = $definition;
         } else {
             throw new NotFindClassException($class);
         }
-		return $this->_singletons[$class] = $object;
+        return static::$_singletons[$class] = $object;
     }
 
 
@@ -134,28 +169,25 @@ class Container extends BaseObject
     {
         /** @var ReflectionClass $reflect */
         [$reflect, $dependencies] = $this->resolveDependencies($class);
-		if (empty($reflect)) {
+        if (empty($reflect) || !$reflect->isInstantiable()) {
             throw new NotFindClassException($class);
         }
-		foreach ($constrict as $index => $param) {
+        $dependencies = array_merge($dependencies, $constrict);
-			$dependencies[$index] = $param;
-		}
-
-		if (!$reflect->isInstantiable()) {
-			throw new NotFindClassException($reflect->getName());
-		}
-
         unset($dependencies['class']);
         if (empty($config) || !is_array($config)) {
             $object = $this->newInstance($reflect, $dependencies);
-		} else if (!empty($dependencies) && $reflect->implementsInterface('Snowflake\Abstracts\Configure')) {
+        } else if (!empty($dependencies) && $reflect->implementsInterface(Configure::class)) {
             $dependencies[count($dependencies) - 1] = $config;
             $object = $this->newInstance($reflect, $dependencies);
         } else {
-			if (!empty($config)) $this->_param[$class] = $config;
+            if (!empty($config)) static::$_param[$class] = $config;
 
             $object = $this->onAfterInit($this->newInstance($reflect, $dependencies), $config);
         }
+        static::$_reflectionClass[$reflect->getName()] = [];
+        foreach ($reflect->getAttributes() as $attribute) {
+            static::$_reflectionClass[$reflect->getName()][] = $attribute->newInstance();
+        }
         return $this->propertyInject($reflect, $object);
     }
 
@@ -182,10 +214,10 @@ class Container extends BaseObject
      */
     private function propertyInject(ReflectionClass $reflect, $object): mixed
     {
-		if (!isset($this->_property[$reflect->getName()])) {
+        if (!isset(static::$_propertyAttributes[$reflect->getName()])) {
             return $object;
         }
-		foreach ($this->_property[$reflect->getName()] as $property => $inject) {
+        foreach (static::$_propertyAttributes[$reflect->getName()] as $property => $inject) {
             /** @var Inject $inject */
             $inject->execute($object, $property);
         }
@@ -193,6 +225,107 @@ class Container extends BaseObject
     }
 
 
+    /**
+     * @param \ReflectionClass $class
+     */
+    private function resolveMethodAttribute(ReflectionClass $class)
+    {
+        if ($class->isAbstract() || $class->isTrait()) {
+            return;
+        }
+        foreach ($class->getMethods() as $method) {
+            if ($method->isStatic()) {
+                continue;
+            }
+            static::$_reflectionMethod[$class->getName()][$method->getName()] = $method;
+            static::$_methodsAttributes[$class->getName()][$method->getName()] = [];
+            foreach ($method->getAttributes() as $attribute) {
+                if (!class_exists($attribute->getName())) {
+                    continue;
+                }
+
+
+                $instance = $attribute->newInstance();
+
+                $this->setAttributeMapping($attribute, $class, $method, $instance);
+                $this->setMethodsAttributes($class, $method, $instance);
+                static::$_methodsAttributes[$class->getName()][$method->getName()][] = $attribute->newInstance();
+            }
+        }
+    }
+
+
+    /**
+     * @param \ReflectionAttribute $attribute
+     * @param \ReflectionClass $class
+     * @param $object
+     */
+    private function setAttributeMapping(\ReflectionAttribute $attribute, ReflectionClass $class, $object)
+    {
+        if (!isset(static::$_attributeMaping[$attribute->getName()])) {
+            static::$_attributeMaping[$attribute->getName()] = [];
+        }
+        static::$_attributeMaping[$attribute->getName()][$class->getName()][] = $object;
+    }
+
+
+    /**
+     * @param \ReflectionAttribute $attribute
+     * @param \ReflectionClass $class
+     * @param $object
+     */
+    private function setMethodsAttributes(\ReflectionClass $attribute, ReflectionMethod $method, $object)
+    {
+        if (!isset(static::$_methodsAttributes[$attribute->getName()])) {
+            static::$_methodsAttributes[$attribute->getName()] = [];
+        }
+        static::$_methodsAttributes[$attribute->getName()][$method->getName()][] = $object;
+    }
+
+
+    /**
+     * @param \ReflectionClass $class
+     */
+    private function resolveTargetAttribute(ReflectionClass $class)
+    {
+        if ($class->isAbstract() || $class->isTrait()) {
+            return;
+        }
+        foreach ($class->getAttributes() as $method) {
+            if ($method->getName() == Target::class) {
+                continue;
+            }
+            static::$_targetAttributes[$class->getName()] = $method->newInstance();
+        }
+    }
+
+
+    /**
+     * @param $className
+     * @param $method
+     * @return \ReflectionMethod|null
+     */
+    public function getReflectionMethod($className, $method): ?ReflectionMethod
+    {
+        return static::$_reflectionMethod[$className][$method] ?? null;
+    }
+
+
+    /**
+     * @param $className
+     * @param $method
+     * @return array
+     */
+    public function getMethodAttribute($className, $method = null): array
+    {
+        $methods = static::$_methodsAttributes[$className] ?? [];
+        if ($method === null || empty($method)) {
+            return $methods;
+        }
+        return $methods[$method] ?? [];
+    }
+
+
     /**
      * @param string $class
      * @param string|null $property
@@ -200,10 +333,10 @@ class Container extends BaseObject
      */
     public function getClassProperty(string $class, string $property = null): ReflectionProperty|null|array
     {
-		if (!isset($this->_reflectionProperty[$class])) {
+        if (!isset(static::$_reflectionProperty[$class])) {
             return null;
         }
-		$properties = $this->_reflectionProperty[$class];
+        $properties = static::$_reflectionProperty[$class];
         if (!empty($property)) {
             return $properties[$property] ?? null;
         }
@@ -232,17 +365,19 @@ class Container extends BaseObject
      */
     private function resolveDependencies($class): ?array
     {
-		if (!isset($this->_reflection[$class])) {
+        if (!isset(static::$_reflection[$class])) {
-			$this->_reflection[$class] = new ReflectionClass($class);
+            static::$_reflection[$class] = new ReflectionClass($class);
-			if (!$this->_reflection[$class]->isInstantiable()) {
+            if (!static::$_reflection[$class]->isInstantiable()) {
                 return null;
             }
-			$this->scanProperty($this->_reflection[$class]);
+            $this->resolveTargetAttribute(static::$_reflection[$class]);
+            $this->resolveMethodAttribute(static::$_reflection[$class]);
+            $this->scanProperty(static::$_reflection[$class]);
         }
-		if (!is_null($constructs = $this->_reflection[$class]->getConstructor())) {
+        if (!is_null($constructs = static::$_reflection[$class]->getConstructor())) {
             $constructs = $this->resolveMethodParam($constructs);
         }
-		return [$this->_reflection[$class], $constructs];
+        return [static::$_reflection[$class], $constructs];
     }
 
 
@@ -263,9 +398,9 @@ class Container extends BaseObject
                 continue;
             }
 
-			$this->_reflectionProperty[$className][$property->getName()] = $property;
+            static::$_reflectionProperty[$className][$property->getName()] = $property;
 
-			$this->_property[$className][$property->getName()] = $targets[0]->newInstance();
+            static::$_propertyAttributes[$className][$property->getName()] = $targets[0]->newInstance();
         }
     }
 
@@ -308,7 +443,7 @@ class Container extends BaseObject
      */
     public function getReflect($class): ?ReflectionClass
     {
-		$reflect = $this->_reflection[$class] ?? null;
+        $reflect = static::$_reflection[$class] ?? null;
         if (!is_null($reflect)) {
             return $reflect;
         }
@@ -330,8 +465,8 @@ class Container extends BaseObject
             $class = $class::class;
         }
         unset(
-			$this->_reflection[$class], $this->_singletons[$class],
+            static::$_reflection[$class], static::$_singletons[$class],
-			$this->_param[$class], $this->_constructs[$class]
+            static::$_param[$class], static::$_constructs[$class]
         );
     }
 
@@ -340,10 +475,10 @@ class Container extends BaseObject
      */
     public function flush(): static
     {
-		$this->_reflection = [];
+        static::$_reflection = [];
-		$this->_singletons = [];
+        static::$_singletons = [];
-		$this->_param = [];
+        static::$_param = [];
-		$this->_constructs = [];
+        static::$_constructs = [];
         return $this;
     }
 
@@ -355,12 +490,12 @@ class Container extends BaseObject
      */
     private function mergeParam($class, $newParam): array
     {
-		if (empty($this->_param[$class])) {
+        if (empty(static::$_param[$class])) {
             return $newParam;
         } else if (empty($newParam)) {
-			return $this->_param[$class];
+            return static::$_param[$class];
         }
-		$old = $this->_param[$class];
+        $old = static::$_param[$class];
         foreach ($newParam as $key => $val) {
             $old[$key] = $val;
         }