@RestController("userOrderController")
@RequestMapping("/user/order")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @PostMapping("/submit")
    public Result<OrderSubmitVO> submit(@RequestBody OrdersSubmitDTO ordersSubmitDTO) {
        OrderSubmitVO orderSubmitVO = orderService.submitOrder(ordersSubmitDTO);
        return Result.success(orderSubmitVO);
    }
}

① 小程序发送 POST 请求到 /user/order/submit（JSON 格式的地址、购物车等数据）
        ↓
② DispatcherServlet 接收请求，查找匹配的 Controller 方法
        ↓
③ 找到 OrderController.submit() 方法
        ↓
④ Spring MVC 自动完成：
   - JWT 拦截器验证 token（WebMvcConfiguration 中配置的）
   - JSON 参数 → OrdersSubmitDTO 对象（@RequestBody）
   - 调用 orderService.submitOrder() 处理业务
        ↓
⑤ Service 层查询地址簿、检查配送范围、创建订单
        ↓
⑥ Controller 拿到结果，Spring MVC 自动封装为 JSON 响应
        ↓
⑦ 小程序收到下单结果

public Result<OrderSubmitVO> submit(...) {
    OrderSubmitVO vo = orderService.submitOrder(dto);
    return Result.success(vo);
}

public class OrderController {
    // 高耦合：Controller 直接 new 出 Service 实现类
    private OrderService orderService = new OrderServiceImpl();
}

@RestController("userOrderController")
@RequestMapping("/user/order")
public class OrderController {

    @Autowired
    private OrderService orderService;  // 依赖接口，不依赖实现类

    @PostMapping("/submit")
    public Result<OrderSubmitVO> submit(@RequestBody OrdersSubmitDTO 
    ordersSubmitDTO) {
        OrderSubmitVO orderSubmitVO = orderService.submitOrder(ordersSubmitDTO);
        return Result.success(orderSubmitVO);
    }
}

@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private OrderDetailMapper orderDetailMapper;
    @Autowired
    private ShoppingCartMapper shoppingCartMapper;
    @Autowired
    private AddressBookMapper addressBookMapper;
    @Autowired
    private WeChatPayUtil weChatPayUtil;

@Autowired
private OrderService orderService;

// 原始 JDBC 写法（伪代码）
public AddressBook getById(Long id) {
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    try {
        conn = DriverManager.getConnection(url, user, password);
        ps = conn.prepareStatement("select * from address_book where id = ?");
        ps.setLong(1, id);
        rs = ps.executeQuery();
        if (rs.next()) {
            AddressBook ab = new AddressBook();
            ab.setId(rs.getLong("id"));
            ab.setUserId(rs.getLong("user_id"));
            ab.setConsignee(rs.getString("consignee"));
            ab.setPhone(rs.getString("phone"));
            ab.setProvinceName(rs.getString("province_name"));
            // ... 还要写十几行 setter
            return ab;
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 手动关闭 ResultSet、PreparedStatement、Connection
        if (rs != null) try { rs.close(); } catch (SQLException e) {}
        if (ps != null) try { ps.close(); } catch (SQLException e) {}
        if (conn != null) try { conn.close(); } catch (SQLException e) {}
    }
    return null;
}

@Mapper
public interface AddressBookMapper {
    @Select("select * from address_book where id = #{id}")
    AddressBook getById(Long id);
}

@Component
@Slf4j
public class JwtTokenUserInterceptor implements HandlerInterceptor {

    @Autowired
    private JwtProperties jwtProperties;

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // ① 判断是不是 Controller 方法
        if (!(handler instanceof HandlerMethod)) {
            return true;  // 不是 Controller 方法，直接放行
        }

        // ② 从请求头获取 token
        String token = request.getHeader(jwtProperties.getUserTokenName());

        try {
            // ③ 解析校验 JWT
            Claims claims = JwtUtil.parseJWT(jwtProperties.getUserSecretKey(), token);
            Long userId = Long.valueOf(claims.get(JwtClaimsConstant.USER_ID).toString());
            // ④ 把用户 id 存入 ThreadLocal，Service 层可以直接取
            BaseContext.setCurrentId(userId);
            return true;  // 放行
        } catch (Exception ex) {
            // ⑤ 校验失败，返回 401
            response.setStatus(401);
            return false; // 拦截，请求到此为止
        }
    }
}

@Target(ElementType.METHOD)   // 作用在方法上
@Retention(RetentionPolicy.RUNTIME)  // 运行时保留
public @interface AutoFill {
    OperationType value();     // INSERT 或 UPDATE
}

@Aspect       // ① 声明这是一个切面
@Component    // ② 交给 Spring 管理
@Slf4j
public class AutoFillAspect {

    // ③ 定义切入点：拦截 mapper 包下所有带 @AutoFill 注解的方法
    @Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)")
    public void autoFillPointCut() {}

    // ④ 前置通知：在目标方法执行前运行
    @Before("autoFillPointCut()")
    public void autoFill(JoinPoint joinPoint) {
        // 获取方法上的 @AutoFill 注解，知道是 INSERT 还是 UPDATE
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        AutoFill autoFill = signature.getMethod().getAnnotation(AutoFill.class);
        OperationType operationType = autoFill.value();

        // 获取方法参数（实体对象）
        Object[] args = joinPoint.getArgs();
        Object entity = args[0];

        LocalDateTime now = LocalDateTime.now();
        Long currentId = BaseContext.getCurrentId();

        if (operationType == OperationType.INSERT) {
            // 通过反射调用 setCreateTime、setCreateUser、setUpdateTime、setUpdateUser
            entity.getClass().getDeclaredMethod("setCreateTime", LocalDateTime.class).invoke(entity, now);
            entity.getClass().getDeclaredMethod("setCreateUser", Long.class).invoke(entity, currentId);
            entity.getClass().getDeclaredMethod("setUpdateTime", LocalDateTime.class).invoke(entity, now);
            entity.getClass().getDeclaredMethod("setUpdateUser", Long.class).invoke(entity, currentId);
        } else if (operationType == OperationType.UPDATE) {
            // 只填充 updateTime 和 updateUser
            entity.getClass().getDeclaredMethod("setUpdateTime", LocalDateTime.class).invoke(entity, now);
            entity.getClass().getDeclaredMethod("setUpdateUser", Long.class).invoke(entity, currentId);
        }
    }
}

@AutoFill(value = OperationType.INSERT)
@Insert("insert into category(...)")
void insert(Category category);

@AutoFill(value = OperationType.UPDATE)
void update(Category category);

@Configuration
public class RedisConfiguration {
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate();
        //创建redis的连接工厂对象
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 设置 key 的序列化器为 String，避免 key 在 Redis 中显示为乱码
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

@PutMapping("/{status}")
public Result setStatus(@PathVariable Integer status) {
    redisTemplate.opsForValue().set("SHOP_STATUS", status);
    return Result.success();
}

@GetMapping("/status")
public Result<Integer> getStatus() {
    Integer status = (Integer) redisTemplate.opsForValue().get("SHOP_STATUS");
    return Result.success(status);
}

@GetMapping("/list")
public Result<List<DishVO>> list(Long categoryId) {
    // ① 构造 Redis key：dish_分类id
    String key = "dish_" + categoryId;

    // ② 先查 Redis 缓存
    List<DishVO> list = (List<DishVO>) redisTemplate.opsForValue().get(key);
    if (list != null && list.size() > 0) {
        return Result.success(list);  // 缓存命中，直接返回
    }

    // ③ 缓存未命中，查数据库
    Dish dish = new Dish();
    dish.setCategoryId(categoryId);
    dish.setStatus(StatusConstant.ENABLE);
    list = dishService.listWithFlavor(dish);

    // ④ 写入 Redis 缓存
    redisTemplate.opsForValue().set(key, list);
    return Result.success(list);
}

// 用 Redis 做后端 → Spring Cache 注解 → 数据存到 Redis
// 用 Caffeine 做后端 → Spring Cache 注解 → 数据存到本地内存
// 用 EhCache 做后端 → Spring Cache 注解 → 数据存到本地文件

@SpringBootApplication
@EnableCaching  // 开启 Spring Cache 注解功能
public class SkyApplication {
    public static void main(String[] args) {
        SpringApplication.run(SkyApplication.class, args);
    }
}

@GetMapping("/list")
@Cacheable(cacheNames = "setmealCache", key = "#categoryId")
public Result<List<Setmeal>> list(Long categoryId) {
    // 第一次请求：执行方法体，返回值自动缓存
    // 后续请求：方法体不执行，直接返回缓存值
    Setmeal setmeal = new Setmeal();
    setmeal.setCategoryId(categoryId);
    setmeal.setStatus(StatusConstant.ENABLE);
    List<Setmeal> list = setmealService.list(setmeal);
    return Result.success(list);
}

@DeleteMapping
@CacheEvict(cacheNames = "setmealCache", allEntries = true)  // 清空整个 setmealCache
public Result delete(@RequestParam List<Long> ids) {
    setmealService.deleteBatch(ids);
    return Result.success();
}

@Cacheable(
    cacheNames = "setmealCache",   // 缓存命名空间，最终 Redis key 是 "setmealCache::10"
    key = "#categoryId",           // SpEL 表达式，指定缓存的 key
    condition = "#categoryId > 0", // 条件：只有满足条件才缓存
    unless = "#result == null"     // 排除条件：结果为 null 时不缓存
)

package com.sky.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

/**
 * WebSocket配置类，用于注册WebSocket的Bean
 */
@Configuration
public class WebSocketConfiguration {

    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }

}

public static void write() throws Exception{
    //在内存中创建一个Excel文件
    XSSFWorkbook excel = new XSSFWorkbook();
    //在Excel文件中创建一个Sheet页
    XSSFSheet sheet = excel.createSheet("info");
    //在Sheet中创建行对象,rownum编号从0开始
    XSSFRow row = sheet.createRow(1);
    //创建单元格并且写入文件内容
    row.createCell(1).setCellValue("姓名");
    row.createCell(2).setCellValue("城市");

    //创建一个新行
    row = sheet.createRow(2);
    row.createCell(1).setCellValue("张三");
    row.createCell(2).setCellValue("北京");

    row = sheet.createRow(3);
    row.createCell(1).setCellValue("李四");
    row.createCell(2).setCellValue("南京");

    //通过输出流将内存中的Excel文件写入到磁盘
    FileOutputStream out = new FileOutputStream(new File("D:\\info.xlsx"));
    excel.write(out);
    
    //关闭资源
    excel.close();
    out.close();
}

public static void read() throws Exception{
    InputStream in = new FileInputStream(new File("D:\\info.xlsx"));
    
    //读取磁盘上已经存在的Excel文件
    XSSFWorkbook excel = new XSSFWorkbook(in);
    //读取Excel文件中的第一个Sheet页
    XSSFSheet sheet = excel.getSheetAt(0);
    
    //获取Sheet中最后一行的行号
    int lastRowNum = sheet.getLastRowNum();
    
    for (int i = 1; i <= lastRowNum ; i++) {
        //获得某一行
        XSSFRow row = sheet.getRow(i);
        //获得单元格对象
        String cellValue1 = row.getCell(1).getStringCellValue();
        String cellValue2 = row.getCell(2).getStringCellValue();
        System.out.println(cellValue1 + " " + cellValue2);
    }
    
    //关闭资源
    in.close();
    excel.close();
}

/**
 * 导出运营数据报表
 * @param response
 */
public void exportBusinessData(HttpServletResponse response) {
    //1. 查询数据库，获取营业数据---查询最近30天的运营数据
    LocalDate dateBegin = LocalDate.now().minusDays(30);
    LocalDate dateEnd = LocalDate.now().minusDays(1);

    //查询概览数据
    BusinessDataVO businessDataVO = workspaceService.getBusinessData(LocalDateTime.of(dateBegin, LocalTime.MIN), LocalDateTime.of(dateEnd, LocalTime.MAX));

    //2. 通过POI将数据写入到Excel文件中
    InputStream in = this.getClass().getClassLoader().getResourceAsStream("template/运营数据报表模板.xlsx");

    try {
        //基于模板文件创建一个新的Excel文件
        XSSFWorkbook excel = new XSSFWorkbook(in);

        //获取表格文件的Sheet页
        XSSFSheet sheet = excel.getSheet("Sheet1");

        //填充数据--时间
        sheet.getRow(1).getCell(1).setCellValue("时间：" + dateBegin + "至" + dateEnd);

        //获得第4行
        XSSFRow row = sheet.getRow(3);
        row.getCell(2).setCellValue(businessDataVO.getTurnover());
        row.getCell(4).setCellValue(businessDataVO.getOrderCompletionRate());
        row.getCell(6).setCellValue(businessDataVO.getNewUsers());

        //获得第5行
        row = sheet.getRow(4);
        row.getCell(2).setCellValue(businessDataVO.getValidOrderCount());
        row.getCell(4).setCellValue(businessDataVO.getUnitPrice());

        //填充明细数据
        for (int i = 0; i < 30; i++) {
            LocalDate date = dateBegin.plusDays(i);
            //查询某一天的营业数据
            BusinessDataVO businessData = workspaceService.getBusinessData(LocalDateTime.of(date, LocalTime.MIN), LocalDateTime.of(date, LocalTime.MAX));

            //获得某一行
            row = sheet.getRow(7 + i);
            row.getCell(1).setCellValue(date.toString());
            row.getCell(2).setCellValue(businessData.getTurnover());
            row.getCell(3).setCellValue(businessData.getValidOrderCount());
            row.getCell(4).setCellValue(businessData.getOrderCompletionRate());
            row.getCell(5).setCellValue(businessData.getUnitPrice());
            row.getCell(6).setCellValue(businessData.getNewUsers());
        }

        //3. 通过输出流将Excel文件下载到客户端浏览器
        ServletOutputStream out = response.getOutputStream();
        excel.write(out);

        //关闭资源
        out.close();
        excel.close();
    } catch (IOException e) {
        e.printStackTrace();
    }