/**
 * 类的职责描述
 *
 * @author 作者
 * @since 1.0.0
 */
public class UserService {

    // 1. 静态常量
    private static final int MAX_RETRY = 3;

    // 2. 实例字段
    private final UserRepository userRepository;
    private final EmailService emailService;

    // 3. 构造器
    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }

    // 4. 公开方法（按业务逻辑分组）
    public User register(RegisterRequest request) { ... }
    public User findById(Long id) { ... }
    public void delete(Long id) { ... }

    // 5. 私有方法（被公开方法调用）
    private void validateEmail(String email) { ... }
    private void sendWelcomeEmail(User user) { ... }
}

// ✅ 方法单一职责
public Order createOrder(CreateOrderRequest request) {
    validateRequest(request);
    User user = findUser(request.getUserId());
    List<Item> items = resolveItems(request.getItemIds());
    Order order = buildOrder(user, items);
    saveOrder(order);
    notifyUser(order);
    return order;
}

// ✅ 提前返回减少嵌套
public String processStatus(Order order) {
    if (order == null) return "无效订单";
    if (order.isCancelled()) return "已取消";
    if (order.isPaid()) return "已支付";
    return "待支付";
}

// ✅ 使用 Optional 代替 null
public Optional<User> findByEmail(String email) {
    return Optional.ofNullable(userMap.get(email));
}

// ❌ 返回 null
public User findByEmailBad(String email) {
    return userMap.get(email);  // 可能返回 null
}

public interface PaymentService {
    void pay(BigDecimal amount);
}

public class PaymentServiceFactory {
    private final Map<String, PaymentService> strategies;

    public PaymentServiceFactory(List<PaymentService> services) {
        this.strategies = services.stream()
            .collect(Collectors.toMap(PaymentService::getType, Function.identity()));
    }

    public PaymentService getService(String type) {
        PaymentService service = strategies.get(type);
        if (service == null) throw new IllegalArgumentException("不支持的支付方式: " + type);
        return service;
    }
}

@Service
public class AlipayService implements PaymentService {
    @Override public String getType() { return "alipay"; }
    @Override public void pay(BigDecimal amount) { /* ... */ }
}

public class DiscountCalculator {
    private final Map<String, Function<BigDecimal, BigDecimal>> strategies = Map.of(
        "VIP", price -> price.multiply(new BigDecimal("0.8")),
        "NEW_USER", price -> price.subtract(new BigDecimal("50")),
        "HOLIDAY", price -> price.multiply(new BigDecimal("0.9"))
    );

    public BigDecimal calculate(String type, BigDecimal price) {
        Function<BigDecimal, BigDecimal> strategy = strategies.get(type);
        if (strategy == null) return price;
        return strategy.apply(price);
    }
}

public class QueryBuilder {
    private String table;
    private final List<String> conditions = new ArrayList<>();
    private final List<String> orders = new ArrayList<>();
    private Integer limit;

    public QueryBuilder from(String table) {
        this.table = table;
        return this;
    }

    public QueryBuilder where(String condition) {
        conditions.add(condition);
        return this;
    }

    public QueryBuilder orderBy(String field, String direction) {
        orders.add(field + " " + direction);
        return this;
    }

    public QueryBuilder limit(int limit) {
        this.limit = limit;
        return this;
    }

    public String build() {
        StringBuilder sql = new StringBuilder("SELECT * FROM " + table);
        if (!conditions.isEmpty()) {
            sql.append(" WHERE ").append(String.join(" AND ", conditions));
        }
        if (!orders.isEmpty()) {
            sql.append(" ORDER BY ").append(String.join(", ", orders));
        }
        if (limit != null) {
            sql.append(" LIMIT ").append(limit);
        }
        return sql.toString();
    }
}

// 使用
String sql = new QueryBuilder()
    .from("users")
    .where("age > 18")
    .where("status = 'ACTIVE'")
    .orderBy("created_at", "DESC")
    .limit(10)
    .build();

// 事件
public record OrderCreatedEvent(Long orderId, String userId) {}

// 发布者
@Service
public class OrderService {
    @Autowired
    private ApplicationEventPublisher publisher;

    public Order createOrder(CreateOrderRequest req) {
        Order order = doCreate(req);
        publisher.publishEvent(new OrderCreatedEvent(order.getId(), req.getUserId()));
        return order;
    }
}

// 监听者
@Component
public class OrderEventListener {
    @EventListener
    public void onOrderCreated(OrderCreatedEvent event) {
        // 发送通知、更新库存等
    }

    @Async
    @EventListener
    public void asyncHandle(OrderCreatedEvent event) {
        // 异步处理
    }
}

// ✅ 指定初始容量
List<User> users = new ArrayList<>(1000);
Map<String, User> map = new HashMap<>(1024);

// ✅ 不可变集合（更省内存）
List<String> immutable = List.of("A", "B", "C");

// ✅ 使用 Stream 的 toList() 代替 collect(Collectors.toList())
List<String> result = list.stream().filter(...).toList();

// ❌ 循环中拼接字符串
String s = "";
for (String item : list) { s += item; }

// ✅ 使用 StringBuilder
StringBuilder sb = new StringBuilder();
for (String item : list) { sb.append(item); }

// ✅ 批量插入代替逐条插入
// ❌ for (item : items) repository.save(item);
// ✅ repository.saveAll(items);

// ✅ 使用投影减少数据传输
public interface UserSummary {
    String getName();
    String getEmail();
}

@Query("SELECT u.name as name, u.email as email FROM User u WHERE u.status = :status")
List<UserSummary> findSummaryByStatus(@Param("status") UserStatus status);

// ✅ 读写锁
ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
// 读操作
lock.readLock().lock();
try { /* ... */ } finally { lock.readLock().unlock(); }
// 写操作
lock.writeLock().lock();
try { /* ... */ } finally { lock.writeLock().unlock(); }

// ✅ ConcurrentHashMap 分段锁
ConcurrentHashMap<String, User> cache = new ConcurrentHashMap<>();

// ✅ 不可变对象（天然线程安全）
public record Money(BigDecimal amount, Currency currency) {}