// 来自 FlowTaskController.java
@RestController
@RequestMapping("/flow-tasks")
@Tag(name = "流程任务", description = "流程任务管理")
public class FlowTaskController {

    @PostMapping("/todo/mine")
    @Operation(summary = "我的待办")
    public IPage<TodoTaskPageResp> myTodo(@RequestBody TaskPageReq req);

    @PostMapping("/done/mine")
    @Operation(summary = "我的已办")
    public IPage<DoneTaskPageResp> myDone(@RequestBody TaskPageReq req);

    @PostMapping("/{id}/approve")
    @RedisLock(prefix = "workflow:task:handle", message = "请稍后重试")
    @Operation(summary = "审批通过")
    public void approve(@PathVariable Long id, @RequestBody WorkflowTaskReq req);

    @PostMapping("/{id}/reject")
    @Operation(summary = "审批拒绝")
    public void reject(@PathVariable Long id, @RequestBody WorkflowTaskReq req);

    @PostMapping("/{id}/return")
    @Operation(summary = "任务驳回")
    public void returnTask(@PathVariable Long id, @RequestBody WorkflowTaskReq req);

    @PostMapping("/{id}/terminate")
    @Operation(summary = "任务终止")
    public void terminate(@PathVariable Long id, @RequestBody WorkflowTaskReq req);

    @PostMapping("/{id}/transfer")
    @Operation(summary = "任务转办")
    public void transfer(@PathVariable Long id, @RequestBody WorkflowTaskReq req);

    @PostMapping("/{id}/sign/add")
    @Operation(summary = "任务加签")
    public void addSign(@PathVariable Long id, @RequestBody WorkflowTaskReq req);

    @PostMapping("/{id}/sign/remove")
    @Operation(summary = "任务减签")
    public void removeSign(@PathVariable Long id, @RequestBody WorkflowTaskReq req);
}

// 来自 FlowInstanceController.java
@RestController
@RequestMapping("/flow-instances")
@Tag(name = "流程实例", description = "流程实例管理")
public class FlowInstanceController {

    @GetMapping
    @Operation(summary = "分页查询")
    public IPage<InstancePageResp> page(InstancePageReq req);

    @GetMapping("/{id}/detail")
    @Operation(summary = "实例详情")
    public InstanceExtDetailResp detail(@PathVariable Long id);

    @GetMapping("/mine")
    @Operation(summary = "我的流程")
    public IPage<InstancePageResp> mine(InstancePageReq req);

    @PutMapping("/{id}/active")
    @Operation(summary = "激活实例")
    public void active(@PathVariable Long id);

    @PutMapping("/{id}/suspend")
    @Operation(summary = "挂起实例")
    public void suspend(@PathVariable Long id);

    @GetMapping("/{id}/tasks")
    @Operation(summary = "任务列表")
    public List<Task> tasks(@PathVariable Long id);

    @GetMapping("/{id}/tasks/history")
    @Operation(summary = "历史任务")
    public List<FlowTaskApproveListResp> taskHistory(@PathVariable Long id);

    @GetMapping("/{id}/form")
    @Operation(summary = "表单预览")
    public ProcessInstanceFormPreviewResp form(@PathVariable String id);
}

// 来自 WorkflowTaskReq.java
@Data
public class WorkflowTaskReq {

    @NotBlank(message = "任务处理意见不能为空")
    @Schema(description = "任务处理意见")
    private String message;

    @Schema(description = "处理对象", example = "1,role:1,role:2")
    private String handlerObject;

    @Schema(description = "流程变量")
    private Map<String, Object> variable = new HashMap<>();
}

// 来自 TaskExtServiceImpl.java
@Override
@Transactional(rollbackFor = Exception.class)
public void pass(Long id, WorkflowTaskReq req) {
    Map<String, Object> variable = ObjUtil.defaultIfNull(req.getVariable(), Maps.newHashMap());
    variable.put(VariableConstant.VAR_APPROVE_USER, context.nickName());
    
    FlowParams flowParams = FlowParams.build()
            .skipType(ApprovalType.PASS.getValue())
            .message(req.getMessage())
            .hisTaskExt(ApprovalAction.PASS.getValue())
            .variable(variable);
    
    taskService.skip(id, flowParams);
}

@Override
@Transactional(rollbackFor = Exception.class)
public void taskReturn(Long id, WorkflowTaskReq req) {
    FlowParams flowParams = FlowParams.build();
    flowParams.message(req.getMessage());
    taskService.rejectLast(id, flowParams);  // 驳回到上一节点
}

// 转办
@Override
@Transactional(rollbackFor = Exception.class)
public void transfer(Long taskId, WorkflowTaskReq req) {
    List<String> list = handlerChangeObject(req);
    taskService.transfer(taskId, FlowParams.build()
        .message(req.getMessage())
        .addHandlers(list));
}

// 加签
@Override
public void addSignature(Long taskId, WorkflowTaskReq req) {
    taskService.addSignature(taskId, FlowParams.build()
        .addHandlers(handlerChangeObject(req)));
}

// 减签
@Override
public void removeSignature(Long taskId, WorkflowTaskReq req) {
    taskService.reductionSignature(taskId, FlowParams.build()
        .reductionHandlers(handlerChangeObject(req)));
}

// handlerObject 格式：用户ID 或 role:角色ID
private List<String> handlerChangeObject(WorkflowTaskReq req) {
    if (StrUtil.isBlank(req.getHandlerObject())) {
        throw CheckedException.badRequest("需要修改的对象不能为空！");
    }
    return StrUtil.split(req.getHandlerObject(), ",");
}

@PostMapping("/{id}/approve")
@RedisLock(prefix = "workflow:task:handle", message = "当前已有任务处理中，请稍后重试")
public void approve(@PathVariable @RedisParam Long id, @RequestBody WorkflowTaskReq req) {
    taskExtService.pass(id, req);
}

@RequiredArgsConstructor
public class DemoService {
    private final AuthenticationContext context;
    
    public void demo() {
        Long userId = context.getUserId();
        Long tenantId = context.getTenantId();
        String username = context.getUsername();
    }
}

@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
    return interceptor;
}

@DS("slave")
public List<User> queryFromSlave() {
    return userMapper.selectList(null);
}

@IgnoreTenant
public List<Dict> queryAllDict() {
    return dictMapper.selectList(null);
}

// 使用 MapStruct 进行对象转换
@Mapper(componentModel = "spring")
public interface OrderConvert {
    
    OrderConvert INSTANCE = Mappers.getMapper(OrderConvert.class);
    
    OrderVO toVO(Order order);
    
    List<OrderVO> toVOList(List<Order> orders);
    
    Order toEntity(OrderDTO dto);
    
    @Mapping(target = "statusName", expression = "java(order.getStatus().getDesc())")
    OrderDetailVO toDetailVO(Order order);
}

// 使用
OrderVO vo = OrderConvert.INSTANCE.toVO(order);

// 业务异常基类
public class BizException extends RuntimeException {
    private Integer code;
    private String message;
    
    public BizException(String message) {
        this(ResultCode.BIZ_ERROR.getCode(), message);
    }
    
    public BizException(ResultCode resultCode) {
        this(resultCode.getCode(), resultCode.getMessage());
    }
    
    public BizException(Integer code, String message) {
        super(message);
        this.code = code;
        this.message = message;
    }
}

// 结果码枚举
public enum ResultCode {
    SUCCESS(0, "成功"),
    BIZ_ERROR(10000, "业务异常"),
    PARAM_ERROR(10001, "参数错误"),
    NOT_FOUND(10002, "资源不存在"),
    UNAUTHORIZED(10003, "未授权"),
    FORBIDDEN(10004, "禁止访问"),
    ;
    
    private final Integer code;
    private final String message;
}

// 工具类
public class BizAssert {
    
    public static void notNull(Object obj, String message) {
        if (obj == null) {
            throw new BizException(message);
        }
    }
    
    public static void isTrue(boolean expression, String message) {
        if (!expression) {
            throw new BizException(message);
        }
    }
    
    public static void notEmpty(Collection<?> collection, String message) {
        if (collection == null || collection.isEmpty()) {
            throw new BizException(message);
        }
    }
}

// 使用
public void updateOrder(Long orderId, OrderDTO dto) {
    Order order = orderMapper.selectById(orderId);
    BizAssert.notNull(order, "订单不存在");
    BizAssert.isTrue(order.canUpdate(), "订单状态不允许修改");
    
    // 业务逻辑
}

@Service
@RequiredArgsConstructor
public class OrderService {
    
    // 基本事务
    @Transactional(rollbackFor = Exception.class)
    public void createOrder(OrderDTO dto) {
        // 所有操作在同一事务中
    }
    
    // 只读事务
    @Transactional(readOnly = true)
    public OrderVO getDetail(Long id) {
        // 只读操作
    }
    
    // 新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void saveLog(String message) {
        // 无论外层事务是否回滚，日志都会保存
    }
}

// ❌ 同类方法调用，事务失效
@Service
public class OrderService {
    
    public void process() {
        this.createOrder();  // 事务失效
    }
    
    @Transactional
    public void createOrder() {
        // ...
    }
}

// ✅ 解决方案1：注入自己
@Service
public class OrderService {
    
    @Autowired
    private OrderService self;
    
    public void process() {
        self.createOrder();  // 事务生效
    }
}

// ✅ 解决方案2：使用 AopContext
public void process() {
    ((OrderService) AopContext.currentProxy()).createOrder();
}

// ❌ 异常被捕获，事务失效
@Transactional
public void createOrder() {
    try {
        // 业务逻辑
    } catch (Exception e) {
        log.error("error", e);
        // 异常被吃掉，事务不会回滚
    }
}

// ✅ 正确做法
@Transactional
public void createOrder() {
    try {
        // 业务逻辑
    } catch (Exception e) {
        log.error("error", e);
        throw e;  // 重新抛出
    }
}

@Data
public class UserDTO {
    
    @NotBlank(message = "用户名不能为空")
    @Size(min = 2, max = 20, message = "用户名长度2-20个字符")
    @Pattern(regexp = "^[a-zA-Z0-9_]+$", message = "用户名只能包含字母、数字、下划线")
    private String username;
    
    @NotBlank(message = "密码不能为空")
    @Size(min = 6, max = 20, message = "密码长度6-20个字符")
    private String password;
    
    @Email(message = "邮箱格式不正确")
    private String email;
    
    @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确")
    private String mobile;
}

// Controller
@PostMapping
public Result<Void> create(@RequestBody @Valid UserDTO dto) {
    // 参数已校验
}

// ❌ 危险：字符串拼接
String sql = "SELECT * FROM user WHERE name = '" + name + "'";

// ✅ 安全：使用参数绑定
@Select("SELECT * FROM user WHERE name = #{name}")
User selectByName(@Param("name") String name);

// ✅ 安全：使用 Wrapper
lambdaQuery().eq(User::getName, name).list();

// 配置 XSS 过滤器
@Configuration
public class XssConfig {
    
    @Bean
    public FilterRegistrationBean<XssFilter> xssFilterRegistration() {
        FilterRegistrationBean<XssFilter> registration = new FilterRegistrationBean<>();
        registration.setFilter(new XssFilter());
        registration.addUrlPatterns("/*");
        registration.setOrder(1);
        return registration;
    }
}

// 或使用 Hutool 的 HtmlUtil
String safe = HtmlUtil.escape(userInput);

// 返回 VO 时脱敏
@Data
public class UserVO {
    private Long id;
    private String username;
    
    @JsonSerialize(using = MobileSerializer.class)
    private String mobile;  // 138****8888
    
    @JsonSerialize(using = IdCardSerializer.class)
    private String idCard;  // 110***********1234
}

// 自定义序列化器
public class MobileSerializer extends JsonSerializer<String> {
    @Override
    public void serialize(String value, JsonGenerator gen, SerializerProvider provider) 
        throws IOException {
        if (StrUtil.isNotBlank(value) && value.length() == 11) {
            gen.writeString(value.substring(0, 3) + "****" + value.substring(7));
        } else {
            gen.writeString(value);
        }
    }
}

// ✅ 好的日志
log.info("创建订单成功, orderId={}, userId={}, amount={}", orderId, userId, amount);
log.error("调用支付接口失败, orderId={}, errorCode={}", orderId, errorCode, e);

// ❌ 不好的日志
log.info("创建订单成功");  // 缺少关键信息
log.info("创建订单成功, 订单: " + order);  // 字符串拼接性能差
log.error(e.getMessage());  // 丢失堆栈信息

@Data
public class Result<T> {
    private Integer code;
    private String message;
    private T data;
    private Long timestamp;
    
    public static <T> Result<T> success(T data) {
        Result<T> result = new Result<>();
        result.setCode(0);
        result.setMessage("success");
        result.setData(data);
        result.setTimestamp(System.currentTimeMillis());
        return result;
    }
    
    public static <T> Result<T> fail(Integer code, String message) {
        Result<T> result = new Result<>();
        result.setCode(code);
        result.setMessage(message);
        result.setTimestamp(System.currentTimeMillis());
        return result;
    }
}

// 分页查询
@GetMapping
public Result<IPage<OrderVO>> page(
    @RequestParam(defaultValue = "1") Integer current,
    @RequestParam(defaultValue = "10") Integer size,
    OrderQuery query
) {
    IPage<OrderVO> page = orderService.page(current, size, query);
    return Result.success(page);
}

// 响应示例
{
    "code": 0,
    "message": "success",
    "data": {
        "records": [...],
        "total": 100,
        "size": 10,
        "current": 1,
        "pages": 10
    }
}

@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
    
    @Mock
    private OrderMapper orderMapper;
    
    @Mock
    private StockService stockService;
    
    @InjectMocks
    private OrderServiceImpl orderService;
    
    @Test
    void createOrder_Success() {
        // Given
        OrderDTO dto = new OrderDTO();
        dto.setProductId(1L);
        dto.setQuantity(2);
        
        when(stockService.checkStock(1L, 2)).thenReturn(true);
        
        // When
        orderService.createOrder(dto);
        
        // Then
        verify(orderMapper).insert(any(Order.class));
        verify(stockService).deduct(1L, 2);
    }
    
    @Test
    void createOrder_StockNotEnough() {
        // Given
        OrderDTO dto = new OrderDTO();
        dto.setProductId(1L);
        dto.setQuantity(100);
        
        when(stockService.checkStock(1L, 100)).thenReturn(false);
        
        // When & Then
        assertThrows(BizException.class, () -> orderService.createOrder(dto));
    }
}

@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
@AutoConfigureMockMvc
class OrderControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @Test
    void createOrder_Success() throws Exception {
        OrderDTO dto = new OrderDTO();
        dto.setProductId(1L);
        dto.setQuantity(2);
        
        mockMvc.perform(post("/api/orders")
                .contentType(MediaType.APPLICATION_JSON)
                .content(JsonUtil.toJson(dto)))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.code").value(0));
    }
}

// ❌ 循环依赖
@Service
public class AService {
    @Autowired
    private BService bService;
}

@Service
public class BService {
    @Autowired
    private AService aService;
}

// ✅ 解决方案：使用 @Lazy
@Service
public class AService {
    @Lazy
    @Autowired
    private BService bService;
}

// ❌ N+1 问题
List<Order> orders = orderMapper.selectList(null);
for (Order order : orders) {
    User user = userMapper.selectById(order.getUserId());  // N 次查询
    order.setUserName(user.getName());
}

// ✅ 批量查询
List<Order> orders = orderMapper.selectList(null);
Set<Long> userIds = orders.stream().map(Order::getUserId).collect(Collectors.toSet());
Map<Long, User> userMap = userMapper.selectBatchIds(userIds).stream()
    .collect(Collectors.toMap(User::getId, Function.identity()));
orders.forEach(order -> order.setUserName(userMap.get(order.getUserId()).getName()));