1. 通常，很多人都是在控制器里直接調(diào)用view()方法渲染視圖文件，因為很多框架都是這么干的，于是大家都這么干了，但這種方式并不好，使得view與controller極度耦合。

2. webman中的controller沒有傳遞request對象，使得代碼寫起來有些繁瑣，基本每個action要傳遞request，但如果在construct中傳遞request，就可以這么寫：

protected $request;

public function __construct(Request $request)
{
    $this->request = $request;
}

3. 可以利用中間件解決很多問題，但中間件無法處理控制器內(nèi)部的業(yè)務(wù)邏輯，假設(shè)在調(diào)用action之前，我們希望業(yè)務(wù)邏輯通過是否有中斷標(biāo)識，決定是否真正調(diào)用action，用中間件搞感覺很麻煩，如果硬編碼在每個action里，又覺得很繁瑣，再有，我們想通過在調(diào)用action后統(tǒng)一處理action的返回結(jié)果，決定是否調(diào)用view渲染視圖還是返回json等等。

修改后的代碼：

protected static function getCallback(string $plugin, string $app, $call, array $args = null, bool $withGlobalMiddleware = true, RouteObject $route = null)
    {
        $args = $args === null ? null : array_values($args);
        $middlewares = [];
        if ($route) {
            $routeMiddlewares = array_reverse($route->getMiddleware());
            foreach ($routeMiddlewares as $className) {
                $middlewares[] = [$className, 'process'];
            }
        }
        $middlewares = array_merge($middlewares, Middleware::getMiddleware($plugin, $app, $withGlobalMiddleware));

        foreach ($middlewares as $key => $item) {
            $middleware = $item[0];
            if (is_string($middleware)) {
                $middleware = static::container($plugin)->get($middleware);
            } elseif ($middleware instanceof Closure) {
                $middleware = call_user_func($middleware, static::container($plugin));
            }
            if (!$middleware instanceof MiddlewareInterface) {
                throw new InvalidArgumentException('Not support middleware type');
            }
            $middlewares[$key][0] = $middleware;
        }

        $needInject = static::isNeedInject($call, $args);

        if (is_array($call) && is_string($call[0])) {
            $controllerReuse = static::config($plugin, 'app.controller_reuse', true);
            if (!$controllerReuse) {
                if ($needInject) {
                    $call = function ($request, ...$args) use ($call, $plugin) {
                        $call[0] = static::container($plugin)->make($call[0], [$request]);

                        if (true !== ($result = static::beforeCall($call[0], $call[1], $request))) {
                            return $result;
                        }

                        $reflector = static::getReflector($call);
                        $args = static::resolveMethodDependencies($plugin, $request, $args, $reflector);
                        // return $call(...$args);
                        return static::afterCall($call[0], $call[1], $call(...$args), $request);
                    };
                    $needInject = false;
                } else {
                    $call = function ($request, ...$args) use ($call, $plugin) {
                        $call[0] = static::container($plugin)->make($call[0], [$request]);

                        if (true !== ($result = static::beforeCall($call[0], $call[1], $request))) {
                            return $result;
                        }

                        // return $call($request, ...$args);
                        return static::afterCall($call[0], $call[1], $call($request, ...$args), $request);
                    };
                }
            } else {
                $call[0] = static::container($plugin)->get($call[0]);
            }
        }

        if ($needInject) {
            $call = static::resolveInject($plugin, $call);
        }

        if ($middlewares) {
            $callback = array_reduce($middlewares, function ($carry, $pipe) {
                return function ($request) use ($carry, $pipe) {
                    try {
                        return $pipe($request, $carry);
                    } catch (Throwable $e) {
                        return static::exceptionResponse($e, $request);
                    }
                };
            }, function ($request) use ($call, $args) {

                try {
                    if ($args === null) {
                        $response = $call($request);
                    } else {
                        $response = $call($request, ...$args);
                    }
                } catch (Throwable $e) {
                    return static::exceptionResponse($e, $request);
                }
                if (!$response instanceof Response) {
                    if (!is_string($response)) {
                        $response = static::stringify($response);
                    }
                    $response = new Response(200, [], $response);
                }
                return $response;
            });
        } else {
            if ($args === null) {
                $callback = $call;
            } else {
                $callback = function ($request) use ($call, $args) {
                    return $call($request, ...$args);
                };
            }
        }
        return $callback;
    }

    protected static function beforeCall($controller, $action, $request)
    {
        if (false !== ($result = static::detectHalted($controller))) {
            return $result;
        }

        static::doBeforeAction($controller, $action, $request);

        if (false !== ($result = static::detectHalted($controller))) {
            return $result;
        }

        return true;
    }

    protected static function afterCall($controller, $action, $response, $request)
    {
        $method = 'after' . ucfirst($action) . 'Action';
        if (method_exists($controller, $method)) {
            $response = $controller->{$method}($response, $request);
        }

        if (method_exists($controller, 'afterAction')) {
            $response = $controller->afterAction($response, $request);
        }

        return $response;
    }

    protected static function detectHalted($controller)
    {
        if (method_exists($controller, 'halted')  && $controller->halted()) {
            return $controller->getHaltedResult();
        }

        return false;
    }

    protected static function doBeforeAction($controller, $action, $request)
    {
        if (method_exists($controller, 'beforeAction')) {
            $controller->beforeAction($request);
        }

        $method = 'before' . ucfirst($action) . 'Action';
        if (method_exists($controller, $method)) {
            $controller->{$method}($request);
        }
    }

食用示例：

namespace app\controller;

use Webman\App;
use support\Model;
use support\Request;
use support\Response;

/**
 * 基礎(chǔ)控制器
 */
class Base
{
    protected $halted = false; //標(biāo)識是否中斷
    protected $haltedResult = null; //接收中斷返回的內(nèi)容
    protected $request = null;

    public function __construct(Request $request)
    {
        $this->request = $request;
    }

    public function halted($flag = null)
    {
        if (is_bool($flag)) {
            $this->halted = $flag;
            return;
        }

        return $this->halted;
    }

    public function getHaltedResult()
    {
        return $this->haltedResult;
    }

    // 統(tǒng)一處理action返回的結(jié)果
    public function afterAction($data)
    {
        $script = $this->request->script;
        if (!$data) {
            return view($script, $data);
        }

        return $data;
    }

}