改名

http-handler/Abstracts/Handler.php

@@ -2,11 +2,12 @@
 
 namespace Http\Handler\Abstracts;
 
+use Http\Handler\Handler as CHl;
+use Kiri\Kiri;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Server\MiddlewareInterface;
 use Psr\Http\Server\RequestHandlerInterface;
-use Http\Handler\Handler as CHl;
 
 
 abstract class Handler implements RequestHandlerInterface
@@ -33,7 +34,11 @@ abstract class Handler implements RequestHandlerInterface
 	protected function execute(ServerRequestInterface $request): ResponseInterface
 	{
 		if (empty($this->middlewares) || !isset($this->middlewares[$this->offset])) {
-			return call_user_func($this->handler->callback, ...$this->handler->params);
+			[$controller, $action] = $this->handler->callback;
+
+			$controller = Kiri::getDi()->get($controller);
+
+			return call_user_func([$controller, $action], ...$this->handler->params);
 		}
 
 		$middleware = $this->middlewares[$this->offset];

http-handler/Abstracts/HandlerManager.php

@@ -13,11 +13,11 @@ class HandlerManager
 
 
 	/**
-	 * @param $path
+	 * @param string $path
-	 * @param $method
+	 * @param string $method
-	 * @param $handler
+	 * @param \Http\Handler\Handler|Closure $handler
 	 */
-	public static function add($path, $method, $handler)
+	public static function add(string $path, string $method, \Http\Handler\Handler|Closure $handler)
 	{
 		if (!isset(static::$handlers[$path])) {
 			static::$handlers[$path] = [];

http-handler/CoreMiddleware.php

@@ -20,6 +20,9 @@ class CoreMiddleware extends Middleware
 	public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
 	{
 		// TODO: Implement process() method.
+
+
+
 		return $handler->handle($request);
 	}
 

http-handler/Dispatcher.php

@@ -3,9 +3,14 @@
 namespace Http\Handler;
 
 use Exception;
+use Kiri\Core\Help;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 
+
+/**
+ *
+ */
 class Dispatcher extends \Http\Handler\Abstracts\Handler
 {
 
@@ -17,6 +22,35 @@ class Dispatcher extends \Http\Handler\Abstracts\Handler
 	 */
 	public function handle(ServerRequestInterface $request): ResponseInterface
 	{
-		return $this->execute($request);
+		$response = $this->execute($request);
+		if (!$response instanceof ResponseInterface) {
+			return $this->transferToResponse($response);
+		}
+		return $response;
+	}
+
+
+	/**
+	 * @param mixed $responseData
+	 * @return \Server\Constrict\ResponseInterface
+	 * @throws Exception
+	 */
+	private function transferToResponse(mixed $responseData): ResponseInterface
+	{
+		$interface = response()->withStatus(200);
+		if (!$interface->hasContentType()) {
+			$interface->withContentType('application/json;charset=utf-8');
+		}
+		if (is_object($responseData)) {
+			$responseData = get_object_vars($responseData);
+		}
+		if ($interface->getContentType() == 'application/xml;charset=utf-8') {
+			$interface->getBody()->write(Help::toXml($responseData));
+		} else if (is_array($responseData)) {
+			$interface->getBody()->write(json_encode($responseData));
+		} else {
+			$interface->getBody()->write((string)$responseData);
+		}
+		return $interface;
 	}
 }

http-handler/TestRequest.php

@@ -8,10 +8,10 @@ use Http\Handler\Abstracts\HandlerManager;
 use Http\Message\ServerRequest;
 use Http\Message\Stream;
 use Http\Route\MiddlewareManager;
-use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Server\Constrict\RequestInterface;
 use Server\Constrict\ResponseEmitter;
+use Server\Constrict\ResponseInterface;
 use Swoole\Http\Request;
 use Swoole\Http\Response;
 
@@ -19,75 +19,65 @@ class TestRequest
 {
 
 
-    private ?ResponseEmitter $response = null;
+	private ?ResponseEmitter $response = null;
 
 
-    /**
+	/**
-     * @param Request $request
+	 * @param Request $request
-     * @param Response $response
+	 * @param Response $response
-     * @throws Exception
+	 * @throws Exception
-     */
+	 */
-    public function onRequest(Request $request, Response $response): void
+	public function onRequest(Request $request, Response $response): void
-    {
+	{
-        try {
+		try {
-            [$PsrRequest, $PsrResponse] = $this->initRequestResponse($request);
+			[$PsrRequest, $PsrResponse] = $this->initRequestResponse($request);
-            /** @var Handler $handler */
+			/** @var Handler $handler */
-            $handler = HandlerManager::get($request->server['request_uri'], $request->getMethod());
+			$handler = HandlerManager::get($request->server['request_uri'], $request->getMethod());
-            if (is_integer($handler)) {
+			if (is_integer($handler)) {
-                $PsrResponse->withStatus($handler)->withBody(null);
+				$PsrResponse->withStatus($handler)->withBody(null);
-            } else if (is_null($handler)) {
+			} else if (is_null($handler)) {
-                $PsrResponse->withStatus(404)->withBody(null);
+				$PsrResponse->withStatus(404)->withBody(null);
-            } else {
+			} else {
-                $PsrResponse = $this->handler($handler, $PsrRequest);
+				$PsrResponse = $this->handler($handler, $PsrRequest);
-            }
+			}
-        } catch (\Throwable $throwable) {
+		} catch (\Throwable $throwable) {
-            $PsrResponse = $this->throwable($throwable);
+			$PsrResponse = \response()->withStatus($throwable->getCode())
-        } finally {
+				->withContentType(\Http\Message\Response::CONTENT_TYPE_HTML)
-            $this->response->sender($response, $PsrResponse);
+				->withBody(new Stream(jTraceEx($throwable)));
-        }
+		} finally {
-    }
+			$this->response->sender($response, $PsrResponse);
+		}
+	}
 
 
-    /**
+	/**
-     * @param \Throwable $throwable
+	 * @param Handler $handler
-     * @return \Psr\Http\Message\ResponseInterface
+	 * @param $PsrRequest
-     */
+	 * @return ResponseInterface
-    protected function throwable(\Throwable $throwable): ResponseInterface
+	 * @throws Exception
-    {
+	 */
-        return \response()->withStatus($throwable->getCode())
+	protected function handler(Handler $handler, $PsrRequest): \Psr\Http\Message\ResponseInterface
-            ->withContentType(\Http\Message\Response::CONTENT_TYPE_HTML)
+	{
-            ->withBody(new Stream(jTraceEx($throwable)));
+		$middlewares = MiddlewareManager::get($handler->callback);
-    }
+
+		$dispatcher = new Dispatcher($handler, $middlewares);
+
+		return $dispatcher->handle($PsrRequest);
+	}
 
 
-    /**
+	/**
-     * @param \Http\Handler\Handler $handler
+	 * @param Request $request
-     * @param $PsrRequest
+	 * @return array<ServerRequestInterface, ResponseInterface>
-     * @return \Psr\Http\Message\ResponseInterface
+	 * @throws Exception
-     * @throws \Exception
+	 */
-     */
+	private function initRequestResponse(Request $request): array
-    protected function handler(Handler $handler, $PsrRequest): ResponseInterface
+	{
-    {
+		$PsrResponse = Context::setContext(ResponseInterface::class, new \Http\Message\Response());
-        $middlewares = MiddlewareManager::get($handler->callback);
 
-        $dispatcher = new Dispatcher($handler, $middlewares);
+		$PsrRequest = Context::setContext(RequestInterface::class, ServerRequest::createServerRequest($request));
 
-        return $dispatcher->handle($PsrRequest);
+		return [$PsrRequest, $PsrResponse];
-    }
+	}
-
-
-    /**
-     * @param Request $request
-     * @return array<ServerRequestInterface, ResponseInterface>
-     * @throws Exception
-     */
-    private function initRequestResponse(Request $request): array
-    {
-        $PsrResponse = Context::setContext(ResponseInterface::class, new \Http\Message\Response());
-
-        $PsrRequest = Context::setContext(RequestInterface::class, ServerRequest::createServerRequest($request));
-
-        return [$PsrRequest, $PsrResponse];
-    }
 
 }

http-server/Service/Http.php

@@ -5,6 +5,7 @@ namespace Server\Service;
 
 use Exception;
 use Http\Exception\RequestException;
+use Http\Handler\TestRequest;
 use Http\Route\Node;
 use Kiri\Core\Help;
 use Server\Constant;
@@ -24,6 +25,17 @@ use Swoole\Server;
 class Http extends \Server\Abstracts\Http implements OnClose, OnConnect
 {
 
+	public TestRequest $request;
+
+
+	public function init()
+	{
+
+		$this->request = new TestRequest();
+
+		parent::init();
+	}
+
 
 	/**
 	 * @param Server $server
@@ -38,9 +50,13 @@ class Http extends \Server\Abstracts\Http implements OnClose, OnConnect
 	/**
 	 * @param Request $request
 	 * @param Response $response
+	 * @throws Exception
 	 */
 	public function onRequest(Request $request, Response $response): void
 	{
+		$this->request->onRequest($request, $response);
+		return;
+
 		try {
 			if (!(($node = $this->router->radix_tree($Psr7Request = ScRequest::create($request))) instanceof Node)) {
 				throw new RequestException(Constant::STATUS_404_MESSAGE, 404);

note/Route/Route.php

@@ -5,8 +5,9 @@ namespace Annotation\Route;
 
 
 use Annotation\Attribute;
+use Http\Handler\Abstracts\HandlerManager;
+use Http\Handler\Handler;
 use Http\Route\Router;
-use Kiri\Kiri;
 
 #[\Attribute(\Attribute::TARGET_METHOD | \Attribute::IS_REPEATABLE)] class Route extends Attribute
 {
@@ -19,6 +20,8 @@ use Kiri\Kiri;
 	 */
 	public function __construct(public string $uri, public string $method, public string $version = 'v.1.0')
 	{
+		$this->uri = '/' . ltrim($this->uri, '/');
+		$this->method = strtoupper($this->method);
 	}
 
 
@@ -26,16 +29,12 @@ use Kiri\Kiri;
 	 * @param mixed $class
 	 * @param mixed|null $method
 	 * @return Router
+	 * @throws \ReflectionException
 	 */
 	public function execute(mixed $class, mixed $method = null): Router
 	{
-		// TODO: Implement setHandler() method.
+		HandlerManager::add($this->uri, $this->method, new Handler($this->uri, [$class, $method]));
-		$router = Kiri::getDi()->get(Router::class);
+		return parent::execute($class, $method);
-		if (is_string($class)) {
-			$class = di($class);
-		}
-		$router->addRoute($this->uri, [$class, $method], strtoupper($this->method));
-		return $router;
 	}