改名

core/Di/Attributes.php

@@ -0,0 +1,281 @@
+<?php
+
+namespace Kiri\Di;
+
+use JetBrains\PhpStorm\Pure;
+use ReflectionAttribute;
+use ReflectionClass;
+use ReflectionProperty;
+
+trait Attributes
+{
+
+
+	private array $_classTarget = [];
+	private array $_classMethodNote = [];
+	private array $_classMethod = [];
+	private array $_classPropertyNote = [];
+	private array $_classProperty = [];
+
+
+	private array $_mapping = [
+		'attributeClass' => [
+			'className' => [
+				'property' => [
+					''
+				],
+				'method'   => [
+
+				]
+			]
+		]
+	];
+
+
+	/**
+	 * @param ReflectionClass $class
+	 */
+	protected function setTargetNote(ReflectionClass $class)
+	{
+		$className = $class->getName();
+		if (!isset($this->_classTarget[$className])) {
+			$this->_classTarget[$className] = [];
+		}
+		foreach ($class->getAttributes() as $attribute) {
+			if (!class_exists($attribute->getName())) {
+				continue;
+			}
+			$this->_classTarget[$className][] = $attribute->newInstance();
+
+			$this->setMappingClass($attribute, $className);
+		}
+	}
+
+
+	/**
+	 * @param ReflectionAttribute $attribute
+	 * @param string $class
+	 */
+	private function setMappingClass(ReflectionAttribute $attribute, string $class)
+	{
+		if (!isset($this->_mapping[$attribute->getName()])) {
+			$this->_mapping[$attribute->getName()] = [];
+		}
+		if (!isset($this->_mapping[$attribute->getName()][$class])) {
+			$this->_mapping[$attribute->getName()][$class] = [];
+		}
+	}
+
+
+	/**
+	 * @param ReflectionAttribute $attribute
+	 * @param string $class
+	 * @param string $method
+	 * @param mixed $instance
+	 */
+	private function setMappingMethod(ReflectionAttribute $attribute, string $class, string $method, mixed $instance)
+	{
+		$this->setMappingClass($attribute, $class);
+
+		if (!isset($this->_mapping[$attribute->getName()][$class]['method'])) {
+			$this->_mapping[$attribute->getName()][$class]['method'] = [];
+		}
+		$this->_mapping[$attribute->getName()][$class]['method'][] = [$method => $instance];
+	}
+
+
+	/**
+	 * @param ReflectionAttribute $attribute
+	 * @param string $class
+	 * @param string $property
+	 * @param $instance
+	 */
+	private function setMappingProperty(ReflectionAttribute $attribute, string $class, string $property, $instance)
+	{
+		$this->setMappingClass($attribute, $class);
+
+		$mapping = $this->_mapping[$attribute->getName()][$class];
+		if (!isset($mapping['property'])) {
+			$mapping['property'] = [];
+		}
+		$mapping['property'][] = [$property => $instance];
+		$this->_mapping[$attribute->getName()][$class] = $mapping;
+	}
+
+
+	/**
+	 * @param mixed $class
+	 * @return array
+	 */
+	public function getTargetNote(mixed $class): array
+	{
+		if (!is_string($class)) {
+			$class = $class::class;
+		}
+		return $this->_classTarget[$class] ?? [];
+	}
+
+
+	/**
+	 * @param ReflectionClass $class
+	 */
+	protected function setMethodNote(ReflectionClass $class)
+	{
+		$className = $class->getName();
+		$this->_classMethodNote[$className] = $this->_classMethod[$className] = [];
+		foreach ($class->getMethods() as $ReflectionMethod) {
+			$this->_classMethod[$className][$ReflectionMethod->getName()] = $ReflectionMethod;
+			$this->_classMethodNote[$className][$ReflectionMethod->getName()] = [];
+			foreach ($ReflectionMethod->getAttributes() as $attribute) {
+				if (!class_exists($attribute->getName())) {
+					continue;
+				}
+				$instance = $attribute->newInstance();
+
+				$this->_classMethodNote[$className][$ReflectionMethod->getName()][] = $instance;
+
+				$this->setMappingMethod($attribute, $className, $ReflectionMethod->getName(), $instance);
+			}
+		}
+	}
+
+
+	/**
+	 * @param string $class
+	 * @param string $method
+	 * @return bool
+	 */
+	public function hasMethod(string $class, string $method): bool
+	{
+		return isset($this->_classMethod[$class]) && isset($this->_classMethod[$class][$method]);
+	}
+
+
+	/**
+	 * @param ReflectionClass $class
+	 * @return array
+	 */
+	#[Pure] public function getMethodNote(ReflectionClass $class): array
+	{
+		return $this->_classMethodNote[$class->getName()] ?? [];
+	}
+
+
+	/**
+	 * @param ReflectionClass $class
+	 */
+	protected function setPropertyNote(ReflectionClass $class)
+	{
+		$className = $class->getName();
+		$this->_classProperty[$className] = $this->_classPropertyNote[$className] = [];
+		foreach ($class->getProperties(ReflectionProperty::IS_PRIVATE | ReflectionProperty::IS_PUBLIC |
+			ReflectionProperty::IS_PROTECTED) as $ReflectionMethod) {
+			$this->_classProperty[$className][$ReflectionMethod->getName()] = $ReflectionMethod;
+			foreach ($ReflectionMethod->getAttributes() as $attribute) {
+				if (!class_exists($attribute->getName())) {
+					continue;
+				}
+				$instance = $attribute->newInstance();
+
+				$this->_classPropertyNote[$className][$ReflectionMethod->getName()] = $instance;
+
+				$this->setMappingProperty($attribute, $className, $ReflectionMethod->getName(), $instance);
+			}
+		}
+	}
+
+
+	/**
+	 * @param string $attribute
+	 * @param string|null $class
+	 * @return array[]
+	 */
+	public function getAttributeTrees(string $attribute, string $class = null): array
+	{
+		$mapping = $this->_mapping[$attribute] ?? [];
+		if (empty($mapping) || empty($class)) {
+			return $mapping;
+		}
+		return $mapping[$class] ?? [];
+	}
+
+
+	/**
+	 * @param string $attribute
+	 * @param string $class
+	 * @param string|null $method
+	 * @return array
+	 */
+	public function getMethodByAnnotation(string $attribute, string $class, string $method = null): mixed
+	{
+		$class = $this->getAttributeTrees($attribute, $class);
+		if (empty($class) || !isset($class['method']) || empty($method)) {
+			return $class['method'] ?? [];
+		}
+		foreach ($class['method'] as $value) {
+			$key = key($value);
+			if ($method == $key) {
+				return $value[$key];
+			}
+		}
+		return null;
+	}
+
+
+	/**
+	 * @param string $attribute
+	 * @param string $class
+	 * @param string $method
+	 * @return mixed
+	 */
+	public function getPropertyByAnnotation(string $attribute, string $class, string $method): mixed
+	{
+		$class = $this->getAttributeTrees($attribute, $class);
+		if (empty($class) || !isset($class['property'])) {
+			return [];
+		}
+		foreach ($class['property'] as $value) {
+			$key = key($value);
+			if ($method == $key) {
+				return $value[$key];
+			}
+		}
+		return null;
+	}
+
+
+	/**
+	 * @param ReflectionClass|string $class
+	 * @return array
+	 * @throws \ReflectionException
+	 */
+	public function getMethods(ReflectionClass|string $class): array
+	{
+		if (is_string($class)) {
+			$class = $this->getReflect($class);
+		}
+		return $this->_classMethod[$class->getName()] ?? [];
+	}
+
+
+	/**
+	 * @param ReflectionClass $class
+	 * @return ReflectionProperty[]
+	 */
+	#[Pure] public function getProperty(ReflectionClass $class): array
+	{
+		return $this->_classProperty[$class->getName()] ?? [];
+	}
+
+
+	/**
+	 * @param ReflectionClass $class
+	 * @return array
+	 */
+	#[Pure] public function getPropertyNote(ReflectionClass $class): array
+	{
+		return $this->_classPropertyNote[$class->getName()] ?? [];
+	}
+
+
+}

core/Di/Container.php

@@ -0,0 +1,458 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/4/24 0024
+ * Time: 17:27
+ */
+declare(strict_types=1);
+
+namespace Kiri\Di;
+
+use Annotation\Inject;
+use Exception;
+use Http\Server;
+use Kiri\Abstracts\BaseObject;
+use Kiri\Exception\NotFindClassException;
+use Kiri\Kiri;
+use ReflectionClass;
+use ReflectionException;
+use ReflectionFunction;
+use ReflectionMethod;
+use ReflectionProperty;
+use Server\Constrict\Request;
+use Server\Constrict\Response;
+use Server\RequestInterface;
+use Server\ResponseInterface;
+
+/**
+ * Class Container
+ * @package Kiri\Di
+ */
+class Container extends BaseObject implements ContainerInterface
+{
+
+	use Attributes;
+
+	/**
+	 * @var array
+	 *
+	 * instance class by className
+	 */
+	private array $_singletons = [];
+
+	/**
+	 * @var ReflectionMethod[]
+	 *
+	 * class new instance construct parameter
+	 */
+	private array $_constructs = [];
+
+	/**
+	 * @var array
+	 *
+	 * implements \ReflectClass
+	 */
+	private array $_reflection = [];
+
+
+	/** @var array */
+	private array $_parameters = [];
+
+
+	/** @var array|string[] */
+	private array $_interfaces = [
+		RequestInterface::class  => Request::class,
+		ResponseInterface::class => Response::class
+	];
+
+
+	/**
+	 * @var array
+	 *
+	 * The construct parameter
+	 */
+	private array $_param = [];
+
+	/**
+	 * @param       $class
+	 * @param array $constrict
+	 * @param array $config
+	 *
+	 * @return mixed
+	 * @throws ReflectionException
+	 * @throws Exception
+	 */
+	public function get($class, array $constrict = [], array $config = []): mixed
+	{
+		if ($this->isInterface($class)) {
+			$class = $this->_interfaces[$class];
+		}
+		if (!isset($this->_singletons[$class])) {
+			$this->_singletons[$class] = $this->resolve($class, $constrict, $config);
+		}
+		return $this->_singletons[$class];
+	}
+
+
+	/**
+	 * @param string $interface
+	 * @param string $class
+	 */
+	public function mapping(string $interface, string $class)
+	{
+		$this->_interfaces[$interface] = $class;
+	}
+
+
+	/**
+	 * @param $class
+	 * @return bool
+	 * @throws ReflectionException
+	 */
+	public function isInterface($class): bool
+	{
+		$reflect = $this->getReflect($class);
+		if ($reflect->isInterface()) {
+			return true;
+		}
+		return false;
+	}
+
+
+	/**
+	 * @param string $interface
+	 * @param $object
+	 */
+	public function setBindings(string $interface, $object)
+	{
+		$this->_singletons[$interface] = $object;
+		$this->_interfaces[$interface] = get_class($object);
+	}
+
+
+	/**
+	 * @param $class
+	 * @param array $constrict
+	 * @param array $config
+	 * @return object
+	 * @throws NotFindClassException
+	 * @throws ReflectionException
+	 * @throws Exception
+	 */
+	public function newObject($class, array $constrict = [], array $config = []): object
+	{
+		return $this->resolve($class, $constrict, $config);
+	}
+
+
+	/**
+	 * @param $class
+	 * @param $constrict
+	 * @param $config
+	 *
+	 * @return object
+	 * @throws Exception
+	 */
+	private function resolve($class, $constrict, $config): object
+	{
+		$reflect = $this->resolveDependencies($class);
+		if (!$reflect->isInstantiable()) {
+			throw new ReflectionException('Class ' . $class . ' cannot be instantiated');
+		}
+
+		$object = $this->newInstance($reflect, $constrict);
+
+		$this->propertyInject($reflect, $object);
+
+		return $this->onAfterInit($object, $config);
+	}
+
+
+	/**
+	 * @param ReflectionClass $reflect
+	 * @param $dependencies
+	 * @return object
+	 * @throws ReflectionException
+	 * @throws NotFindClassException
+	 */
+	private function newInstance(ReflectionClass $reflect, $dependencies): object
+	{
+		if (!isset($this->_constructs[$reflect->getName()])) {
+			return $reflect->newInstance();
+		}
+		$construct = $this->_constructs[$reflect->getName()];
+		if ($construct->getNumberOfParameters() < 1) {
+			return $reflect->newInstance();
+		}
+		$parameters = $this->mergeParam($this->resolveMethodParameters($construct), $dependencies);
+		return $reflect->newInstanceArgs($parameters);
+	}
+
+
+	/**
+	 * @param ReflectionClass $reflect
+	 * @param $object
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public function propertyInject(ReflectionClass $reflect, $object): mixed
+	{
+		foreach ($this->getPropertyNote($reflect) as $property => $inject) {
+			/** @var Inject $inject */
+			$inject->execute($object, $property);
+		}
+		return $object;
+	}
+
+
+	/**
+	 * @param $className
+	 * @param $method
+	 * @return array
+	 * @throws ReflectionException
+	 */
+	public function getMethodAttribute($className, $method = null): array
+	{
+		$methods = $this->getMethodNote($this->getReflect($className));
+		if (!empty($method)) {
+			return $methods[$method] ?? [];
+		}
+		return $methods;
+	}
+
+
+	/**
+	 * @param string $class
+	 * @param string|null $property
+	 * @return ReflectionProperty|ReflectionProperty[]|null
+	 * @throws ReflectionException
+	 */
+	public function getClassReflectionProperty(string $class, string $property = null): ReflectionProperty|null|array
+	{
+		$lists = $this->getProperty($this->getReflect($class));
+		if (empty($lists)) {
+			return null;
+		}
+		if (!empty($property)) {
+			return $lists[$property] ?? null;
+		}
+		return $lists;
+	}
+
+
+	/**
+	 * @param $object
+	 * @param $config
+	 * @return mixed
+	 */
+	private function onAfterInit($object, $config): mixed
+	{
+		Kiri::configure($object, $config);
+		if (method_exists($object, 'init')) {
+			call_user_func([$object, 'init']);
+		}
+		return $object;
+	}
+
+
+	/**
+	 * @param $class
+	 * @return ReflectionClass
+	 */
+	private function resolveDependencies($class): ReflectionClass
+	{
+		if (isset($this->_reflection[$class])) {
+			return $this->_reflection[$class];
+		}
+		$reflect = new ReflectionClass($class);
+		if ($reflect->isAbstract() || $reflect->isTrait() || $reflect->isInterface()) {
+			return $this->_reflection[$class] = $reflect;
+		}
+		$this->setPropertyNote($reflect);
+		$this->setTargetNote($reflect);
+		$this->setMethodNote($reflect);
+		$construct = $reflect->getConstructor();
+		if (!empty($construct) && $construct->getNumberOfParameters() > 0) {
+			$this->_constructs[$class] = $construct;
+		}
+		return $this->_reflection[$class] = $reflect;
+	}
+
+
+	/**
+	 * @param ReflectionClass|string $class
+	 * @return ReflectionMethod[]
+	 * @throws ReflectionException
+	 */
+	public function getReflectMethods(ReflectionClass|string $class): array
+	{
+		if (is_string($class)) {
+			$class = $this->getReflect($class);
+		}
+		return $this->getMethods($class);
+	}
+
+
+	/**
+	 * @param ReflectionClass|string $class
+	 * @param string $method
+	 * @return ReflectionMethod|null
+	 * @throws ReflectionException
+	 */
+	public function getReflectMethod(ReflectionClass|string $class, string $method): ?ReflectionMethod
+	{
+		return $this->getReflectMethods($class)[$method] ?? null;
+	}
+
+
+	/**
+	 * @param ReflectionClass|string $class
+	 * @param string $method
+	 * @return array|null
+	 * @throws NotFindClassException
+	 * @throws ReflectionException
+	 */
+	public function getMethodParameters(ReflectionClass|string $class, string $method): ?array
+	{
+		$className = $class;
+		if (is_object($class)) $className = $class->getName();
+		if (isset($this->_parameters[$className]) && isset($this->_parameters[$className][$method])) {
+			return $this->_parameters[$className][$method];
+		}
+		$reflectMethod = $this->getReflectMethod($class, $method);
+		if (!($reflectMethod instanceof ReflectionMethod)) {
+			throw new ReflectionException("Class does not have a function $className::$method");
+		}
+		$className = $reflectMethod->getDeclaringClass()->getName();
+		if (isset($this->_parameters[$className]) && isset($this->_parameters[$className][$reflectMethod->getName()])) {
+			return $this->_parameters[$className][$reflectMethod->getName()];
+		}
+		return $this->setParameters($className, $reflectMethod->getName(), $this->resolveMethodParameters($reflectMethod));
+	}
+
+
+	/**
+	 * @param $class
+	 * @param $method
+	 * @param $parameters
+	 */
+	private function setParameters($class, $method, $parameters)
+	{
+		if (!isset($this->_parameters[$class])) {
+			$this->_parameters[$class] = [];
+		}
+		if (!isset($this->_parameters[$class][$method])) {
+			$this->_parameters[$class][$method] = [];
+		}
+		return $this->_parameters[$class][$method] = $parameters;
+	}
+
+
+	/**
+	 * @param \Closure $reflectionMethod
+	 * @return array
+	 * @throws NotFindClassException
+	 * @throws ReflectionException
+	 */
+	public function resolveFunctionParameters(\Closure $reflectionMethod): array
+	{
+		return $this->resolveMethodParameters(new ReflectionFunction($reflectionMethod));
+	}
+
+
+	/**
+	 * @param ReflectionMethod|ReflectionFunction $reflectionMethod
+	 * @return array
+	 * @throws NotFindClassException
+	 * @throws ReflectionException
+	 */
+	private function resolveMethodParameters(ReflectionMethod|ReflectionFunction $reflectionMethod): array
+	{
+		if ($reflectionMethod->getNumberOfParameters() < 1) {
+			return [];
+		}
+		$params = [];
+		foreach ($reflectionMethod->getParameters() as $key => $parameter) {
+			if ($parameter->isDefaultValueAvailable()) {
+				$params[$key] = $parameter->getDefaultValue();
+			} else if ($parameter->getType() === null) {
+				$params[$key] = $parameter->getType();
+			} else {
+				$type = $parameter->getType()->getName();
+				if (is_string($type) && class_exists($type)) {
+					$type = Kiri::getDi()->get($type);
+				}
+				$params[$key] = match ($parameter->getType()) {
+					'string' => '',
+					'int', 'float' => 0,
+					'', null, 'object', 'mixed' => NULL,
+					'bool' => false,
+					default => $type
+				};
+			}
+		}
+		return $params;
+	}
+
+
+	/**
+	 * @param $class
+	 * @return ReflectionClass|null
+	 * @throws ReflectionException
+	 */
+	public function getReflect($class): ?ReflectionClass
+	{
+		if (!isset($this->_reflection[$class])) {
+			return $this->resolveDependencies($class);
+		}
+		return $this->_reflection[$class];
+	}
+
+	/**
+	 * @param $class
+	 */
+	public function unset($class)
+	{
+		if (is_array($class) && isset($class['class'])) {
+			$class = $class['class'];
+		} else if (is_object($class)) {
+			$class = $class::class;
+		}
+		unset(
+			$this->_reflection[$class], $this->_singletons[$class],
+			$this->_param[$class], $this->_constructs[$class]
+		);
+	}
+
+	/**
+	 * @return $this
+	 */
+	public function flush(): static
+	{
+		$this->_reflection = [];
+		$this->_singletons = [];
+		$this->_param = [];
+		$this->_constructs = [];
+		return $this;
+	}
+
+	/**
+	 * @param $old
+	 * @param $newParam
+	 *
+	 * @return mixed
+	 */
+	private function mergeParam($old, $newParam): array
+	{
+		if (empty($old)) {
+			return $newParam;
+		} else if (empty($newParam)) {
+			return $old;
+		}
+		foreach ($newParam as $key => $val) {
+			$old[$key] = $val;
+		}
+		return $old;
+	}
+}

core/Di/ContainerInterface.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Kiri\Di;
+
+
+/**
+ * @mixin Container
+ */
+interface ContainerInterface
+{
+
+}

core/Di/LocalService.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace Kiri\Di;
+
+use Annotation\Inject;
+use Kiri\Abstracts\Component;
+use Kiri\Kiri;
+
+
+/**
+ * 服务定位器
+ */
+class LocalService extends Component
+{
+
+
+    private array $_components = [];
+
+
+    private array $_definition = [];
+
+
+    /**
+     * @param $name
+     * @param $define
+     */
+    public function set($name, $define)
+    {
+        unset($this->_components[$name]);
+
+        $this->_definition[$name] = $define;
+    }
+
+
+    /**
+     * @throws \Exception
+     */
+    public function get(string $name, $throwException = true)
+    {
+        if (isset($this->_components[$name])) {
+            return $this->_components[$name];
+        }
+        if (isset($this->_definition[$name])) {
+            $definition = $this->_definition[$name];
+            if (is_object($definition) && !$definition instanceof \Closure) {
+                return $this->_components[$name] = $definition;
+            }
+            return $this->_components[$name] = Kiri::createObject($definition);
+        } else if ($throwException) {
+            throw new \Exception("Unknown component ID: $name");
+        }
+        return null;
+    }
+
+
+    /**
+     * @param array $components
+     */
+    public function setComponents(array $components)
+    {
+        foreach ($components as $name => $component) {
+            $this->set($name, $component);
+        }
+    }
+
+
+    /**
+     * @param $id
+     * @return bool
+     */
+    public function has($id): bool
+    {
+        return isset($this->_components[$id]) || isset($this->_definition[$id]);
+    }
+
+
+    /**
+     * @param $id
+     */
+    public function remove($id): void
+    {
+        unset($this->_components[$id], $this->_definition[$id]);
+    }
+
+
+}