Cache construction of middleware handlers

aiohttp/web_app.py

@@ -16,6 +16,7 @@
     MutableMapping,
     Optional,
     Sequence,
+    Tuple,
     Type,
     TypeVar,
     Union,
@@ -30,7 +31,7 @@
 from . import hdrs
 from .helpers import AppKey
 from .log import web_logger
-from .typedefs import Middleware
+from .typedefs import Handler, Middleware
 from .web_exceptions import NotAppKeyWarning
 from .web_middlewares import _fix_request_current_app
 from .web_request import Request
@@ -79,6 +80,7 @@ class Application(MutableMapping[Union[str, AppKey[Any]], Any]):
         "_handler_args",
         "_middlewares",
         "_middlewares_handlers",
+        "_middlewares_cache",
         "_run_middlewares",
         "_state",
         "_frozen",
@@ -117,6 +119,7 @@ def __init__(
         self._middlewares_handlers: _MiddlewaresHandlers = tuple()
         # initialized on freezing
         self._run_middlewares: Optional[bool] = None
+        self._middlewares_cache: Dict[Tuple[Handler, Tuple[int, ...]], Handler] = {}
 
         self._state: Dict[Union[AppKey[Any], str], object] = {}
         self._frozen = False
@@ -380,15 +383,31 @@ async def _handle(self, request: Request) -> StreamResponse:
             handler = match_info.handler
 
             if self._run_middlewares:
-                for app in match_info.apps[::-1]:
-                    assert app.pre_frozen, "middleware handlers are not ready"
-                    for m in app._middlewares_handlers:
-                        handler = update_wrapper(partial(m, handler=handler), handler)
+                handler = self._apply_middlewares(handler, match_info.apps[::-1])
 
             resp = await handler(request)
 
         return resp
 
+    def _apply_middlewares(
+        self,
+        handler: Handler,
+        apps: Tuple["Application", ...],
+    ) -> Callable[[Request], Awaitable[StreamResponse]]:
+        """Apply middlewares to handler."""
+        cache_key = (handler, tuple(id(app) for app in apps))
+
+        if cache_key in self._middlewares_cache:
+            return self._middlewares_cache[cache_key]
+
+        for app in apps:
+            assert app.pre_frozen, "middleware handlers are not ready"
+            for m in app._middlewares_handlers:
+                handler = update_wrapper(partial(m, handler=handler), handler)
+
+        self._middlewares_cache[cache_key] = handler
+        return handler
+
     def __call__(self) -> "Application":
         """gunicorn compatibility"""
         return self

tests/test_web_middleware.py

@@ -23,10 +23,13 @@ async def middleware(request, handler: Handler):
     app.middlewares.append(middleware)
     app.router.add_route("GET", "/", handler)
     client = await aiohttp_client(app)
-    resp = await client.get("/")
-    assert 201 == resp.status
-    txt = await resp.text()
-    assert "OK[MIDDLEWARE]" == txt
+
+    # Call twice to verify cache works
+    for _ in range(2):
+        resp = await client.get("/")
+        assert 201 == resp.status
+        txt = await resp.text()
+        assert "OK[MIDDLEWARE]" == txt
 
 
 async def test_middleware_handles_exception(loop: Any, aiohttp_client: Any) -> None:
@@ -42,10 +45,13 @@ async def middleware(request, handler: Handler):
     app.middlewares.append(middleware)
     app.router.add_route("GET", "/", handler)
     client = await aiohttp_client(app)
-    resp = await client.get("/")
-    assert 501 == resp.status
-    txt = await resp.text()
-    assert "Error text[MIDDLEWARE]" == txt
+
+    # Call twice to verify cache works
+    for _ in range(2):
+        resp = await client.get("/")
+        assert 501 == resp.status
+        txt = await resp.text()
+        assert "Error text[MIDDLEWARE]" == txt
 
 
 async def test_middleware_chain(loop: Any, aiohttp_client: Any) -> None: