// 添加JVM参数监控类卸载
-XX:+TraceClassUnloading
-XX:+PrintGCDetails
-XX:+PrintGCTimeStamps

// 分析类是否能正常卸载
jcmd <pid> GC.class_stats

// 1. 检查是否有类似代码（容易导致类泄漏）
URLClassLoader loader = new URLClassLoader(urls);
Class<?> clazz = loader.loadClass("SomeClass");
// 注意：如果不关闭 loader，会导致类加载器泄漏

// 2. 检查大量使用反射的地方
Method[] methods = clazz.getDeclaredMethods(); // 每次调用都可能产生新类

// 3. 检查动态代理使用
Proxy.newProxyInstance(classLoader, interfaces, handler); // 会生成代理类

// 4. 检查序列化框架配置
ObjectMapper mapper = new ObjectMapper(); // Jackson 可能生成大量类

// Direct ByteBuffer 使用堆外内存
ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);

// NIO 文件映射
FileChannel.map(MapMode.READ_WRITE, 0, fileSize);

// 应用可能有异常处理机制
try {
    // 类加载或反射操作
} catch (OutOfMemoryError e) {
    // 记录日志但不终止进程
    logger.error("Metaspace OOM occurred", e);
}

// 传统写法
List<User> activeUsers = new ArrayList<>();
for (User user : users) {
    if (user.isActive() && user.getRole().equals("USER")) {
        activeUsers.add(user);
    }
}

// Stream API写法
List<User> activeUsers = users.stream()
    .filter(User::isActive)
    .filter(user -> user.getRole().equals("USER"))
    .collect(Collectors.toList());

// 数据转换
List<UserDto> userDtos = users.stream()
    .map(user -> new UserDto(user.getId(), user.getUsername(), user.getEmail()))
    .collect(Collectors.toList());

// 聚合操作
Map<String, Long> userCountByRole = users.stream()
    .collect(Collectors.groupingBy(User::getRole, Collectors.counting()));

// Service层安全处理
@Service
public class UserService {
    public UserDto getUserById(Long id) {
        return userRepository.findById(id)
            .map(this::convertToDto)
            .orElseThrow(() -> new UserNotFoundException("User not found: " + id));
    }
    
    public void sendWelcomeEmailIfActive(Long userId) {
        userRepository.findById(userId)
            .filter(User::isActive)
            .ifPresent(this::sendWelcomeEmail);
    }
}

// 传统的DTO类 - 需要大量样板代码
public class UserDto {
    private Long id;
    private String username;
    private String email;
    
    // 构造函数
    public UserDto(Long id, String username, String email) {
        this.id = id;
        this.username = username;
        this.email = email;
    }
    
    // Getter方法
    public Long getId() { return id; }
    public String getUsername() { return username; }
    public String getEmail() { return email; }
    
    // Setter方法
    public void setId(Long id) { this.id = id; }
    public void setUsername(String username) { this.username = username; }
    public void setEmail(String email) { this.email = email; }
    
    // equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        UserDto userDto = (UserDto) o;
        return Objects.equals(id, userDto.id) &&
               Objects.equals(username, userDto.username) &&
               Objects.equals(email, userDto.email);
    }
    
    // hashCode方法
    @Override
    public int hashCode() {
        return Objects.hash(id, username, email);
    }
    
    // toString方法
    @Override
    public String toString() {
        return "UserDto{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

// Record类 - 自动生成所有样板代码
public record UserDto(Long id, String username, String email) {}

// 相当于自动生成：
// - 构造函数：public UserDto(Long id, String username, String email)
// - 访问器方法：id(), username(), email()
// - equals(), hashCode(), toString()
// - 所有字段都是 private final

// 1. 简单DTO
public record UserDto(Long id, String username, String email) {}

// 2. 嵌套Records
public record UserProfileDto(
    Long id,
    String username,
    String email,
    AddressDto address  // 嵌套另一个Record
) {}

public record AddressDto(String street, String city, String zipCode) {}

// 3. 带验证的Records
public record CreateUserRequest(
    String username,
    String email,
    String password
) {
    // 可以添加验证逻辑
    public CreateUserRequest {
        if (username == null || username.isBlank()) {
            throw new IllegalArgumentException("Username cannot be blank");
        }
        if (email == null || !email.contains("@")) {
            throw new IllegalArgumentException("Invalid email format");
        }
    }
}

// 4. 带静态方法的Records
public record UserDto(Long id, String username, String email) {
    // 静态工厂方法
    public static UserDto from(User user) {
        return new UserDto(user.getId(), user.getUsername(), user.getEmail());
    }
    
    // 实例方法
    public boolean isValidEmail() {
        return email != null && email.contains("@");
    }
}

// 5. 使用示例
@RestController
public class UserController {
    
    @PostMapping("/users")
    public ApiResponse<UserDto> createUser(@RequestBody CreateUserRequest request) {
        // 创建Record实例
        var user = userService.createUser(request.username(), request.email(), request.password());
        
        // 使用静态工厂方法
        var userDto = UserDto.from(user);
        
        return new ApiResponse<>(200, "success", userDto);
    }
    
    @GetMapping("/users/{id}")
    public ApiResponse<UserDto> getUser(@PathVariable Long id) {
        return userService.findById(id)
            .map(user -> {
                // 直接创建Record
                var dto = new UserDto(user.getId(), user.getUsername(), user.getEmail());
                return new ApiResponse<>(200, "success", dto);
            })
            .orElse(new ApiResponse<>(404, "User not found", null));
    }
}

// 微服务间通信
@Service
public class ExternalApiService {
    private final HttpClient client = HttpClient.newHttpClient();
    
    public CompletableFuture<UserProfile> getUserProfile(String userId) {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/users/" + userId))
            .header("Authorization", "Bearer " + getToken())
            .GET()
            .build();
        
        return client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
            .thenApply(HttpResponse::body)
            .thenApply(this::parseUserProfile);
    }
}

// 简化变量声明
var userList = userRepository.findAll();
var filteredUsers = userList.stream()
    .filter(user -> user.isActive())
    .collect(Collectors.toList());

// 复杂泛型简化
var userMap = users.stream()
    .collect(Collectors.groupingBy(User::getRole, 
        Collectors.mapping(User::getUsername, Collectors.toList())));

// 复杂SQL查询
@Repository
public class UserRepository {
    private static final String COMPLEX_QUERY = """
        SELECT u.id, u.username, u.email, p.name as profile_name
        FROM users u
        LEFT JOIN profiles p ON u.id = p.user_id
        WHERE u.active = true
        AND u.created_date > ?
        ORDER BY u.created_date DESC
        """;
    
    // JSON模板
    private static final String USER_JSON_TEMPLATE = """
        {
            "id": %d,
            "username": "%s",
            "email": "%s",
            "profile": {
                "name": "%s"
            }
        }
        """;
}

// 异步Controller
@RestController
public class UserController {
    @GetMapping("/users/{id}")
    public CompletableFuture<UserDto> getUser(@PathVariable Long id) {
        return CompletableFuture.supplyAsync(() -> {
            // 可能的阻塞操作：数据库查询、外部API调用
            return userService.findById(id);
        }, virtualThreadExecutor);
    }
}

// 配置虚拟线程
@Configuration
public class AsyncConfig {
    @Bean
    public Executor virtualThreadExecutor() {
        return Executors.newVirtualThreadPerTaskExecutor();
    }
}

// 批量处理
@Service
public class BatchUserService {
    public List<UserDto> processUsers(List<Long> userIds) {
        return userIds.parallelStream()
            .map(id -> CompletableFuture.supplyAsync(() -> 
                userService.findById(id), virtualThreadExecutor))
            .map(CompletableFuture::join)
            .collect(Collectors.toList());
    }
}

// 支付方式建模
public sealed interface PaymentMethod 
    permits CreditCard, PayPal, BankTransfer {
}

public record CreditCard(String number, String cvv) implements PaymentMethod {}
public record PayPal(String email) implements PaymentMethod {}
public record BankTransfer(String account, String routingNumber) implements PaymentMethod {}

// 订单状态
public sealed interface OrderStatus
    permits Pending, Processing, Shipped, Delivered, Cancelled {
}

public record Pending() implements OrderStatus {}
public record Processing(String operatorId) implements OrderStatus {}
public record Shipped(String trackingNumber) implements OrderStatus {}
public record Delivered(LocalDateTime deliveredAt) implements OrderStatus {}
public record Cancelled(String reason) implements OrderStatus {}

// 处理不同支付方式
@Service
public class PaymentService {
    public PaymentResult processPayment(PaymentMethod method, BigDecimal amount) {
        return switch (method) {
            case CreditCard(var number, var cvv) -> 
                processCreditCard(number, cvv, amount);
            case PayPal(var email) -> 
                processPayPal(email, amount);
            case BankTransfer(var account, var routing) -> 
                processBankTransfer(account, routing, amount);
        };
    }
}

// 订单状态处理
public String getOrderStatusMessage(OrderStatus status) {
    return switch (status) {
        case Pending() -> "订单等待处理";
        case Processing(var operatorId) -> "订单处理中，操作员：" + operatorId;
        case Shipped(var trackingNumber) -> "订单已发货，追踪号：" + trackingNumber;
        case Delivered(var deliveredAt) -> "订单已送达，时间：" + deliveredAt;
        case Cancelled(var reason) -> "订单已取消，原因：" + reason;
    };
}

// 用户DTO
public record UserDto(Long id, String username, String email, String role) {}

// 分页查询结果
public record PageResult<T>(List<T> content, int page, int size, long total) {}

// API响应
public record ApiResponse<T>(int status, String message, T data) {}

// Controller
@RestController
@RequestMapping("/api/users")
public class UserController {
    private final UserService userService;
    
    @GetMapping
    public ApiResponse<PageResult<UserDto>> getUsers(
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size,
            @RequestParam(required = false) String role) {
        
        var pageResult = userService.findUsers(page, size, role);
        return new ApiResponse<>(200, "success", pageResult);
    }
    
    @GetMapping("/{id}")
    public ApiResponse<UserDto> getUser(@PathVariable Long id) {
        return userService.findById(id)
            .map(user -> new ApiResponse<>(200, "success", user))
            .orElse(new ApiResponse<>(404, "User not found", null));
    }
}

// Service
@Service
public class UserService {
    private final UserRepository userRepository;
    
    public PageResult<UserDto> findUsers(int page, int size, String role) {
        var users = userRepository.findAll();
        
        var filteredUsers = users.stream()
            .filter(user -> role == null || user.getRole().equals(role))
            .skip((long) page * size)
            .limit(size)
            .map(this::convertToDto)
            .collect(Collectors.toList());
        
        return new PageResult<>(filteredUsers, page, size, users.size());
    }
    
    public Optional<UserDto> findById(Long id) {
        return userRepository.findById(id)
            .map(this::convertToDto);
    }
    
    private UserDto convertToDto(User user) {
        return new UserDto(user.getId(), user.getUsername(), 
                          user.getEmail(), user.getRole());
    }
}

public class TestThread {

    public static void main(String[] args) {
        Runnable task = () -> {
            System.out.println("异步执行");
        };
        new Thread(task).start();

        System.out.println("同步执行");
    }
    
}

public class TestThread {

    public static void main(String[] args) {
        // 结果集合
        List<String> pdfList = new LinkedList<>();
        
        // 异步任务
        Runnable task = () -> {
            String pdf = downloadPdf();
            // 将结果放入list
            pdfList.add(pdf);
        };
        new Thread(task).start();
        
        // 输出结果集合的大小
        System.out.println(pdfList.size());
    }

    private static String downloadPdf() {
        return "pdf";
    }

}

public class TestThread {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 结果集合
        List<String> pdfList = new LinkedList<>();

        // 异步任务
        FutureTask<String> task = new FutureTask(() -> {
            String pdf = downloadPdf();
            // 返回结果
            return pdf;
        });
        new Thread(task).start();
        
        // 等待异步任务执行完成后，添加到集合
        pdfList.add(task.get());
        
        // 输出集合大小
        System.out.println(pdfList.size());
    }

    private static String downloadPdf() {
        return "pdf";
    }

}

public class TestThread {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 结果集合
        List<String> pdfList = new LinkedList<>();

        // 异步任务1
        FutureTask<String> task1 = new FutureTask(() -> {
            String pdf = downloadPdf();
            // 返回结果
            return pdf;
        });
        new Thread(task1).start();

        // 异步任务2
        FutureTask<String> task2 = new FutureTask(() -> {
            String pdf = downloadPdf();
            // 返回结果
            return pdf;
        });
        new Thread(task2).start();

        // 异步任务执行完成后，添加到集合
        String pdfFont1 = getFontFromPdf(task1.get());
        String pdfFont2 = getFontFromPdf(task2.get());
        
        pdfList.add(pdfFont1);
        pdfList.add(pdfFont2);

        // 输出集合大小
        System.out.println(pdfList.size());
    }
    
    private static String getFontFromPdf(String pdf) {
        return "pdf-font";
    }

    private static String downloadPdf() {
        return "pdf";
    }

}

// 异步任务
FutureTask<String> task1 = new FutureTask(() -> {
    String pdf = downloadPdf();
    // 返回结果
    return getFontFromPdf(pdf);
});

public class TestThread {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 结果集合
        List<String> pdfList = new LinkedList<>();

        // 异步任务1
        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
            String pdf = downloadPdf();
            // 返回结果
            return pdf;
        }).thenApplyAsync(pdf -> getFontFromPdf(pdf));

        // 异步任务2
        CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> {
            String pdf = downloadPdf();
            // 返回结果
            return pdf;
        }).thenApplyAsync(pdf -> getFontFromPdf(pdf));

        pdfList.add(task1.get());
        pdfList.add(task2.get());

        // 输出集合大小
        System.out.println(pdfList.size());
    }

    private static String getFontFromPdf(String pdf) {
        return "pdf-font";
    }

    private static String downloadPdf() {
        return "pdf";
    }

}