增加模型关联注解

top-think · Mar 4, 2020 · 2c8cb77 · 2c8cb77
1 parent 8df7414
commit 2c8cb77
Show file tree

Hide file tree

Showing 15 changed files with 569 additions and 11 deletions.
diff --git a/README.md b/README.md
@@ -10,7 +10,9 @@
 
 ## 使用方法
 
-~~~
+### 路由注解
+
+~~~php
 <?php
 
 namespace app\controller;
@@ -56,6 +58,28 @@ class IndexController
 
 ~~~
 
+### 模型注解
+
+~~~php
+<?php
+
+namespace app\model;
+
+use think\Model;
+use think\annotation\model\InteractsWithAnnotations;
+use think\annotation\model\relation\HasMany;
+
+/**
+ * @HasMany("articles", model=Article::class, foreignKey="user_id")
+ */
+class User extends Model
+{
+    use InteractsWithAnnotations;
+
+    //...
+}
+~~~
+
 IDE Support
 -----------
 

diff --git a/composer.json b/composer.json
@@ -8,7 +8,6 @@
             "email": "[email protected]"
         }
     ],
-    "minimum-stability": "dev",
     "require": {
         "topthink/framework": "^6.0",
         "doctrine/annotations": "^1.6",

diff --git a/src/Service.php b/src/Service.php
@@ -5,6 +5,12 @@
 use Doctrine\Common\Annotations\AnnotationReader;
 use Doctrine\Common\Annotations\AnnotationRegistry;
 use Doctrine\Common\Annotations\Reader;
+use InvalidArgumentException;
+use RecursiveCallbackFilterIterator;
+use RecursiveDirectoryIterator;
+use RecursiveIteratorIterator;
+use SplFileInfo;
+use think\App;
 
 class Service extends \think\Service
 {
@@ -20,7 +26,15 @@ public function register()
         // TODO: this method is deprecated and will be removed in doctrine/annotations 2.0
         AnnotationRegistry::registerLoader('class_exists');
 
-        $this->reader = new CachedReader(new AnnotationReader(), $this->app);
+        $this->app->bind(Reader::class, function (App $app) {
+            return new CachedReader(new AnnotationReader(), $app);
+        });
+    }
+
+    public function boot(Reader $reader)
+    {
+        $this->reader = $reader;
+
         //注解路由
         $this->registerAnnotationRoute();
 
@@ -35,17 +49,17 @@ public function register()
      */
     protected function findClasses($dir)
     {
-        $files = iterator_to_array(new \RecursiveIteratorIterator(
-            new \RecursiveCallbackFilterIterator(
-                new \RecursiveDirectoryIterator($dir, \FilesystemIterator::SKIP_DOTS | \FilesystemIterator::FOLLOW_SYMLINKS),
-                function (\SplFileInfo $current) {
+        $files = iterator_to_array(new RecursiveIteratorIterator(
+            new RecursiveCallbackFilterIterator(
+                new RecursiveDirectoryIterator($dir, \FilesystemIterator::SKIP_DOTS | \FilesystemIterator::FOLLOW_SYMLINKS),
+                function (SplFileInfo $current) {
                     return '.' !== substr($current->getBasename(), 0, 1);
                 }
             ),
-            \RecursiveIteratorIterator::LEAVES_ONLY
+            RecursiveIteratorIterator::LEAVES_ONLY
         ));
 
-        usort($files, function (\SplFileInfo $a, \SplFileInfo $b) {
+        usort($files, function (SplFileInfo $a, SplFileInfo $b) {
             return (string) $a > (string) $b ? 1 : -1;
         });
 
@@ -64,8 +78,8 @@ protected function findClass($file)
         $class     = false;
         $namespace = false;
         $tokens    = token_get_all(file_get_contents($file));
-        if (1 === \count($tokens) && T_INLINE_HTML === $tokens[0][0]) {
-            throw new \InvalidArgumentException(sprintf('The file "%s" does not contain PHP code. Did you forgot to add the "<?php" start tag at the beginning of the file?', $file));
+        if (1 === count($tokens) && T_INLINE_HTML === $tokens[0][0]) {
+            throw new InvalidArgumentException(sprintf('The file "%s" does not contain PHP code. Did you forgot to add the "<?php" start tag at the beginning of the file?', $file));
         }
         for ($i = 0; isset($tokens[$i]); ++$i) {
             $token = $tokens[$i];

diff --git a/src/model/InteractsWithAnnotations.php b/src/model/InteractsWithAnnotations.php
@@ -0,0 +1,169 @@
+<?php
+
+namespace think\annotation\model;
+
+use Doctrine\Common\Annotations\Reader;
+use think\annotation\model\relation\BelongsTo;
+use think\annotation\model\relation\BelongsToMany;
+use think\annotation\model\relation\HasMany;
+use think\annotation\model\relation\HasManyThrough;
+use think\annotation\model\relation\HasOne;
+use think\annotation\model\relation\HasOneThrough;
+use think\annotation\model\relation\MorphByMany;
+use think\annotation\model\relation\MorphMany;
+use think\annotation\model\relation\MorphOne;
+use think\annotation\model\relation\MorphTo;
+use think\annotation\model\relation\MorphToMany;
+use think\Model;
+
+/**
+ * Trait InteractsWithAnnotations
+ * @package think\annotation\model
+ * @mixin Model
+ */
+trait InteractsWithAnnotations
+{
+    static protected $annotationRelations = [];
+
+    protected function prepareAnnotationRelations()
+    {
+        if (empty(self::$annotationRelations)) {
+
+            $this->invoke(function (Reader $reader) {
+                $annotations = $reader->getClassAnnotations(new \ReflectionClass($this));
+
+                foreach ($annotations as $annotation) {
+                    switch (true) {
+                        case $annotation instanceof HasOne:
+                            $relation = function (Model $model) use ($annotation) {
+                                return $model->hasOneThrough(
+                                    $annotation->model,
+                                    $annotation->foreignKey,
+                                    $annotation->localKey
+                                );
+                            };
+                            break;
+                        case $annotation instanceof BelongsTo:
+                            $relation = function (Model $model) use ($annotation) {
+                                return $model->belongsTo(
+                                    $annotation->model,
+                                    $annotation->foreignKey,
+                                    $annotation->localKey
+                                );
+                            };
+                            break;
+                        case $annotation instanceof HasMany:
+                            $relation = function (Model $model) use ($annotation) {
+                                return $model->hasMany(
+                                    $annotation->model,
+                                    $annotation->foreignKey,
+                                    $annotation->localKey
+                                );
+                            };
+                            break;
+                        case $annotation instanceof HasManyThrough:
+                            $relation = function (Model $model) use ($annotation) {
+                                return $model->hasManyThrough(
+                                    $annotation->model,
+                                    $annotation->through,
+                                    $annotation->foreignKey,
+                                    $annotation->throughKey,
+                                    $annotation->localKey,
+                                    $annotation->throughPk
+                                );
+                            };
+                            break;
+                        case $annotation instanceof HasOneThrough:
+                            $relation = function (Model $model) use ($annotation) {
+                                return $model->hasOneThrough(
+                                    $annotation->model,
+                                    $annotation->through,
+                                    $annotation->foreignKey,
+                                    $annotation->throughKey,
+                                    $annotation->localKey,
+                                    $annotation->throughPk
+                                );
+                            };
+                            break;
+                        case $annotation instanceof BelongsToMany:
+                            $relation = function (Model $model) use ($annotation) {
+                                return $model->belongsToMany($annotation->model,
+                                    $annotation->middle,
+                                    $annotation->foreignKey,
+                                    $annotation->localKey
+                                );
+                            };
+                            break;
+                        case $annotation instanceof MorphOne:
+                            $relation = function (Model $model) use ($annotation) {
+                                return $model->morphOne(
+                                    $annotation->model,
+                                    $annotation->morph ?: $annotation->value,
+                                    $annotation->type
+                                );
+                            };
+                            break;
+                        case $annotation instanceof MorphMany:
+                            $relation = function (Model $model) use ($annotation) {
+                                return $model->morphMany(
+                                    $annotation->model,
+                                    $annotation->morph ?: $annotation->value,
+                                    $annotation->type
+                                );
+                            };
+                            break;
+                        case $annotation instanceof MorphTo:
+                            $relation = function (Model $model) use ($annotation) {
+                                return $model->morphTo($annotation->morph ?: $annotation->value, $annotation->alias);
+                            };
+                            break;
+                        case $annotation instanceof MorphToMany:
+                            $relation = function (Model $model) use ($annotation) {
+                                return $model->morphToMany(
+                                    $annotation->model,
+                                    $annotation->middle,
+                                    $annotation->morph,
+                                    $annotation->localKey
+                                );
+                            };
+                            break;
+                        case $annotation instanceof MorphByMany:
+                            $relation = function (Model $model) use ($annotation) {
+                                return $model->morphByMany(
+                                    $annotation->model,
+                                    $annotation->middle,
+                                    $annotation->morph,
+                                    $annotation->foreignKey
+                                );
+                            };
+                            break;
+                    }
+
+                    if (!empty($relation)) {
+                        static::$annotationRelations[$annotation->value] = $relation;
+                    }
+                }
+            });
+        }
+    }
+
+    protected function isAnnotationRelationMethod($method)
+    {
+        return array_key_exists($method, static::$annotationRelations);
+    }
+
+    protected function getAnnotationRelation($method)
+    {
+        return (static::$annotationRelations[$method])($this);
+    }
+
+    public function __call($method, $args)
+    {
+        $this->prepareAnnotationRelations();
+        if ($this->isAnnotationRelationMethod($method)) {
+            return $this->getAnnotationRelation($method);
+        }
+
+        return parent::__call($method, $args);
+    }
+}
diff --git a/src/model/relation/BelongsTo.php b/src/model/relation/BelongsTo.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace think\annotation\model\relation;
+
+use Doctrine\Common\Annotations\Annotation;
+
+/**
+ * @Annotation
+ * @Annotation\Target({"CLASS"})
+ */
+final class BelongsTo extends Annotation
+{
+    /**
+     * @var string
+     * @Annotation\Required
+     */
+    public $model;
+
+    /**
+     * @var string
+     */
+    public $foreignKey = '';
+
+    /**
+     * @var string
+     */
+    public $localKey = '';
+}
diff --git a/src/model/relation/BelongsToMany.php b/src/model/relation/BelongsToMany.php
@@ -0,0 +1,33 @@
+<?php
+
+namespace think\annotation\model\relation;
+
+use Doctrine\Common\Annotations\Annotation;
+
+/**
+ * @Annotation
+ * @Annotation\Target({"CLASS"})
+ */
+final class BelongsToMany extends Annotation
+{
+    /**
+     * @var string
+     * @Annotation\Required
+     */
+    public $model;
+
+    /**
+     * @var string
+     */
+    public $middle = '';
+
+    /**
+     * @var string
+     */
+    public $foreignKey = '';
+
+    /**
+     * @var string
+     */
+    public $localKey = '';
+}
diff --git a/src/model/relation/HasMany.php b/src/model/relation/HasMany.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace think\annotation\model\relation;
+
+use Doctrine\Common\Annotations\Annotation;
+
+/**
+ * @Annotation
+ * @Annotation\Target({"CLASS"})
+ */
+final class HasMany extends Annotation
+{
+    /**
+     * @var string
+     * @Annotation\Required
+     */
+    public $model;
+
+    /**
+     * @var string
+     */
+    public $foreignKey = '';
+
+    /**
+     * @var string
+     */
+    public $localKey = '';
+
+}