refactor: 重构Redis依赖注入以提升代码可维护性

将Redis依赖从Request对象中解耦，改为通过Depends注入，提高代码的可测试性和可维护性

backend/app/api/v1/controllers/monitor/cache_controller.py

@@ -1,9 +1,10 @@
 # -*- coding: utf-8 -*-
 
-from fastapi import APIRouter, Depends, Request
+from fastapi import APIRouter, Depends
 from fastapi.responses import JSONResponse
+from aioredis import Redis
 
-from app.core.dependencies import AuthPermission
+from app.core.dependencies import AuthPermission, redis_getter
 from app.api.v1.services.monitor.cache_service import CacheService
 from app.core.logger import logger
 from app.common.response import SuccessResponse
@@ -20,9 +21,11 @@ router = APIRouter(route_class=OperationLogRoute)
     summary="获取缓存监控信息",
     description="获取缓存监控信息"
 )
-async def get_monitor_cache_info_controller(request: Request) -> JSONResponse:
+async def get_monitor_cache_info_controller(
+    redis: Redis = Depends(redis_getter)
+) -> JSONResponse:
     """获取缓存监控统计信息"""
-    result = await CacheService.get_cache_monitor_statistical_info_service(request)
+    result = await CacheService.get_cache_monitor_statistical_info_service(redis=redis)
     logger.info('获取缓存监控信息成功')
     return SuccessResponse(data=result, msg='获取缓存监控信息成功')
 
@@ -46,9 +49,12 @@ async def get_monitor_cache_name_controller() -> JSONResponse:
     summary="获取缓存键名列表",
     description="获取缓存键名列表"
 )
-async def get_monitor_cache_key_controller(request: Request, cache_name: str) -> JSONResponse:
+async def get_monitor_cache_key_controller(
+    cache_name: str,
+    redis: Redis = Depends(redis_getter)
+    ) -> JSONResponse:
     """获取指定缓存名称下的键名列表"""
-    result = await CacheService.get_cache_monitor_cache_key_service(request, cache_name)
+    result = await CacheService.get_cache_monitor_cache_key_service(redis=redis, cache_name=cache_name)
     logger.info(f'获取缓存{cache_name}的键名列表成功')
     return SuccessResponse(data=result, msg=f'获取缓存{cache_name}的键名列表成功')
 
@@ -59,9 +65,13 @@ async def get_monitor_cache_key_controller(request: Request, cache_name: str) ->
     summary="获取缓存值",
     description="获取缓存值"
 )
-async def get_monitor_cache_value_controller(request: Request, cache_name: str, cache_key: str) -> JSONResponse:
+async def get_monitor_cache_value_controller(
+    cache_name: str, 
+    cache_key: str,
+    redis: Redis = Depends(redis_getter)
+)-> JSONResponse:
     """获取指定缓存键的值"""
-    result = await CacheService.get_cache_monitor_cache_value_service(request, cache_name, cache_key)
+    result = await CacheService.get_cache_monitor_cache_value_service(redis=redis, cache_name=cache_name, cache_key=cache_key)
     logger.info(f'获取缓存{cache_name}:{cache_key}的值成功')
     return SuccessResponse(data=result, msg=f'获取缓存{cache_name}:{cache_key}的值成功')
 
@@ -72,9 +82,12 @@ async def get_monitor_cache_value_controller(request: Request, cache_name: str,
     summary="清除指定缓存名称的所有缓存",
     description="清除指定缓存名称的所有缓存"
 )
-async def clear_monitor_cache_name_controller(request: Request, cache_name: str) -> JSONResponse:
+async def clear_monitor_cache_name_controller(
+    cache_name: str,
+    redis: Redis = Depends(redis_getter)
+) -> JSONResponse:
     """清除指定缓存名称下的所有缓存"""
-    result = await CacheService.clear_cache_monitor_cache_name_service(request, cache_name)
+    result = await CacheService.clear_cache_monitor_cache_name_service(redis=redis, cache_name=cache_name)
     if not result:
         raise CustomException(message='清除缓存失败', data=result)
     logger.info(f'清除缓存{cache_name}成功')
@@ -87,9 +100,12 @@ async def clear_monitor_cache_name_controller(request: Request, cache_name: str)
     summary="清除指定缓存键",
     description="清除指定缓存键"
 )
-async def clear_monitor_cache_key_controller(request: Request, cache_key: str) -> JSONResponse:
+async def clear_monitor_cache_key_controller(
+    cache_key: str,
+    redis: Redis = Depends(redis_getter)
+) -> JSONResponse:
     """清除指定缓存键"""
-    result = await CacheService.clear_cache_monitor_cache_key_service(request, cache_key)
+    result = await CacheService.clear_cache_monitor_cache_key_service(redis=redis, cache_key=cache_key)
     if not result:
         raise CustomException(message='清除缓存失败', data=result)
     logger.info(f'清除缓存键{cache_key}成功')
@@ -102,9 +118,11 @@ async def clear_monitor_cache_key_controller(request: Request, cache_key: str) -
     summary="清除所有缓存",
     description="清除所有缓存"
 )
-async def clear_monitor_cache_all_controller(request: Request) -> JSONResponse:
+async def clear_monitor_cache_all_controller(
+    redis: Redis = Depends(redis_getter)
+) -> JSONResponse:
     """清除所有缓存"""
-    result = await CacheService.clear_cache_monitor_all_service(request)
+    result = await CacheService.clear_cache_monitor_all_service(redis=redis)
     if not result:
         raise CustomException(message='清除缓存失败', data=result)
     logger.info('清除所有缓存成功')

backend/app/api/v1/controllers/monitor/online_controller.py

@@ -1,9 +1,10 @@
 # -*- coding: utf-8 -*-
 
-from fastapi import APIRouter, Body, Depends, Request
+from fastapi import APIRouter, Body, Depends
 from fastapi.responses import JSONResponse
+from aioredis import Redis
 
-from app.core.dependencies import AuthPermission
+from app.core.dependencies import AuthPermission, redis_getter
 from app.core.logger import logger
 from app.common.request import PaginationService
 from app.common.response import SuccessResponse,ErrorResponse
@@ -23,12 +24,12 @@ router = APIRouter(route_class=OperationLogRoute)
     description="获取在线用户列表"
 )
 async def get_online_list_controller(
-    request: Request, 
+    redis: Redis = Depends(redis_getter), 
     paging_query: PaginationQueryParams = Depends(),
     search: OnlineQueryParams = Depends()
 )->JSONResponse:
     # 获取全量数据
-    result_dict_list = await OnlineService.get_online_list_service(request=request, search=search)
+    result_dict_list = await OnlineService.get_online_list_service(redis=redis, search=search)
     result_dict = await PaginationService.get_page_obj(data_list= result_dict_list, page_no= paging_query.page_no, page_size = paging_query.page_size)
     logger.info('获取成功')
 
@@ -42,10 +43,10 @@ async def get_online_list_controller(
     description="强制下线"
 )
 async def delete__online_controller(
-    request: Request, 
+    redis: Redis = Depends(redis_getter),
     username: str = Body(..., description="用户"),
 )->JSONResponse:
-    delete_online_result = await OnlineService.delete_online_service(request=request, username=username)
+    delete_online_result = await OnlineService.delete_online_service(redis=redis, username=username)
     if delete_online_result:
         logger.info("强制下线成功")
         return SuccessResponse(msg="强制下线成功")

backend/app/api/v1/controllers/system/auth_controller.py

@@ -5,6 +5,7 @@ from typing import Union, Dict
 from fastapi import APIRouter, Depends, Request, BackgroundTasks, WebSocket
 from fastapi.responses import JSONResponse, StreamingResponse
 from sqlalchemy.ext.asyncio import AsyncSession
+from aioredis import Redis
 
 from app.config.setting import settings
 from app.common.response import ErrorResponse, SuccessResponse
@@ -20,7 +21,8 @@ from app.api.v1.schemas.system.auth_schema import (
 )
 from app.core.dependencies import (
     db_getter,
-    get_current_user
+    get_current_user,
+    redis_getter
 )
 from app.core.router_class import OperationLogRoute
 from app.core.security import CustomOAuth2PasswordRequestForm
@@ -33,11 +35,12 @@ router = APIRouter(route_class=OperationLogRoute)
 @router.post("/login", summary="登录", description="登录", response_model=JWTOutSchema)
 async def login_for_access_token_controller(
     request: Request,
+    redis: Redis = Depends(redis_getter), 
     login_form: CustomOAuth2PasswordRequestForm = Depends(),
     db: AsyncSession = Depends(db_getter),
 ) -> Union[JSONResponse, Dict]:
-    user = await LoginService.authenticate_user_service(request=request, login_form=login_form, db=db)
-    login_token = await LoginService.create_token_service(request=request, username=user.username)
+    user = await LoginService.authenticate_user_service(request=request, redis=redis, login_form=login_form, db=db)
+    login_token = await LoginService.create_token_service(redis=redis, username=user.username)
     logger.info(f"用户{user.username}登录成功")
 
     # 如果是文档请求，则不记录日志:http://localhost:8000/api/v1/docs
@@ -48,11 +51,11 @@ async def login_for_access_token_controller(
 
 @router.post("/token/refresh", summary="刷新token", description="刷新token", response_model=JWTOutSchema, dependencies=[Depends(get_current_user)])
 async def get_new_token_controller(
-    request: Request,
-    payload: RefreshTokenPayloadSchema
+    payload: RefreshTokenPayloadSchema,
+    redis: Redis = Depends(redis_getter) 
 ) -> JSONResponse:
     # 解析当前的访问Token以获取用户名
-    new_token = await LoginService.refresh_token_service(request=request, refresh_token=payload)
+    new_token = await LoginService.refresh_token_service(redis=redis, refresh_token=payload)
     token_dict = new_token.model_dump()
     logger.info(f"刷新token成功: {token_dict}")
     return SuccessResponse(data=token_dict, msg="刷新成功")
@@ -60,20 +63,20 @@ async def get_new_token_controller(
 
 @router.post("/captcha/get", summary="获取验证码", description="获取登录验证码", response_model=CaptchaOutSchema)
 async def get_captcha_for_login_controller(
-    request: Request
+    redis: Redis = Depends(redis_getter)
 ) -> JSONResponse:
     # 获取验证码
-    captcha = await CaptchaService.get_captcha_service(request=request)
+    captcha = await CaptchaService.get_captcha_service(redis=redis)
     logger.info(f"获取验证码成功")
     return SuccessResponse(data=captcha, msg="获取验证码成功")
 
 
 @router.post('/logout', summary="退出登录", description="退出登录", dependencies=[Depends(get_current_user)])
 async def logout_controller(
-    request: Request,
-    payload: LogoutPayloadSchema
+    payload: LogoutPayloadSchema,
+    redis: Redis = Depends(redis_getter)
 ) -> JSONResponse:
-    if await LoginService.logout_services_service(request=request, token=payload):
+    if await LoginService.logout_services_service(redis=redis, token=payload):
         logger.info('退出成功')
         return SuccessResponse(msg='退出成功')
     return ErrorResponse(msg='退出失败')

backend/app/api/v1/controllers/system/config_controller.py

@@ -2,9 +2,10 @@
 
 from fastapi import APIRouter, Depends, Request, UploadFile
 from fastapi.responses import JSONResponse
+from aioredis import Redis
 
 from app.common.response import SuccessResponse
-from app.core.dependencies import AuthPermission
+from app.core.dependencies import AuthPermission, redis_getter
 from app.core.router_class import OperationLogRoute
 from app.core.logger import logger
 from app.api.v1.schemas.system.auth_schema import AuthSchema
@@ -26,11 +27,11 @@ async def get_obj_list_controller(
 
 @router.put("/update", summary="修改配置", description="修改配置")
 async def update_objs_controller(
-    request: Request,
     data: ConfigUpdateSchema,
+    redis: Redis = Depends(redis_getter), 
     auth: AuthSchema = Depends(AuthPermission(permissions=["system:config:update"]))
 ) -> JSONResponse:
-    result_dict = await ConfigService.update_service(auth=auth, request=request, data=data)
+    result_dict = await ConfigService.update_service(auth=auth, redis=redis, data=data)
     logger.info(f"{auth.user.name} 更新配置成功 {result_dict}")
     return SuccessResponse(data=result_dict, msg="更新配置成功")
 
@@ -40,15 +41,15 @@ async def upload_file_controller(
     file: UploadFile,
     request: Request
 ) -> JSONResponse:
-    result_str = await ConfigService.upload_service(request=request, file=file)
+    result_str = await ConfigService.upload_service(base_url=str(request.base_url), file=file)
     logger.info(f"上传文件: {result_str}")
     return SuccessResponse(data=result_str, msg='上传文件成功')
 
 
 @router.get("/init", summary="获取初始化配置", description="获取初始化配置")
 async def get_init_config_controller(
-    request: Request
+    redis: Redis = Depends(redis_getter)
 ) -> JSONResponse:
-    result_dict = await ConfigService.get_init_config_service(request=request)
+    result_dict = await ConfigService.get_init_config_service(redis=redis)
     logger.info(f"获取初始化配置成功 {result_dict}")
     return SuccessResponse(data=result_dict, msg="获取初始化配置成功")

backend/app/api/v1/controllers/system/dict_controller.py

@@ -1,13 +1,13 @@
 # -*- coding: utf-8 -*-
 
 import json
-from fastapi import APIRouter, Depends, Query, Request
+from fastapi import APIRouter, Depends, Query
 from fastapi.responses import JSONResponse, StreamingResponse
 from aioredis import Redis
 
 from app.common.response import StreamResponse, SuccessResponse
 from app.core.base_params import PaginationQueryParams
-from app.core.dependencies import AuthPermission
+from app.core.dependencies import AuthPermission, redis_getter
 from app.core.router_class import OperationLogRoute
 from app.core.logger import logger
 from app.common.request import PaginationService
@@ -55,31 +55,31 @@ async def get_type_list_controller(
 
 @router.post("/type/create", summary="创建字典类型", description="创建字典类型")
 async def create_type_controller(
-    request: Request,
     data: DictTypeCreateSchema,
+    redis: Redis = Depends(redis_getter),
     auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:create"]))
 ) -> JSONResponse:
-    result_dict = await DictTypeService.create_obj_service(auth=auth, request=request, data=data)
+    result_dict = await DictTypeService.create_obj_service(auth=auth, redis=redis, data=data)
     logger.info(f"{auth.user.name} 创建字典类型成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="创建字典类型成功")
 
 @router.put("/type/update", summary="修改字典类型", description="修改字典类型")
 async def update_type_controller(
-    request: Request,
     data: DictTypeUpdateSchema,
+    redis: Redis = Depends(redis_getter),
     auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:update"]))
 ) -> JSONResponse:
-    result_dict = await DictTypeService.update_obj_service(auth=auth, request=request, data=data)
+    result_dict = await DictTypeService.update_obj_service(auth=auth, redis=redis, data=data)
     logger.info(f"{auth.user.name} 修改字典类型成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="修改字典类型成功")
 
 @router.delete("/type/delete", summary="删除字典类型", description="删除字典类型")
 async def delete_type_controller(
-    request: Request,
+    redis: Redis = Depends(redis_getter),
     id: int = Query(..., description="字典类型ID"),
     auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:delete"]))
 ) -> JSONResponse:
-    await DictTypeService.delete_obj_service(auth=auth, request=request, id=id)
+    await DictTypeService.delete_obj_service(auth=auth, redis=redis, id=id)
     logger.info(f"{auth.user.name} 删除字典类型成功: {id}")
     return SuccessResponse(msg="删除字典类型成功")
 
@@ -123,31 +123,31 @@ async def get_data_list_controller(
 
 @router.post("/data/create", summary="创建字典数据", description="创建字典数据")
 async def create_data_controller(
-    request: Request,
     data: DictDataCreateSchema,
+    redis: Redis = Depends(redis_getter),
     auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_data:create"]))
 ) -> JSONResponse:
-    result_dict = await DictDataService.create_obj_service(auth=auth, request=request, data=data)
+    result_dict = await DictDataService.create_obj_service(auth=auth, redis=redis, data=data)
     logger.info(f"{auth.user.name} 创建字典数据成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="创建字典数据成功")
 
 @router.put("/data/update", summary="修改字典数据", description="修改字典数据")
 async def update_data_controller(
-    request: Request,
     data: DictDataUpdateSchema,
+    redis: Redis = Depends(redis_getter),
     auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_data:update"]))
 ) -> JSONResponse:
-    result_dict = await DictDataService.update_obj_service(auth=auth, request=request, data=data)
+    result_dict = await DictDataService.update_obj_service(auth=auth, redis=redis, data=data)
     logger.info(f"{auth.user.name} 修改字典数据成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="修改字典数据成功")
 
 @router.delete("/data/delete", summary="删除字典数据", description="删除字典数据")
 async def delete_data_controller(
-    request: Request,
+    redis: Redis = Depends(redis_getter),
     id: int = Query(..., description="字典数据ID"),
     auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_data:delete"]))
 ) -> JSONResponse:
-    await DictDataService.delete_obj_service(auth=auth, request=request, id=id)
+    await DictDataService.delete_obj_service(auth=auth, redis=redis, id=id)
     logger.info(f"{auth.user.name} 删除字典数据成功: {id}")
     return SuccessResponse(msg="删除字典数据成功")
 
@@ -171,20 +171,20 @@ async def export_data_list_controller(
 
 @router.get('/type/data',  summary="获取字典类型", description="获取字典类型", dependencies=[Depends(AuthPermission(permissions=["system:dict_data:query"]))])
 async def query_system_dict_type_options_controller(
-    request: Request
+    redis: Redis = Depends(redis_getter)
 ):
-    result = await DictDataService.get_init_dict_service(redis=request.app.state.redis)
+    result = await DictDataService.get_init_dict_service(redis=redis)
     logger.info(f"获取初始化字典数据成功 {result}")
     return SuccessResponse(data=result, msg="获取初始字典数据成功")
 
 @router.get('/data/type/{dict_type}', summary="根据字典类型获取数据", description="根据字典类型获取数据", dependencies=[Depends(AuthPermission(permissions=["system:dict_data:query"]))])
 async def query_system_dict_type_data_controller(
-    request: Request, 
-    dict_type: str
+    dict_type: str,
+    redis: Redis = Depends(redis_getter)
 ):
     # 获取全量数据
     dict_data_query_result = await DictDataService.query_init_dict_service(
-        redis=request.app.state.redis, dict_type=dict_type
+        redis=redis, dict_type=dict_type
     )
     logger.info(f"获取字典数据：{dict_data_query_result}")
 

backend/app/api/v1/controllers/system/job_controller.py

@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 
-from unittest import result
 from fastapi import APIRouter, Depends, Query
 from fastapi.responses import JSONResponse, StreamingResponse
 

backend/app/api/v1/controllers/system/user_controller.py

@@ -42,7 +42,7 @@ async def user_avatar_upload_controller(
     file: UploadFile, 
     request: Request
 ) -> JSONResponse:
-    result_str = await UserService.upload_avatar_service(request=request, file=file)
+    result_str = await UserService.upload_avatar_service(base_url=str(request.base_url), file=file)
     logger.info(f"上传头像成功: {result_str}")
     return SuccessResponse(data=result_str, msg='上传头像成功')