改名

http-server/Abstracts/MiddlewareHandler.php

@@ -1,15 +0,0 @@
-<?php
-
-
-namespace HttpServer\Abstracts;
-
-use HttpServer\IInterface\IMiddleware;
-
-/**
- * Class MiddlewareHandler
- * @package Snowflake\Snowflake\Route
- */
-abstract class MiddlewareHandler implements IMiddleware
-{
-
-}

http-server/IInterface/Middleware.php

@@ -10,7 +10,7 @@ use HttpServer\Http\Request;
  * Interface IMiddleware
  * @package Snowflake\Snowflake\Route
  */
-interface IMiddleware
+interface Middleware
 {
 
 	public function handler(Request $request,\Closure $next);

http-server/Route/Annotation/Annotation.php

@@ -0,0 +1,53 @@
+<?php
+
+
+namespace HttpServer\Route\Annotation;
+
+use ReflectionException;
+use Snowflake\Abstracts\BaseAnnotation;
+use Snowflake\Snowflake;
+
+/**
+ * Class Annotation
+ */
+class Annotation extends \Snowflake\Annotation\Annotation
+{
+
+	const HTTP_EVENT = 'http:event:';
+
+	/**
+	 * @var string
+	 * @Interceptor(LoginInterceptor)
+	 */
+	private $Interceptor = 'required|not empty';
+
+
+	/**
+	 * @var string
+	 */
+	private $Limits = 'required|not empty';
+
+	protected $_annotations = [];
+
+
+	/**
+	 * @param $events
+	 * @return bool
+	 */
+	public function isLegitimate($events)
+	{
+		return isset($events[2]) && !empty($events[2]);
+	}
+
+
+	/**
+	 * @param $name
+	 * @param $events
+	 * @return false|string
+	 */
+	public function getName($name, $events)
+	{
+		return self::HTTP_EVENT . $name . ':' . $events[2];
+	}
+
+}

http-server/Route/CoreMiddleware.php

@@ -4,27 +4,27 @@
 namespace HttpServer\Route;
 
 
+use Closure;
+use Exception;
 use HttpServer\Http\Context;
 use HttpServer\Http\Request;
 use HttpServer\Http\Response;
-use HttpServer\Abstracts\MiddlewareHandler;
-use Snowflake\Snowflake;
 
 /**
  * Class CoreMiddleware
  * @package Snowflake\Snowflake\Route
  * 跨域中间件
  */
-class CoreMiddleware extends MiddlewareHandler
+class CoreMiddleware implements \HttpServer\IInterface\Middleware
 {
 
 	/**
 	 * @param Request $request
-	 * @param \Closure $next
+	 * @param Closure $next
 	 * @return mixed
-	 * @throws \Exception
+	 * @throws Exception
 	 */
-	public function handler(Request $request,\Closure $next)
+	public function handler(Request $request, Closure $next)
 	{
 		$header = $request->headers;
 

http-server/Route/Dispatch/Dispatch.php

@@ -61,12 +61,10 @@ class Dispatch
 	 */
 	protected function bindParam()
 	{
-		/** @var Controller $controller */
-		if (is_array($this->handler)) {
-			$controller = $this->handler[0];
-		} else {
-			$controller = $this->handler;
+		if ($this->handler instanceof \Closure) {
+			return;
 		}
+		$controller = $this->handler[0];
 		$controller->request = Context::getContext('request');
 		$controller->headers = $controller->request->headers;
 		$controller->input = $controller->request->params;

http-server/Route/Middleware.php

@@ -10,7 +10,6 @@ namespace HttpServer\Route;
 
 use Closure;
 use Exception;
-use HttpServer\IInterface\IMiddleware;
 use HttpServer\Route\Dispatch\Dispatch;
 
 /**
@@ -65,7 +64,7 @@ class Middleware
 	{
 		return function ($stack, $pipe) {
 			return function ($passable) use ($stack, $pipe) {
-				if ($pipe instanceof IMiddleware) {
+				if ($pipe instanceof \HttpServer\IInterface\Middleware) {
 					return $pipe->handler($passable, $stack);
 				} else {
 					return $pipe($passable, $stack);

http-server/Route/Node.php

@@ -7,6 +7,7 @@ namespace HttpServer\Route;
 use HttpServer\Http\Request;
 use Exception;
 use HttpServer\Application;
+use HttpServer\Route\Annotation\Annotation;
 use Snowflake\Snowflake;
 
 /**
@@ -36,6 +37,8 @@ class Node extends Application
 	public $middleware = [];
 	public $callback = [];
 
+	private $_interceptors = [];
+
 	/**
 	 * @param $handler
 	 * @return Node
@@ -118,7 +121,7 @@ class Node extends Application
 	private function getReflect(string $controller, string $action)
 	{
 		try {
-			$reflect = new \ReflectionClass($controller);
+			$reflect = Snowflake::getDi()->getReflect($controller);
 			if (!$reflect->isInstantiable()) {
 				throw new Exception($controller . ' Class is con\'t Instantiable.');
 			}
@@ -126,6 +129,15 @@ class Node extends Application
 			if (!empty($action) && !$reflect->hasMethod($action)) {
 				throw new Exception('method ' . $action . ' not exists at ' . $controller . '.');
 			}
+
+			/** @var Annotation $annotation */
+			$annotation = Snowflake::createObject(Annotation::class);
+			if (!empty($methods)) {
+				$annotations = $annotation->instance($reflect);
+				if (isset($annotations['Interceptor'])) {
+				}
+
+			}
 			return [$reflect->newInstance(), $action];
 		} catch (Exception $exception) {
 			$this->_error = $exception->getMessage();

http-server/Route/Router.php

@@ -9,9 +9,12 @@ use HttpServer\Http\Context;
 use HttpServer\Controller;
 use HttpServer\IInterface\RouterInterface;
 use HttpServer\Application;
+use HttpServer\Route\Annotation\Annotation;
+use ReflectionException;
 use Snowflake\Config;
 use Snowflake\Core\JSON;
 use Snowflake\Exception\ConfigException;
+use Snowflake\Exception\NotFindClassException;
 use Snowflake\Snowflake;
 
 /**
@@ -498,10 +501,20 @@ class Router extends Application implements RouterInterface
 
 	/**
 	 * @param $file
+	 * @throws ReflectionException
+	 * @throws NotFindClassException
 	 */
 	private function loadFile($file)
 	{
 		$router = $this;
+
+		$prefix = APP_PATH . 'app/Http/';
+
+		/** @var Annotation $annotation */
+		$annotation = Snowflake::createObject(Annotation::class);
+		$annotation->registration_notes($prefix . 'Interceptor', 'App\Http\Interceptor');
+		$annotation->registration_notes($prefix . 'Limits', 'App\Http\Limits');
+
 		include_once "$file";
 	}
 

http-server/config.php

@@ -93,10 +93,9 @@ return [
 			],
 			'events'   => [
 				Event::SERVER_WORKER_START => function () {
+					$path = APP_PATH . 'app/Websocket';
 					$websocket = Snowflake::get()->annotation->websocket;
-//					$websocket->path = $this->socketControllers;
-					$websocket->namespace = 'App\\Sockets\\';
-					$websocket->registration_notes();
+					$websocket->registration_notes($path, 'App\\Sockets\\');
 				},
 				Event::SERVER_HANDSHAKE    => function (Request $request, Response $response) {
 					$this->error($request->fd . ' connect.');
@@ -105,8 +104,15 @@ return [
 				},
 				Event::SERVER_MESSAGE      => function (\Swoole\WebSocket\Server $server, Frame $frame) {
 					$this->error('websocket SERVER_MESSAGE.');
-
-					return $server->push($frame->fd, 'hello word~');
+					if (is_null($json = json_decode($frame->data, true))) {
+						return $server->push($frame->fd, 'format error~');
+					}
+					$websocket = Snowflake::get()->annotation->websocket;
+					if ($websocket->has($json['path'])) {
+						return $websocket->runWith($json['path'], [$frame->fd, $json]);
+					} else {
+						return $server->push($frame->fd, 'hello word~');
+					}
 				},
 				Event::SERVER_CLOSE        => function (int $fd) {
 					$this->error($fd . ' disconnect.');

system/Abstracts/BaseAnnotation.php

@@ -4,6 +4,12 @@
 namespace Snowflake\Abstracts;
 
 
+use Exception;
+use ReflectionClass;
+use ReflectionException;
+use ReflectionMethod;
+use Snowflake\Exception\NotFindClassException;
+use Snowflake\Snowflake;
 
 /**
  * Class BaseAnnotation
@@ -12,9 +18,108 @@ namespace Snowflake\Abstracts;
 abstract class BaseAnnotation extends Component
 {
 
-	public function each()
-	{
 
+	/**
+	 * @param ReflectionClass $reflect
+	 * @return array
+	 */
+	protected function getPrivates(ReflectionClass $reflect)
+	{
+		$arrays = [];
+		$properties = $reflect->getProperties(ReflectionMethod::IS_PRIVATE);
+		foreach ($properties as $property) {
+			$arrays[] = $property->getName();
+		}
+		return $arrays;
 	}
 
+
+	/**
+	 * @param ReflectionClass $reflect
+	 * @param array $rules
+	 * @return array
+	 * @throws Exception
+	 */
+	public function instance($reflect, $rules = [])
+	{
+		$annotations = $this->getPrivates($reflect);
+
+		$classMethods = $reflect->getMethods(ReflectionMethod::IS_PUBLIC);
+		if (!$reflect->isInstantiable()) {
+			throw new Exception('Class ' . $reflect->getName() . ' cannot be instantiated.');
+		}
+
+		$object = $reflect->newInstance();
+
+		$array = [];
+		foreach ($classMethods as $classMethod) {
+			$array = $this->resolveDocComment($classMethod, $object, $annotations, $array);
+		}
+		return $array;
+	}
+
+
+	/**
+	 * @param ReflectionMethod $function
+	 * @param $object
+	 * @param $annotations
+	 * @param $array
+	 * @return array
+	 * @throws
+	 */
+	protected function resolveDocComment($function, $object, $annotations, $array)
+	{
+		$comment = $function->getDocComment();
+		foreach ($annotations as $annotation) {
+			preg_match('/@(' . $annotation . ')\((.*?)\)/', $comment, $events);
+			if (!isset($events[1])) {
+				continue;
+			}
+			if (!($_key = $this->getName($function, $events))) {
+				continue;
+			}
+			if (isset($events[2])) {
+				$handler = Snowflake::createObject($events[2]);
+			} else {
+				$handler = [$object, $events[1]];
+			}
+			if (!isset($array[$annotation])) {
+				$array[$annotation] = [];
+			}
+			$array[$annotation][] = [$_key, $handler];
+		}
+		return $array;
+	}
+
+
+	/**
+	 * @param $rule
+	 * @param $content
+	 * @param $rules
+	 * @return bool
+	 * @throws ReflectionException
+	 * @throws NotFindClassException
+	 * @throws Exception
+	 */
+	public function check($rule, $content, $rules)
+	{
+		if (empty($rule)) {
+			return true;
+		}
+		$explode = explode('|', $rule);
+		foreach ($explode as $value) {
+			$reflect = array_merge($rules[$value], [
+				'value' => $content
+			]);
+			$validator = Snowflake::createObject($reflect);
+			if (!$validator->check()) {
+				throw new Exception($validator->getMessage());
+			}
+		}
+		return false;
+	}
+
+
+	abstract public function runWith($path);
+
 }

system/Annotation/Annotation.php

@@ -6,19 +6,24 @@ namespace Snowflake\Annotation;
 use Exception;
 use ReflectionClass;
 use ReflectionException;
+use ReflectionMethod;
 use Snowflake\Abstracts\BaseAnnotation;
 use Snowflake\Exception\NotFindClassException;
 use Snowflake\Snowflake;
+use validator\RequiredValidator;
+use validator\RequiredValidator as NotEmptyValidator;
 
 /**
  * Class Annotation
  * @package Snowflake\Snowflake\Annotation
  * @property Websocket $websocket
+ * @property Http $http
  */
 class Annotation extends BaseAnnotation
 {
 
 	protected $_Scan_directory = [];
+	protected $params = [];
 
 	public $namespace = '';
 
@@ -27,8 +32,19 @@ class Annotation extends BaseAnnotation
 	public $path = '';
 
 
+	private $rules = [
+		'required'  => [
+			'class' => RequiredValidator::class
+		],
+		'not empty' => [
+			'class' => NotEmptyValidator::class
+		]
+	];
+
+
 	private $_classMap = [
-		'websocket' => Websocket::class
+		'websocket' => Websocket::class,
+		'http'      => Http::class
 	];
 
 
@@ -43,59 +59,126 @@ class Annotation extends BaseAnnotation
 
 
 	/**
+	 * @param $path
+	 * @param $namespace
 	 * @throws ReflectionException
 	 */
-	public function registration_notes()
+	public function registration_notes($path, $namespace)
 	{
-		if (!is_array($this->path)) {
-			return;
-		}
-		foreach ($this->path as $item) {
-			$this->scanning($item);
+		foreach ($path as $item) {
+			$this->scanning($item, $namespace);
 		}
 	}
 
+
+	/**
+	 * @return string
+	 * @throws
+	 */
+	public function getHttp()
+	{
+		return Snowflake::createObject($this->_classMap['http']);
+	}
+
+
+	/**
+	 * @return string
+	 * @throws
+	 */
+	public function getWebsocket()
+	{
+		return Snowflake::createObject($this->_classMap['websocket']);
+	}
+
+	/**
+	 * @param ReflectionClass $reflect
+	 * @Message(updatePosition)
+	 * @throws Exception
+	 */
+	public function resolve(ReflectionClass $reflect)
+	{
+		$controller = $reflect->newInstance();
+
+		$methods = $this->getPrivates($reflect);
+
+		foreach ($methods as $function) {
+			$comment = $function->getDocComment();
+			$methodName = $function->getName();
+
+			preg_match('/@(' . $function . ')\((.*?)\)/', $comment, $events);
+			if (!isset($events[1])) {
+				continue;
+			}
+			if (!$this->isLegitimate($events)) {
+				continue;
+			}
+			$_key = $this->getName($function, $events);
+			if (empty($events[2])) {
+				$this->push($_key, [$controller, $methodName]);
+			} else {
+				$handler = $this->createHandler($controller, $methodName, $events[2]);
+
+				$this->push($_key, $handler, [request(), [$controller, $methodName]]);
+			}
+		}
+	}
+
+
+	/**
+	 * @param $events
+	 * @throws Exception
+	 */
+	public function isLegitimate($events)
+	{
+		throw new Exception('Undefined analytic function.');
+	}
+
+
+	/**
+	 * @param $function
+	 * @param $events
+	 * @throws Exception
+	 */
+	public function getName($function, $events)
+	{
+		throw new Exception('Undefined analytic function.');
+	}
+
+
+	/**
+	 * @param $controller
+	 * @param $methodName
+	 * @param $events
+	 * @throws Exception
+	 */
+	public function createHandler($controller, $methodName, $events)
+	{
+		throw new Exception('Undefined analytic function.');
+	}
+
+
 	/**
 	 * @param string $path
+	 * @param $namespace
 	 * @throws ReflectionException
 	 * @throws Exception
 	 */
-	protected function scanning($path = '')
+	protected function scanning($path, $namespace)
 	{
-		if (empty($path)) {
-			$path = rtrim($this->path, '/');
-		}
+		$di = Snowflake::getDi();
 		foreach (glob($path . '/*') as $file) {
 			if (is_dir($file)) {
-				$this->scanning($path);
+				$this->scanning($path, $namespace);
 			}
 
 			$explode = explode('/', $file);
 
 			$class = str_replace('.php', '', end($explode));
 
-			$reflect = new ReflectionClass($this->namespace . $class);
-
-			$methods = $reflect->getMethods(\ReflectionMethod::IS_PUBLIC);
-			if (empty($methods) || !$reflect->isInstantiable()) {
-				continue;
-			}
-			$this->resolve($reflect, $methods);
+			$this->resolve($di->getReflect($namespace . '\\' . $class));
 		}
 	}
 
-
-	/**
-	 * @param ReflectionClass $class
-	 * @param array $methods
-	 * @throws Exception
-	 */
-	public function resolve(ReflectionClass $class, array $methods)
-	{
-		throw new Exception('Undefined analytic function.');
-	}
-
-
 	/**
 	 * @param $path
 	 * @param mixed ...$param
@@ -106,17 +189,25 @@ class Annotation extends BaseAnnotation
 		if (!$this->has($path)) {
 			return null;
 		}
-		return call_user_func($this->_Scan_directory[$path], ...$param);
+		$callback = $this->_Scan_directory[$path];
+		if (!isset($this->params[$path])) {
+			return $callback(...$param);
+		}
+		return $callback(...$this->params[$path]);
 	}
 
 
 	/**
 	 * @param $name
 	 * @param $callback
+	 * @param array $params
 	 */
-	public function push($name, $callback)
+	public function push($name, $callback, $params = [])
 	{
 		$this->_Scan_directory[$name] = $callback;
+		if (!empty($params)) {
+			$this->params[$name] = $params;
+		}
 	}
 
 

system/Annotation/Definition/Http.php

@@ -0,0 +1,85 @@
+<?php
+
+
+namespace Snowflake\Annotation;
+
+
+use Closure;
+use ReflectionClass;
+use ReflectionException;
+use Snowflake\Snowflake;
+
+/**
+ * Class Http
+ * @package Snowflake\Annotation
+ */
+class Http extends Annotation
+{
+
+	const HTTP_EVENT = 'http:event:';
+
+	/**
+	 * @var string
+	 * 拦截器
+	 */
+	private $Interceptor;
+
+
+	/**
+	 * @var string
+	 * 限速
+	 */
+	private $Limits;
+
+
+	/**
+	 * @param $controller
+	 * @param $methodName
+	 * @param $handler
+	 * @return array
+	 * @throws ReflectionException
+	 */
+	public function createLimits($controller, $methodName, $handler)
+	{
+		$namespace = 'App\Http\Interceptor\\' . $handler;
+		$class = Snowflake::getDi()->getReflect($namespace);
+
+		$object = $class->newInstance();
+
+
+		$method = $class->getMethod('Interceptor');
+
+
+		return [$object, 'Interceptor'];
+	}
+
+
+	/**
+	 * @param $controller
+	 * @param $methodName
+	 * @param $handler
+	 * @return array
+	 * @throws ReflectionException
+	 */
+	public function createInterceptor($controller, $methodName, $handler)
+	{
+		$namespace = 'App\Interceptor\\' . $handler;
+		$class = Snowflake::getDi()->getReflect($namespace);
+
+		$object = $class->newInstance();
+
+		return [$object, 'Interceptor', [request(), [$controller, $methodName]]];
+	}
+
+
+	/**
+	 * @param $name
+	 * @param $events
+	 * @return false|string
+	 */
+	public function getName($name, $events)
+	{
+		return self::HTTP_EVENT . $name . ':' . $events[1];
+	}
+
+}

system/Annotation/Definition/Websocket.php

@@ -12,55 +12,41 @@ use ReflectionClass;
 class Websocket extends Annotation
 {
 
-	const MESSAGE = 'WEBSOCKET:MESSAGE:';
-	const EVENT = 'WEBSOCKET:EVENT:';
+	const WEBSOCKET_ANNOTATION = 'WEBSOCKET:ANNOTATION:';
 
-	public $Message;
+	private $Message = 'required|not empty';
 
 
-	public $Event;
+	private $Handshake;
+
+
+	private $Close;
 
 
 	/**
-	 * @param ReflectionClass $reflect
-	 * @param array $methods
+	 * @param $controller
+	 * @param $methodName
+	 * @param $events
+	 * @return array
 	 */
-	public function resolve(ReflectionClass $reflect, array $methods)
+	public function createHandler($controller, $methodName, $events)
 	{
-		$controller = $reflect->newInstance();
-
-		foreach ($methods as $function) {
-			$comment = $function->getDocComment();
-			$methodName = $function->getName();
-
-			preg_match('/@Event\((.*)?\)/', $comment, $events);
-			if (!isset($events[1])) {
-				continue;
-			}
-
-			if (!($_key = $this->getName($events, $comment))) {
-				continue;
-			}
-			$this->push($_key, [$controller, $methodName]);
-		}
+		return [$controller, $methodName];
 	}
 
+
 	/**
 	 * @param $events
 	 * @param $comment
 	 * @return false|string
 	 */
-	private function getName($events, $comment)
+	public function getName($events, $comment)
 	{
-		$event = $events[1];
-		if ($event !== 'message') {
-			return self::EVENT . $event;
+		$prefix = self::WEBSOCKET_ANNOTATION . $events;
+		if (isset($comment[2])) {
+			return $prefix . ':' . $comment[2];
 		}
-		preg_match('/@Message\((.*)?\)/', $comment, $message);
-		if (isset($message[1])) {
-			return false;
-		}
-		return self::MESSAGE . $message[1];
+		return $prefix;
 	}
 
 }

system/Di/Container.php

@@ -182,6 +182,21 @@ class Container extends BaseObject
 		return [$reflection, $dependencies];
 	}
 
+
+	/**
+	 * @param $class
+	 * @return mixed
+	 * @throws ReflectionException
+	 */
+	public function getReflect($class): ReflectionClass
+	{
+		if (!isset($this->_reflection[$class])) {
+			$this->resolveDependencies($class);
+		}
+		return $this->_reflection[$class];
+	}
+
+
 	/**
 	 * @param $class
 	 */