改名

Database/ActiveQuery.php

@@ -12,7 +12,6 @@ namespace Database;
 use Database\Traits\QueryTrait;
 use Exception;
 use Snowflake\Abstracts\Component;
-use Snowflake\Snowflake;
 
 /**
  * Class ActiveQuery
@@ -107,22 +106,12 @@ class ActiveQuery extends Component implements ISqlBuilder
 		if (is_string($name)) {
 			$name = explode(',', $name);
 		}
-		foreach ($name as $key => $val) {
+		foreach ($name as $val) {
 			array_push($this->with, $val);
 		}
 		return $this;
 	}
 
-	/**
-	 * @param bool $isArray
-	 * @return $this
-	 */
-	public function asArray(bool $isArray = TRUE): static
-	{
-		$this->asArray = $isArray;
-		return $this;
-	}
-
 
 	/**
 	 * @param $sql
@@ -137,20 +126,16 @@ class ActiveQuery extends Component implements ISqlBuilder
 
 
 	/**
-	 * @return ActiveRecord|array|null
+	 * @return ActiveRecord|null
 	 * @throws Exception
 	 */
-	public function first(): ActiveRecord|array|null
+	public function first(): ActiveRecord|null
 	{
 		$data = $this->execute($this->builder->one())->one();
 		if (empty($data)) {
 			return NULL;
 		}
-		$newModel = $this->modelClass::populate($data);
-		if ($this->asArray) {
-			return $newModel->toArray();
-		}
-		return $newModel;
+		return $this->modelClass::populate($data);
 	}
 
 

Database/Base/BaseActiveRecord.php

@@ -43,7 +43,7 @@ use validator\Validator;
  * @property bool $isCreate
  * @method rules()
  * @method static tableName()
- * @property Application $application
+ * @property Application $container
  */
 abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess
 {
@@ -106,7 +106,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess
 	/**
 	 * @return Application
 	 */
-	#[Pure] private function getApplication(): Application
+	#[Pure] private function getContainer(): Application
 	{
 		return Snowflake::app();
 	}
@@ -322,14 +322,30 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess
 
 	/**
 	 * @return ActiveQuery
-	 * @throws ReflectionException
-	 * @throws NotFindClassException
 	 */
 	public static function find(): ActiveQuery
 	{
-		return Snowflake::createObject(ActiveQuery::class, [static::class]);
+		return new ActiveQuery(get_called_class());
 	}
 
+	/**
+	 * @return ActiveQuery
+	 */
+	public static function query(): ActiveQuery
+	{
+		return new ActiveQuery(get_called_class());
+	}
+
+
+	/**
+	 * @throws ConfigException
+	 */
+	protected function getConnection()
+	{
+		return Config::get('connections.' . static::$ab_name, null, true);
+	}
+
+
 	/**
 	 * @param null $condition
 	 * @param array $attributes
@@ -710,7 +726,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess
 	 * @return bool
 	 * @throws Exception
 	 */
-	#[Event(ActiveRecord::AFTER_SAVE)]
+	#[Event(self::AFTER_SAVE)]
 	public function afterSave($attributes, $changeAttributes): bool
 	{
 		return true;

HttpServer/Controller.php

@@ -10,6 +10,7 @@ use HttpServer\Http\HttpParams;
 use HttpServer\Http\Request;
 use HttpServer\Http\Response;
 use Snowflake\Abstracts\TraitApplication;
+use Snowflake\Application;
 
 /**
  * Class WebController
@@ -18,39 +19,48 @@ use Snowflake\Abstracts\TraitApplication;
 class Controller
 {
 
-    use TraitApplication;
+	use TraitApplication;
 
 
-    /**
-     * inject request
-     *
-     * @var Request|null
-     */
-    #[Inject('request')]
-    public ?Request $request = null;
+	/**
+	 * @param Application $container
+	 */
+	public function __construct(protected Application $container)
+	{
+
+	}
 
 
-    /**
-     * @var HttpParams|null
-     */
-    #[Inject('input')]
-    public ?HttpParams $input = null;
+	/**
+	 * inject request
+	 *
+	 * @var Request|null
+	 */
+	#[Inject('request')]
+	public ?Request $request = null;
 
 
-    /**
-     * @var HttpHeaders|null
-     */
-    #[Inject('header')]
-    public ?HttpHeaders $header = null;
+	/**
+	 * @var HttpParams|null
+	 */
+	#[Inject('input')]
+	public ?HttpParams $input = null;
 
 
-    /**
-     * inject response
-     *
-     * @var Response|null
-     */
-    #[Inject('response')]
-    public ?Response $response = null;
+	/**
+	 * @var HttpHeaders|null
+	 */
+	#[Inject('header')]
+	public ?HttpHeaders $header = null;
+
+
+	/**
+	 * inject response
+	 *
+	 * @var Response|null
+	 */
+	#[Inject('response')]
+	public ?Response $response = null;
 
 
 }

System/Abstracts/BaseApplication.php

@@ -50,429 +50,431 @@ use Swoole\Table;
 abstract class BaseApplication extends Service
 {
 
-    use TraitApplication;
-
-
-    /**
-     * @var string
-     */
-    public string $storage = APP_PATH . 'storage';
-
-    public string $envPath = APP_PATH . '.env';
-
-    /**
-     * Init constructor.
-     *
-     * @param array $config
-     *
-     * @throws
-     */
-    public function __construct(array $config = [])
-    {
-        Snowflake::init($this);
-
-        $this->moreComponents();
-        $this->parseInt($config);
-        $this->parseEvents($config);
-        $this->initErrorHandler();
-        $this->enableEnvConfig();
-
-        parent::__construct($config);
-    }
-
-
-    /**
-     * @return array
-     */
-    public function enableEnvConfig(): array
-    {
-        if (!file_exists($this->envPath)) {
-            return [];
-        }
-        $lines = $this->readLinesFromFile($this->envPath);
-        foreach ($lines as $line) {
-            if (!$this->isComment($line) && $this->looksLikeSetter($line)) {
-                [$key, $value] = explode('=', $line);
-                putenv(trim($key) . '=' . trim($value));
-            }
-        }
-        return $lines;
-    }
-
-
-    /**
-     * Read lines from the file, auto detecting line endings.
-     *
-     * @param string $filePath
-     *
-     * @return array
-     */
-    protected function readLinesFromFile(string $filePath): array
-    {
-        // Read file into an array of lines with auto-detected line endings
-        $autodetect = ini_get('auto_detect_line_endings');
-        ini_set('auto_detect_line_endings', '1');
-        $lines = file($filePath, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
-        ini_set('auto_detect_line_endings', $autodetect);
-
-        return $lines;
-    }
-
-    /**
-     * Determine if the line in the file is a comment, e.g. begins with a #.
-     *
-     * @param string $line
-     *
-     * @return bool
-     */
-    protected function isComment(string $line): bool
-    {
-        $line = ltrim($line);
-
-        return isset($line[0]) && $line[0] === '#';
-    }
-
-    /**
-     * Determine if the given line looks like it's setting a variable.
-     *
-     * @param string $line
-     *
-     * @return bool
-     */
-    #[Pure] protected function looksLikeSetter(string $line): bool
-    {
-        return str_contains($line, '=');
-    }
-
-
-    /**
-     * @param $config
-     *
-     * @throws
-     */
-    public function parseInt($config)
-    {
-        Config::sets($config);
-        if ($storage = Config::get('storage', 'storage')) {
-            if (!str_contains($storage, APP_PATH)) {
-                $storage = APP_PATH . $storage . '/';
-            }
-            if (!is_dir($storage)) {
-                mkdir($storage);
-            }
-            if (!is_dir($storage) || !is_writeable($storage)) {
-                throw new InitException("Directory {$storage} does not have write permission");
-            }
-        }
-    }
-
-
-    /**
-     * @param $config
-     *
-     * @throws
-     */
-    public function parseEvents($config)
-    {
-        if (!isset($config['events']) || !is_array($config['events'])) {
-            return;
-        }
-        foreach ($config['events'] as $key => $value) {
-            if (is_string($value)) {
-                $value = Snowflake::createObject($value);
-            }
-            $this->addEvent($key, $value);
-        }
-    }
-
-
-    /**
-     * @param $key
-     * @param $value
-     * @throws InitException
-     * @throws NotFindClassException
-     * @throws ReflectionException
-     * @throws Exception
-     */
-    private function addEvent($key, $value): void
-    {
-        if ($value instanceof \Closure) {
-            Event::on($key, $value, [], true);
-            return;
-        }
-        if (is_object($value)) {
-            Event::on($key, $value, [], true);
-            return;
-        }
-        if (is_array($value)) {
-            if (is_object($value[0]) && !($value[0] instanceof \Closure)) {
-                Event::on($key, $value, [], true);
-                return;
-            }
-
-            if (is_string($value[0])) {
-                $value[0] = Snowflake::createObject($value[0]);
-                Event::on($key, $value, [], true);
-                return;
-            }
-
-            foreach ($value as $item) {
-                if (!is_callable($item, true)) {
-                    throw new InitException("Class does not hav callback.");
-                }
-                Event::on($key, $item, [], true);
-            }
-        }
-
-    }
-
-
-    /**
-     * @param $name
-     * @return mixed
-     * @throws Exception
-     */
-    public function clone($name): mixed
-    {
-        return clone $this->get($name);
-    }
-
-    /**
-     *
-     * @throws Exception
-     */
-    public function initErrorHandler()
-    {
-        $this->get('error')->register();
-    }
-
-    /**
-     * @return mixed
-     */
-    public function getLocalIps(): mixed
-    {
-        return swoole_get_local_ip();
-    }
-
-    /**
-     * @return mixed
-     */
-    public function getFirstLocal(): mixed
-    {
-        return current($this->getLocalIps());
-    }
-
-
-    /**
-     * @return Logger
-     * @throws Exception
-     */
-    public function getLogger(): Logger
-    {
-        return $this->get('logger');
-    }
-
-
-    /**
-     * @return Producer
-     * @throws Exception
-     */
-    public function getKafka(): Producer
-    {
-        return $this->get('kafka');
-    }
-
-
-    /**
-     * @return \Redis|Redis
-     * @throws Exception
-     */
-    public function getRedis(): Redis|\Redis
-    {
-        return $this->get('redis');
-    }
-
-    /**
-     * @param $ip
-     * @return bool
-     */
-    public function isLocal($ip): bool
-    {
-        return $this->getFirstLocal() == $ip;
-    }
-
-
-    /**
-     * @return ErrorHandler
-     * @throws Exception
-     */
-    public function getError(): ErrorHandler
-    {
-        return $this->get('error');
-    }
-
-
-    /**
-     * @return Connection
-     * @throws Exception
-     */
-    public function getMysqlFromPool(): Connection
-    {
-        return $this->get('connections');
-    }
-
-
-    /**
-     * @return SRedis
-     * @throws Exception
-     */
-    public function getRedisFromPool(): SRedis
-    {
-        return $this->get('redis_connections');
-    }
-
-
-    /**
-     * @param $name
-     * @return Table
-     * @throws Exception
-     */
-    public function getTable($name): Table
-    {
-        return $this->get($name);
-    }
-
-
-    /**
-     * @return Config
-     * @throws Exception
-     */
-    public function getConfig(): Config
-    {
-        return $this->get('config');
-    }
-
-
-    /**
-     * @return Router
-     * @throws Exception
-     */
-    public function getRouter(): Router
-    {
-        return $this->get('router');
-    }
-
-
-    /**
-     * @return Jwt
-     * @throws Exception
-     */
-    public function getJwt(): Jwt
-    {
-        return $this->get('jwt');
-    }
-
-
-    /**
-     * @return Server
-     * @throws Exception
-     */
-    public function getServer(): Server
-    {
-        return $this->get('server');
-    }
-
-
-    /**
-     * @return \Swoole\Http\Server|\Swoole\Server|\Swoole\WebSocket\Server|null
-     */
-    public function getSwoole(): \Swoole\Http\Server|\Swoole\Server|\Swoole\WebSocket\Server|null
-    {
-        return ServerManager::getContext()->getServer();
-    }
-
-
-    /**
-     * @return SAnnotation
-     * @throws Exception
-     */
-    public function getAnnotation(): SAnnotation
-    {
-        return $this->get('annotation');
-    }
-
-
-    /**
-     * @return Async
-     * @throws Exception
-     */
-    public function getAsync(): Async
-    {
-        return $this->get('async');
-    }
-
-
-    /**
-     * @return \Rpc\Producer
-     * @throws Exception
-     */
-    public function getRpc(): \Rpc\Producer
-    {
-        return $this->get('rpc');
-    }
-
-
-    /**
-     * @return Channel
-     * @throws Exception
-     */
-    public function getChannel(): Channel
-    {
-        return $this->get('channel');
-    }
-
-
-    /**
-     * @return Pool
-     * @throws Exception
-     */
-    public function getClientsPool(): Pool
-    {
-        return $this->get('clientsPool');
-    }
-
-
-    /**
-     * @throws Exception
-     */
-    protected function moreComponents(): void
-    {
-        $this->setComponents([
-            'error'             => ['class' => ErrorHandler::class],
-            'connections'       => ['class' => Connection::class],
-            'redis_connections' => ['class' => SRedis::class],
-            'clientsPool'       => ['class' => Pool::class],
-            'config'            => ['class' => Config::class],
-            'logger'            => ['class' => Logger::class],
-            'annotation'        => ['class' => SAnnotation::class],
-            'router'            => ['class' => Router::class],
-            'event'             => ['class' => Event::class],
-            'redis'             => ['class' => Redis::class],
-            'aop'               => ['class' => Aop::class],
-            'input'             => ['class' => HttpParams::class],
-            'header'            => ['class' => HttpHeaders::class],
-            'jwt'               => ['class' => Jwt::class],
-            'async'             => ['class' => Async::class],
-            'kafka-container'   => ['class' => TaskContainer::class],
-            'filter'            => ['class' => HttpFilter::class],
-            'goto'              => ['class' => BaseGoto::class],
-            'response'          => ['class' => Response::class],
-            'request'           => ['class' => Request::class],
-            'channel'           => ['class' => Channel::class],
-            'rpc'               => ['class' => \Rpc\Producer::class],
-            'rpc-service'       => ['class' => \Rpc\Service::class],
-            'http2'             => ['class' => Http2::class],
-            'shutdown'          => ['class' => Shutdown::class],
-        ]);
-    }
+	use TraitApplication;
+
+
+	/**
+	 * @var string
+	 */
+	public string $storage = APP_PATH . 'storage';
+
+	public string $envPath = APP_PATH . '.env';
+
+	/**
+	 * Init constructor.
+	 *
+	 *
+	 * @throws
+	 */
+	public function __construct()
+	{
+		Snowflake::init($this);
+
+		$config = sweep(APP_PATH . '/config');
+
+		$this->moreComponents();
+		$this->parseInt($config);
+		$this->parseEvents($config);
+		$this->initErrorHandler();
+		$this->enableEnvConfig();
+
+		parent::__construct();
+	}
+
+
+	/**
+	 * @return array
+	 */
+	public function enableEnvConfig(): array
+	{
+		if (!file_exists($this->envPath)) {
+			return [];
+		}
+		$lines = $this->readLinesFromFile($this->envPath);
+		foreach ($lines as $line) {
+			if (!$this->isComment($line) && $this->looksLikeSetter($line)) {
+				[$key, $value] = explode('=', $line);
+				putenv(trim($key) . '=' . trim($value));
+			}
+		}
+		return $lines;
+	}
+
+
+	/**
+	 * Read lines from the file, auto detecting line endings.
+	 *
+	 * @param string $filePath
+	 *
+	 * @return array
+	 */
+	protected function readLinesFromFile(string $filePath): array
+	{
+		// Read file into an array of lines with auto-detected line endings
+		$autodetect = ini_get('auto_detect_line_endings');
+		ini_set('auto_detect_line_endings', '1');
+		$lines = file($filePath, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
+		ini_set('auto_detect_line_endings', $autodetect);
+
+		return $lines;
+	}
+
+	/**
+	 * Determine if the line in the file is a comment, e.g. begins with a #.
+	 *
+	 * @param string $line
+	 *
+	 * @return bool
+	 */
+	protected function isComment(string $line): bool
+	{
+		$line = ltrim($line);
+
+		return isset($line[0]) && $line[0] === '#';
+	}
+
+	/**
+	 * Determine if the given line looks like it's setting a variable.
+	 *
+	 * @param string $line
+	 *
+	 * @return bool
+	 */
+	#[Pure] protected function looksLikeSetter(string $line): bool
+	{
+		return str_contains($line, '=');
+	}
+
+
+	/**
+	 * @param $config
+	 *
+	 * @throws
+	 */
+	public function parseInt($config)
+	{
+		Config::sets($config);
+		if ($storage = Config::get('storage', 'storage')) {
+			if (!str_contains($storage, APP_PATH)) {
+				$storage = APP_PATH . $storage . '/';
+			}
+			if (!is_dir($storage)) {
+				mkdir($storage);
+			}
+			if (!is_dir($storage) || !is_writeable($storage)) {
+				throw new InitException("Directory {$storage} does not have write permission");
+			}
+		}
+	}
+
+
+	/**
+	 * @param $config
+	 *
+	 * @throws
+	 */
+	public function parseEvents($config)
+	{
+		if (!isset($config['events']) || !is_array($config['events'])) {
+			return;
+		}
+		foreach ($config['events'] as $key => $value) {
+			if (is_string($value)) {
+				$value = Snowflake::createObject($value);
+			}
+			$this->addEvent($key, $value);
+		}
+	}
+
+
+	/**
+	 * @param $key
+	 * @param $value
+	 * @throws InitException
+	 * @throws NotFindClassException
+	 * @throws ReflectionException
+	 * @throws Exception
+	 */
+	private function addEvent($key, $value): void
+	{
+		if ($value instanceof \Closure) {
+			Event::on($key, $value, [], true);
+			return;
+		}
+		if (is_object($value)) {
+			Event::on($key, $value, [], true);
+			return;
+		}
+		if (is_array($value)) {
+			if (is_object($value[0]) && !($value[0] instanceof \Closure)) {
+				Event::on($key, $value, [], true);
+				return;
+			}
+
+			if (is_string($value[0])) {
+				$value[0] = Snowflake::createObject($value[0]);
+				Event::on($key, $value, [], true);
+				return;
+			}
+
+			foreach ($value as $item) {
+				if (!is_callable($item, true)) {
+					throw new InitException("Class does not hav callback.");
+				}
+				Event::on($key, $item, [], true);
+			}
+		}
+
+	}
+
+
+	/**
+	 * @param $name
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public function clone($name): mixed
+	{
+		return clone $this->get($name);
+	}
+
+	/**
+	 *
+	 * @throws Exception
+	 */
+	public function initErrorHandler()
+	{
+		$this->get('error')->register();
+	}
+
+	/**
+	 * @return mixed
+	 */
+	public function getLocalIps(): mixed
+	{
+		return swoole_get_local_ip();
+	}
+
+	/**
+	 * @return mixed
+	 */
+	public function getFirstLocal(): mixed
+	{
+		return current($this->getLocalIps());
+	}
+
+
+	/**
+	 * @return Logger
+	 * @throws Exception
+	 */
+	public function getLogger(): Logger
+	{
+		return $this->get('logger');
+	}
+
+
+	/**
+	 * @return Producer
+	 * @throws Exception
+	 */
+	public function getKafka(): Producer
+	{
+		return $this->get('kafka');
+	}
+
+
+	/**
+	 * @return \Redis|Redis
+	 * @throws Exception
+	 */
+	public function getRedis(): Redis|\Redis
+	{
+		return $this->get('redis');
+	}
+
+	/**
+	 * @param $ip
+	 * @return bool
+	 */
+	public function isLocal($ip): bool
+	{
+		return $this->getFirstLocal() == $ip;
+	}
+
+
+	/**
+	 * @return ErrorHandler
+	 * @throws Exception
+	 */
+	public function getError(): ErrorHandler
+	{
+		return $this->get('error');
+	}
+
+
+	/**
+	 * @return Connection
+	 * @throws Exception
+	 */
+	public function getMysqlFromPool(): Connection
+	{
+		return $this->get('connections');
+	}
+
+
+	/**
+	 * @return SRedis
+	 * @throws Exception
+	 */
+	public function getRedisFromPool(): SRedis
+	{
+		return $this->get('redis_connections');
+	}
+
+
+	/**
+	 * @param $name
+	 * @return Table
+	 * @throws Exception
+	 */
+	public function getTable($name): Table
+	{
+		return $this->get($name);
+	}
+
+
+	/**
+	 * @return Config
+	 * @throws Exception
+	 */
+	public function getConfig(): Config
+	{
+		return $this->get('config');
+	}
+
+
+	/**
+	 * @return Router
+	 * @throws Exception
+	 */
+	public function getRouter(): Router
+	{
+		return $this->get('router');
+	}
+
+
+	/**
+	 * @return Jwt
+	 * @throws Exception
+	 */
+	public function getJwt(): Jwt
+	{
+		return $this->get('jwt');
+	}
+
+
+	/**
+	 * @return Server
+	 * @throws Exception
+	 */
+	public function getServer(): Server
+	{
+		return $this->get('server');
+	}
+
+
+	/**
+	 * @return \Swoole\Http\Server|\Swoole\Server|\Swoole\WebSocket\Server|null
+	 */
+	public function getSwoole(): \Swoole\Http\Server|\Swoole\Server|\Swoole\WebSocket\Server|null
+	{
+		return ServerManager::getContext()->getServer();
+	}
+
+
+	/**
+	 * @return SAnnotation
+	 * @throws Exception
+	 */
+	public function getAnnotation(): SAnnotation
+	{
+		return $this->get('annotation');
+	}
+
+
+	/**
+	 * @return Async
+	 * @throws Exception
+	 */
+	public function getAsync(): Async
+	{
+		return $this->get('async');
+	}
+
+
+	/**
+	 * @return \Rpc\Producer
+	 * @throws Exception
+	 */
+	public function getRpc(): \Rpc\Producer
+	{
+		return $this->get('rpc');
+	}
+
+
+	/**
+	 * @return Channel
+	 * @throws Exception
+	 */
+	public function getChannel(): Channel
+	{
+		return $this->get('channel');
+	}
+
+
+	/**
+	 * @return Pool
+	 * @throws Exception
+	 */
+	public function getClientsPool(): Pool
+	{
+		return $this->get('clientsPool');
+	}
+
+
+	/**
+	 * @throws Exception
+	 */
+	protected function moreComponents(): void
+	{
+		$this->setComponents([
+			'error'             => ['class' => ErrorHandler::class],
+			'connections'       => ['class' => Connection::class],
+			'redis_connections' => ['class' => SRedis::class],
+			'clientsPool'       => ['class' => Pool::class],
+			'config'            => ['class' => Config::class],
+			'logger'            => ['class' => Logger::class],
+			'annotation'        => ['class' => SAnnotation::class],
+			'router'            => ['class' => Router::class],
+			'event'             => ['class' => Event::class],
+			'redis'             => ['class' => Redis::class],
+			'databases'                => ['class' => \Database\Connection::class],
+			'aop'               => ['class' => Aop::class],
+			'input'             => ['class' => HttpParams::class],
+			'header'            => ['class' => HttpHeaders::class],
+			'jwt'               => ['class' => Jwt::class],
+			'async'             => ['class' => Async::class],
+			'kafka-container'   => ['class' => TaskContainer::class],
+			'filter'            => ['class' => HttpFilter::class],
+			'goto'              => ['class' => BaseGoto::class],
+			'response'          => ['class' => Response::class],
+			'request'           => ['class' => Request::class],
+			'channel'           => ['class' => Channel::class],
+			'rpc'               => ['class' => \Rpc\Producer::class],
+			'rpc-service'       => ['class' => \Rpc\Service::class],
+			'http2'             => ['class' => Http2::class],
+			'shutdown'          => ['class' => Shutdown::class],
+		]);
+	}
 }

System/Abstracts/TraitApplication.php

@@ -16,15 +16,15 @@ use HttpServer\Route\Router;
 use HttpServer\Server;
 use HttpServer\Shutdown;
 use Kafka\Producer;
+use Rpc\Producer as RPCProducer;
 use Snowflake\Async;
 use Snowflake\Cache\Redis;
 use Snowflake\Channel;
 use Snowflake\Error\Logger;
 use Snowflake\Event;
 use Snowflake\Jwt\Jwt;
-use Snowflake\Pool\Pool;
 use Snowflake\Pool\Connection;
-use Rpc\Producer as RPCProducer;
+use Snowflake\Pool\Pool;
 
 /**
  * Trait TraitApplication
@@ -45,6 +45,7 @@ use Rpc\Producer as RPCProducer;
  * @property BaseGoto $goto
  * @property Producer $kafka
  * @property Client $client
+ * @property \Database\Connection $databases
  * @property Curl $curl
  * @property \Snowflake\Crontab\Producer $crontab
  * @property HttpFilter $filter

System/Cache/Redis.php

@@ -25,12 +25,7 @@ use Snowflake\Snowflake;
  */
 class Redis extends Component
 {
-	public string $host = '127.0.0.1';
-	public string $auth = 'xl.2005113426';
-	public int $port = 6973;
-	public int $databases = 0;
-	public int $timeout = -1;
-	public string $prefix = 'idd';
+
 
 	/**
 	 * @throws Exception
@@ -54,7 +49,7 @@ class Redis extends Component
 
 		$config = $this->get_config();
 
-		$length = (int)env('REDIS.POOL_LENGTH', 100);
+		$length = Config::get('connections.pool.max',10);
 
 		$connections->initConnections('Redis:' . $config['host'], true, $length);
 	}

System/Di/Attributes.php

@@ -0,0 +1,132 @@
+<?php
+
+namespace Snowflake\Di;
+
+use JetBrains\PhpStorm\Pure;
+use ReflectionClass;
+use ReflectionMethod;
+
+trait Attributes
+{
+
+
+	private array $_classTarget = [];
+	private array $_classMethodNote = [];
+	private array $_classMethod = [];
+	private array $_classPropertyNote = [];
+	private array $_classProperty = [];
+
+
+	/**
+	 * @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();
+		}
+	}
+
+
+	/**
+	 * @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(ReflectionMethod::IS_FINAL | ReflectionMethod::IS_PRIVATE
+			| ReflectionMethod::IS_PUBLIC | ReflectionMethod::IS_PROTECTED | ReflectionMethod::IS_ABSTRACT
+		) as $ReflectionMethod) {
+			$this->_classMethod[$className][$ReflectionMethod->getName()] = $ReflectionMethod;
+			foreach ($ReflectionMethod->getAttributes() as $attribute) {
+				if (!class_exists($attribute->getName())) {
+					continue;
+				}
+				$this->_classMethodNote[$className][] = $attribute->newInstance();
+			}
+		}
+	}
+
+
+	/**
+	 * @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;
+				}
+				$this->_classPropertyNote[$className][] = $attribute->newInstance();
+			}
+		}
+	}
+
+
+	/**
+	 * @param ReflectionClass $class
+	 * @return array
+	 */
+	#[Pure] public function getMethods(ReflectionClass $class): array
+	{
+		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()] ?? [];
+	}
+
+
+}

System/Di/Container.php

@@ -10,14 +10,13 @@ declare(strict_types=1);
 namespace Snowflake\Di;
 
 use Annotation\Inject;
-use Annotation\Target;
 use Exception;
+use JetBrains\PhpStorm\Pure;
 use ReflectionClass;
 use ReflectionException;
 use ReflectionMethod;
 use ReflectionProperty;
 use Snowflake\Abstracts\BaseObject;
-use Snowflake\Abstracts\Configure;
 use Snowflake\Exception\NotFindClassException;
 use Snowflake\Snowflake;
 
@@ -28,63 +27,32 @@ use Snowflake\Snowflake;
 class Container extends BaseObject
 {
 
+	use Attributes;
+
 	/**
 	 * @var array
 	 *
 	 * instance class by className
 	 */
-	private static array $_singletons = [];
+	private array $_singletons = [];
 
 	/**
 	 * @var array
 	 *
 	 * class new instance construct parameter
 	 */
-	private static array $_constructs = [];
+	private array $_constructs = [];
 
 	/**
 	 * @var array
 	 *
 	 * implements \ReflectClass
 	 */
-	private static array $_reflection = [];
+	private array $_reflection = [];
 
 
-	/**
-	 * @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 $_attributeMapping = [];
+	/** @var array */
+	private array $_parameters = [];
 
 
 	/**
@@ -92,7 +60,7 @@ class Container extends BaseObject
 	 *
 	 * The construct parameter
 	 */
-	private static array $_param = [];
+	private array $_param = [];
 
 	/**
 	 * @param       $class
@@ -106,50 +74,25 @@ class Container extends BaseObject
 	 */
 	public function get($class, array $constrict = [], array $config = []): mixed
 	{
-		if (isset(static::$_singletons[$class])) {
-			return static::$_singletons[$class];
-		} else if (!isset(static::$_constructs[$class])) {
-			return $this->resolve($class, $constrict, $config);
-		}
-		$definition = static::$_constructs[$class];
-		if (is_callable($definition, TRUE)) {
-			return call_user_func($definition, $this, $constrict, $config);
-		} else if (is_array($definition)) {
-			return static::$_singletons[$class] = $this->resolveDefinition($definition, $class, $config, $constrict);
-		} else if (is_object($definition)) {
-			return static::$_singletons[$class] = $definition;
-		} else {
-			throw new NotFindClassException($class);
+		if (!isset($this->_singletons[$class])) {
+			$this->_singletons[$class] = $this->resolve($class, $constrict, $config);
 		}
+		return $this->_singletons[$class];
 	}
 
 
 	/**
-	 * @param $definition
 	 * @param $class
-	 * @param $config
-	 * @param $constrict
-	 * @return mixed
+	 * @param array $constrict
+	 * @param array $config
+	 * @return object
 	 * @throws NotFindClassException
 	 * @throws ReflectionException
 	 * @throws Exception
 	 */
-	private function resolveDefinition($definition, $class, $config, $constrict): mixed
+	public function newObject($class, array $constrict = [], array $config = []): object
 	{
-		if (!isset($definition['class'])) {
-			throw new NotFindClassException($class);
-		}
-		$_className = $definition['class'];
-		unset($definition['class']);
-
-		$definition = $this->mergeParam($class, $constrict);
-
-		if ($_className === $class) {
-			$object = $this->resolve($class, $definition, $config);
-		} else {
-			$object = $this->get($class, $definition, $config);
-		}
-		return $object;
+		return $this->resolve($class, $constrict, $config);
 	}
 
 
@@ -163,65 +106,44 @@ class Container extends BaseObject
 	 */
 	private function resolve($class, $constrict, $config): object
 	{
-		/** @var ReflectionClass $reflect */
-		[$reflect, $dependencies] = $this->resolveDependencies($class, $constrict);
+		$reflect = $this->resolveDependencies($class);
 		if (empty($reflect) || !$reflect->isInstantiable()) {
 			throw new NotFindClassException($class);
 		}
-		$object = $this->setConfig($config, $reflect, $dependencies, $class);
 
-		return $this->setClassAnnotation($reflect, $object);
-	}
+		$object = $this->setConfig($config, $reflect, $constrict);
 
-
-	/**
-	 * @param $reflect
-	 * @param $object
-	 * @return mixed
-	 * @throws Exception
-	 */
-	private function setClassAnnotation($reflect, $object): mixed
-	{
-		static::$_reflectionClass[$reflect->getName()] = [];
-		foreach ($reflect->getAttributes() as $attribute) {
-			static::$_reflectionClass[$reflect->getName()][] = $attribute->newInstance();
-		}
 		return $this->propertyInject($reflect, $object);
 	}
 
-
 	/**
 	 * @param $config
 	 * @param $reflect
 	 * @param $dependencies
-	 * @param $class
-	 * @return mixed
+	 * @return object
+	 * @throws NotFindClassException
+	 * @throws ReflectionException
 	 */
-	private function setConfig($config, $reflect, $dependencies, $class): mixed
+	private function setConfig($config, $reflect, $dependencies): object
 	{
-		if (empty($config) || !is_array($config)) {
-			$object = $this->newInstance($reflect, $dependencies);
-		} else if (!empty($dependencies) && $reflect->implementsInterface(Configure::class)) {
-			$dependencies[count($dependencies) - 1] = $config;
-			$object = $this->newInstance($reflect, $dependencies);
-		} else {
-			static::$_param[$class] = $config;
-
-			$object = $this->onAfterInit($this->newInstance($reflect, $dependencies), $config);
-		}
-		return $object;
+		$object = $this->newInstance($reflect, $dependencies);
+		return $this->onAfterInit($object, $config);
 	}
 
 
 	/**
-	 * @param $reflect
+	 * @param ReflectionClass $reflect
 	 * @param $dependencies
-	 * @return mixed
+	 * @return object
+	 * @throws ReflectionException
+	 * @throws NotFindClassException
 	 */
-	private function newInstance($reflect, $dependencies): mixed
+	private function newInstance(ReflectionClass $reflect, $dependencies): object
 	{
-		if (!empty($dependencies)) {
-			return $reflect->newInstanceArgs($dependencies);
+		$parameters = $this->getMethodParameters($reflect, '__construct');
+		$parameters = $this->mergeParam($parameters, $dependencies);
+		if (!empty($parameters)) {
+			return $reflect->newInstanceArgs($parameters);
 		}
 		return $reflect->newInstance();
 	}
@@ -235,10 +157,7 @@ class Container extends BaseObject
 	 */
 	public function propertyInject(ReflectionClass $reflect, $object): mixed
 	{
-		if (!isset(static::$_propertyAttributes[$reflect->getName()])) {
-			return $object;
-		}
-		foreach (static::$_propertyAttributes[$reflect->getName()] as $property => $inject) {
+		foreach ($this->getPropertyNote($reflect) as $property => $inject) {
 			/** @var Inject $inject */
 			$inject->execute($object, $property);
 		}
@@ -246,102 +165,15 @@ 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;
-			}
-			$this->setReflectionMethod($class, $method);
-			foreach ($method->getAttributes() as $attribute) {
-				if (!class_exists($attribute->getName())) {
-					continue;
-				}
-				$this->setMethodsAttributes($class, $method, $attribute->newInstance());
-			}
-		}
-	}
-
-
-	/**
-	 * @param ReflectionClass $class
-	 * @param ReflectionMethod $method
-	 */
-	private function setReflectionMethod(ReflectionClass $class, ReflectionMethod $method)
-	{
-		if (!isset(static::$_attributeMapping[$class->getName()])) {
-			static::$_attributeMapping[$class->getName()] = [];
-		}
-		static::$_attributeMapping[$class->getName()][$method->getName()][] = $method;
-	}
-
-
-	/**
-	 * @param ReflectionClass $attribute
-	 * @param ReflectionMethod $method
-	 * @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
-	 * @return ReflectionMethod|null
-	 */
-	public function getTargetAnnotation($className): ?ReflectionMethod
-	{
-		return static::$_targetAttributes[$className] ?? null;
-	}
-
-
 	/**
 	 * @param $className
 	 * @param $method
 	 * @return array
+	 * @throws ReflectionException
 	 */
 	public function getMethodAttribute($className, $method = null): array
 	{
-		$methods = static::$_methodsAttributes[$className] ?? [];
+		$methods = $this->getMethodNote($this->getReflect($className));
 		if (!empty($method)) {
 			return $methods[$method] ?? [];
 		}
@@ -353,17 +185,18 @@ class Container extends BaseObject
 	 * @param string $class
 	 * @param string|null $property
 	 * @return ReflectionProperty|ReflectionProperty[]|null
+	 * @throws ReflectionException
 	 */
 	public function getClassReflectionProperty(string $class, string $property = null): ReflectionProperty|null|array
 	{
-		if (!isset(static::$_reflectionProperty[$class])) {
+		$lists = $this->getProperty($this->getReflect($class));
+		if (empty($lists)) {
 			return null;
 		}
-		$properties = static::$_reflectionProperty[$class];
 		if (!empty($property)) {
-			return $properties[$property] ?? null;
+			return $lists[$property] ?? null;
 		}
-		return $properties;
+		return $lists;
 	}
 
 
@@ -381,75 +214,78 @@ class Container extends BaseObject
 		return $object;
 	}
 
+
 	/**
 	 * @param $class
-	 * @param array $dependencies
+	 * @return ReflectionClass
+	 * @throws ReflectionException
+	 */
+	private function resolveDependencies($class): ReflectionClass
+	{
+		$this->_reflection[$class] = new ReflectionClass($class);
+		if (!$this->_reflection[$class]->isInstantiable()) {
+			throw new ReflectionException('Class ' . $class . ' cannot be instantiated');
+		}
+		$this->setPropertyNote($this->_reflection[$class]);
+		$this->setTargetNote($this->_reflection[$class]);
+		$this->setMethodNote($this->_reflection[$class]);
+		if (!is_null($construct = $this->_reflection[$class]->getConstructor())) {
+			$this->_constructs[$class] = $construct;
+		}
+		return $this->_reflection[$class];
+	}
+
+
+	/**
+	 * @param ReflectionClass|string $class
+	 * @return ReflectionMethod[]
+	 */
+	#[Pure] public function getReflectMethods(ReflectionClass|string $class): array
+	{
+		return $this->getMethods($class);
+	}
+
+
+	/**
+	 * @param ReflectionClass|string $class
+	 * @param string $method
+	 * @return ReflectionMethod|null
+	 */
+	#[Pure] 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
 	 */
-	private function resolveDependencies($class, array $dependencies = []): ?array
+	public function getMethodParameters(ReflectionClass|string $class, string $method): ?array
 	{
-		if (!isset(static::$_reflection[$class])) {
-			if (!($reflect = new ReflectionClass($class))->isInstantiable()) {
-				throw new ReflectionException('Class ' . $class . ' cannot be instantiated');
-			}
-			static::$_reflection[$class] = $reflect;
-			$this->resolveTargetAttribute(static::$_reflection[$class]);
-			$this->resolveMethodAttribute(static::$_reflection[$class]);
-			$this->scanProperty(static::$_reflection[$class]);
+		if (isset($this->_parameters[$class]) && isset($this->_parameters[$class][$method])) {
+			return $this->_parameters[$class][$method];
 		}
-		if (!is_null($construct = static::$_reflection[$class]->getConstructor())) {
-			foreach ($this->resolveMethodParam($construct) as $key => $item) {
-				$dependencies[$key] = $item;
-			}
+		$reflectMethod = $this->getReflectMethod($class, $method);
+		if (!($reflectMethod instanceof ReflectionMethod)) {
+			throw new ReflectionException("Class does not have a function $class::$method");
 		}
-		return [static::$_reflection[$class], $dependencies];
-	}
-
-
-	/**
-	 * @param ReflectionClass $reflectionClass
-	 * @return void
-	 */
-	private function scanProperty(ReflectionClass $reflectionClass): void
-	{
-		$properties = $reflectionClass->getProperties(ReflectionProperty::IS_PUBLIC |
-			ReflectionProperty::IS_PRIVATE | ReflectionProperty::IS_PROTECTED
-		);
-
-		$className = $reflectionClass->getName();
-		foreach ($properties as $property) {
-			$targets = $property->getAttributes(Inject::class);
-			if (count($targets) < 1) {
-				continue;
-			}
-
-			static::$_reflectionProperty[$className][$property->getName()] = $property;
-
-			static::$_propertyAttributes[$className][$property->getName()] = $targets[0]->newInstance();
+		if ($reflectMethod->getNumberOfParameters() < 1) {
+			return [];
 		}
-	}
-
-
-	/**
-	 * @param ReflectionMethod|null $method
-	 * @return array
-	 * @throws NotFindClassException
-	 * @throws ReflectionException
-	 */
-	private function resolveMethodParam(?ReflectionMethod $method): array
-	{
-		$array = [];
-		foreach ($method->getParameters() as $parameter) {
+		$this->_parameters[$class][$method] = $params = [];
+		foreach ($reflectMethod->getParameters() as $key => $parameter) {
 			if ($parameter->isDefaultValueAvailable()) {
-				$array[] = $parameter->getDefaultValue();
+				$params[$key] = $parameter->getDefaultValue();
 			} else {
 				$type = $parameter->getType();
 				if (is_string($type) && class_exists($type)) {
-					$type = Snowflake::createObject($type);
+					$type = Snowflake::getDi()->get($type);
 				}
-				$array[] = match ($parameter->getType()) {
+				$params[$key] = match ($parameter->getType()) {
 					'string' => '',
 					'int', 'float' => 0,
 					'', null, 'object', 'mixed' => NULL,
@@ -458,23 +294,21 @@ class Container extends BaseObject
 				};
 			}
 		}
-		return $array;
+		return $this->_parameters[$class][$method] = $params;
 	}
 
 
 	/**
 	 * @param $class
 	 * @return ReflectionClass|null
-	 * @throws NotFindClassException
 	 * @throws ReflectionException
 	 */
 	public function getReflect($class): ?ReflectionClass
 	{
-		$reflect = static::$_reflection[$class] ?? null;
-		if (!is_null($reflect)) {
-			return $reflect;
+		if (!isset($this->_reflection[$class])) {
+			return $this->resolveDependencies($class);
 		}
-		return $this->resolveDependencies($class)[0];
+		return $this->_reflection[$class];
 	}
 
 	/**
@@ -488,8 +322,8 @@ class Container extends BaseObject
 			$class = $class::class;
 		}
 		unset(
-			static::$_reflection[$class], static::$_singletons[$class],
-			static::$_param[$class], static::$_constructs[$class]
+			$this->_reflection[$class], $this->_singletons[$class],
+			$this->_param[$class], $this->_constructs[$class]
 		);
 	}
 
@@ -498,10 +332,10 @@ class Container extends BaseObject
 	 */
 	public function flush(): static
 	{
-		static::$_reflection = [];
-		static::$_singletons = [];
-		static::$_param = [];
-		static::$_constructs = [];
+		$this->_reflection = [];
+		$this->_singletons = [];
+		$this->_param = [];
+		$this->_constructs = [];
 		return $this;
 	}
 
@@ -513,12 +347,12 @@ class Container extends BaseObject
 	 */
 	private function mergeParam($class, $newParam): array
 	{
-		if (empty(static::$_param[$class])) {
+		if (empty($this->_param[$class])) {
 			return $newParam;
 		} else if (empty($newParam)) {
-			return static::$_param[$class];
+			return $this->_param[$class];
 		}
-		$old = static::$_param[$class];
+		$old = $this->_param[$class];
 		foreach ($newParam as $key => $val) {
 			$old[$key] = $val;
 		}

System/Di/Service.php

@@ -23,133 +23,143 @@ use Snowflake\Snowflake;
 class Service extends Component
 {
 
-    private array $_components = [];
+	private array $_components = [];
 
 
-    private array $_definition = [];
+	private array $_definition = [];
 
 
-    private array $_ids = [];
+	private array $_ids = [];
 
 
-    protected array $_alias = [];
+	protected array $_alias = [];
 
-    /**
-     * @param $id
-     * @param bool $try
-     * @return mixed
-     * @throws Exception
-     */
-    public function get($id, bool $try = true): mixed
-    {
-        if (isset($this->_components[$id])) {
-            return $this->_components[$id];
-        }
-        if (!isset($this->_definition[$id]) && !isset($this->_alias[$id])) {
-            if ($try === false) {
-                return null;
-            }
-            throw new ComponentException("Unknown component ID: $id");
-        }
-        if (isset($this->_definition[$id])) {
-            $config = $this->_definition[$id];
-            if (is_object($config)) {
-                return $this->_components[$id] = $config;
-            }
-        } else {
-            $config = $this->_alias[$id];
-        }
-	    return $this->_components[$id] = Snowflake::createObject($config);
-    }
-
-    /**
-     * @param string $className
-     * @param string $alias
-     */
-    public function setAlias(string $className, string $alias)
-    {
-        $this->_alias[$className] = $alias;
-    }
-
-    /**
-     * @param $id
-     * @param $definition
-     *
-     * @return mixed
-     * @throws Exception
-     */
-    public function set($id, $definition): void
-    {
-        if ($definition === NULL) {
-            $this->remove($id);
-            return;
-        }
-
-        $this->_ids[] = $id;
-
-        unset($this->_components[$id]);
-        if (is_object($definition) || is_callable($definition, TRUE)) {
-            $this->_definition[$id] = $definition;
-        } else if (!is_array($definition)) {
-            throw new ComponentException("Unexpected configuration type for the \"$id\" component: " . gettype($definition));
-        }
-        $this->_definition[$id] = $definition;
-    }
-
-    /**
-     * @param $id
-     * @return bool
-     */
-    #[Pure] public function has($id): bool
-    {
-        return in_array($id, $this->_ids);
-    }
-
-    /**
-     * @param array $data
-     * @throws Exception
-     */
-    public function setComponents(array $data)
-    {
-        foreach ($data as $key => $val) {
-            $this->set($key, $val);
-        }
-    }
+	/**
+	 * @param $id
+	 * @param bool $try
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public function get($id, bool $try = true): mixed
+	{
+		if (isset($this->_components[$id])) {
+			return $this->_components[$id];
+		}
+		$config = $this->_getConfig($id, $try);
+		if (!is_object($config)) {
+			$config = Snowflake::createObject($config);
+		}
+		return $this->_components[$id] = $config;
+	}
 
 
-    /**
-     * @param $name
-     * @return mixed
-     * @throws Exception
-     */
-    public function __get($name): mixed
-    {
-        if ($this->has($name)) {
-            return $this->get($name);
-        }
+	/**
+	 * @param $id
+	 * @param $try
+	 * @return mixed
+	 * @throws ComponentException
+	 */
+	private function _getConfig($id, $try): mixed
+	{
+		$config = $this->_definition[$id] ?? $this->_alias[$id] ?? null;
+		if (is_null($config)) {
+			if ($try === false) {
+				return null;
+			}
+			throw new ComponentException("Unknown component ID: $id");
+		}
+		return $config;
+	}
 
-        return parent::__get($name);
-    }
 
-    /**
-     * @param $id
-     * @return bool
-     */
-    public function remove($id): bool
-    {
-        $component = $this->_components[$id];
-        $className = $component::class;
+	/**
+	 * @param string $className
+	 * @param string $alias
+	 */
+	public function setAlias(string $className, string $alias)
+	{
+		$this->_alias[$className] = $alias;
+	}
 
-        unset($component, $this->_components[$id]);
-        unset($this->_definition[$id]);
-        if (isset($this->_alias[$id])) {
-            unset($this->_components[$this->_alias[$id]]);
-            unset($this->_definition[$this->_alias[$id]]);
-            unset($this->_alias[$id]);
-        }
+	/**
+	 * @param $id
+	 * @param $definition
+	 *
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public function set($id, $definition): void
+	{
+		if ($definition === NULL) {
+			$this->remove($id);
+			return;
+		}
+		$this->_ids[] = $id;
+		unset($this->_components[$id]);
+		if (is_object($definition)) {
+			$this->_components[$id] = $definition;
+			$this->_definition[$id] = $definition;
+		} else if (!is_array($definition)) {
+			throw new ComponentException("Unexpected configuration type for the \"$id\" component: " . gettype($definition));
+		} else {
+			$this->_definition[$id] = $definition;
+		}
+	}
 
-        Snowflake::getDi()->unset($className);
+	/**
+	 * @param $id
+	 * @return bool
+	 */
+	#[Pure] public function has($id): bool
+	{
+		return in_array($id, $this->_ids);
+	}
 
-        return $this->has($id);
-    }
+	/**
+	 * @param array $data
+	 * @throws Exception
+	 */
+	public function setComponents(array $data)
+	{
+		foreach ($data as $key => $val) {
+			$this->set($key, $val);
+		}
+	}
+
+
+	/**
+	 * @param $name
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public function __get($name): mixed
+	{
+		if ($this->has($name)) {
+			return $this->get($name);
+		}
+
+		return parent::__get($name);
+	}
+
+	/**
+	 * @param $id
+	 * @return bool
+	 */
+	public function remove($id): bool
+	{
+		$component = $this->_components[$id];
+		$className = $component::class;
+
+		unset($component, $this->_components[$id]);
+		unset($this->_definition[$id]);
+		if (isset($this->_alias[$id])) {
+			unset($this->_components[$this->_alias[$id]]);
+			unset($this->_definition[$this->_alias[$id]]);
+			unset($this->_alias[$id]);
+		}
+
+		Snowflake::getDi()->unset($className);
+
+		return $this->has($id);
+	}
 }

System/Events/EventDispatch.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Snowflake\Events;
+
+class EventDispatch
+{
+
+	private EventListener $eventListener;
+
+
+	/**
+	 * @param $event
+	 * @param array $params
+	 */
+	public function emit($event, array $params = [])
+	{
+		$events = $this->eventListener->getEventListeners($event);
+		if (empty($events)) {
+			return;
+		}
+		while ($events->valid()) {
+			/** @var EventDispatchInterface $interface */
+			$interface = $events->current();
+			$interface->onHandler();
+			if ($interface->stopPagination()) {
+				break;
+			}
+			$events->next();
+		}
+	}
+
+}

System/Events/EventDispatchInterface.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Snowflake\Events;
+
+
+/**
+ *
+ */
+interface EventDispatchInterface
+{
+
+	public function getZOrder(): int;
+
+	public function onHandler(): void;
+
+	public function stopPagination(): bool;
+
+}

System/Events/EventListener.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Snowflake\Events;
+
+use SplPriorityQueue;
+
+class EventListener
+{
+
+	/** @var SplPriorityQueue[] */
+	private array $_events = [];
+
+
+	/**
+	 * @param $event
+	 * @param EventDispatchInterface $handler
+	 */
+	public function on($event, EventDispatchInterface $handler)
+	{
+		if (!isset($this->_events[$event])) {
+			$this->_events[$event] = new SplPriorityQueue();
+		}
+		$this->_events[$event]->insert($handler, $handler->getZOrder());
+	}
+
+
+	/**
+	 * @param $event
+	 * @return SplPriorityQueue|null
+	 */
+	public function getEventListeners($event): ?SplPriorityQueue
+	{
+		return $this->_events[$event] ?? null;
+	}
+
+
+}

System/Events/EventProviders.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Snowflake\Events;
+
+class EventProviders
+{
+
+}

System/Snowflake.php

@@ -202,7 +202,7 @@ class Snowflake
 			$class = $className['class'];
 			unset($className['class']);
 
-			return static::$container->get($class, $construct, $className);
+			return static::$container->newObject($class, $construct, $className);
 		} else if (is_callable($className, TRUE)) {
 			return call_user_func($className, $construct);
 		} else {
@@ -250,7 +250,7 @@ class Snowflake
 	 */
 	public static function setManagerId($workerId): mixed
 	{
-		if (empty($workerId) || static::isDcoker()) {
+		if (empty($workerId) || static::isDocker()) {
 			return $workerId;
 		}
 
@@ -267,7 +267,7 @@ class Snowflake
 	 */
 	public static function setProcessId($workerId): mixed
 	{
-		if (empty($workerId) || static::isDcoker()) {
+		if (empty($workerId) || static::isDocker()) {
 			return $workerId;
 		}
 
@@ -280,7 +280,7 @@ class Snowflake
 	/**
 	 * @return bool
 	 */
-	public static function isDcoker(): bool
+	public static function isDocker(): bool
 	{
 		$output = shell_exec('[ -f /.dockerenv ] && echo yes || echo no');
 		if (trim($output) === 'yes') {
@@ -297,7 +297,7 @@ class Snowflake
 	 */
 	public static function setWorkerId($workerId): mixed
 	{
-		if (empty($workerId) || static::isDcoker()) {
+		if (empty($workerId) || static::isDocker()) {
 			return $workerId;
 		}
 
@@ -314,7 +314,7 @@ class Snowflake
 	 */
 	public static function setTaskId($workerId): mixed
 	{
-		if (empty($workerId) || static::isDcoker()) {
+		if (empty($workerId) || static::isDocker()) {
 			return $workerId;
 		}