update middleware

Author: jarry

domain-driven-design/python-web/src/app.py

@@ -14,14 +14,15 @@
 from src.interfaces.controllers.order_controller import OrderController
 from src.application.services.order_service import OrderService
 from src.infrastructure.repository.order_repository_impl import OrderRepositoryImpl as OrderRepository 
-from src.middleware.logging_middleware import logging_middleware
 from src.utils.logging import setup_logging
 from src.config.server_config import PORT, LOGGING
 
+log_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), LOGGING['file'])
 logging.basicConfig(
     level=logging.DEBUG,
     format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[logging.StreamHandler()]  # 确保日志输出到控制台
+    handlers=[logging.StreamHandler(), logging.FileHandler(log_file, encoding="utf-8")],
+    force=True  # 强制重新配置
 )
 
 #""" 以下修复端口占用问题
@@ -39,14 +40,21 @@ def is_port_in_use(port):
 order_service = OrderService(order_repository)
 order_controller = OrderController(order_service)
 
-# 初始化日志系统
-setup_logging(LOGGING['file'])
-
 # 初始化路由
-router = order_routes(order_controller, logging_middleware)
+router = order_routes(order_controller)
+
 
+# MainHandler类，启动HTTP server
+class MainHandler(http.server.BaseHTTPRequestHandler):
+
+    def log_message(self, format, *args):
+        logging.info("%s - - [%s] %s\n" %
+                     (self.client_address[0],
+                      self.log_date_time_string(),
+                      format % args))
+    # 初始化日志系统
+    setup_logging(log_file)
 
-class MainHandler(http.server.SimpleHTTPRequestHandler):
     def handle_request(self):
         if self.path == '/favicon.ico':
             self.send_response(204)
@@ -80,18 +88,17 @@ def handle_request(self):
             return
 
         # 处理其他 API 路由
-        middleware, handler = router.match_route(method, path)
-        logging.debug(f"Route match result: {middleware}, {handler}")
+        handler = router.match_route(method, path)
+        logging.debug(f"Route match result: Handler: {handler}")
 
         if not handler:
             logging.warning(f"No matching route found for {method} {path}")
             self.send_error(404, "Not Found")
             return
 
         try:
-            if middleware:
-                middleware(self)  # 执行中间件
-            handler(self)  # 调用处理函数，传递 request 和 response
+            # 调用包装后的处理函数，将 self 同时作为 req 和 resp 传递
+            handler(self, self)
         except Exception as e:
             logging.error(f"Error handling request: {e}")
             self.send_error(500, "Internal Server Error")
@@ -108,6 +115,7 @@ def do_PUT(self):
     def do_DELETE(self):
         self.handle_request()
 
+
 def run_server():
     with socketserver.TCPServer(("", PORT), MainHandler) as httpd:
         logging.info(f"Starting server on :{PORT} successfully.")

domain-driven-design/python-web/src/interfaces/routes/order_routes.py

@@ -1,22 +1,23 @@
 # -*- coding: utf-8 -*-
 import logging
 from src.interfaces.routes.router import create_router
+from src.middleware.logging_middleware import logging_middleware
+from src.middleware.auth_middleware import auth_middleware
 
 api_prefix = "/api"
 
 # 订单路由设置函数
-def order_routes(order_controller, logging_middleware):
+def order_routes(order_controller):
     if order_controller is None:
         raise ValueError("order_controller cannot be None")
-    if logging_middleware is None:
-        raise ValueError("logging_middleware cannot be None")
 
     router = create_router()
 
     # 注册路由
     router.post(
         api_prefix + '/orders',
         logging_middleware,
+        auth_middleware,
         order_controller.create_order
     )
     logging.debug("Registered route: POST /api/orders")
@@ -38,13 +39,15 @@ def order_routes(order_controller, logging_middleware):
     router.put(
         api_prefix + '/orders/:id',
         logging_middleware,
+        auth_middleware,
         order_controller.update_order
     )
     logging.debug("Registered route: PUT /api/orders/:id")
 
     router.delete(
         api_prefix + '/orders/:id',
         logging_middleware,
+        auth_middleware,
         order_controller.delete_order
     )
     logging.debug("Registered route: DELETE /api/orders/:id")

domain-driven-design/python-web/src/interfaces/routes/router.py

@@ -1,9 +1,8 @@
 # -*- coding: utf-8 -*-
-# 自定义路由类
 import logging
 import re
 
-
+# 自定义路由工具
 class Router:
     def __init__(self):
         self.routes = {
@@ -13,41 +12,57 @@ def __init__(self):
             'DELETE': []
         }
 
-    def add_route(self, method, path, middleware, handler):
-        self.routes[method].append((path, middleware, handler))
+    def add_route(self, method, path, *handlers):
+        if not handlers:
+            raise ValueError("必须至少提供一个处理函数")
+        # 最后一个参数是真正的处理函数
+        handler = handlers[-1]
+        # 前面的参数是中间件
+        middlewares = handlers[:-1]
+        # 按顺序应用中间件（先提供的中间件最先执行）
+        for middleware in reversed(middlewares):
+            handler = middleware(handler)
+        self.routes[method].append((path, handler))
 
-    def get(self, path, middleware, handler):
-        self.add_route('GET', path, middleware, handler)
+    def get(self, path, *handlers):
+        self.add_route('GET', path, *handlers)
 
-    def post(self, path, middleware, handler):
-        self.add_route('POST', path, middleware, handler)
+    def post(self, path, *handlers):
+        self.add_route('POST', path, *handlers)
 
-    def put(self, path, middleware, handler):
-        self.add_route('PUT', path, middleware, handler)
+    def put(self, path, *handlers):
+        self.add_route('PUT', path, *handlers)
 
-    def delete(self, path, middleware, handler):
-        self.add_route('DELETE', path, middleware, handler)
+    def delete(self, path, *handlers):
+        self.add_route('DELETE', path, *handlers)
 
     def match_route(self, method, path):
         if method not in self.routes:
-            return None, None
+            return None
 
-        for route_path, middleware, handler in self.routes[method]:
+        for route_path, handler in self.routes[method]:
             if ':' in route_path:
-                # 将路径参数替换为正则表达式，并在前后加 `^` 和 `$`
+                # 将路径参数替换为正则表达式，并在前后加上 ^ 和 $
                 pattern = '^' + re.sub(r':(\w+)', r'(?P<\1>[^/]+)', route_path) + '$'
                 try:
                     match = re.fullmatch(pattern, path)
                     if match:
                         # 提取参数并存储到 request.params
                         params = match.groupdict()
-                        return middleware, lambda req: setattr(req, 'params', params) or handler(req, req)
+                        # 包装处理函数，先将参数写入 request 对象
+                        def wrapped_handler(req, resp, h=handler, params=params):
+                            setattr(req, 'params', params)
+                            return h(req, resp)  # 传入 request 和 response
+                        return wrapped_handler
                 except re.error as e:
                     logging.error(f"正则表达式匹配出错: {e}")
             elif route_path == path:
-                return middleware, lambda req: handler(req, req)
+                # 对于无参数的静态路由，同样包装后调用 h(req, resp)
+                def wrapped_handler(req, resp, h=handler):
+                    return h(req, resp)
+                return wrapped_handler
 
-        return None, None
+        return None
 
 # 创建路由实例的函数
 def create_router():

domain-driven-design/python-web/src/middleware/auth_middleware.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+import time
+import logging
+from utils.logging import log_request
+def auth_middleware(handler):
+    def wrapper(request, response):
+        start_time = time.time()
+        log_message = f"Auth Checking: {request.command} {request.path}"
+        logging.info("auth_middleware:", log_message)
+        log_request(request, start_time)
+        # 模拟授权检查，这里总是通过
+        authorized = True
+        if not authorized:
+            response.send_response(401)
+            response.send_header("Content-Type", "text/plain")
+            response.end_headers()
+            response.wfile.write(b"Unauthorized")
+            return
+        return handler(request, response)
+    return wrapper

domain-driven-design/python-web/src/middleware/logging_middleware.py

@@ -1,34 +1,16 @@
 # -*- coding: utf-8 -*-
 import time
 from utils.logging import log_request
+import logging
 
-def logging_middleware(request, response=None, next_handler=None):
-    """
-    当只传入一个参数时（装饰器调用模式），
-    将 request 视为处理函数 handler，返回包装后的函数；
-    
-    当传入三个参数时（中间件链调用模式），
-    分别认为参数为 request, response, next_handler，
-    并在调用 next_handler(request) 前后记录日志。
-    """
-    # 装饰器模式：只传入一个参数，request 实际上是 handler
-    if response is None and next_handler is None:
-        handler = request
-        def middleware(req):
-            start_time = time.time()
-            res = handler(req)
-            duration = (time.time() - start_time) * 1000
-            log_message = f"REQUEST: {req.method} {req.path} took {duration:.2f}ms\n"
-            print("logging_middleware:", log_message)
-            log_request(log_message, start_time)
-            return res
-        return middleware
+import functools
 
-    # 中间件链模式：传入 request, response, next_handler
-    start_time = time.time()
-    result = next_handler(request)
-    duration = (time.time() - start_time) * 1000
-    log_message = f"REQUEST: {request.method} {request.path} took {duration:.2f}ms\n"
-    print("logging_middleware:", log_message)
-    log_request(log_message, start_time)
-    return result
+def logging_middleware(handler):
+    @functools.wraps(handler)
+    def wrapper(self, *args, **kwargs):
+        start_time = time.time()
+        log_message = f"REQUEST recoder: {self.command} {self.path}"
+        logging.info(f"logging_middleware: {log_message}")
+        log_request(self, start_time)
+        return handler(self, *args, **kwargs)
+    return wrapper

domain-driven-design/python-web/src/utils/logging.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 import os
 import time
+from src.config.server_config import LOGGING
 
 # 全局变量，用于存储日志文件路径
 log_file_path = None
@@ -33,9 +34,12 @@ def log_error(message):
 
 # 将日志消息写入文件
 def log_to_file(message):
-    global log_file_path
-    if log_file_path:
-        with open(log_file_path, 'a', encoding='utf-8') as log_file:
-            log_file.write(message)
-    else:
-        print("日志文件路径未初始化，无法写入日志。")
+    print('log_to_file:', message)
+    # global log_file_path
+    # log_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), LOGGING['file'])
+    # print('log_to_file:', log_file_path)
+    # if log_file_path:
+    #     with open(log_file_path, 'a', encoding='utf-8') as log_file:
+    #         log_file.write(message)
+    # else:
+    #     print("日志文件路径未初始化，无法写入日志。")