通过 header 中的 version 字段来做 API 多版本兼容

Route::prefix('v1')->group(function () {
    Route::get('users', function () {
        // Matches The "/v1/users" URL
    });
});Copy

/**
* Dispatch a request to a given controller and method.
*
* @param  \Illuminate\Routing\Route  $route
* @param  mixed  $controller
* @param  string  $method
* @return mixed
*/
public function dispatch(Route $route, $controller, $method)
{
    $parameters = $this->resolveClassMethodDependencies(
        $route->parametersWithoutNulls(), $controller, $method
    );

    if (method_exists($controller, 'callAction')) {
        return $controller->callAction($method, $parameters);
    }

    return $controller->{$method}(...array_values($parameters));
}Copy

public function dispatch(Route $route, $controller, $method)
{
    $request = $this->container->make('request');
    $version = $request->header('version');
    if ($version && $version !== 'v1') {
        $class = get_class($controller);
        $class_path = explode('\\', $class);
        array_splice($class_path, -1, 0, $version);
        $controller = $this->container->make(implode('\\', $class_path));
    }
    return parent::dispatch($route, $controller, $method);
}Copy

Route::get('/test','TestController@test');Copy

declare(strict_types=1);

namespace Dezsidog\Routing;

use Illuminate\Routing\Route as LaravelRoute;

class Route extends LaravelRoute
{
    /**
     * set the version property
     * @param null|string $version
     * @return Route
     */
    public function setVersion(?string $version): self
    {
        $version ? $this->action['version'] = $version : $this->action['version'] = 'v1';

        return $this;
    }

    /**
     * get the version property
     * @return null|string
     */
    public function getVersion(): ?string
    {
        $this->action['version'] = $this->action['version'] ?? 'v1';
        return $this->action['version'];
    }
}Copy

Route::group(['version' => 'v1'], function () {
    ...........
});Copy

declare(strict_types=1);

namespace Dezsidog\Routing;

use Illuminate\Routing\RouteGroup as LaravelRouteGroup;
use Illuminate\Support\Arr;

class RouteGroup extends LaravelRouteGroup
{
    public static function merge($new, $old)
    {
        if (isset($new['domain'])) {
            unset($old['domain']);
        }

        $new = array_merge(static::formatAs($new, $old), [
            'namespace' => static::formatNamespace($new, $old),
            'prefix' => static::formatPrefix($new, $old),
            'where' => static::formatWhere($new, $old),
            'version' => static::formatVersion($new, $old),
        ]);

        return array_merge_recursive(Arr::except(
            $old, ['namespace', 'prefix', 'where', 'as']
        ), $new);
    }

    public static function formatVersion($new, $old)
    {
        return $old['version'];
    }
}Copy

declare(strict_types=1);

namespace Dezsidog\Routing;

use Illuminate\Routing\RouteCollection as LaravelRouteCollection;

class RouteCollection extends LaravelRouteCollection
{
    /**
     * @var RouteCollection[]
     */
    protected $versions = [];

    /**
     * @param Route $route
     */
    public function addLookups($route)
    {
        parent::addLookups($route);
        $this->createVersion($route->getVersion());
        $this->versions[$route->getVersion()]->add($route);
    }

    public function version(string $version): \Illuminate\Routing\RouteCollection
    {
        return $this->versions[$version] ?? null;
    }

    public function createVersion($version)
    {
        if (!isset($this->versions[$version])) {
            $this->versions[$version] = new \Illuminate\Routing\RouteCollection();
        }
    }
}Copy

declare(strict_types=1);

namespace Dezsidog\Routing;

use Illuminate\Container\Container;
use Illuminate\Contracts\Events\Dispatcher;
use Illuminate\Http\Request;
use Illuminate\Routing\Router as LaravelRouter;

class Router extends LaravelRouter
{
    /**
     * @var RouteCollection $routes
     */
    protected $routes;

    public function __construct(Dispatcher $events, Container $container = null)
    {
        parent::__construct($events, $container);
        $this->routes = new RouteCollection();
    }

    public function dispatchByVersion(Request $request, string $version)
    {
        if (! $routes = $this->routes->version($version)) {
            throw new \RuntimeException('unknown route version');
        }

        $router = clone $this;
        $router->setRoutes($routes);

        $response = $router->dispatch($request);

        unset($router);

        return $response;
    }

    /**
     * Create a new Route object.
     *
     * @param  array|string  $methods
     * @param  string  $uri
     * @param  mixed  $action
     * @return \Illuminate\Routing\Route
     */
    protected function newRoute($methods, $uri, $action)
    {
        return (new Route($methods, $uri, $action))
            ->setRouter($this)
            ->setContainer($this->container);
    }
}Copy

namespace Dezsidog\Http;

use Dezsidog\Routing\Router;
use Illuminate\Foundation\Http\Kernel as LaravelHttpKernel;
use Illuminate\Http\Request;

class Kernel extends LaravelHttpKernel
{
    /**
     * @var Router
     */
    protected $router;

    /**
     * Get the route dispatcher callback.
     *
     * @return \Closure
     */
    protected function dispatchToRouter()
    {
        return function ($request) {
            /**
             * @var Request $request
             */
            $this->app->instance('request', $request);

            $oldRouter = $this->router;

            $this->router = $this->app->make('router');

            foreach ($oldRouter->getMiddlewareGroups() as $key => $value) {
                $this->router->middlewareGroup($key, $value);
            }

            foreach ($oldRouter->getMiddleware() as $key => $value) {
                $this->router->aliasMiddleware($key, $value);
            }

            return $this->router->dispatchByVersion($request, $request->header('version', 'v1'));
        };
    }
}Copy

Route::get('test', "V1Controller@test");

Route::group(['version' => 'v2'], function(){
    Route::get('test', "V2Controller@test");
    Route::get('test2', "V2Controller@test2");
    Route::get('test3', "V1Controller@test");
});Copy

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class V1Controller extends Controller
{
    public function test()
    {
        return 'v1';
    }
}Copy

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class V2Controller extends Controller
{
    public function test()
    {
        return 'v2';
    }

    public function test2()
    {
        return 'v2';
    }
}Copy

public function testVersion()
    {
        $response = $this->getJson('api/test');

        $this->assertEquals('v1', $response->content());

        $response = $this->getJson('api/test',['version' => 'v2']);
        $this->assertEquals('v2', $response->content());

        $response = $this->getJson('api/test2', ['version' => 'v2']);
        $this->assertEquals('v2', $response->content());

        $response = $this->getJson('api/test2');
        $response->assertStatus(404);

        $response = $this->getJson('api/test3',['version' => 'v2']);
        $this->assertEquals('v1', $response->content());
    }Copy