refactor: 重构项目结构，将Result类及相关工具类移动到dto和util包

将Result类从common包移动到dto包，ResultUtils类从common包移动到util包
调整所有相关文件的import语句以匹配新的包结构
新增CorsConfig配置类处理跨域请求
优化AuthController的登录接口返回统一响应格式

src/main/java/com/qf/backend/config/CorsConfig.java

@@ -0,0 +1,50 @@
+package com.qf.backend.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.filter.CorsFilter;
+import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
+
+@Configuration
+public class CorsConfig {
+    /**
+     * 跨域配置
+     */
+    @Bean
+    public CorsFilter corsFilter(){
+        // 创建跨域配置对象
+        CorsConfiguration configuration = new CorsConfiguration();
+        // 允许的来源使用通配符，允许所有来源
+        configuration.addAllowedOriginPattern("*");
+        // 允许携带cookie
+        configuration.setAllowCredentials(true);
+       
+        // 明确列出允许的HTTP方法，比使用通配符更安全
+        configuration.addAllowedMethod("GET");
+        configuration.addAllowedMethod("POST");
+        configuration.addAllowedMethod("PUT");
+        configuration.addAllowedMethod("DELETE");
+        configuration.addAllowedMethod("OPTIONS");
+        configuration.addAllowedMethod("PATCH");
+        // 允许所有请求头（新增）
+        configuration.addAllowedHeader("*");
+        
+        // 明确暴露的响应头，对于JWT认证很重要
+        configuration.addExposedHeader("Authorization");
+        configuration.addExposedHeader("Content-Type");
+        configuration.addExposedHeader("X-Requested-With");
+        configuration.addExposedHeader("Accept");
+        configuration.addExposedHeader("Access-Control-Allow-Origin");
+        // 设置最大缓存时间为1小时，减少预检请求次数
+        configuration.setMaxAge(3600L);
+        // 创建基于URL的CORS配置源
+        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+        
+        // 为所有路径应用CORS配置
+        source.registerCorsConfiguration("/**", configuration);
+        
+        // 返回配置好的CORS过滤器
+        return new CorsFilter(source);
+    }
+}

src/main/java/com/qf/backend/controller/AuthController.java

@@ -14,7 +14,10 @@ import org.springframework.web.bind.annotation.RestController;
 
 import com.qf.backend.dto.LoginRequest;
 import com.qf.backend.dto.LoginResponse;
+import com.qf.backend.dto.Result;
+import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.util.JwtUtils;
+import com.qf.backend.util.ResultUtils;
 
 /**
  * 认证控制器，用于处理用户登录请求
@@ -51,7 +54,7 @@ public class AuthController {
      * 6. 返回包含JWT令牌的响应
      */
     @PostMapping("/login")
-    public ResponseEntity<LoginResponse> login(@RequestBody LoginRequest loginRequest) {
+    public  Result<ResponseEntity<LoginResponse>> login(@RequestBody LoginRequest loginRequest) {
         try {
             // 1. 创建认证令牌，将用户名和密码封装到UsernamePasswordAuthenticationToken中
             // 这里的令牌是未认证状态的，因为还没有验证密码是否正确
@@ -79,11 +82,11 @@ public class AuthController {
             loginResponse.setTokenType(jwtUtils.getTokenPrefix());
             // 5. 返回包含JWT令牌的响应
             // 响应格式为：{"token": "xxx", "tokenType": "Bearer"}
-            return ResponseEntity.ok(loginResponse);
+            return ResultUtils.success(ResponseEntity.ok(loginResponse));
         } catch (BadCredentialsException e) {
             // 认证失败，通常是用户名不存在或密码错误
             // 返回401 Unauthorized响应
-            return ResponseEntity.status(401).build();
+            return ResultUtils.fail(ErrorCode.PASSWORD_ERROR, "用户名或密码错误");
         }
     }
 }

src/main/java/com/qf/backend/controller/OrderItemsController.java

@@ -0,0 +1,147 @@
+package com.qf.backend.controller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import com.qf.backend.dto.Result;
+import com.qf.backend.entity.OrderItems;
+import com.qf.backend.service.OrderItemsService;
+import java.util.List;
+
+/**
+ * 订单项控制器
+ * 处理订单项相关的HTTP请求
+ * 遵循RESTful API设计规范
+ */
+@RequestMapping("/api/order-items")
+@RestController
+public class OrderItemsController {
+    private static final Logger logger = LoggerFactory.getLogger(OrderItemsController.class);
+    
+    @Autowired
+    private OrderItemsService orderItemsService;
+    
+    /**
+     * 根据订单ID查询订单项
+     * @param orderId 订单ID
+     * @return 订单项列表
+     */
+    @GetMapping("/order/{orderId}")
+    public Result<List<OrderItems>> getOrderItemsByOrderId(@PathVariable Long orderId) {
+        logger.info("根据订单ID查询订单项，订单ID：{}", orderId);
+        return orderItemsService.getOrderItemsByOrderId(orderId);
+    }
+    
+    /**
+     * 根据商品ID查询订单项
+     * @param productId 商品ID
+     * @return 订单项列表
+     */
+    @GetMapping("/product/{productId}")
+    public Result<List<OrderItems>> getOrderItemsByProductId(@PathVariable Long productId) {
+        logger.info("根据商品ID查询订单项，商品ID：{}", productId);
+        return orderItemsService.getOrderItemsByProductId(productId);
+    }
+    
+    /**
+     * 创建订单项
+     * @param orderItems 订单项信息
+     * @return 是否成功
+     */
+    @PostMapping("/create")
+    @PreAuthorize("hasRole('ROLE_ADMIN') or hasRole('ROLE_USER')")
+    public Result<Boolean> createOrderItem(@RequestBody OrderItems orderItems) {
+        logger.info("创建订单项，订单项信息：{}", orderItems);
+        return orderItemsService.createOrderItem(orderItems);
+    }
+    
+    /**
+     * 更新订单项信息
+     * @param orderItems 订单项信息
+     * @return 是否成功
+     */
+    @PutMapping("/update")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updateOrderItem(@RequestBody OrderItems orderItems) {
+        logger.info("更新订单项信息，订单项信息：{}", orderItems);
+        return orderItemsService.updateOrderItem(orderItems);
+    }
+    
+    /**
+     * 删除订单项
+     * @param id 订单项ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete/{id}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteOrderItem(@PathVariable Long id) {
+        logger.info("删除订单项，订单项ID：{}", id);
+        return orderItemsService.deleteOrderItem(id);
+    }
+    
+    /**
+     * 根据订单项ID查询订单项
+     * @param id 订单项ID
+     * @return 订单项信息
+     */
+    @GetMapping("/{id}")
+    public Result<OrderItems> getOrderItemById(@PathVariable Long id) {
+        logger.info("根据订单项ID查询订单项，订单项ID：{}", id);
+        return orderItemsService.getOrderItemById(id);
+    }
+    
+    /**
+     * 批量创建订单项
+     * @param orderItemsList 订单项列表
+     * @return 是否成功
+     */
+    @PostMapping("/batch-create")
+    @PreAuthorize("hasRole('ROLE_ADMIN') or hasRole('ROLE_USER')")
+    public Result<Boolean> batchCreateOrderItems(@RequestBody List<OrderItems> orderItemsList) {
+        logger.info("批量创建订单项，订单项数量：{}", orderItemsList.size());
+        return orderItemsService.batchCreateOrderItems(orderItemsList);
+    }
+    
+    /**
+     * 根据订单ID删除所有订单项
+     * @param orderId 订单ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete-by-order/{orderId}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteOrderItemsByOrderId(@PathVariable Long orderId) {
+        logger.info("根据订单ID删除所有订单项，订单ID：{}", orderId);
+        return orderItemsService.deleteOrderItemsByOrderId(orderId);
+    }
+    
+    /**
+     * 计算订单总金额
+     * @param orderId 订单ID
+     * @return 订单总金额
+     */
+    @GetMapping("/calculate-total/{orderId}")
+    public Result<Double> calculateOrderTotal(@PathVariable Long orderId) {
+        logger.info("计算订单总金额，订单ID：{}", orderId);
+        return orderItemsService.calculateOrderTotal(orderId);
+    }
+    
+    /**
+     * 根据SKU ID查询订单项
+     * @param skuId SKU ID
+     * @return 订单项列表
+     */
+    @GetMapping("/sku/{skuId}")
+    public Result<List<OrderItems>> getOrderItemsBySkuId(@PathVariable Long skuId) {
+        logger.info("根据SKU ID查询订单项，SKU ID：{}", skuId);
+        return orderItemsService.getOrderItemsBySkuId(skuId);
+    }
+}

src/main/java/com/qf/backend/controller/OrderStatusHistoryController.java

@@ -0,0 +1,137 @@
+package com.qf.backend.controller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import com.qf.backend.dto.Result;
+import com.qf.backend.entity.OrderStatusHistory;
+import com.qf.backend.service.OrderStatusHistoryService;
+import java.util.List;
+
+/**
+ * 订单状态历史控制器
+ * 处理订单状态历史相关的HTTP请求
+ * 遵循RESTful API设计规范
+ */
+@RequestMapping("/api/order-status-history")
+@RestController
+public class OrderStatusHistoryController {
+    private static final Logger logger = LoggerFactory.getLogger(OrderStatusHistoryController.class);
+    
+    @Autowired
+    private OrderStatusHistoryService orderStatusHistoryService;
+    
+    /**
+     * 根据订单ID查询状态历史
+     * @param orderId 订单ID
+     * @return 订单状态历史列表
+     */
+    @GetMapping("/order/{orderId}")
+    public Result<List<OrderStatusHistory>> getHistoryByOrderId(@PathVariable Long orderId) {
+        logger.info("根据订单ID查询状态历史，订单ID：{}", orderId);
+        return orderStatusHistoryService.getHistoryByOrderId(orderId);
+    }
+    
+    /**
+     * 创建订单状态历史记录
+     * @param orderStatusHistory 订单状态历史信息
+     * @return 是否成功
+     */
+    @PostMapping("/create")
+    @PreAuthorize("hasRole('ROLE_ADMIN') or hasRole('ROLE_USER')")
+    public Result<Boolean> createStatusHistory(@RequestBody OrderStatusHistory orderStatusHistory) {
+        logger.info("创建订单状态历史记录，订单状态历史信息：{}", orderStatusHistory);
+        return orderStatusHistoryService.createStatusHistory(orderStatusHistory);
+    }
+    
+    /**
+     * 更新订单状态历史信息
+     * @param orderStatusHistory 订单状态历史信息
+     * @return 是否成功
+     */
+    @PutMapping("/update")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updateStatusHistory(@RequestBody OrderStatusHistory orderStatusHistory) {
+        logger.info("更新订单状态历史信息，订单状态历史信息：{}", orderStatusHistory);
+        return orderStatusHistoryService.updateStatusHistory(orderStatusHistory);
+    }
+    
+    /**
+     * 删除订单状态历史记录
+     * @param id 记录ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete/{id}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteStatusHistory(@PathVariable Long id) {
+        logger.info("删除订单状态历史记录，记录ID：{}", id);
+        return orderStatusHistoryService.deleteStatusHistory(id);
+    }
+    
+    /**
+     * 根据记录ID查询订单状态历史
+     * @param id 记录ID
+     * @return 订单状态历史信息
+     */
+    @GetMapping("/{id}")
+    public Result<OrderStatusHistory> getStatusHistoryById(@PathVariable Long id) {
+        logger.info("根据记录ID查询订单状态历史，记录ID：{}", id);
+        return orderStatusHistoryService.getStatusHistoryById(id);
+    }
+    
+    /**
+     * 批量创建订单状态历史记录
+     * @param historyList 订单状态历史列表
+     * @return 是否成功
+     */
+    @PostMapping("/batch-create")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> batchCreateStatusHistory(@RequestBody List<OrderStatusHistory> historyList) {
+        logger.info("批量创建订单状态历史记录，记录数量：{}", historyList.size());
+        return orderStatusHistoryService.batchCreateStatusHistory(historyList);
+    }
+    
+    /**
+     * 根据订单ID和状态查询历史记录
+     * @param orderId 订单ID
+     * @param status 订单状态
+     * @return 订单状态历史列表
+     */
+    @GetMapping("/order/{orderId}/status/{status}")
+    public Result<List<OrderStatusHistory>> getHistoryByOrderIdAndStatus(@PathVariable Long orderId, @PathVariable Integer status) {
+        logger.info("根据订单ID和状态查询历史记录，订单ID：{}，状态：{}", orderId, status);
+        return orderStatusHistoryService.getHistoryByOrderIdAndStatus(orderId, status);
+    }
+    
+    /**
+     * 获取订单最新状态
+     * @param orderId 订单ID
+     * @return 最新订单状态历史信息
+     */
+    @GetMapping("/order/{orderId}/latest")
+    public Result<OrderStatusHistory> getLatestStatusHistory(@PathVariable Long orderId) {
+        logger.info("获取订单最新状态，订单ID：{}", orderId);
+        return orderStatusHistoryService.getLatestStatusHistory(orderId);
+    }
+    
+    /**
+     * 根据订单ID删除所有状态历史
+     * @param orderId 订单ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete-by-order/{orderId}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteHistoryByOrderId(@PathVariable Long orderId) {
+        logger.info("根据订单ID删除所有状态历史，订单ID：{}", orderId);
+        return orderStatusHistoryService.deleteHistoryByOrderId(orderId);
+    }
+}

src/main/java/com/qf/backend/controller/OrdersController.java

@@ -0,0 +1,149 @@
+package com.qf.backend.controller;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import com.qf.backend.dto.Result;
+import com.qf.backend.entity.Orders;
+import com.qf.backend.service.OrdersService;
+import java.util.List;
+
+/**
+ * 订单控制器
+ * 处理订单相关的HTTP请求
+ * 遵循RESTful API设计规范
+ */
+@RequestMapping("/api/orders")
+@RestController
+public class OrdersController {
+    private static final Logger logger = LoggerFactory.getLogger(OrdersController.class);
+    
+    @Autowired
+    private OrdersService ordersService;
+    
+    /**
+     * 根据订单号查询订单
+     * @param orderNumber 订单号
+     * @return 订单信息
+     */
+    @GetMapping("/number/{orderNumber}")
+    public Result<Orders> getOrderByNumber(@PathVariable String orderNumber) {
+        logger.info("根据订单号查询订单，订单号：{}", orderNumber);
+        return ordersService.getOrderByNumber(orderNumber);
+    }
+    
+    /**
+     * 根据用户ID查询订单列表
+     * @param userId 用户ID
+     * @return 订单列表
+     */
+    @GetMapping("/user/{userId}")
+    public Result<List<Orders>> getOrdersByUserId(@PathVariable Long userId) {
+        logger.info("根据用户ID查询订单列表，用户ID：{}", userId);
+        return ordersService.getOrdersByUserId(userId);
+    }
+    
+    /**
+     * 创建订单
+     * @param orders 订单信息
+     * @return 是否成功
+     */
+    @PostMapping("/create")
+    @PreAuthorize("hasRole('ROLE_ADMIN') or hasRole('ROLE_USER')")
+    public Result<Boolean> createOrder(@RequestBody Orders orders) {
+        logger.info("创建订单，订单信息：{}", orders);
+        return ordersService.createOrder(orders);
+    }
+    
+    /**
+     * 更新订单信息
+     * @param orders 订单信息
+     * @return 是否成功
+     */
+    @PutMapping("/update")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updateOrder(@RequestBody Orders orders) {
+        logger.info("更新订单信息，订单信息：{}", orders);
+        return ordersService.updateOrder(orders);
+    }
+    
+    /**
+     * 删除订单
+     * @param id 订单ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete/{id}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteOrder(@PathVariable Long id) {
+        logger.info("删除订单，订单ID：{}", id);
+        return ordersService.deleteOrder(id);
+    }
+    
+    /**
+     * 根据订单ID查询订单
+     * @param id 订单ID
+     * @return 订单信息
+     */
+    @GetMapping("/{id}")
+    public Result<Orders> getOrderById(@PathVariable Long id) {
+        logger.info("根据订单ID查询订单，订单ID：{}", id);
+        return ordersService.getOrderById(id);
+    }
+    
+    /**
+     * 分页查询订单
+     * @param page 当前页码
+     * @param size 每页数量
+     * @return 订单列表
+     */
+    @GetMapping("/page/{page}/{size}")
+    public Result<List<Orders>> listOrdersByPage(@PathVariable int page, @PathVariable int size) {
+        logger.info("分页查询订单，页码：{}，每页数量：{}", page, size);
+        return ordersService.listOrdersByPage(page, size);
+    }
+    
+    /**
+     * 根据店铺ID查询订单
+     * @param shopId 店铺ID
+     * @return 订单列表
+     */
+    @GetMapping("/shop/{shopId}")
+    public Result<List<Orders>> getOrdersByShopId(@PathVariable Long shopId) {
+        logger.info("根据店铺ID查询订单，店铺ID：{}", shopId);
+        return ordersService.getOrdersByShopId(shopId);
+    }
+    
+    /**
+     * 更新订单状态
+     * @param orderId 订单ID
+     * @param status 订单状态
+     * @return 是否成功
+     */
+    @PutMapping("/update-status/{orderId}/{status}")
+    @PreAuthorize("hasRole('ROLE_ADMIN') or hasRole('ROLE_USER')")
+    public Result<Boolean> updateOrderStatus(@PathVariable Long orderId, @PathVariable Integer status) {
+        logger.info("更新订单状态，订单ID：{}，状态：{}", orderId, status);
+        return ordersService.updateOrderStatus(orderId, status);
+    }
+    
+    /**
+     * 根据订单状态查询订单
+     * @param status 订单状态
+     * @return 订单列表
+     */
+    @GetMapping("/status/{status}")
+    public Result<List<Orders>> getOrdersByStatus(@PathVariable Integer status) {
+        logger.info("根据订单状态查询订单，状态：{}", status);
+        return ordersService.getOrdersByStatus(status);
+    }
+}

src/main/java/com/qf/backend/controller/PaymentsController.java

@@ -0,0 +1,158 @@
+package com.qf.backend.controller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import com.qf.backend.dto.Result;
+import com.qf.backend.entity.Payments;
+import com.qf.backend.service.PaymentsService;
+import java.util.List;
+
+/**
+ * 支付控制器
+ * 处理支付相关的HTTP请求
+ * 遵循RESTful API设计规范
+ */
+@RequestMapping("/api/payments")
+@RestController
+public class PaymentsController {
+    private static final Logger logger = LoggerFactory.getLogger(PaymentsController.class);
+    
+    @Autowired
+    private PaymentsService paymentsService;
+    
+    /**
+     * 根据订单ID查询支付记录
+     * @param orderId 订单ID
+     * @return 支付记录
+     */
+    @GetMapping("/order/{orderId}")
+    public Result<Payments> getPaymentByOrderId(@PathVariable Long orderId) {
+        logger.info("根据订单ID查询支付记录，订单ID：{}", orderId);
+        Payments payment = paymentsService.getPaymentByOrderId(orderId);
+        return Result.success(payment);
+    }
+    
+    /**
+     * 根据支付流水号查询支付记录
+     * @param transactionId 支付流水号
+     * @return 支付记录
+     */
+    @GetMapping("/transaction/{transactionId}")
+    public Result<Payments> getPaymentByTransactionId(@PathVariable String transactionId) {
+        logger.info("根据支付流水号查询支付记录，支付流水号：{}", transactionId);
+        Payments payment = paymentsService.getPaymentByTransactionId(transactionId);
+        return Result.success(payment);
+    }
+    
+    /**
+     * 创建支付记录
+     * @param payments 支付信息
+     * @return 是否成功
+     */
+    @PostMapping("/create")
+    @PreAuthorize("hasRole('ROLE_ADMIN') or hasRole('ROLE_USER')")
+    public Result<Boolean> createPayment(@RequestBody Payments payments) {
+        logger.info("创建支付记录，支付信息：{}", payments);
+        boolean result = paymentsService.createPayment(payments);
+        return Result.success(result);
+    }
+    
+    /**
+     * 更新支付信息
+     * @param payments 支付信息
+     * @return 是否成功
+     */
+    @PutMapping("/update")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updatePayment(@RequestBody Payments payments) {
+        logger.info("更新支付信息，支付信息：{}", payments);
+        boolean result = paymentsService.updatePayment(payments);
+        return Result.success(result);
+    }
+    
+    /**
+     * 删除支付记录
+     * @param id 支付ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete/{id}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deletePayment(@PathVariable Long id) {
+        logger.info("删除支付记录，支付ID：{}", id);
+        boolean result = paymentsService.deletePayment(id);
+        return Result.success(result);
+    }
+    
+    /**
+     * 根据支付ID查询支付记录
+     * @param id 支付ID
+     * @return 支付记录
+     */
+    @GetMapping("/{id}")
+    public Result<Payments> getPaymentById(@PathVariable Long id) {
+        logger.info("根据支付ID查询支付记录，支付ID：{}", id);
+        Payments payment = paymentsService.getPaymentById(id);
+        return Result.success(payment);
+    }
+    
+    /**
+     * 根据用户ID查询支付记录
+     * @param userId 用户ID
+     * @return 支付记录列表
+     */
+    @GetMapping("/user/{userId}")
+    public Result<List<Payments>> getPaymentsByUserId(@PathVariable Long userId) {
+        logger.info("根据用户ID查询支付记录，用户ID：{}", userId);
+        List<Payments> payments = paymentsService.getPaymentsByUserId(userId);
+        return Result.success(payments);
+    }
+    
+    /**
+     * 根据支付状态查询支付记录
+     * @param status 支付状态
+     * @return 支付记录列表
+     */
+    @GetMapping("/status/{status}")
+    public Result<List<Payments>> getPaymentsByStatus(@PathVariable Integer status) {
+        logger.info("根据支付状态查询支付记录，状态：{}", status);
+        List<Payments> payments = paymentsService.getPaymentsByStatus(status);
+        return Result.success(payments);
+    }
+    
+    /**
+     * 更新支付状态
+     * @param paymentId 支付ID
+     * @param status 支付状态
+     * @return 是否成功
+     */
+    @PutMapping("/update-status/{paymentId}/{status}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updatePaymentStatus(@PathVariable Long paymentId, @PathVariable Integer status) {
+        logger.info("更新支付状态，支付ID：{}，状态：{}", paymentId, status);
+        boolean result = paymentsService.updatePaymentStatus(paymentId, status);
+        return Result.success(result);
+    }
+    
+    /**
+     * 分页查询支付记录
+     * @param page 当前页码
+     * @param size 每页数量
+     * @return 支付记录列表
+     */
+    @GetMapping("/page/{page}/{size}")
+    public Result<List<Payments>> listPaymentsByPage(@PathVariable int page, @PathVariable int size) {
+        logger.info("分页查询支付记录，页码：{}，每页数量：{}", page, size);
+        List<Payments> payments = paymentsService.listPaymentsByPage(page, size);
+        return Result.success(payments);
+    }
+}

src/main/java/com/qf/backend/controller/PermissionsController.java

@@ -17,7 +17,7 @@ import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.security.access.prepost.PreAuthorize;
 
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Permissions;
 import com.qf.backend.service.PermissionsService;
 import java.util.List;

src/main/java/com/qf/backend/controller/ProductAttributeValuesController.java

@@ -0,0 +1,137 @@
+package com.qf.backend.controller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import com.qf.backend.dto.Result;
+import com.qf.backend.entity.ProductAttributeValues;
+import com.qf.backend.service.ProductAttributeValuesService;
+import java.util.List;
+
+/**
+ * 商品属性值控制器
+ * 处理商品属性值相关的HTTP请求
+ * 遵循RESTful API设计规范
+ */
+@RequestMapping("/api/product-attribute-values")
+@RestController
+public class ProductAttributeValuesController {
+    private static final Logger logger = LoggerFactory.getLogger(ProductAttributeValuesController.class);
+    
+    @Autowired
+    private ProductAttributeValuesService productAttributeValuesService;
+    
+    /**
+     * 根据商品ID查询属性值
+     * @param productId 商品ID
+     * @return 属性值列表
+     */
+    @GetMapping("/product/{productId}")
+    public Result<List<ProductAttributeValues>> getAttributeValuesByProductId(@PathVariable Long productId) {
+        logger.info("根据商品ID查询属性值，商品ID：{}", productId);
+        return productAttributeValuesService.getAttributeValuesByProductId(productId);
+    }
+    
+    /**
+     * 根据属性ID查询属性值
+     * @param attributeId 属性ID
+     * @return 属性值列表
+     */
+    @GetMapping("/attribute/{attributeId}")
+    public Result<List<ProductAttributeValues>> getAttributeValuesByAttributeId(@PathVariable Long attributeId) {
+        logger.info("根据属性ID查询属性值，属性ID：{}", attributeId);
+        return productAttributeValuesService.getAttributeValuesByAttributeId(attributeId);
+    }
+    
+    /**
+     * 创建属性值
+     * @param productAttributeValues 属性值信息
+     * @return 是否成功
+     */
+    @PostMapping("/create")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> createAttributeValue(@RequestBody ProductAttributeValues productAttributeValues) {
+        logger.info("创建属性值，属性值信息：{}", productAttributeValues);
+        return productAttributeValuesService.createAttributeValue(productAttributeValues);
+    }
+    
+    /**
+     * 更新属性值信息
+     * @param productAttributeValues 属性值信息
+     * @return 是否成功
+     */
+    @PutMapping("/update")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updateAttributeValue(@RequestBody ProductAttributeValues productAttributeValues) {
+        logger.info("更新属性值信息，属性值信息：{}", productAttributeValues);
+        return productAttributeValuesService.updateAttributeValue(productAttributeValues);
+    }
+    
+    /**
+     * 删除属性值
+     * @param id 属性值ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete/{id}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteAttributeValue(@PathVariable Long id) {
+        logger.info("删除属性值，属性值ID：{}", id);
+        return productAttributeValuesService.deleteAttributeValue(id);
+    }
+    
+    /**
+     * 根据属性值ID查询属性值
+     * @param id 属性值ID
+     * @return 属性值信息
+     */
+    @GetMapping("/{id}")
+    public Result<ProductAttributeValues> getAttributeValueById(@PathVariable Long id) {
+        logger.info("根据属性值ID查询属性值，属性值ID：{}", id);
+        return productAttributeValuesService.getAttributeValueById(id);
+    }
+    
+    /**
+     * 批量创建商品属性值
+     * @param attributeValues 属性值列表
+     * @return 是否成功
+     */
+    @PostMapping("/batch-create")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> batchCreateAttributeValues(@RequestBody List<ProductAttributeValues> attributeValues) {
+        logger.info("批量创建商品属性值，属性值数量：{}", attributeValues.size());
+        return productAttributeValuesService.batchCreateAttributeValues(attributeValues);
+    }
+    
+    /**
+     * 根据商品ID和属性ID查询属性值
+     * @param productId 商品ID
+     * @param attributeId 属性ID
+     * @return 属性值信息
+     */
+    @GetMapping("/product/{productId}/attribute/{attributeId}")
+    public Result<ProductAttributeValues> getAttributeValueByProductAndAttribute(@PathVariable Long productId, @PathVariable Long attributeId) {
+        logger.info("根据商品ID和属性ID查询属性值，商品ID：{}，属性ID：{}", productId, attributeId);
+        return productAttributeValuesService.getAttributeValueByProductAndAttribute(productId, attributeId);
+    }
+    
+    /**
+     * 根据商品ID删除所有属性值
+     * @param productId 商品ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete-by-product/{productId}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteAttributeValuesByProductId(@PathVariable Long productId) {
+        logger.info("根据商品ID删除所有属性值，商品ID：{}", productId);
+        return productAttributeValuesService.deleteAttributeValuesByProductId(productId);
+    }
+}

src/main/java/com/qf/backend/controller/ProductAttributesController.java

@@ -0,0 +1,136 @@
+package com.qf.backend.controller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import com.qf.backend.dto.Result;
+import com.qf.backend.entity.ProductAttributes;
+import com.qf.backend.service.ProductAttributesService;
+import java.util.List;
+
+/**
+ * 商品属性控制器
+ * 处理商品属性相关的HTTP请求
+ * 遵循RESTful API设计规范
+ */
+@RequestMapping("/api/product-attributes")
+@RestController
+public class ProductAttributesController {
+    private static final Logger logger = LoggerFactory.getLogger(ProductAttributesController.class);
+    
+    @Autowired
+    private ProductAttributesService productAttributesService;
+    
+    /**
+     * 根据分类ID查询属性
+     * @param categoryId 分类ID
+     * @return 属性列表
+     */
+    @GetMapping("/category/{categoryId}")
+    public Result<List<ProductAttributes>> getAttributesByCategoryId(@PathVariable Long categoryId) {
+        logger.info("根据分类ID查询属性，分类ID：{}", categoryId);
+        return productAttributesService.getAttributesByCategoryId(categoryId);
+    }
+    
+    /**
+     * 根据属性名称查询属性
+     * @param attributeName 属性名称
+     * @return 属性列表
+     */
+    @GetMapping("/name/{attributeName}")
+    public Result<List<ProductAttributes>> getAttributesByName(@PathVariable String attributeName) {
+        logger.info("根据属性名称查询属性，属性名称：{}", attributeName);
+        return productAttributesService.getAttributesByName(attributeName);
+    }
+    
+    /**
+     * 创建属性
+     * @param productAttributes 属性信息
+     * @return 是否成功
+     */
+    @PostMapping("/create")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> createAttribute(@RequestBody ProductAttributes productAttributes) {
+        logger.info("创建属性，属性信息：{}", productAttributes);
+        return productAttributesService.createAttribute(productAttributes);
+    }
+    
+    /**
+     * 更新属性信息
+     * @param productAttributes 属性信息
+     * @return 是否成功
+     */
+    @PutMapping("/update")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updateAttribute(@RequestBody ProductAttributes productAttributes) {
+        logger.info("更新属性信息，属性信息：{}", productAttributes);
+        return productAttributesService.updateAttribute(productAttributes);
+    }
+    
+    /**
+     * 删除属性
+     * @param id 属性ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete/{id}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteAttribute(@PathVariable Long id) {
+        logger.info("删除属性，属性ID：{}", id);
+        return productAttributesService.deleteAttribute(id);
+    }
+    
+    /**
+     * 根据属性ID查询属性
+     * @param id 属性ID
+     * @return 属性信息
+     */
+    @GetMapping("/{id}")
+    public Result<ProductAttributes> getAttributeById(@PathVariable Long id) {
+        logger.info("根据属性ID查询属性，属性ID：{}", id);
+        return productAttributesService.getAttributeById(id);
+    }
+    
+    /**
+     * 批量删除属性
+     * @param ids 属性ID列表
+     * @return 是否成功
+     */
+    @DeleteMapping("/batch-delete")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> batchDeleteAttributes(@RequestBody List<Long> ids) {
+        logger.info("批量删除属性，属性ID数量：{}", ids.size());
+        return productAttributesService.batchDeleteAttributes(ids);
+    }
+    
+    /**
+     * 根据属性类型查询属性
+     * @param attributeType 属性类型
+     * @return 属性列表
+     */
+    @GetMapping("/type/{attributeType}")
+    public Result<List<ProductAttributes>> getAttributesByType(@PathVariable String attributeType) {
+        logger.info("根据属性类型查询属性，属性类型：{}", attributeType);
+        return productAttributesService.getAttributesByType(attributeType);
+    }
+    
+    /**
+     * 查询是否可搜索的属性
+     * @param searchable 是否可搜索
+     * @return 属性列表
+     */
+    @GetMapping("/searchable")
+    public Result<List<ProductAttributes>> getAttributesBySearchable(@RequestParam Boolean searchable) {
+        logger.info("查询是否可搜索的属性，可搜索：{}", searchable);
+        return productAttributesService.getAttributesBySearchable(searchable);
+    }
+}

src/main/java/com/qf/backend/controller/ProductCategoriesController.java

@@ -0,0 +1,133 @@
+package com.qf.backend.controller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import com.qf.backend.dto.Result;
+import com.qf.backend.entity.ProductCategories;
+import com.qf.backend.service.ProductCategoriesService;
+import java.util.List;
+
+/**
+ * 商品分类控制器
+ * 处理商品分类相关的HTTP请求
+ * 遵循RESTful API设计规范
+ */
+@RequestMapping("/api/product-categories")
+@RestController
+public class ProductCategoriesController {
+    private static final Logger logger = LoggerFactory.getLogger(ProductCategoriesController.class);
+    
+    @Autowired
+    private ProductCategoriesService productCategoriesService;
+    
+    /**
+     * 根据分类名称查询分类
+     * @param categoryName 分类名称
+     * @return 分类信息
+     */
+    @GetMapping("/name/{categoryName}")
+    public Result<ProductCategories> getCategoryByName(@PathVariable String categoryName) {
+        logger.info("根据分类名称查询分类，分类名称：{}", categoryName);
+        return productCategoriesService.getCategoryByName(categoryName);
+    }
+    
+    /**
+     * 根据父分类ID查询子分类
+     * @param parentId 父分类ID
+     * @return 子分类列表
+     */
+    @GetMapping("/parent/{parentId}")
+    public Result<List<ProductCategories>> getSubCategoriesByParentId(@PathVariable Long parentId) {
+        logger.info("根据父分类ID查询子分类，父分类ID：{}", parentId);
+        return productCategoriesService.getSubCategoriesByParentId(parentId);
+    }
+    
+    /**
+     * 创建分类
+     * @param productCategories 分类信息
+     * @return 是否成功
+     */
+    @PostMapping("/create")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> createCategory(@RequestBody ProductCategories productCategories) {
+        logger.info("创建分类，分类信息：{}", productCategories);
+        return productCategoriesService.createCategory(productCategories);
+    }
+    
+    /**
+     * 更新分类信息
+     * @param productCategories 分类信息
+     * @return 是否成功
+     */
+    @PutMapping("/update")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updateCategory(@RequestBody ProductCategories productCategories) {
+        logger.info("更新分类信息，分类信息：{}", productCategories);
+        return productCategoriesService.updateCategory(productCategories);
+    }
+    
+    /**
+     * 删除分类
+     * @param id 分类ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete/{id}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteCategory(@PathVariable Long id) {
+        logger.info("删除分类，分类ID：{}", id);
+        return productCategoriesService.deleteCategory(id);
+    }
+    
+    /**
+     * 查询所有根分类（父分类ID为0或null的分类）
+     * @return 根分类列表
+     */
+    @GetMapping("/root")
+    public Result<List<ProductCategories>> listRootCategories() {
+        logger.info("查询所有根分类");
+        return productCategoriesService.listRootCategories();
+    }
+    
+    /**
+     * 根据分类ID查询分类
+     * @param id 分类ID
+     * @return 分类信息
+     */
+    @GetMapping("/{id}")
+    public Result<ProductCategories> getCategoryById(@PathVariable Long id) {
+        logger.info("根据分类ID查询分类，分类ID：{}", id);
+        return productCategoriesService.getCategoryById(id);
+    }
+    
+    /**
+     * 批量删除分类
+     * @param ids 分类ID列表
+     * @return 是否成功
+     */
+    @DeleteMapping("/batch-delete")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> batchDeleteCategories(@RequestBody List<Long> ids) {
+        logger.info("批量删除分类，分类ID数量：{}", ids.size());
+        return productCategoriesService.batchDeleteCategories(ids);
+    }
+    
+    /**
+     * 查询所有分类（树形结构）
+     * @return 分类树形列表
+     */
+    @GetMapping("/tree")
+    public Result<List<ProductCategories>> listAllCategoriesWithTree() {
+        logger.info("查询所有分类（树形结构）");
+        return productCategoriesService.listAllCategoriesWithTree();
+    }
+}

src/main/java/com/qf/backend/controller/ProductImagesController.java

@@ -0,0 +1,138 @@
+package com.qf.backend.controller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import com.qf.backend.dto.Result;
+import com.qf.backend.entity.ProductImages;
+import com.qf.backend.service.ProductImagesService;
+import java.util.List;
+
+/**
+ * 商品图片控制器
+ * 处理商品图片相关的HTTP请求
+ * 遵循RESTful API设计规范
+ */
+@RequestMapping("/api/product-images")
+@RestController
+public class ProductImagesController {
+    private static final Logger logger = LoggerFactory.getLogger(ProductImagesController.class);
+    
+    @Autowired
+    private ProductImagesService productImagesService;
+    
+    /**
+     * 根据商品ID查询图片
+     * @param productId 商品ID
+     * @return 图片列表
+     */
+    @GetMapping("/product/{productId}")
+    public Result<List<ProductImages>> getImagesByProductId(@PathVariable Long productId) {
+        logger.info("根据商品ID查询图片，商品ID：{}", productId);
+        return productImagesService.getImagesByProductId(productId);
+    }
+    
+    /**
+     * 根据商品ID查询主图
+     * @param productId 商品ID
+     * @return 主图信息
+     */
+    @GetMapping("/product/{productId}/main")
+    public Result<ProductImages> getMainImageByProductId(@PathVariable Long productId) {
+        logger.info("根据商品ID查询主图，商品ID：{}", productId);
+        return productImagesService.getMainImageByProductId(productId);
+    }
+    
+    /**
+     * 创建商品图片
+     * @param productImages 图片信息
+     * @return 是否成功
+     */
+    @PostMapping("/create")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> createImage(@RequestBody ProductImages productImages) {
+        logger.info("创建商品图片，图片信息：{}", productImages);
+        return productImagesService.createImage(productImages);
+    }
+    
+    /**
+     * 更新图片信息
+     * @param productImages 图片信息
+     * @return 是否成功
+     */
+    @PutMapping("/update")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updateImage(@RequestBody ProductImages productImages) {
+        logger.info("更新图片信息，图片信息：{}", productImages);
+        return productImagesService.updateImage(productImages);
+    }
+    
+    /**
+     * 删除图片
+     * @param id 图片ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete/{id}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteImage(@PathVariable Long id) {
+        logger.info("删除图片，图片ID：{}", id);
+        return productImagesService.deleteImage(id);
+    }
+    
+    /**
+     * 根据图片ID查询图片
+     * @param id 图片ID
+     * @return 图片信息
+     */
+    @GetMapping("/{id}")
+    public Result<ProductImages> getImageById(@PathVariable Long id) {
+        logger.info("根据图片ID查询图片，图片ID：{}", id);
+        return productImagesService.getImageById(id);
+    }
+    
+    /**
+     * 批量创建商品图片
+     * @param images 图片列表
+     * @return 是否成功
+     */
+    @PostMapping("/batch-create")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> batchCreateImages(@RequestBody List<ProductImages> images) {
+        logger.info("批量创建商品图片，图片数量：{}", images.size());
+        return productImagesService.batchCreateImages(images);
+    }
+    
+    /**
+     * 根据商品ID删除所有图片
+     * @param productId 商品ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete-by-product/{productId}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteImagesByProductId(@PathVariable Long productId) {
+        logger.info("根据商品ID删除所有图片，商品ID：{}", productId);
+        return productImagesService.deleteImagesByProductId(productId);
+    }
+    
+    /**
+     * 设置主图
+     * @param productId 商品ID
+     * @param imageId 图片ID
+     * @return 是否成功
+     */
+    @PutMapping("/set-main/{productId}/{imageId}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> setMainImage(@PathVariable Long productId, @PathVariable Long imageId) {
+        logger.info("设置主图，商品ID：{}，图片ID：{}", productId, imageId);
+        return productImagesService.setMainImage(productId, imageId);
+    }
+}

src/main/java/com/qf/backend/controller/ProductInventoriesController.java

@@ -0,0 +1,151 @@
+package com.qf.backend.controller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import com.qf.backend.dto.Result;
+import com.qf.backend.entity.ProductInventories;
+import com.qf.backend.service.ProductInventoriesService;
+import java.util.List;
+
+/**
+ * 商品库存控制器
+ * 处理商品库存相关的HTTP请求
+ * 遵循RESTful API设计规范
+ */
+@RequestMapping("/api/product-inventories")
+@RestController
+public class ProductInventoriesController {
+    private static final Logger logger = LoggerFactory.getLogger(ProductInventoriesController.class);
+    
+    @Autowired
+    private ProductInventoriesService productInventoriesService;
+    
+    /**
+     * 根据商品ID查询库存
+     * @param productId 商品ID
+     * @return 库存列表
+     */
+    @GetMapping("/product/{productId}")
+    public Result<List<ProductInventories>> getInventoriesByProductId(@PathVariable Long productId) {
+        logger.info("根据商品ID查询库存，商品ID：{}", productId);
+        return productInventoriesService.getInventoriesByProductId(productId);
+    }
+    
+    /**
+     * 根据SKU ID查询库存
+     * @param skuId SKU ID
+     * @return 库存信息
+     */
+    @GetMapping("/sku/{skuId}")
+    public Result<ProductInventories> getInventoryBySkuId(@PathVariable Long skuId) {
+        logger.info("根据SKU ID查询库存，SKU ID：{}", skuId);
+        return productInventoriesService.getInventoryBySkuId(skuId);
+    }
+    
+    /**
+     * 创建库存记录
+     * @param productInventories 库存信息
+     * @return 是否成功
+     */
+    @PostMapping("/create")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> createInventory(@RequestBody ProductInventories productInventories) {
+        logger.info("创建库存记录，库存信息：{}", productInventories);
+        return productInventoriesService.createInventory(productInventories);
+    }
+    
+    /**
+     * 更新库存信息
+     * @param productInventories 库存信息
+     * @return 是否成功
+     */
+    @PutMapping("/update")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updateInventory(@RequestBody ProductInventories productInventories) {
+        logger.info("更新库存信息，库存信息：{}", productInventories);
+        return productInventoriesService.updateInventory(productInventories);
+    }
+    
+    /**
+     * 删除库存记录
+     * @param id 库存ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete/{id}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteInventory(@PathVariable Long id) {
+        logger.info("删除库存记录，库存ID：{}", id);
+        return productInventoriesService.deleteInventory(id);
+    }
+    
+    /**
+     * 根据库存ID查询库存
+     * @param id 库存ID
+     * @return 库存信息
+     */
+    @GetMapping("/{id}")
+    public Result<ProductInventories> getInventoryById(@PathVariable Long id) {
+        logger.info("根据库存ID查询库存，库存ID：{}", id);
+        return productInventoriesService.getInventoryById(id);
+    }
+    
+    /**
+     * 增加库存
+     * @param skuId SKU ID
+     * @param quantity 增加数量
+     * @return 是否成功
+     */
+    @PutMapping("/increase/{skuId}/{quantity}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> increaseInventory(@PathVariable Long skuId, @PathVariable Integer quantity) {
+        logger.info("增加库存，SKU ID：{}，增加数量：{}", skuId, quantity);
+        return productInventoriesService.increaseInventory(skuId, quantity);
+    }
+    
+    /**
+     * 减少库存
+     * @param skuId SKU ID
+     * @param quantity 减少数量
+     * @return 是否成功
+     */
+    @PutMapping("/decrease/{skuId}/{quantity}")
+    @PreAuthorize("hasRole('ROLE_ADMIN') or hasRole('ROLE_USER')")
+    public Result<Boolean> decreaseInventory(@PathVariable Long skuId, @PathVariable Integer quantity) {
+        logger.info("减少库存，SKU ID：{}，减少数量：{}", skuId, quantity);
+        return productInventoriesService.decreaseInventory(skuId, quantity);
+    }
+    
+    /**
+     * 检查库存是否充足
+     * @param skuId SKU ID
+     * @param quantity 需要的数量
+     * @return 是否充足
+     */
+    @GetMapping("/check/{skuId}/{quantity}")
+    public Result<Boolean> checkInventorySufficient(@PathVariable Long skuId, @PathVariable Integer quantity) {
+        logger.info("检查库存是否充足，SKU ID：{}，需要数量：{}", skuId, quantity);
+        return productInventoriesService.checkInventorySufficient(skuId, quantity);
+    }
+    
+    /**
+     * 批量更新库存
+     * @param inventoryUpdates 库存更新列表
+     * @return 是否成功
+     */
+    @PutMapping("/batch-update")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> batchUpdateInventory(@RequestBody List<ProductInventories> inventoryUpdates) {
+        logger.info("批量更新库存，更新数量：{}", inventoryUpdates.size());
+        return productInventoriesService.batchUpdateInventory(inventoryUpdates);
+    }
+}

src/main/java/com/qf/backend/controller/ProductSkusController.java

@@ -0,0 +1,149 @@
+package com.qf.backend.controller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import com.qf.backend.dto.Result;
+import com.qf.backend.entity.ProductSkus;
+import com.qf.backend.service.ProductSkusService;
+import java.util.List;
+
+/**
+ * 商品SKU控制器
+ * 处理商品SKU相关的HTTP请求
+ * 遵循RESTful API设计规范
+ */
+@RequestMapping("/api/product-skus")
+@RestController
+public class ProductSkusController {
+    private static final Logger logger = LoggerFactory.getLogger(ProductSkusController.class);
+    
+    @Autowired
+    private ProductSkusService productSkusService;
+    
+    /**
+     * 根据商品ID查询SKU
+     * @param productId 商品ID
+     * @return SKU列表
+     */
+    @GetMapping("/product/{productId}")
+    public Result<List<ProductSkus>> getSkusByProductId(@PathVariable Long productId) {
+        logger.info("根据商品ID查询SKU，商品ID：{}", productId);
+        return productSkusService.getSkusByProductId(productId);
+    }
+    
+    /**
+     * 根据SKU编码查询SKU
+     * @param skuCode SKU编码
+     * @return SKU信息
+     */
+    @GetMapping("/code/{skuCode}")
+    public Result<ProductSkus> getSkuByCode(@PathVariable String skuCode) {
+        logger.info("根据SKU编码查询SKU，SKU编码：{}", skuCode);
+        return productSkusService.getSkuByCode(skuCode);
+    }
+    
+    /**
+     * 创建SKU
+     * @param productSkus SKU信息
+     * @return 是否成功
+     */
+    @PostMapping("/create")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> createSku(@RequestBody ProductSkus productSkus) {
+        logger.info("创建SKU，SKU信息：{}", productSkus);
+        return productSkusService.createSku(productSkus);
+    }
+    
+    /**
+     * 更新SKU信息
+     * @param productSkus SKU信息
+     * @return 是否成功
+     */
+    @PutMapping("/update")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updateSku(@RequestBody ProductSkus productSkus) {
+        logger.info("更新SKU信息，SKU信息：{}", productSkus);
+        return productSkusService.updateSku(productSkus);
+    }
+    
+    /**
+     * 删除SKU
+     * @param id SKU ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete/{id}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteSku(@PathVariable Long id) {
+        logger.info("删除SKU，SKU ID：{}", id);
+        return productSkusService.deleteSku(id);
+    }
+    
+    /**
+     * 根据SKU ID查询SKU
+     * @param id SKU ID
+     * @return SKU信息
+     */
+    @GetMapping("/{id}")
+    public Result<ProductSkus> getSkuById(@PathVariable Long id) {
+        logger.info("根据SKU ID查询SKU，SKU ID：{}", id);
+        return productSkusService.getSkuById(id);
+    }
+    
+    /**
+     * 批量创建SKU
+     * @param skus SKU列表
+     * @return 是否成功
+     */
+    @PostMapping("/batch-create")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> batchCreateSkus(@RequestBody List<ProductSkus> skus) {
+        logger.info("批量创建SKU，SKU数量：{}", skus.size());
+        return productSkusService.batchCreateSkus(skus);
+    }
+    
+    /**
+     * 根据商品ID删除所有SKU
+     * @param productId 商品ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete-by-product/{productId}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteSkusByProductId(@PathVariable Long productId) {
+        logger.info("根据商品ID删除所有SKU，商品ID：{}", productId);
+        return productSkusService.deleteSkusByProductId(productId);
+    }
+    
+    /**
+     * 更新SKU库存
+     * @param skuId SKU ID
+     * @param quantity 库存数量
+     * @return 是否成功
+     */
+    @PutMapping("/update-stock/{skuId}/{quantity}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updateSkuStock(@PathVariable Long skuId, @PathVariable Integer quantity) {
+        logger.info("更新SKU库存，SKU ID：{}，库存数量：{}", skuId, quantity);
+        return productSkusService.updateSkuStock(skuId, quantity);
+    }
+    
+    /**
+     * 批量查询SKU
+     * @param skuIds SKU ID列表
+     * @return SKU列表
+     */
+    @PostMapping("/batch-get")
+    public Result<List<ProductSkus>> batchGetSkus(@RequestBody List<Long> skuIds) {
+        logger.info("批量查询SKU，SKU ID数量：{}", skuIds.size());
+        return productSkusService.batchGetSkus(skuIds);
+    }
+}

src/main/java/com/qf/backend/controller/ProductsController.java

@@ -0,0 +1,151 @@
+package com.qf.backend.controller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import com.qf.backend.dto.Result;
+import com.qf.backend.entity.Products;
+import com.qf.backend.service.ProductsService;
+import java.util.List;
+
+/**
+ * 商品控制器
+ * 处理商品相关的HTTP请求
+ * 遵循RESTful API设计规范
+ */
+@RequestMapping("/api/products")
+@RestController
+public class ProductsController {
+    private static final Logger logger = LoggerFactory.getLogger(ProductsController.class);
+    
+    @Autowired
+    private ProductsService productsService;
+    
+    /**
+     * 根据商品名称查询商品
+     * @param productName 商品名称
+     * @return 商品列表
+     */
+    @GetMapping("/name/{productName}")
+    public Result<List<Products>> getProductsByName(@PathVariable String productName) {
+        logger.info("根据商品名称查询商品，商品名称：{}", productName);
+        return productsService.getProductsByName(productName);
+    }
+    
+    /**
+     * 根据分类ID查询商品
+     * @param categoryId 分类ID
+     * @return 商品列表
+     */
+    @GetMapping("/category/{categoryId}")
+    public Result<List<Products>> getProductsByCategoryId(@PathVariable Long categoryId) {
+        logger.info("根据分类ID查询商品，分类ID：{}", categoryId);
+        return productsService.getProductsByCategoryId(categoryId);
+    }
+    
+    /**
+     * 创建商品
+     * @param products 商品信息
+     * @return 是否成功
+     */
+    @PostMapping("/create")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> createProduct(@RequestBody Products products) {
+        logger.info("创建商品，商品信息：{}", products);
+        return productsService.createProduct(products);
+    }
+    
+    /**
+     * 更新商品信息
+     * @param products 商品信息
+     * @return 是否成功
+     */
+    @PutMapping("/update")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updateProduct(@RequestBody Products products) {
+        logger.info("更新商品信息，商品信息：{}", products);
+        return productsService.updateProduct(products);
+    }
+    
+    /**
+     * 删除商品
+     * @param id 商品ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete/{id}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteProduct(@PathVariable Long id) {
+        logger.info("删除商品，商品ID：{}", id);
+        return productsService.deleteProduct(id);
+    }
+    
+    /**
+     * 根据商品ID查询商品
+     * @param id 商品ID
+     * @return 商品信息
+     */
+    @GetMapping("/{id}")
+    public Result<Products> getProductById(@PathVariable Long id) {
+        logger.info("根据商品ID查询商品，商品ID：{}", id);
+        return productsService.getProductById(id);
+    }
+    
+    /**
+     * 分页查询商品
+     * @param page 当前页码
+     * @param size 每页数量
+     * @return 商品列表
+     */
+    @GetMapping("/page/{page}/{size}")
+    public Result<List<Products>> listProductsByPage(@PathVariable int page, @PathVariable int size) {
+        logger.info("分页查询商品，页码：{}，每页数量：{}", page, size);
+        return productsService.listProductsByPage(page, size);
+    }
+    
+    /**
+     * 根据店铺ID查询商品
+     * @param shopId 店铺ID
+     * @return 商品列表
+     */
+    @GetMapping("/shop/{shopId}")
+    public Result<List<Products>> getProductsByShopId(@PathVariable Long shopId) {
+        logger.info("根据店铺ID查询商品，店铺ID：{}", shopId);
+        return productsService.getProductsByShopId(shopId);
+    }
+    
+    /**
+     * 批量上下架商品
+     * @param ids 商品ID列表
+     * @param status 状态（上架/下架）
+     * @return 是否成功
+     */
+    @PutMapping("/batch-status")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> batchUpdateProductStatus(@RequestBody List<Long> ids, @RequestParam Integer status) {
+        logger.info("批量上下架商品，商品ID数量：{}，状态：{}", ids.size(), status);
+        return productsService.batchUpdateProductStatus(ids, status);
+    }
+    
+    /**
+     * 搜索商品
+     * @param keyword 关键词
+     * @param page 当前页码
+     * @param size 每页数量
+     * @return 商品列表
+     */
+    @GetMapping("/search")
+    public Result<List<Products>> searchProducts(@RequestParam String keyword, @RequestParam int page, @RequestParam int size) {
+        logger.info("搜索商品，关键词：{}，页码：{}，每页数量：{}", keyword, page, size);
+        return productsService.searchProducts(keyword, page, size);
+    }
+}

src/main/java/com/qf/backend/controller/RefundsController.java

@@ -0,0 +1,158 @@
+package com.qf.backend.controller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import com.qf.backend.dto.Result;
+import com.qf.backend.entity.Refunds;
+import com.qf.backend.service.RefundsService;
+import java.util.List;
+
+/**
+ * 退款控制器
+ * 处理退款相关的HTTP请求
+ * 遵循RESTful API设计规范
+ */
+@RequestMapping("/api/refunds")
+@RestController
+public class RefundsController {
+    private static final Logger logger = LoggerFactory.getLogger(RefundsController.class);
+    
+    @Autowired
+    private RefundsService refundsService;
+    
+    /**
+     * 根据订单ID查询退款记录
+     * @param orderId 订单ID
+     * @return 退款记录列表
+     */
+    @GetMapping("/order/{orderId}")
+    public Result<List<Refunds>> getRefundsByOrderId(@PathVariable Long orderId) {
+        logger.info("根据订单ID查询退款记录，订单ID：{}", orderId);
+        List<Refunds> refunds = refundsService.getRefundsByOrderId(orderId);
+        return Result.success(refunds);
+    }
+    
+    /**
+     * 根据退款单号查询退款记录
+     * @param refundNumber 退款单号
+     * @return 退款记录
+     */
+    @GetMapping("/number/{refundNumber}")
+    public Result<Refunds> getRefundByNumber(@PathVariable String refundNumber) {
+        logger.info("根据退款单号查询退款记录，退款单号：{}", refundNumber);
+        Refunds refund = refundsService.getRefundByNumber(refundNumber);
+        return Result.success(refund);
+    }
+    
+    /**
+     * 创建退款记录
+     * @param refunds 退款信息
+     * @return 是否成功
+     */
+    @PostMapping("/create")
+    @PreAuthorize("hasRole('ROLE_ADMIN') or hasRole('ROLE_USER')")
+    public Result<Boolean> createRefund(@RequestBody Refunds refunds) {
+        logger.info("创建退款记录，退款信息：{}", refunds);
+        boolean result = refundsService.createRefund(refunds);
+        return Result.success(result);
+    }
+    
+    /**
+     * 更新退款信息
+     * @param refunds 退款信息
+     * @return 是否成功
+     */
+    @PutMapping("/update")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updateRefund(@RequestBody Refunds refunds) {
+        logger.info("更新退款信息，退款信息：{}", refunds);
+        boolean result = refundsService.updateRefund(refunds);
+        return Result.success(result);
+    }
+    
+    /**
+     * 删除退款记录
+     * @param id 退款ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete/{id}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteRefund(@PathVariable Long id) {
+        logger.info("删除退款记录，退款ID：{}", id);
+        boolean result = refundsService.deleteRefund(id);
+        return Result.success(result);
+    }
+    
+    /**
+     * 根据退款ID查询退款记录
+     * @param id 退款ID
+     * @return 退款记录
+     */
+    @GetMapping("/{id}")
+    public Result<Refunds> getRefundById(@PathVariable Long id) {
+        logger.info("根据退款ID查询退款记录，退款ID：{}", id);
+        Refunds refund = refundsService.getRefundById(id);
+        return Result.success(refund);
+    }
+    
+    /**
+     * 根据用户ID查询退款记录
+     * @param userId 用户ID
+     * @return 退款记录列表
+     */
+    @GetMapping("/user/{userId}")
+    public Result<List<Refunds>> getRefundsByUserId(@PathVariable Long userId) {
+        logger.info("根据用户ID查询退款记录，用户ID：{}", userId);
+        List<Refunds> refunds = refundsService.getRefundsByUserId(userId);
+        return Result.success(refunds);
+    }
+    
+    /**
+     * 根据退款状态查询退款记录
+     * @param status 退款状态
+     * @return 退款记录列表
+     */
+    @GetMapping("/status/{status}")
+    public Result<List<Refunds>> getRefundsByStatus(@PathVariable Integer status) {
+        logger.info("根据退款状态查询退款记录，状态：{}", status);
+        List<Refunds> refunds = refundsService.getRefundsByStatus(status);
+        return Result.success(refunds);
+    }
+    
+    /**
+     * 更新退款状态
+     * @param refundId 退款ID
+     * @param status 退款状态
+     * @return 是否成功
+     */
+    @PutMapping("/update-status/{refundId}/{status}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updateRefundStatus(@PathVariable Long refundId, @PathVariable Integer status) {
+        logger.info("更新退款状态，退款ID：{}，状态：{}", refundId, status);
+        boolean result = refundsService.updateRefundStatus(refundId, status);
+        return Result.success(result);
+    }
+    
+    /**
+     * 分页查询退款记录
+     * @param page 当前页码
+     * @param size 每页数量
+     * @return 退款记录列表
+     */
+    @GetMapping("/page/{page}/{size}")
+    public Result<List<Refunds>> listRefundsByPage(@PathVariable int page, @PathVariable int size) {
+        logger.info("分页查询退款记录，页码：{}，每页数量：{}", page, size);
+        List<Refunds> refunds = refundsService.listRefundsByPage(page, size);
+        return Result.success(refunds);
+    }
+}

src/main/java/com/qf/backend/controller/RolePermissionsController.java

@@ -0,0 +1,180 @@
+package com.qf.backend.controller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import com.qf.backend.dto.Result;
+import com.qf.backend.entity.RolePermissions;
+import com.qf.backend.service.RolePermissionsService;
+import java.util.List;
+
+/**
+ * 角色权限关联控制器
+ * 处理角色与权限关联相关的HTTP请求
+ * 遵循RESTful API设计规范
+ */
+@RequestMapping("/api/role-permissions")
+@RestController
+public class RolePermissionsController {
+    private static final Logger logger = LoggerFactory.getLogger(RolePermissionsController.class);
+    
+    @Autowired
+    private RolePermissionsService rolePermissionsService;
+    
+    /**
+     * 根据角色ID查询角色权限关联
+     * @param roleId 角色ID
+     * @return 角色权限关联列表
+     */
+    @GetMapping("/role/{roleId}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<List<RolePermissions>> getRolePermissionsByRoleId(@PathVariable Long roleId) {
+        logger.info("管理员根据角色ID查询角色权限关联，角色ID：{}", roleId);
+        List<RolePermissions> rolePermissions = rolePermissionsService.getRolePermissionsByRoleId(roleId);
+        return Result.success(rolePermissions);
+    }
+    
+    /**
+     * 根据权限ID查询角色权限关联
+     * @param permissionId 权限ID
+     * @return 角色权限关联列表
+     */
+    @GetMapping("/permission/{permissionId}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<List<RolePermissions>> getRolePermissionsByPermissionId(@PathVariable Long permissionId) {
+        logger.info("管理员根据权限ID查询角色权限关联，权限ID：{}", permissionId);
+        List<RolePermissions> rolePermissions = rolePermissionsService.getRolePermissionsByPermissionId(permissionId);
+        return Result.success(rolePermissions);
+    }
+    
+    /**
+     * 为角色添加权限
+     * @param request 角色权限关联请求体
+     * @return 是否成功
+     */
+    @PostMapping("/add")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> addPermissionToRole(@RequestBody RolePermissionRequest request) {
+        logger.info("管理员为角色添加权限，角色ID：{}，权限ID：{}", request.getRoleId(), request.getPermissionId());
+        boolean result = rolePermissionsService.addPermissionToRole(request.getRoleId(), request.getPermissionId());
+        return Result.success(result);
+    }
+    
+    /**
+     * 从角色移除权限
+     * @param request 角色权限关联请求体
+     * @return 是否成功
+     */
+    @DeleteMapping("/remove")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> removePermissionFromRole(@RequestBody RolePermissionRequest request) {
+        logger.info("管理员从角色移除权限，角色ID：{}，权限ID：{}", request.getRoleId(), request.getPermissionId());
+        boolean result = rolePermissionsService.removePermissionFromRole(request.getRoleId(), request.getPermissionId());
+        return Result.success(result);
+    }
+    
+    /**
+     * 批量为角色添加权限
+     * @param request 批量角色权限关联请求体
+     * @return 是否成功
+     */
+    @PostMapping("/batch-add")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> batchAddPermissionsToRole(@RequestBody BatchRolePermissionRequest request) {
+        logger.info("管理员批量为角色添加权限，角色ID：{}，权限ID列表：{}", request.getRoleId(), request.getPermissionIds());
+        boolean result = rolePermissionsService.batchAddPermissionsToRole(request.getRoleId(), request.getPermissionIds());
+        return Result.success(result);
+    }
+    
+    /**
+     * 清空角色的所有权限
+     * @param roleId 角色ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/clear/{roleId}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> clearRolePermissions(@PathVariable Long roleId) {
+        logger.info("管理员清空角色的所有权限，角色ID：{}", roleId);
+        boolean result = rolePermissionsService.clearRolePermissions(roleId);
+        return Result.success(result);
+    }
+    
+    /**
+     * 检查角色是否拥有指定权限
+     * @param roleId 角色ID
+     * @param permissionId 权限ID
+     * @return 是否拥有
+     */
+    @GetMapping("/check")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> checkRoleHasPermission(Long roleId, Long permissionId) {
+        logger.info("管理员检查角色是否拥有指定权限，角色ID：{}，权限ID：{}", roleId, permissionId);
+        boolean result = rolePermissionsService.checkRoleHasPermission(roleId, permissionId);
+        return Result.success(result);
+    }
+    
+    /**
+     * 根据角色ID查询其拥有的权限ID列表
+     * @param roleId 角色ID
+     * @return 权限ID列表
+     */
+    @GetMapping("/permission-ids/{roleId}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<List<Long>> listPermissionIdsByRoleId(@PathVariable Long roleId) {
+        logger.info("管理员根据角色ID查询其拥有的权限ID列表，角色ID：{}", roleId);
+        List<Long> permissionIds = rolePermissionsService.listPermissionIdsByRoleId(roleId);
+        return Result.success(permissionIds);
+    }
+    
+    /**
+     * 角色权限关联请求体
+     */
+    public static class RolePermissionRequest {
+        private Long roleId;
+        private Long permissionId;
+        
+        // getter和setter
+        public Long getRoleId() {
+            return roleId;
+        }
+        public void setRoleId(Long roleId) {
+            this.roleId = roleId;
+        }
+        public Long getPermissionId() {
+            return permissionId;
+        }
+        public void setPermissionId(Long permissionId) {
+            this.permissionId = permissionId;
+        }
+    }
+    
+    /**
+     * 批量角色权限关联请求体
+     */
+    public static class BatchRolePermissionRequest {
+        private Long roleId;
+        private List<Long> permissionIds;
+        
+        // getter和setter
+        public Long getRoleId() {
+            return roleId;
+        }
+        public void setRoleId(Long roleId) {
+            this.roleId = roleId;
+        }
+        public List<Long> getPermissionIds() {
+            return permissionIds;
+        }
+        public void setPermissionIds(List<Long> permissionIds) {
+            this.permissionIds = permissionIds;
+        }
+    }
+}

src/main/java/com/qf/backend/controller/RolesController.java

@@ -17,7 +17,7 @@ import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.security.access.prepost.PreAuthorize;
 
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Roles;
 import com.qf.backend.service.RolesService;
 import java.util.List;

src/main/java/com/qf/backend/controller/ShopCategoriesController.java

@@ -0,0 +1,133 @@
+package com.qf.backend.controller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import com.qf.backend.dto.Result;
+import com.qf.backend.entity.ShopCategories;
+import com.qf.backend.service.ShopCategoriesService;
+import java.util.List;
+
+/**
+ * 店铺分类控制器
+ * 处理店铺分类相关的HTTP请求
+ * 遵循RESTful API设计规范
+ */
+@RequestMapping("/api/shop-categories")
+@RestController
+public class ShopCategoriesController {
+    private static final Logger logger = LoggerFactory.getLogger(ShopCategoriesController.class);
+    
+    @Autowired
+    private ShopCategoriesService shopCategoriesService;
+    
+    /**
+     * 根据分类名称查询分类
+     * @param categoryName 分类名称
+     * @return 分类信息
+     */
+    @GetMapping("/name/{categoryName}")
+    public Result<ShopCategories> getCategoryByName(@PathVariable String categoryName) {
+        logger.info("根据分类名称查询分类，分类名称：{}", categoryName);
+        return shopCategoriesService.getCategoryByName(categoryName);
+    }
+    
+    /**
+     * 根据父分类ID查询子分类
+     * @param parentId 父分类ID
+     * @return 子分类列表
+     */
+    @GetMapping("/parent/{parentId}")
+    public Result<List<ShopCategories>> getSubCategoriesByParentId(@PathVariable Long parentId) {
+        logger.info("根据父分类ID查询子分类，父分类ID：{}", parentId);
+        return shopCategoriesService.getSubCategoriesByParentId(parentId);
+    }
+    
+    /**
+     * 创建分类
+     * @param shopCategories 分类信息
+     * @return 是否成功
+     */
+    @PostMapping("/create")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> createCategory(@RequestBody ShopCategories shopCategories) {
+        logger.info("创建分类，分类信息：{}", shopCategories);
+        return shopCategoriesService.createCategory(shopCategories);
+    }
+    
+    /**
+     * 更新分类信息
+     * @param shopCategories 分类信息
+     * @return 是否成功
+     */
+    @PutMapping("/update")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updateCategory(@RequestBody ShopCategories shopCategories) {
+        logger.info("更新分类信息，分类信息：{}", shopCategories);
+        return shopCategoriesService.updateCategory(shopCategories);
+    }
+    
+    /**
+     * 删除分类
+     * @param id 分类ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete/{id}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteCategory(@PathVariable Long id) {
+        logger.info("删除分类，分类ID：{}", id);
+        return shopCategoriesService.deleteCategory(id);
+    }
+    
+    /**
+     * 查询所有根分类（父分类ID为0或null的分类）
+     * @return 根分类列表
+     */
+    @GetMapping("/root")
+    public Result<List<ShopCategories>> listRootCategories() {
+        logger.info("查询所有根分类");
+        return shopCategoriesService.listRootCategories();
+    }
+    
+    /**
+     * 根据分类ID查询分类
+     * @param id 分类ID
+     * @return 分类信息
+     */
+    @GetMapping("/{id}")
+    public Result<ShopCategories> getCategoryById(@PathVariable Long id) {
+        logger.info("根据分类ID查询分类，分类ID：{}", id);
+        return shopCategoriesService.getCategoryById(id);
+    }
+    
+    /**
+     * 批量删除分类
+     * @param ids 分类ID列表
+     * @return 是否成功
+     */
+    @DeleteMapping("/batch-delete")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> batchDeleteCategories(@RequestBody List<Long> ids) {
+        logger.info("批量删除分类，分类ID数量：{}", ids.size());
+        return shopCategoriesService.batchDeleteCategories(ids);
+    }
+    
+    /**
+     * 查询所有分类（树形结构）
+     * @return 分类树形列表
+     */
+    @GetMapping("/tree")
+    public Result<List<ShopCategories>> listAllCategoriesWithTree() {
+        logger.info("查询所有分类（树形结构）");
+        return shopCategoriesService.listAllCategoriesWithTree();
+    }
+}

src/main/java/com/qf/backend/controller/ShopRatingsController.java

@@ -0,0 +1,161 @@
+package com.qf.backend.controller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import com.qf.backend.dto.Result;
+import com.qf.backend.entity.ShopRatings;
+import com.qf.backend.service.ShopRatingsService;
+import java.util.List;
+
+/**
+ * 店铺评分控制器
+ * 处理店铺评分相关的HTTP请求
+ * 遵循RESTful API设计规范
+ */
+@RequestMapping("/api/shop-ratings")
+@RestController
+public class ShopRatingsController {
+    private static final Logger logger = LoggerFactory.getLogger(ShopRatingsController.class);
+    
+    @Autowired
+    private ShopRatingsService shopRatingsService;
+    
+    /**
+     * 根据店铺ID查询评分
+     * @param shopId 店铺ID
+     * @return 评分列表
+     */
+    @GetMapping("/shop/{shopId}")
+    public Result<List<ShopRatings>> getRatingsByShopId(@PathVariable Long shopId) {
+        logger.info("根据店铺ID查询评分，店铺ID：{}", shopId);
+        return shopRatingsService.getRatingsByShopId(shopId);
+    }
+    
+    /**
+     * 根据用户ID查询评分
+     * @param userId 用户ID
+     * @return 评分列表
+     */
+    @GetMapping("/user/{userId}")
+    public Result<List<ShopRatings>> getRatingsByUserId(@PathVariable Long userId) {
+        logger.info("根据用户ID查询评分，用户ID：{}", userId);
+        return shopRatingsService.getRatingsByUserId(userId);
+    }
+    
+    /**
+     * 创建评分
+     * @param shopRatings 评分信息
+     * @return 是否成功
+     */
+    @PostMapping("/create")
+    @PreAuthorize("hasRole('ROLE_ADMIN') or hasRole('ROLE_USER')")
+    public Result<Boolean> createRating(@RequestBody ShopRatings shopRatings) {
+        logger.info("创建评分，评分信息：{}", shopRatings);
+        return shopRatingsService.createRating(shopRatings);
+    }
+    
+    /**
+     * 更新评分信息
+     * @param shopRatings 评分信息
+     * @return 是否成功
+     */
+    @PutMapping("/update")
+    @PreAuthorize("hasRole('ROLE_ADMIN') or hasRole('ROLE_USER')")
+    public Result<Boolean> updateRating(@RequestBody ShopRatings shopRatings) {
+        logger.info("更新评分信息，评分信息：{}", shopRatings);
+        return shopRatingsService.updateRating(shopRatings);
+    }
+    
+    /**
+     * 删除评分
+     * @param id 评分ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete/{id}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteRating(@PathVariable Long id) {
+        logger.info("删除评分，评分ID：{}", id);
+        return shopRatingsService.deleteRating(id);
+    }
+    
+    /**
+     * 根据评分ID查询评分
+     * @param id 评分ID
+     * @return 评分信息
+     */
+    @GetMapping("/{id}")
+    public Result<ShopRatings> getRatingById(@PathVariable Long id) {
+        logger.info("根据评分ID查询评分，评分ID：{}", id);
+        return shopRatingsService.getRatingById(id);
+    }
+    
+    /**
+     * 获取店铺平均评分
+     * @param shopId 店铺ID
+     * @return 平均评分
+     */
+    @GetMapping("/shop/{shopId}/average")
+    public Result<Double> getAverageRatingByShopId(@PathVariable Long shopId) {
+        logger.info("获取店铺平均评分，店铺ID：{}", shopId);
+        return shopRatingsService.getAverageRatingByShopId(shopId);
+    }
+    
+    /**
+     * 获取店铺评分数量
+     * @param shopId 店铺ID
+     * @return 评分数量
+     */
+    @GetMapping("/shop/{shopId}/count")
+    public Result<Integer> getRatingCountByShopId(@PathVariable Long shopId) {
+        logger.info("获取店铺评分数量，店铺ID：{}", shopId);
+        return shopRatingsService.getRatingCountByShopId(shopId);
+    }
+    
+    /**
+     * 根据评分星级查询店铺评分
+     * @param shopId 店铺ID
+     * @param rating 评分星级
+     * @return 评分列表
+     */
+    @GetMapping("/shop/{shopId}/rating/{rating}")
+    public Result<List<ShopRatings>> getRatingsByShopIdAndRating(@PathVariable Long shopId, @PathVariable Integer rating) {
+        logger.info("根据评分星级查询店铺评分，店铺ID：{}，评分星级：{}", shopId, rating);
+        return shopRatingsService.getRatingsByShopIdAndRating(shopId, rating);
+    }
+    
+    /**
+     * 检查用户是否已对店铺评分
+     * @param shopId 店铺ID
+     * @param userId 用户ID
+     * @return 是否已评分
+     */
+    @GetMapping("/check")
+    public Result<Boolean> checkUserHasRated(@RequestParam Long shopId, @RequestParam Long userId) {
+        logger.info("检查用户是否已对店铺评分，店铺ID：{}，用户ID：{}", shopId, userId);
+        return shopRatingsService.checkUserHasRated(shopId, userId);
+    }
+    
+    /**
+     * 分页查询店铺评分
+     * @param shopId 店铺ID
+     * @param page 当前页码
+     * @param size 每页数量
+     * @return 评分列表
+     */
+    @GetMapping("/shop/{shopId}/page/{page}/{size}")
+    public Result<List<ShopRatings>> listRatingsByShopIdAndPage(@PathVariable Long shopId, @PathVariable int page, @PathVariable int size) {
+        logger.info("分页查询店铺评分，店铺ID：{}，页码：{}，每页数量：{}", shopId, page, size);
+        return shopRatingsService.listRatingsByShopIdAndPage(shopId, page, size);
+    }
+}

src/main/java/com/qf/backend/controller/ShopsController.java

@@ -0,0 +1,151 @@
+package com.qf.backend.controller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import com.qf.backend.dto.Result;
+import com.qf.backend.entity.Shops;
+import com.qf.backend.service.ShopsService;
+import java.util.List;
+
+/**
+ * 店铺控制器
+ * 处理店铺相关的HTTP请求
+ * 遵循RESTful API设计规范
+ */
+@RequestMapping("/api/shops")
+@RestController
+public class ShopsController {
+    private static final Logger logger = LoggerFactory.getLogger(ShopsController.class);
+    
+    @Autowired
+    private ShopsService shopsService;
+    
+    /**
+     * 根据店铺名称查询店铺
+     * @param shopName 店铺名称
+     * @return 店铺列表
+     */
+    @GetMapping("/name/{shopName}")
+    public Result<List<Shops>> getShopsByName(@PathVariable String shopName) {
+        logger.info("根据店铺名称查询店铺，店铺名称：{}", shopName);
+        return shopsService.getShopsByName(shopName);
+    }
+    
+    /**
+     * 根据用户ID查询店铺
+     * @param userId 用户ID
+     * @return 店铺信息
+     */
+    @GetMapping("/user/{userId}")
+    public Result<Shops> getShopByUserId(@PathVariable Long userId) {
+        logger.info("根据用户ID查询店铺，用户ID：{}", userId);
+        return shopsService.getShopByUserId(userId);
+    }
+    
+    /**
+     * 创建店铺
+     * @param shops 店铺信息
+     * @return 是否成功
+     */
+    @PostMapping("/create")
+    @PreAuthorize("hasRole('ROLE_ADMIN') or hasRole('ROLE_USER')")
+    public Result<Boolean> createShop(@RequestBody Shops shops) {
+        logger.info("创建店铺，店铺信息：{}", shops);
+        return shopsService.createShop(shops);
+    }
+    
+    /**
+     * 更新店铺信息
+     * @param shops 店铺信息
+     * @return 是否成功
+     */
+    @PutMapping("/update")
+    @PreAuthorize("hasRole('ROLE_ADMIN') or hasRole('ROLE_USER')")
+    public Result<Boolean> updateShop(@RequestBody Shops shops) {
+        logger.info("更新店铺信息，店铺信息：{}", shops);
+        return shopsService.updateShop(shops);
+    }
+    
+    /**
+     * 删除店铺
+     * @param id 店铺ID
+     * @return 是否成功
+     */
+    @DeleteMapping("/delete/{id}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> deleteShop(@PathVariable Long id) {
+        logger.info("删除店铺，店铺ID：{}", id);
+        return shopsService.deleteShop(id);
+    }
+    
+    /**
+     * 根据店铺ID查询店铺
+     * @param id 店铺ID
+     * @return 店铺信息
+     */
+    @GetMapping("/{id}")
+    public Result<Shops> getShopById(@PathVariable Long id) {
+        logger.info("根据店铺ID查询店铺，店铺ID：{}", id);
+        return shopsService.getShopById(id);
+    }
+    
+    /**
+     * 分页查询店铺
+     * @param page 当前页码
+     * @param size 每页数量
+     * @return 店铺列表
+     */
+    @GetMapping("/page/{page}/{size}")
+    public Result<List<Shops>> listShopsByPage(@PathVariable int page, @PathVariable int size) {
+        logger.info("分页查询店铺，页码：{}，每页数量：{}", page, size);
+        return shopsService.listShopsByPage(page, size);
+    }
+    
+    /**
+     * 根据店铺分类ID查询店铺
+     * @param categoryId 分类ID
+     * @return 店铺列表
+     */
+    @GetMapping("/category/{categoryId}")
+    public Result<List<Shops>> getShopsByCategoryId(@PathVariable Long categoryId) {
+        logger.info("根据店铺分类ID查询店铺，分类ID：{}", categoryId);
+        return shopsService.getShopsByCategoryId(categoryId);
+    }
+    
+    /**
+     * 更新店铺状态
+     * @param shopId 店铺ID
+     * @param status 店铺状态
+     * @return 是否成功
+     */
+    @PutMapping("/update-status/{shopId}/{status}")
+    @PreAuthorize("hasRole('ROLE_ADMIN')")
+    public Result<Boolean> updateShopStatus(@PathVariable Long shopId, @PathVariable Integer status) {
+        logger.info("更新店铺状态，店铺ID：{}，状态：{}", shopId, status);
+        return shopsService.updateShopStatus(shopId, status);
+    }
+    
+    /**
+     * 搜索店铺
+     * @param keyword 关键词
+     * @param page 当前页码
+     * @param size 每页数量
+     * @return 店铺列表
+     */
+    @GetMapping("/search")
+    public Result<List<Shops>> searchShops(@RequestParam String keyword, @RequestParam int page, @RequestParam int size) {
+        logger.info("搜索店铺，关键词：{}，页码：{}，每页数量：{}", keyword, page, size);
+        return shopsService.searchShops(keyword, page, size);
+    }
+}

src/main/java/com/qf/backend/controller/UserRolesController.java

@@ -16,7 +16,7 @@ import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.security.access.prepost.PreAuthorize;
 
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.UserRoles;
 import com.qf.backend.service.UserRolesService;
 import java.util.List;

src/main/java/com/qf/backend/controller/UsersController.java

@@ -13,7 +13,7 @@ import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.security.access.prepost.PreAuthorize;
 
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Users;
 import com.qf.backend.service.UsersService;
 import java.util.List;

src/main/java/com/qf/backend/dto/Result.java

@@ -1,4 +1,4 @@
-package com.qf.backend.common;
+package com.qf.backend.dto;
 
 import lombok.Data;
 

src/main/java/com/qf/backend/exception/ExceptionUsageExample.java

@@ -1,7 +1,7 @@
 package com.qf.backend.exception;
 
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
+import com.qf.backend.util.ResultUtils;
 
 /**
  * 异常处理使用示例

src/main/java/com/qf/backend/exception/GlobalExceptionHandler.java

@@ -23,8 +23,8 @@ import org.springframework.web.bind.annotation.RestControllerAdvice;
 import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
 import org.springframework.web.servlet.NoHandlerFoundException;
 
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
+import com.qf.backend.util.ResultUtils;
 
 import jakarta.servlet.http.HttpServletRequest;
 import lombok.extern.slf4j.Slf4j;

src/main/java/com/qf/backend/inti/RoleInitializer.java

@@ -1,4 +1,4 @@
-package com.qf.backend.config;
+package com.qf.backend.inti;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

src/main/java/com/qf/backend/inti/UserInitializer.java

@@ -1,4 +1,4 @@
-package com.qf.backend.config;
+package com.qf.backend.inti;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -8,9 +8,6 @@ import org.springframework.stereotype.Component;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.qf.backend.entity.Users;
 import com.qf.backend.service.UsersService;
-import com.qf.backend.util.ValidateUtil;
-
-import jakarta.annotation.PostConstruct;
 
 /**
  * 用户初始化配置类，用于在系统启动时创建内置用户

src/main/java/com/qf/backend/service/OrderItemsService.java

@@ -3,7 +3,7 @@ package com.qf.backend.service;
 import java.util.List;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.OrderItems;
 
 /**

src/main/java/com/qf/backend/service/OrderStatusHistoryService.java

@@ -1,7 +1,7 @@
 package com.qf.backend.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.OrderStatusHistory;
 
 import java.util.List;

src/main/java/com/qf/backend/service/OrdersService.java

@@ -1,7 +1,7 @@
 package com.qf.backend.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Orders;
 
 import java.util.List;

src/main/java/com/qf/backend/service/PermissionsService.java

@@ -1,7 +1,7 @@
 package com.qf.backend.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Permissions;
 
 import java.util.List;

src/main/java/com/qf/backend/service/ProductAttributeValuesService.java

@@ -1,7 +1,7 @@
 package com.qf.backend.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.ProductAttributeValues;
 
 import java.util.List;

src/main/java/com/qf/backend/service/ProductAttributesService.java

@@ -1,7 +1,7 @@
 package com.qf.backend.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.ProductAttributes;
 
 import java.util.List;

src/main/java/com/qf/backend/service/ProductCategoriesService.java

@@ -1,7 +1,7 @@
 package com.qf.backend.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.ProductCategories;
 
 import java.util.List;

src/main/java/com/qf/backend/service/ProductImagesService.java

@@ -1,7 +1,7 @@
 package com.qf.backend.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.ProductImages;
 
 import java.util.List;

src/main/java/com/qf/backend/service/ProductInventoriesService.java

@@ -1,7 +1,7 @@
 package com.qf.backend.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.ProductInventories;
 
 import java.util.List;

src/main/java/com/qf/backend/service/ProductSkusService.java

@@ -1,7 +1,7 @@
 package com.qf.backend.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.ProductSkus;
 
 import java.util.List;

src/main/java/com/qf/backend/service/ProductsService.java

@@ -1,7 +1,7 @@
 package com.qf.backend.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Products;
 
 import java.util.List;

src/main/java/com/qf/backend/service/RolesService.java

@@ -3,7 +3,7 @@ package com.qf.backend.service;
 import java.util.List;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Roles;
 
 /**

src/main/java/com/qf/backend/service/ShopCategoriesService.java

@@ -1,7 +1,7 @@
 package com.qf.backend.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.ShopCategories;
 
 import java.util.List;

src/main/java/com/qf/backend/service/ShopRatingsService.java

@@ -1,7 +1,7 @@
 package com.qf.backend.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.ShopRatings;
 
 import java.util.List;

src/main/java/com/qf/backend/service/ShopsService.java

@@ -3,7 +3,7 @@ package com.qf.backend.service;
 import java.util.List;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Shops;
 
 /**

src/main/java/com/qf/backend/service/UserDetailsService.java

@@ -1,7 +1,7 @@
 package com.qf.backend.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.UserDetails;
 
 /**

src/main/java/com/qf/backend/service/UserLoginService.java

@@ -5,8 +5,8 @@
 
 package com.qf.backend.service;
 
-import com.qf.backend.common.Result;
 import com.qf.backend.dto.LoginResponse;
+import com.qf.backend.dto.Result;
 
 /**
  * 用户登录服务接口

src/main/java/com/qf/backend/service/UserRolesService.java

@@ -3,7 +3,7 @@ package com.qf.backend.service;
 import java.util.List;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.UserRoles;
 
 /**

src/main/java/com/qf/backend/service/UsersService.java

@@ -3,7 +3,7 @@ package com.qf.backend.service;
 import java.util.List;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Users;
 
 /**

src/main/java/com/qf/backend/service/impl/OrderItemsServiceImpl.java

@@ -13,13 +13,13 @@ import org.springframework.stereotype.Service;
 import com.baomidou.mybatisplus.core.conditions.Wrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.OrderItems;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.mapper.OrderItemsMapper;
 import com.qf.backend.service.OrderItemsService;
+import com.qf.backend.util.ResultUtils;
 
 @Service
 public class OrderItemsServiceImpl implements OrderItemsService  {

src/main/java/com/qf/backend/service/impl/OrderStatusHistoryServiceImpl.java

@@ -9,7 +9,7 @@ import org.springframework.stereotype.Service;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.OrderStatusHistory;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;

src/main/java/com/qf/backend/service/impl/OrdersServiceImpl.java

@@ -11,13 +11,13 @@ import org.springframework.stereotype.Service;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Orders;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.mapper.OrdersMapper;
 import com.qf.backend.service.OrdersService;
+import com.qf.backend.util.ResultUtils;
 
 @Service
 public class OrdersServiceImpl extends ServiceImpl<OrdersMapper, Orders> implements OrdersService {

src/main/java/com/qf/backend/service/impl/PermissionsServiceImpl.java

@@ -9,13 +9,13 @@ import org.springframework.stereotype.Service;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Permissions;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.mapper.PermissionsMapper;
 import com.qf.backend.service.PermissionsService;
+import com.qf.backend.util.ResultUtils;
 import com.qf.backend.util.ValidateUtil;
 
 @Service

src/main/java/com/qf/backend/service/impl/ProductAttributeValuesServiceImpl.java

@@ -7,13 +7,13 @@ import org.springframework.stereotype.Service;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.ProductAttributeValues;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.mapper.ProductAttributeValuesMapper;
 import com.qf.backend.service.ProductAttributeValuesService;
+import com.qf.backend.util.ResultUtils;
 import com.qf.backend.util.ValidateUtil;
 
 /**

src/main/java/com/qf/backend/service/impl/ProductAttributesServiceImpl.java

@@ -2,13 +2,13 @@ package com.qf.backend.service.impl;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.ProductAttributes;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.mapper.ProductAttributesMapper;
 import com.qf.backend.service.ProductAttributesService;
+import com.qf.backend.util.ResultUtils;
 import com.qf.backend.util.ValidateUtil;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;

src/main/java/com/qf/backend/service/impl/ProductCategoriesServiceImpl.java

@@ -2,13 +2,13 @@ package com.qf.backend.service.impl;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.ProductCategories;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.mapper.ProductCategoriesMapper;
 import com.qf.backend.service.ProductCategoriesService;
+import com.qf.backend.util.ResultUtils;
 import com.qf.backend.util.ValidateUtil;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;

src/main/java/com/qf/backend/service/impl/ProductImagesServiceImpl.java

@@ -10,13 +10,13 @@ import org.springframework.stereotype.Service;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.ProductImages;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.mapper.ProductImagesMapper;
 import com.qf.backend.service.ProductImagesService;
+import com.qf.backend.util.ResultUtils;
 import com.qf.backend.util.ValidateUtil;
 
 @Service

src/main/java/com/qf/backend/service/impl/ProductInventoriesServiceImpl.java

@@ -9,13 +9,13 @@ import org.springframework.stereotype.Service;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.ProductInventories;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.mapper.ProductInventoriesMapper;
 import com.qf.backend.service.ProductInventoriesService;
+import com.qf.backend.util.ResultUtils;
 import com.qf.backend.util.ValidateUtil;
 
 @Service

src/main/java/com/qf/backend/service/impl/ProductSkusServiceImpl.java

@@ -9,13 +9,13 @@ import org.springframework.stereotype.Service;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.ProductSkus;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.mapper.ProductSkusMapper;
 import com.qf.backend.service.ProductSkusService;
+import com.qf.backend.util.ResultUtils;
 import com.qf.backend.util.ValidateUtil;
 
 @Service

src/main/java/com/qf/backend/service/impl/ProductsServiceImpl.java

@@ -8,13 +8,13 @@ import org.springframework.stereotype.Service;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Products;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.mapper.ProductsMapper;
 import com.qf.backend.service.ProductsService;
+import com.qf.backend.util.ResultUtils;
 import com.qf.backend.util.ValidateUtil;
 
 /**

src/main/java/com/qf/backend/service/impl/RolesServiceImpl.java

@@ -15,13 +15,13 @@ import org.springframework.stereotype.Service;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Roles;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.mapper.RolesMapper;
 import com.qf.backend.service.RolesService;
+import com.qf.backend.util.ResultUtils;
 import com.qf.backend.util.ValidateUtil;
 
 /**

src/main/java/com/qf/backend/service/impl/ShopCategoriesServiceImpl.java

@@ -9,13 +9,13 @@ import org.springframework.stereotype.Service;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.ShopCategories;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.mapper.ShopCategoriesMapper;
 import com.qf.backend.service.ShopCategoriesService;
+import com.qf.backend.util.ResultUtils;
 import com.qf.backend.util.ValidateUtil;
 
 @Service

src/main/java/com/qf/backend/service/impl/ShopRatingsServiceImpl.java

@@ -10,13 +10,13 @@ import org.springframework.stereotype.Service;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.ShopRatings;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.mapper.ShopRatingsMapper;
 import com.qf.backend.service.ShopRatingsService;
+import com.qf.backend.util.ResultUtils;
 import com.qf.backend.util.ValidateUtil;
 
 @Service

src/main/java/com/qf/backend/service/impl/ShopsServiceImpl.java

@@ -10,13 +10,13 @@ import org.springframework.stereotype.Service;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Shops;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.mapper.ShopsMapper;
 import com.qf.backend.service.ShopsService;
+import com.qf.backend.util.ResultUtils;
 import com.qf.backend.util.ValidateUtil;
 
 @Service

src/main/java/com/qf/backend/service/impl/UserDetailsServiceImpl.java

@@ -12,7 +12,7 @@ import org.springframework.security.core.userdetails.UserDetailsService;
 import org.springframework.security.core.userdetails.UsernameNotFoundException;
 import org.springframework.stereotype.Service;
 
-import com.qf.backend.common.Result;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Roles;
 import com.qf.backend.entity.UserRoles;
 import com.qf.backend.entity.Users;

src/main/java/com/qf/backend/service/impl/UserLoginServiceImpl.java

@@ -15,9 +15,8 @@ import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
 import com.qf.backend.dto.LoginResponse;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Permissions;
 import com.qf.backend.entity.Roles;
 import com.qf.backend.entity.UserRoles;
@@ -29,6 +28,7 @@ import com.qf.backend.service.RolesService;
 import com.qf.backend.service.UserLoginService;
 import com.qf.backend.service.UserRolesService;
 import com.qf.backend.service.UsersService;
+import com.qf.backend.util.ResultUtils;
 import com.qf.backend.util.ValidateUtil;
 
 

src/main/java/com/qf/backend/service/impl/UsersRolesServiceImpl.java

@@ -12,13 +12,13 @@ import org.springframework.stereotype.Service;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.UserRoles;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.mapper.UserRolesMapper;
 import com.qf.backend.service.UserRolesService;
+import com.qf.backend.util.ResultUtils;
 
 
 

src/main/java/com/qf/backend/service/impl/UsersServiceImpl.java

@@ -12,13 +12,13 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.qf.backend.common.Result;
-import com.qf.backend.common.ResultUtils;
+import com.qf.backend.dto.Result;
 import com.qf.backend.entity.Users;
 import com.qf.backend.exception.BusinessException;
 import com.qf.backend.exception.ErrorCode;
 import com.qf.backend.mapper.UsersMapper;
 import com.qf.backend.service.UsersService;
+import com.qf.backend.util.ResultUtils;
 import com.qf.backend.util.ValidateUtil;
 
 @Service

src/main/java/com/qf/backend/util/ResultUtils.java

@@ -1,7 +1,10 @@
-package com.qf.backend.common;
+package com.qf.backend.util;
 
+import com.qf.backend.dto.Result;
 import com.qf.backend.exception.ErrorCode;
 
+
+
 /**
  * 响应结果工具类
  * 提供各种响应结果的快速创建方法