Ankündigung

Einklappen
Keine Ankündigung bisher.

Route mit Middleware vereinen

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Route mit Middleware vereinen

    Hallo zusammen

    Befasse mich gerade intesiv mit dem Middleware Design. Nach Psr-15 HTTP Middlewares (Draft)
    habe ich mal ein einfaches Beispiel gemacht. Denn mir ist nicht ganz klar wie man den Router mit den Middlewares "vereint".

    So wie ich das sehe wird die route Response am Middleware Dispatcher übergeben. Hoffe ich sehe das richtig? Oder mache ich das falsch?

    Wäre sehr dankbar um Rat. Besten Dank im voraus.

    Set up:
    PHP-Code:
    // Middleware interfaces and classes. //////////////////////////////////////
    interface MiddlewareInterface {

        public function 
    process(ServerRequestInterface $requestRequestHandlerInterface $handler): ResponseInterface;
    }

    class 
    MiddlewareDispatcher {

        private 
    $middleware = [];

        public function 
    register(MiddlewareInterface $middleware) {

            
    $this->middleware[] = $middleware;
        }

        public function 
    dispatch(ServerRequestInterface $requestResponseInterface $response): ResponseInterface {

            
    $requestHandler = new RequestHandler(function(ServerRequestInterface $request) use (&$requestHandler$response) {

                
    $middleware array_shift($this->middleware);

                if (
    $middleware === null) {

                    echo 
    '######### Middle ##########<br>';
                    return 
    $response;
                }

                return 
    $middleware->process($request$requestHandler);
            });

            return 
    $requestHandler->handle($request);
        }
    }

    // Request and Response interfaces and classes. //////////////////////////////////////
    interface RequestHandlerInterface {

        public function 
    handle(ServerRequestInterface $request): ResponseInterface;
    }

    interface 
    ServerRequestInterface {}

    interface 
    ResponseInterface {

        public function 
    write(string $data);
        public function 
    getBody(): string;
    }

    class 
    RequestHandler implements RequestHandlerInterface {

        private 
    $callback;

        public function 
    __construct(callable $callback) {

            
    $this->callback $callback;
        }

        public function 
    handle(ServerRequestInterface $request): ResponseInterface {

            return 
    call_user_func($this->callback$request);
        }
    }

    class 
    Request implements ServerRequestInterface { }

    class 
    Response implements ResponseInterface {

        private 
    $content;

        public function 
    write(string $data) {

            
    $this->content .= $data;
            return 
    $this;
        }

        public function 
    getBody(): string {
            return 
    $this->content;
        }
    }

    // Middleware classes ///////////////////////////////////////////////////////////
    class FooMiddleware implements MiddlewareInterface {

        public function 
    process(ServerRequestInterface $requestRequestHandlerInterface $handler): ResponseInterface {

            echo 
    '--- FooMiddleware BEFORE ---<br>';
            
    //return new Response(); // would skip all next middleware.
            
    $response $handler->handle($request);
            echo 
    '--- FooMiddleware AFTER ---<br>';
            return 
    $response->write('--- FooMiddleware AFTER ---<br>');
        }
    }

    class 
    BarMiddleware implements MiddlewareInterface {

        public function 
    process(ServerRequestInterface $requestRequestHandlerInterface $handler): ResponseInterface {

            echo 
    '--- BarMiddleware BEFORE ---<br>';
            
    $response $handler->handle($request);
            echo 
    '--- BarMiddleware AFTER ---<br>';
            return 
    $response->write('--- BarMiddleware AFTER ---<br>');
        }


    Alles vereinen wo ich eben nicht ganz sicher bin ob ich das richtig mache:
    PHP-Code:
    // Do the logic. //////////////////////////////////////////
    $middlewareDispatcher = new MiddlewareDispatcher();
    $middlewareDispatcher->register(new FooMiddleware());
    $middlewareDispatcher->register(new BarMiddleware());

    $request = new Request();
    $response = new Response();

    // Route Dispatching - for simplicity:
    $route = function() use ($request$response): ResponseInterface {

        return 
    $response->write('The matched route action<br>');
    };

    $routeResponse call_user_func_array($route, []);

    // register routes middleware if defined.
    /*foreach($routeMiddlewares as $routeMiddleware) {
        $middlewareDispatcher->register($routeMiddleware);
    }*/

    // Pass the route response to the middleware dispatcher.
    $middlewareDispatcher->dispatch($request$routeResponse);

    echo 
    '<br>Response:<br>'$response->getBody(); 

    output:
    Code:
    --- FooMiddleware BEFORE ---
    --- BarMiddleware BEFORE ---
    ######### Middle ##########
    --- BarMiddleware AFTER ---
    --- FooMiddleware AFTER ---
    
    Response:
    The matched route action
    --- BarMiddleware AFTER ---
    --- FooMiddleware AFTER ---


  • #2
    Ich persönlich bilde auch das Routing als Middleware ab. Quasi so wie FastRoute Middleware.

    Kommentar


    • #3
      Hallo Lottikarotti, besten Dank für deine Hilfe. Ich habe es fast angenommen, das man das Routing auch als Middleware übergibt, somit habe ich den folgendes als einfaches Beispiel:

      PHP-Code:
      $middlewareDispatcher = new MiddlewareDispatcher();
      $middlewareDispatcher->register(new FooMiddleware());
      $middlewareDispatcher->register(new BarMiddleware());

      $request = new Request();
      $response = new Response();

      // Route Dispatching - for simplicity:
      class Router {

          public function 
      __construct(ServerRequestInterface $requestResponseInterface $response) {

              
      $this->request $request;
              
      $this->response $response;
          }

          public function 
      dispatch() {

              return 
      $this->response->write('The matched route action<br>');
          }
      }

      // Route middleware
      class RouteMiddleware implements MiddlewareInterface {

          private 
      $router;

          public function 
      __construct($router) {

              
      $this->router $router;
          }

          public function 
      process(ServerRequestInterface $requestRequestHandlerInterface $handler): ResponseInterface {

              
      $routeResponse $this->router->dispatch();
              
      // handle route response
              
      echo '--- RouteMiddleware BEFORE ---<br>';
              return 
      $handler->handle($request);
          }
      }

      $middlewareDispatcher->register(new RouteMiddleware(new Router($request$response)));

      $middlewareDispatcher->dispatch($request$response);

      echo 
      '<br>Response:<br>'$response->getBody(); 
      output:
      Code:
      --- FooMiddleware BEFORE ---
      --- BarMiddleware BEFORE ---
      --- RouteMiddleware BEFORE ---
      ######### Middle ##########
      --- BarMiddleware AFTER ---
      --- FooMiddleware AFTER ---
      
      Response:
      The matched route action
      --- BarMiddleware AFTER ---
      --- FooMiddleware AFTER ---

      Kommentar

      Lädt...
      X