// 下面代碼實現(xiàn)了一個插件系統(tǒng)的類加載器，用于隔離插件的類加載環(huán)境
public class PluginClassLoader extends URLClassLoader {
    private final String pluginName;
    private final Set<String> allowedPackages;
    public PluginClassLoader(String pluginName, URL[] urls, ClassLoader parent) {
        super(urls, parent);
        this.pluginName = pluginName;
        this.allowedPackages = new HashSet<>();
        // 配置允許的包名，防止插件訪問系統(tǒng)敏感包
        allowedPackages.add("com.plugin." + pluginName.toLowerCase());
    }
    @Override
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        // 安全檢查：禁止加載某些敏感包的類
        if (isRestrictedClass(name)) {
            throw new ClassNotFoundException("Access to restricted class " + name + " is denied");
        }
        // 優(yōu)先從插件自身加載
        try {
            return findClass(name, resolve);
        } catch (ClassNotFoundException e) {
            // 插件中沒有，則委派給父加載器
            return super.loadClass(name, resolve);
        }
    }
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] classData = loadClassData(name);
            if (classData != null) {
                return defineClass(name, classData, 0, classData.length);
            }
        } catch (IOException e) {
            throw new ClassNotFoundException("Failed to load class " + name, e);
        }
        throw new ClassNotFoundException("Class " + name + " not found");
    }
    private byte[] loadClassData(String name) throws IOException {
        // 簡化實現(xiàn)：從URL中讀取class文件
        String path = name.replace('.', '/').concat(".class");
        InputStream is = getResourceAsStream(path);
        if (is != null) {
            ByteArrayOutputStream buffer = new ByteArrayOutputStream();
            int nRead;
            byte[] data = new byte[1024];
            while ((nRead = is.read(data, 0, data.length)) != -1) {
                buffer.write(data, 0, nRead);
            }
            return buffer.toByteArray();
        }
        return null;
    }
    private boolean isRestrictedClass(String className) {
        // 禁止插件加載系統(tǒng)敏感類
        return className.startsWith("java.") || 
               className.startsWith("javax.") ||
               className.startsWith("sun.");
    }
}

// 下面代碼實現(xiàn)了一個支持熱部署的類加載器，用于在不重啟應(yīng)用的情況下更新類
public class HotSwapClassLoader extends ClassLoader {
    private final Map<String, Class<?>> loadedClasses = new ConcurrentHashMap<>();
    private final Map<String, Long> classTimestamps = new ConcurrentHashMap<>();
    private final String classPath;
    public HotSwapClassLoader(String classPath) {
        this.classPath = classPath;
    }
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            String classFile = name.replace('.', '/').concat(".class");
            File file = new File(classPath, classFile);
            if (!file.exists()) {
                throw new ClassNotFoundException("Class file not found: " + classFile);
            }
            // 檢查文件是否被修改
            long lastModified = file.lastModified();
            Long cachedTimestamp = classTimestamps.get(name);
            if (cachedTimestamp != null && cachedTimestamp.equals(lastModified)) {
                return loadedClasses.get(name);
            }
            // 讀取class文件
            byte[] classData = Files.readAllBytes(file.toPath());
            // 定義類
            Class<?> clazz = defineClass(name, classData, 0, classData.length);
            // 緩存類和時間戳
            loadedClasses.put(name, clazz);
            classTimestamps.put(name, lastModified);
            System.out.println("Hot loaded class: " + name);
            return clazz;
        } catch (IOException e) {
            throw new ClassNotFoundException("Failed to load class " + name, e);
        }
    }
    // 檢查是否有類需要重新加載
    public void checkForUpdates() {
        for (Map.Entry<String, Class<?>> entry : loadedClasses.entrySet()) {
            String className = entry.getKey();
            String classFile = className.replace('.', '/').concat(".class");
            File file = new File(classPath, classFile);
            if (file.exists()) {
                long lastModified = file.lastModified();
                Long cachedTimestamp = classTimestamps.get(className);
                if (cachedTimestamp == null || !cachedTimestamp.equals(lastModified)) {
                    // 移除舊類，強(qiáng)制重新加載
                    loadedClasses.remove(className);
                    System.out.println("Detected changes in class: " + className);
                }
            }
        }
    }
    // 清除緩存的類，強(qiáng)制重新加載
    public void invalidateClass(String className) {
        loadedClasses.remove(className);
        classTimestamps.remove(className);
    }
}

// 下面代碼實現(xiàn)了一個類加載監(jiān)控器，用于統(tǒng)計和分析類加載的性能數(shù)據(jù)
public class ClassLoadingMonitor {
    private final Map<String, LoadingInfo> loadingStats = new ConcurrentHashMap<>();
    private final AtomicLong totalClassesLoaded = new AtomicLong(0);
    private final AtomicLong totalLoadingTime = new AtomicLong(0);
    public static class LoadingInfo {
        private final String className;
        private final ClassLoader loader;
        private final long loadTime;
        private final int classSize;
        private final long timestamp;
        public LoadingInfo(String className, ClassLoader loader, long loadTime, int classSize) {
            this.className = className;
            this.loader = loader;
            this.loadTime = loadTime;
            this.classSize = classSize;
            this.timestamp = System.currentTimeMillis();
        }
        // getter方法省略
    }
    // 監(jiān)控類加載過程
    public void onClassLoaded(String className, ClassLoader loader, long loadTime, int classSize) {
        LoadingInfo info = new LoadingInfo(className, loader, loadTime, classSize);
        loadingStats.put(className, info);
        totalClassesLoaded.incrementAndGet();
        totalLoadingTime.addAndGet(loadTime);
        // 記錄慢加載
        if (loadTime > 100) { // 超過100ms認(rèn)為是慢加載
            System.out.println("Slow class loading detected: " + className + 
                             " took " + loadTime + "ms, size: " + classSize + " bytes");
        }
    }
    // 生成類加載報告
    public void generateReport() {
        System.out.println("=== Class Loading Report ===");
        System.out.println("Total classes loaded: " + totalClassesLoaded.get());
        System.out.println("Total loading time: " + totalLoadingTime.get() + "ms");
        System.out.println("Average loading time: " + 
                         (totalLoadingTime.get() / Math.max(1, totalClassesLoaded.get())) + "ms");
        // 按加載時間排序
        List<LoadingInfo> sortedByTime = loadingStats.values().stream()
                .sorted((a, b) -> Long.compare(b.getLoadTime(), a.getLoadTime()))
                .limit(10)
                .collect(Collectors.toList());
        System.out.println("\nTop 10 slowest class loading:");
        for (int i = 0; i < sortedByTime.size(); i++) {
            LoadingInfo info = sortedByTime.get(i);
            System.out.println((i + 1) + ". " + info.getClassName() + 
                             " - " + info.getLoadTime() + "ms (" + 
                             info.getClassSize() + " bytes)");
        }
    }
    // 分析類加載器分布
    public void analyzeLoaderDistribution() {
        Map<String, Long> loaderStats = loadingStats.values().stream()
                .collect(Collectors.groupingBy(
                    info -> info.getLoader().getClass().getSimpleName(),
                    Collectors.counting()
                ));
        System.out.println("\nClass distribution by loader:");
        loaderStats.forEach((loaderType, count) -> 
            System.out.println(loaderType + ": " + count + " classes"));
    }
    // 檢測內(nèi)存泄漏（類未正確卸載）
    public void detectMemoryLeaks() {
        // 簡化實現(xiàn)：檢查是否有大量類被重復(fù)加載
        Map<String, Long> classLoadCount = new HashMap<>();
        for (LoadingInfo info : loadingStats.values()) {
            String className = info.getClassName().split("\\$")[0]; // 忽略內(nèi)部類
            classLoadCount.merge(className, 1L, Long::sum);
        }
        List<Map.Entry<String, Long>> suspiciousClasses = classLoadCount.entrySet().stream()
                .filter(entry -> entry.getValue() > 10) // 同一個類被加載超過10次
                .sorted((a, b) -> b.getValue().compareTo(a.getValue()))
                .collect(Collectors.toList());
        if (!suspiciousClasses.isEmpty()) {
            System.out.println("\nPotential memory leaks detected (classes loaded many times):");
            for (Map.Entry<String, Long> entry : suspiciousClasses) {
                System.out.println(entry.getKey() + ": " + entry.getValue() + " times");
            }
        }
    }
}

// 下面代碼實現(xiàn)了一個帶安全檢查的類加載器，用于保護(hù)系統(tǒng)安全
public class SecureClassLoader extends URLClassLoader {
    private final Set<String> trustedSources;
    private final Set<String> prohibitedPackages;
    private final SecurityManager securityManager;
    public SecureClassLoader(URL[] urls, Set<String> trustedSources) {
        super(urls, getSystemClassLoader());
        this.trustedSources = new HashSet<>(trustedSources);
        this.prohibitedPackages = new HashSet<>();
        this.securityManager = System.getSecurityManager();
        // 配置禁止的包
        initializeProhibitedPackages();
    }
    private void initializeProhibitedPackages() {
        prohibitedPackages.add("java.");
        prohibitedPackages.add("javax.");
        prohibitedPackages.add("sun.");
        prohibitedPackages.add("com.sun.");
        prohibitedPackages.add("org.omg.");
    }
    @Override
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        // 安全檢查1：禁止加載敏感包
        if (isProhibitedPackage(name)) {
            throw new SecurityException("Access to restricted package in class " + name);
        }
        // 安全檢查2：驗證簽名（如果啟用）
        if (securityManager != null) {
            checkSecurityPermissions(name);
        }
        return super.loadClass(name, resolve);
    }
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            // 安全檢查3：驗證字節(jié)碼完整性
            byte[] classData = loadClassData(name);
            if (!verifyClassIntegrity(name, classData)) {
                throw new SecurityException("Class integrity verification failed: " + name);
            }
            // 安全檢查4：檢查字節(jié)碼中是否有惡意代碼
            if (containsMaliciousCode(classData)) {
                throw new SecurityException("Potential malicious code detected in class: " + name);
            }
            return defineClass(name, classData, 0, classData.length);
        } catch (IOException e) {
            throw new ClassNotFoundException("Failed to load class " + name, e);
        }
    }
    private boolean isProhibitedPackage(String className) {
        return prohibitedPackages.stream().anyMatch(className::startsWith);
    }
    private void checkSecurityPermissions(String className) {
        try {
            // 檢查是否有加載權(quán)限
            securityManager.checkPermission(new RuntimePermission("createClassLoader"));
            // 檢查類來源
            URL sourceUrl = findResource(className.replace('.', '/') + ".class");
            if (sourceUrl != null) {
                String source = sourceUrl.toString();
                boolean isTrusted = trustedSources.stream().anyMatch(source::contains);
                if (!isTrusted) {
                    securityManager.checkPermission(new RuntimePermission("accessClassInPackage." + className));
                }
            }
        } catch (SecurityException e) {
            throw new SecurityException("Security check failed for class " + className + ": " + e.getMessage());
        }
    }
    private boolean verifyClassIntegrity(String className, byte[] classData) {
        // 簡化實現(xiàn)：檢查字節(jié)碼魔數(shù)
        if (classData.length < 4) {
            return false;
        }
        // Java class文件應(yīng)該以0xCAFEBABE開頭
        return (classData[0] & 0xFF) == 0xCA &&
               (classData[1] & 0xFF) == 0xFE &&
               (classData[2] & 0xFF) == 0xBA &&
               (classData[3] & 0xFF) == 0xBE;
    }
    private boolean containsMaliciousCode(byte[] classData) {
        // 簡化實現(xiàn)：檢查字節(jié)碼中是否包含危險模式
        // 實際應(yīng)該使用字節(jié)碼分析庫進(jìn)行深度分析
        String bytecode = new String(classData);
        return bytecode.contains("Runtime.getRuntime()") ||
               bytecode.contains("System.exit") ||
               bytecode.contains("java.lang.reflect");
    }
    private byte[] loadClassData(String className) throws IOException {
        String path = className.replace('.', '/').concat(".class");
        InputStream is = getResourceAsStream(path);
        if (is != null) {
            ByteArrayOutputStream buffer = new ByteArrayOutputStream();
            int nRead;
            byte[] data = new byte[1024];
            while ((nRead = is.read(data, 0, data.length)) != -1) {
                buffer.write(data, 0, nRead);
            }
            return buffer.toByteArray();
        }
        throw new IOException("Class resource not found: " + className);
    }
}

// 下面代碼實現(xiàn)了一個類加載性能優(yōu)化工具，用于預(yù)熱和緩存常用類
public class ClassLoadingOptimizer {
    private final Map<String, WeakReference<Class<?>>> classCache = new ConcurrentHashMap<>();
    private final Set<String> preloadedClasses = ConcurrentHashMap.newKeySet();
    private final ClassLoader targetClassLoader;
    public ClassLoadingOptimizer(ClassLoader classLoader) {
        this.targetClassLoader = classLoader;
    }
    // 預(yù)加載常用類
    public void preloadCommonClasses(List<String> classNames) {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        for (String className : classNames) {
            executor.submit(() -> {
                try {
                    Class<?> clazz = targetClassLoader.loadClass(className);
                    preloadedClasses.add(className);
                    classCache.put(className, new WeakReference<>(clazz));
                    System.out.println("Preloaded class: " + className);
                } catch (ClassNotFoundException e) {
                    System.out.println("Failed to preload class: " + className);
                }
            });
        }
        executor.shutdown();
        try {
            executor.awaitTermination(30, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    // 優(yōu)化的類加載方法
    public Class<?> loadClassOptimized(String className) throws ClassNotFoundException {
        // 1. 檢查緩存
        WeakReference<Class<?>> cachedRef = classCache.get(className);
        if (cachedRef != null) {
            Class<?> cachedClass = cachedRef.get();
            if (cachedClass != null) {
                return cachedClass;
            } else {
                // 緩存引用已失效，清理
                classCache.remove(className);
            }
        }
        // 2. 加載類
        Class<?> clazz = targetClassLoader.loadClass(className);
        // 3. 更新緩存
        classCache.put(className, new WeakReference<>(clazz));
        return clazz;
    }
    // 清理失效的緩存項
    public void cleanupCache() {
        classCache.entrySet().removeIf(entry -> entry.getValue().get() == null);
        System.out.println("Cleaned up class cache, remaining entries: " + classCache.size());
    }
    // 獲取預(yù)加載統(tǒng)計
    public Map<String, Object> getPreloadingStats() {
        Map<String, Object> stats = new HashMap<>();
        stats.put("totalPreloaded", preloadedClasses.size());
        stats.put("cacheSize", classCache.size());
        stats.put("preloadedClasses", new ArrayList<>(preloadedClasses));
        return stats;
    }
}