JDK25都出来了，但为什么很多公司还在坚持用JDK8？

import sun.misc.BASE64Encoder;

public class OldBase64Example {
    public String encode(String data) {
        BASE64Encoder encoder = new BASE64Encoder();
        return encoder.encode(data.getBytes());
    }
    
    public static void main(String[] args) {
        OldBase64Example example = new OldBase64Example();
        String result = example.encode("Hello, World!");
        System.out.println(result);
    }
}

import java.util.Base64;

public class NewBase64Example {
    public String encode(String data) {
        Base64.Encoder encoder = Base64.getEncoder();
        return encoder.encodeToString(data.getBytes());
    }
    
    public static void main(String[] args) {
        NewBase64Example example = NewBase64Example();
        String result = example.encode("Hello, World!");
        System.out.println(result);
    }
}

// 在JDK8中，这样的代码很常见
public class ReflectionExample {
    public void accessInternal() throws Exception {
        Class<?> clazz = Class.forName("sun.misc.Unsafe");
        Field field = clazz.getDeclaredField("theUnsafe");
        field.setAccessible(true);
        Object unsafe = field.get(null);
        // 使用unsafe对象...
    }
}

module com.example.myapp {
    requires java.base;
    requires jdk.unsupported; // 需要明确声明
    exports com.example.mypackage;
}

public class MemoryLeakExample {
    privatestatic List<byte[]> list = new ArrayList<>();
    
    public void createMemoryLeak() {
        // 模拟内存泄漏
        for (int i = 0; i < 100; i++) {
            list.add(newbyte[1024 * 1024]); // 每次分配1MB
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String[] args) {
        MemoryLeakExample example = new MemoryLeakExample();
        example.createMemoryLeak();
    }
}

# application.yml
spring:
datasource:
    url:jdbc:mysql://localhost:3306/test
    username:root
    password:password
jpa:
    hibernate:
      ddl-auto:update
    show-sql:true

# 对应的Java配置类
@Configuration
@EnableJpaRepositories
publicclassJpaConfig{
    
    @Bean
    @ConfigurationProperties("spring.datasource")
    publicDataSourcedataSource(){
        returnDataSourceBuilder.create().build();
    }
}

// JDK8风格
publicclass User {
    privatefinal String name;
    privatefinalint age;
    privatefinal String email;
    
    public User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    
    // 一堆getter、equals、hashCode、toString方法...
    // 通常需要IDE生成或者使用Lombok
}

// JDK14+ 使用Record
public record User(String name, int age, String email) {
    // 编译器自动生成constructor、getter、equals、hashCode、toString
}

// 使用示例
publicclass RecordExample {
    public void processUser() {
        User user = new User("张三", 25, "zhangsan@example.com");
        System.out.println(user.name()); // 自动生成的getter
        System.out.println(user); // 自动生成的toString
    }
}

// Spring Boot 2.x + JDK8 的典型配置
@SpringBootApplication
publicclass Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// 如果升级到JDK17+，可能需要调整模块配置
module com.example.app {
    requires spring.boot;
    requires spring.boot.autoconfigure;
    requires spring.context;
    opens com.example to spring.core;
}

public class DependencyConflictExample {
    // 假设项目同时依赖了library-a和library-b
    // library-a 依赖 guava:20.0
    // library-b 依赖 guava:30.0
    // 升级JDK后，可能需要升级这两个库，但新版本可能不兼容
}

public class GCPressureTest {
    privatestaticfinalint OBJECT_COUNT = 1000000;
    privatestatic List<byte[]> objectPool = new ArrayList<>();
    
    public static void createGCPressure() {
        Random random = new Random();
        for (int i = 0; i < OBJECT_COUNT; i++) {
            // 创建不同大小的对象，模拟真实内存分配模式
            int size = random.nextInt(1024) + 64;
            objectPool.add(newbyte[size]);
            
            // 随机释放一些对象，制造内存碎片
            if (random.nextDouble() < 0.3 && !objectPool.isEmpty()) {
                objectPool.remove(random.nextInt(objectPool.size()));
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        while (true) {
            createGCPressure();
            Thread.sleep(1000);
            System.out.println("Created " + objectPool.size() + " objects");
        }
    }
}

// 传统线程池方式
publicclass TraditionalThreadExample {
    privatefinal ExecutorService executor = Executors.newFixedThreadPool(100);
    
    public void processRequests(List<Request> requests) {
        List<CompletableFuture<Result>> futures = requests.stream()
            .map(request -> CompletableFuture.supplyAsync(() -> 
                processRequest(request), executor))
            .collect(Collectors.toList());
            
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
    }
    
    private Result processRequest(Request request) {
        // 模拟IO密集型操作
        try { Thread.sleep(100); } 
        catch (InterruptedException e) { /* 处理中断 */ }
        returnnew Result();
    }
}

// 虚拟线程方式
publicclass VirtualThreadExample {
    public void processRequests(List<Request> requests) {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<CompletableFuture<Result>> futures = requests.stream()
                .map(request -> CompletableFuture.supplyAsync(() -> 
                    processRequest(request), executor))
                .collect(Collectors.toList());
                
            CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
        }
    }
    
    private Result processRequest(Request request) {
        // 同样的处理逻辑
        try { Thread.sleep(100); } 
        catch (InterruptedException e) { /* 处理中断 */ }
        returnnew Result();
    }
}

public class UpgradeROIAnalysis {
    // 直接成本
    privatedouble hardwareCost;      // 可能需要更好的硬件
    privatedouble softwareCost;      // 许可证费用
    privatedouble manpowerCost;      // 人力成本
    privatedouble trainingCost;      // 培训成本
    privatedouble testingCost;       // 测试成本
    
    // 间接成本
    privatedouble riskCost;          // 风险成本
    privatedouble downtimeCost;      // 停机时间成本
    
    // 预期收益
    privatedouble performanceGain;   // 性能提升收益
    privatedouble maintenanceGain;   // 维护成本降低
    privatedouble securityGain;      // 安全性提升
    privatedouble featureGain;       // 新特性带来的价值
    
    public boolean shouldUpgrade() {
        double totalCost = hardwareCost + softwareCost + manpowerCost 
                          + trainingCost + testingCost + riskCost + downtimeCost;
        double totalGain = performanceGain + maintenanceGain 
                          + securityGain + featureGain;
        
        return totalGain > totalCost * 1.5; // 通常要求收益是成本的1.5倍以上
    }
}

// JDK8的监控通常使用JMX
publicclass JmxMonitoringExample {
    privatefinal MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    
    public void registerCustomMetric() throws Exception {
        ObjectName name = new ObjectName("com.example:type=CustomMetric");
        CustomMetric mbean = new CustomMetric();
        mbs.registerMBean(mbean, name);
    }
}

// 新版本可能有更先进的监控方式，如JFR（Java Flight Recorder）
publicclass JfrMonitoringExample {
    @Label("Custom Event")
    @Description("Custom business event")
    staticclass CustomEvent extends Event {
        @Label("Event Data")
        private String data;
    }
    
    public void recordBusinessEvent(String data) {
        CustomEvent event = new CustomEvent();
        event.data = data;
        event.commit();
    }
}