public class UserService {
    
    public User createUser(UserCreateRequest request) {
        // 参数验证
        Objects.requireNonNull(request, "请求对象不能为空");
        if (request.getEmail() == null || !isValidEmail(request.getEmail())) {
            throw new IllegalArgumentException("邮箱格式不正确");
        }
        if (request.getPassword() == null || request.getPassword().length() < 8) {
            throw new IllegalArgumentException("密码长度至少8位");
        }
        
        // 业务逻辑
        return userRepository.save(toEntity(request));
    }
    
    private boolean isValidEmail(String email) {
        return email != null && email.matches("^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$");
    }
}

@Service
public class PaymentService {
    
    public PaymentResult processPayment(PaymentRequest request) {
        try {
            validateRequest(request);
            return executePayment(request);
        } catch (ValidationException e) {
            log.error("支付请求验证失败: {}", e.getMessage(), e);
            return PaymentResult.failure("参数错误: " + e.getMessage());
        } catch (PaymentProcessingException e) {
            log.error("支付处理失败: {}", e.getMessage(), e);
            return PaymentResult.failure("支付失败，请稍后重试");
        } catch (Exception e) {
            log.error("支付处理发生未知错误: {}", e.getMessage(), e);
            return PaymentResult.systemError();
        }
    }
}

@Service
public class OrderService {
    
    public OrderDetail getOrderDetail(Long orderId) {
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new OrderNotFoundException("订单不存在: " + orderId));
            
        Customer customer = customerRepository.findById(order.getCustomerId())
            .orElse(null);
            
        // 使用Optional处理可能为空的对象
        String customerName = Optional.ofNullable(customer)
            .map(Customer::getName)
            .orElse("匿名用户");
            
        return new OrderDetail(order, customerName);
    }
}

@Service
public class FileService {
    
    public String readFile(String filePath) {
        // 使用try-with-resources确保资源自动释放
        try (BufferedReader reader = Files.newBufferedReader(Paths.get(filePath))) {
            return reader.lines()
                .collect(Collectors.joining("\n"));
        } catch (IOException e) {
            log.error("读取文件失败: {}", filePath, e);
            throw new FileOperationException("读取文件失败", e);
        }
    }
}

@Service
public class CounterService {
    
    private final ConcurrentHashMap<String, AtomicLong> counters = new ConcurrentHashMap<>();
    
    public long increment(String key) {
        return counters.computeIfAbsent(key, k -> new AtomicLong(0))
                      .incrementAndGet();
    }
    
    // 使用ConcurrentHashMap避免并发修改异常
    public Map<String, Long> getAllCounters() {
        Map<String, Long> result = new HashMap<>();
        counters.forEach((key, value) -> result.put(key, value.get()));
        return Collections.unmodifiableMap(result);
    }
}

@Repository
public class UserRepository {
    
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    // 使用参数化查询防止SQL注入
    public List<User> findUsersByName(String name) {
        String sql = "SELECT * FROM users WHERE name LIKE ?";
        return jdbcTemplate.query(sql, 
            new Object[]{"%" + escapeLikePattern(name) + "%"}, 
            new BeanPropertyRowMapper<>(User.class));
    }
    
    // 转义LIKE语句中的特殊字符
    private String escapeLikePattern(String pattern) {
        return pattern.replace("\\", "\\\\")
                     .replace("%", "\\%")
                     .replace("_", "\\_");
    }
}

@ControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(IllegalArgumentException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public ErrorResponse handleIllegalArgument(IllegalArgumentException e) {
        log.warn("参数错误: {}", e.getMessage());
        return new ErrorResponse("PARAM_ERROR", e.getMessage());
    }
    
    @ExceptionHandler(ResourceNotFoundException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public ErrorResponse handleNotFound(ResourceNotFoundException e) {
        log.info("资源未找到: {}", e.getMessage());
        return new ErrorResponse("RESOURCE_NOT_FOUND", e.getMessage());
    }
    
    @ExceptionHandler(Exception.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public ErrorResponse handleGeneric(Exception e) {
        log.error("系统内部错误", e);
        return new ErrorResponse("SYSTEM_ERROR", "系统繁忙，请稍后重试");
    }
}

public class UserCreateRequest {
    
    @NotBlank(message = "用户名不能为空")
    @Size(min = 2, max = 20, message = "用户名长度应在2-20之间")
    private String username;
    
    @Email(message = "邮箱格式不正确")
    @NotBlank(message = "邮箱不能为空")
    private String email;
    
    @NotBlank(message = "密码不能为空")
    @Size(min = 8, max = 20, message = "密码长度应在8-20之间")
    @Pattern(regexp = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)[a-zA-Z\\d@$!%*?&]{8,}$", 
             message = "密码必须包含大小写字母和数字")
    private String password;
    
    // getters and setters...
}

@Service
public class ExternalApiService {
    
    // 使用Resilience4j进行熔断
    private final CircuitBreaker circuitBreaker = CircuitBreaker.ofDefaults("external-api");
    
    // 限流
    private final RateLimiter rateLimiter = RateLimiter.ofDefaults("api-call");
    
    public ApiResponse callExternalApi(String param) {
        Supplier<CompletableFuture<ApiResponse>> decoratedSupplier = 
            CircuitBreaker.decorateCompletionStage(
                circuitBreaker,
                () -> RateLimiter.decorateCompletionStage(
                    rateLimiter,
                    () -> CompletableFuture.supplyAsync(() -> doActualCall(param))
                ).get()
            );
            
        return decoratedSupplier.get().join();
    }
    
    private ApiResponse doActualCall(String param) {
        // 实际的外部API调用
        return externalApiClient.call(param);
    }
}

List<String> list = new ArrayList<String>() {{
add(new String(new char[]{'h','e','l','l','o'}));
}};

@PostMapping("/order")
public Result createOrder(OrderDTO dto) {
    // 1. 校验库存
    if (stockService.get(dto.getSkuId()) < dto.getCount()) {
        return error("库存不足");
    }
    
    // 2. 扣减库存（直接调 DB）
    stockMapper.decrease(dto.getSkuId(), dto.getCount());
    
    // 3. 创建订单
    orderMapper.insert(dto);
    
    // 4. 发送短信
    smsService.send("下单成功");
    
    return success();
}

// 1. 应用服务层 - 处理业务流程
@Transactional
public OrderId createOrder(CreateOrderCommand cmd) {
    // 领域校验
    Product product = productRepository.findById(cmd.getSkuId());
    product.checkStock(cmd.getCount());
    
    // 创建订单
    Order order = Order.create(cmd);
    orderRepository.save(order);
    
    // 发布事件（解耦）
    eventPublisher.publish(new OrderCreatedEvent(order.getId()));
    
    return order.getId();
}

// 2. 基础设施层 - 监听事件发短信
@EventListener
public void onOrderCreated(OrderCreatedEvent event) {
    smsClient.sendAsync("下单成功"); // 异步处理
}

    /**
     * 登录拦截器：拦截需要登录的接口
     */
    @Component
    public static class LoginInterceptor implements HandlerInterceptor { // 改为 static

        @Override
        public boolean preHandle(HttpServletRequest request,
                                 HttpServletResponse response,
                                 Object handler) throws IOException {

            String uri = request.getRequestURI();
            log.info("LoginInterceptor 拦截请求: {}", uri);

            // 只处理 Controller 请求
            if (!(handler instanceof HandlerMethod)) {
                return true;
            }

            // 模拟未登录
            String authHeader = request.getHeader("Authorization");
            if (authHeader == null || !authHeader.startsWith("Bearer ")) {
                log.warn("未登录，拒绝访问: {}", uri);
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.setContentType("application/json;charset=utf-8");
                response.getWriter().write("{\"code\":401, \"msg\":\"请先登录\"}");
                return false;
            }

            return true;
        }

        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
            log.info("LoginInterceptor 拦截请求完成: {}", response.getStatus());
            HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
        }
    }

@Configuration
public static class WebConfig implements WebMvcConfigurer { 

    @Autowired
    private LoginInterceptor loginInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 拦截所有，但排除 /public/**
        registry.addInterceptor(loginInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/public/**");
    }
}

/**
 * 自定义 Filter 1：记录所有请求（包括静态资源）
 */
@Component
@Order(1) // 优先级高（数字小）
public static class MyCustomFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        log.info(">>> MyCustomFilter 开始: {}", req.getRequestURI());

        String token = req.getHeader("Authorization");
        if (token != null){
            // 进入程序
            chain.doFilter(request, response);
        }
        else{
            // 模拟未登录
            log.warn("未登录，拒绝访问: {}", req.getRequestURI());
            HttpServletResponse httpResponse = (HttpServletResponse) response;
            httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            httpResponse.setContentType("application/json;charset=utf-8");
            httpResponse.getWriter().write("{\"code\":401, \"msg\":\"请先登录\"}");
        }


        log.info("<<< MyCustomFilter 结束: {}", req.getRequestURI());
    }
}

@Slf4j
@SpringBootApplication
public class MvcTestApplication {

    public static void main(String[] args) {
        SpringApplication.run(MvcTestApplication.class, args);
    }

    @Slf4j
    @RestController
    public static class MyController {

        @GetMapping("/test")
        public String index1() {
            log.info("访问 /test");
            return "Hello MyController!";
        }

        @GetMapping("/public/test")
        public String index2() {
            log.info("访问 /public/test");
            return "Hello Public!";
        }

        @PostMapping("/test2")
        public String index3() {
            log.info("访问 /test2 (POST)");
            return "Hello POST!";
        }
    }

    /**
     * 登录拦截器：拦截需要登录的接口
     */
    @Component
    public static class LoginInterceptor implements HandlerInterceptor { // 改为 static

        @Override
        public boolean preHandle(HttpServletRequest request,
                                 HttpServletResponse response,
                                 Object handler) throws IOException {

            String uri = request.getRequestURI();
            log.info("LoginInterceptor 拦截请求: {}", uri);

            // 只处理 Controller 请求
            if (!(handler instanceof HandlerMethod)) {
                return true;
            }

            // 模拟未登录
            String authHeader = request.getHeader("Authorization");
            if (authHeader == null || !authHeader.startsWith("Bearer ")) {
                log.warn("未登录，拒绝访问: {}", uri);
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.setContentType("application/json;charset=utf-8");
                response.getWriter().write("{\"code\":401, \"msg\":\"请先登录\"}");
                return false;
            }

            return true;
        }

        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
            log.info("LoginInterceptor 拦截请求完成: {}", response.getStatus());
            HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
        }
    }
    @Component
    public static class LoginInterceptor2 implements HandlerInterceptor { // 改为 static

        @Override
        public boolean preHandle(HttpServletRequest request,
                                 HttpServletResponse response,
                                 Object handler) throws IOException {

            String uri = request.getRequestURI();
            log.info("LoginInterceptor2 拦截请求: {}", uri);

            // 只处理 Controller 请求
            if (!(handler instanceof HandlerMethod)) {
                return true;
            }

            // 模拟未登录
            String authHeader = request.getHeader("Authorization");
            if (authHeader == null || !authHeader.startsWith("Bearer ")) {
                log.warn("未登录，拒绝访问: {}", uri);
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.setContentType("application/json;charset=utf-8");
                response.getWriter().write("{\"code\":401, \"msg\":\"请先登录\"}");
                return false;
            }

            return true;
        }

        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
            log.info("LoginInterceptor2 拦截请求完成: {}", response.getStatus());
            HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
        }
    }

    @Configuration
    public static class WebConfig implements WebMvcConfigurer { // 改为 static

        @Autowired
        private LoginInterceptor loginInterceptor;
        @Autowired
        private LoginInterceptor2 loginInterceptor2;

        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            // 拦截所有，但排除 /public/**
            registry.addInterceptor(loginInterceptor)
                    .addPathPatterns("/**")
                    .excludePathPatterns("/public/**");
            registry.addInterceptor(loginInterceptor2)
                    .addPathPatterns("/**")
                    .excludePathPatterns("/public/**");
        }
    }

    /**
     * 自定义 Filter 1：记录所有请求（包括静态资源）
     */
    @Component
    @Order(1) // 优先级高（数字小）
    public static class MyCustomFilter implements Filter {

        @Override
        public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
                throws IOException, ServletException {
            HttpServletRequest req = (HttpServletRequest) request;
            log.info(">>> MyCustomFilter 开始: {}", req.getRequestURI());

            String token = req.getHeader("Authorization");
            if (token != null){
                // 进入程序
                chain.doFilter(request, response);
            }
            else{
                // 模拟未登录
                log.warn("未登录，拒绝访问: {}", req.getRequestURI());
                HttpServletResponse httpResponse = (HttpServletResponse) response;
                httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                httpResponse.setContentType("application/json;charset=utf-8");
                httpResponse.getWriter().write("{\"code\":401, \"msg\":\"请先登录\"}");
            }


            log.info("<<< MyCustomFilter 结束: {}", req.getRequestURI());
        }
    }

    /**
     * 自定义 Filter 2
     */
    @Component
    @Order(2)
    public static class MyCustomFilter2 implements Filter {

        @Override
        public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
                throws IOException, ServletException {
            HttpServletRequest req = (HttpServletRequest) request;
            log.info(">>> MyCustomFilter2 开始: {}", req.getRequestURI());

            chain.doFilter(request, response);

            log.info("<<< MyCustomFilter2 结束: {}", req.getRequestURI());
        }
    }
}