Loader加载器的核心机制与实战使用指南

// 简化的 ELF 加载器实现示例
#include <stdio.h>
#include <stdlib.h>
#include <elf.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
 
typedef struct {
    void* base_addr;
    size_t size;
    Elf64_Ehdr* header;
    Elf64_Phdr* segments;
} ElfLoader;
 
ElfLoader* load_elf_file(const char* filename) {
    int fd = open(filename, O_RDONLY);
    if (fd < 0) {
        perror("Failed to open file");
        return NULL;
    }
    
    // 读取 ELF 头部
    Elf64_Ehdr header;
    if (read(fd, &header, sizeof(header)) != sizeof(header)) {
        close(fd);
        return NULL;
    }
    
    // 验证 ELF 魔数
    if (header.e_ident[EI_MAG0] != ELFMAG0 ||
        header.e_ident[EI_MAG1] != ELFMAG1 ||
        header.e_ident[EI_MAG2] != ELFMAG2 ||
        header.e_ident[EI_MAG3] != ELFMAG3) {
        fprintf(stderr, "Not a valid ELF file\n");
        close(fd);
        return NULL;
    }
    
    // 分配加载器结构
    ElfLoader* loader = malloc(sizeof(ElfLoader));
    loader->header = malloc(sizeof(Elf64_Ehdr));
    *loader->header = header;
    
    // 加载程序段
    loader->segments = malloc(header.e_phnum * sizeof(Elf64_Phdr));
    lseek(fd, header.e_phoff, SEEK_SET);
    read(fd, loader->segments, header.e_phnum * sizeof(Elf64_Phdr));
    
    // 映射可执行段到内存
    for (int i = 0; i < header.e_phnum; i++) {
        Elf64_Phdr* phdr = &loader->segments[i];
        if (phdr->p_type == PT_LOAD) {
            void* addr = mmap(
                (void*)phdr->p_vaddr,
                phdr->p_memsz,
                PROT_READ | PROT_WRITE | PROT_EXEC,
                MAP_PRIVATE | MAP_FIXED,
                fd,
                phdr->p_offset
            );
            
            if (addr == MAP_FAILED) {
                perror("Failed to map segment");
                free(loader);
                close(fd);
                return NULL;
            }
        }
    }
    
    close(fd);
    return loader;
}
 
void execute_elf(ElfLoader* loader) {
    // 获取入口点地址
    void (*entry_point)() = (void(*)())loader->header->e_entry;
    
    // 跳转到程序入口点执行
    entry_point();
}

// 动态加载共享库示例
#include <dlfcn.h>
#include <stdio.h>
 
typedef int (*math_func)(int, int);
 
int main() {
    // 动态加载数学库
    void* handle = dlopen("libmath.so", RTLD_LAZY);
    if (!handle) {
        fprintf(stderr, "Cannot open library: %s\n", dlerror());
        return 1;
    }
    
    // 获取函数符号
    math_func add_func = (math_func)dlsym(handle, "add");
    if (!add_func) {
        fprintf(stderr, "Cannot load symbol: %s\n", dlerror());
        dlclose(handle);
        return 1;
    }
    
    // 调用动态加载的函数
    int result = add_func(10, 20);
    printf("Result: %d\n", result);
    
    // 卸载库
    dlclose(handle);
    return 0;
}

// 自定义 Webpack Loader 实现
module.exports = function customLoader(source) {
    // 获取 loader 配置选项
    const options = this.getOptions();
    
    // 标记为异步 loader
    const callback = this.async();
    
    // 处理源代码
    processSource(source, options)
        .then(result => {
            // 返回处理后的代码和 source map
            callback(null, result.code, result.map);
        })
        .catch(error => {
            callback(error);
        });
};
 
// 处理源代码的异步函数
async function processSource(source, options) {
    // 解析源代码
    const ast = parseCode(source);
    
    // 应用转换
    const transformedAst = await transform(ast, options);
    
    // 生成代码
    const { code, map } = generateCode(transformedAst);
    
    return { code, map };
}
 
// Webpack 配置示例
module.exports = {
    module: {
        rules: [
            {
                test: /\.custom$/,
                use: [
                    {
                        loader: path.resolve('./custom-loader.js'),
                        options: {
                            transformMode: 'advanced',
                            sourceMaps: true
                        }
                    }
                ]
            },
            {
                test: /\.scss$/,
                use: [
                    'style-loader',
                    'css-loader',
                    'sass-loader'
                ]
            }
        ]
    }
};

class ModuleLoader {
    constructor() {
        this.modules = new Map();
        this.loading = new Map();
    }
    
    // 定义模块
    define(name, dependencies, factory) {
        if (this.modules.has(name)) {
            console.warn(`Module ${name} already defined`);
            return;
        }
        
        this.modules.set(name, {
            dependencies,
            factory,
            exports: null,
            loaded: false
        });
    }
    
    // 异步加载模块
    async require(name) {
        // 检查缓存
        if (this.modules.has(name)) {
            const module = this.modules.get(name);
            if (module.loaded) {
                return module.exports;
            }
        }
        
        // 检查是否正在加载
        if (this.loading.has(name)) {
            return this.loading.get(name);
        }
        
        // 开始加载
        const loadPromise = this.loadModule(name);
        this.loading.set(name, loadPromise);
        
        try {
            const exports = await loadPromise;
            this.loading.delete(name);
            return exports;
        } catch (error) {
            this.loading.delete(name);
            throw error;
        }
    }
    
    // 加载模块实现
    async loadModule(name) {
        // 动态加载模块文件
        if (!this.modules.has(name)) {
            await this.loadModuleFile(name);
        }
        
        const module = this.modules.get(name);
        
        // 加载依赖
        const deps = await Promise.all(
            module.dependencies.map(dep => this.require(dep))
        );
        
        // 执行模块工厂函数
        const exports = {};
        const moduleContext = {
            exports,
            require: (dep) => this.require(dep)
        };
        
        module.factory.apply(moduleContext, deps);
        module.exports = moduleContext.exports;
        module.loaded = true;
        
        return module.exports;
    }
    
    // 从远程加载模块文件
    async loadModuleFile(name) {
        const response = await fetch(`/modules/${name}.js`);
        const code = await response.text();
        
        // 使用 Function 构造器执行代码
        const moduleWrapper = new Function('define', code);
        moduleWrapper((deps, factory) => {
            this.define(name, deps, factory);
        });
    }
}
 
// 使用示例
const loader = new ModuleLoader();
 
// 定义模块
loader.define('math', [], function() {
    this.exports.add = (a, b) => a + b;
    this.exports.multiply = (a, b) => a * b;
});
 
loader.define('calculator', ['math'], function(math) {
    this.exports.calculate = (a, b, op) => {
        switch(op) {
            case '+': return math.add(a, b);
            case '*': return math.multiply(a, b);
            default: throw new Error('Unknown operation');
        }
    };
});
 
// 使用模块
loader.require('calculator').then(calc => {
    console.log(calc.calculate(5, 3, '+')); // 8
    console.log(calc.calculate(5, 3, '*')); // 15
});

import java.io.*;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.ByteBuffer;
import java.security.SecureClassLoader;
 
// 自定义类加载器实现
public class CustomClassLoader extends SecureClassLoader {
    private final String classPath;
    
    public CustomClassLoader(String classPath) {
        this.classPath = classPath;
    }
    
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            // 将类名转换为文件路径
            String fileName = name.replace('.', File.separatorChar) + ".class";
            File classFile = new File(classPath, fileName);
            
            if (!classFile.exists()) {
                throw new ClassNotFoundException(name);
            }
            
            // 读取类文件字节码
            byte[] classBytes = loadClassBytes(classFile);
            
            // 定义类
            return defineClass(name, classBytes, 0, classBytes.length);
        } catch (IOException e) {
            throw new ClassNotFoundException(name, e);
        }
    }
    
    private byte[] loadClassBytes(File file) throws IOException {
        try (FileInputStream fis = new FileInputStream(file);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            
            byte[] buffer = new byte[4096];
            int bytesRead;
            
            while ((bytesRead = fis.read(buffer)) != -1) {
                baos.write(buffer, 0, bytesRead);
            }
            
            return baos.toByteArray();
        }
    }
    
    // 实现热加载功能
    public Class<?> reloadClass(String className) throws ClassNotFoundException {
        // 创建新的类加载器实例
        CustomClassLoader newLoader = new CustomClassLoader(classPath);
        return newLoader.loadClass(className);
    }
}
 
// 插件加载器示例
public class PluginLoader {
    private final Map<String, Plugin> plugins = new HashMap<>();
    private final Map<String, URLClassLoader> pluginLoaders = new HashMap<>();
    
    public void loadPlugin(String pluginPath) throws Exception {
        File pluginFile = new File(pluginPath);
        
        // 创建插件专用的类加载器
        URL[] urls = { pluginFile.toURI().toURL() };
        URLClassLoader loader = new URLClassLoader(urls, getClass().getClassLoader());
        
        // 读取插件配置
        Properties props = loadPluginConfig(loader);
        String mainClass = props.getProperty("main.class");
        
        // 加载插件主类
        Class<?> pluginClass = loader.loadClass(mainClass);
        Plugin plugin = (Plugin) pluginClass.getDeclaredConstructor().newInstance();
        
        // 初始化插件
        plugin.initialize();
        
        // 存储插件和加载器
        String pluginName = props.getProperty("plugin.name");
        plugins.put(pluginName, plugin);
        pluginLoaders.put(pluginName, loader);
    }
    
    public void unloadPlugin(String pluginName) throws Exception {
        // 停止插件
        Plugin plugin = plugins.get(pluginName);
        if (plugin != null) {
            plugin.shutdown();
            plugins.remove(pluginName);
        }
        
        // 关闭类加载器
        URLClassLoader loader = pluginLoaders.get(pluginName);
        if (loader != null) {
            loader.close();
            pluginLoaders.remove(pluginName);
        }
    }
    
    private Properties loadPluginConfig(URLClassLoader loader) throws IOException {
        Properties props = new Properties();
        try (InputStream is = loader.getResourceAsStream("plugin.properties")) {
            if (is != null) {
                props.load(is);
            }
        }
        return props;
    }
}
 
// 插件接口定义
interface Plugin {
    void initialize();
    void execute();
    void shutdown();
}

import asyncio
import hashlib
import json
import os
from enum import Enum
from typing import Dict, Any, Optional, Callable
from dataclasses import dataclass
import aiofiles
import numpy as np
from PIL import Image
 
class ResourceType(Enum):
    TEXTURE = "texture"
    MODEL = "model"
    AUDIO = "audio"
    SHADER = "shader"
    CONFIG = "config"
 
@dataclass
class ResourceInfo:
    path: str
    type: ResourceType
    size: int
    checksum: str
    dependencies: list
 
class ResourceLoader:
    def __init__(self, base_path: str, cache_size: int = 100):
        self.base_path = base_path
        self.cache = {}
        self.cache_size = cache_size
        self.loading_queue = asyncio.Queue()
        self.loaders = {
            ResourceType.TEXTURE: self._load_texture,
            ResourceType.MODEL: self._load_model,
            ResourceType.AUDIO: self._load_audio,
            ResourceType.SHADER: self._load_shader,
            ResourceType.CONFIG: self._load_config
        }
        self.resource_manifest = {}
        self.load_callbacks = {}
        
    async def initialize(self):
        """初始化资源加载器"""
        # 加载资源清单
        await self._load_manifest()
        
        # 启动异步加载工作线程
        asyncio.create_task(self._process_loading_queue())
        
    async def _load_manifest(self):
        """加载资源清单文件"""
        manifest_path = os.path.join(self.base_path, "manifest.json")
        async with aiofiles.open(manifest_path, 'r') as f:
            data = await f.read()
            manifest = json.loads(data)
            
        for resource_id, info in manifest.items():
            self.resource_manifest[resource_id] = ResourceInfo(**info)
            
    async def load_resource(self, resource_id: str, 
                           callback: Optional[Callable] = None) -> Any:
        """异步加载资源"""
        # 检查缓存
        if resource_id in self.cache:
            return self.cache[resource_id]
            
        # 检查资源是否存在
        if resource_id not in self.resource_manifest:
            raise ValueError(f"Resource {resource_id} not found")
            
        # 添加到加载队列
        if callback:
            self.load_callbacks[resource_id] = callback
            
        await self.loading_queue.put(resource_id)
        
        # 等待资源加载完成
        while resource_id not in self.cache:
            await asyncio.sleep(0.1)
            
        return self.cache[resource_id]
        
    async def _process_loading_queue(self):
        """处理加载队列"""
        while True:
            try:
                resource_id = await self.loading_queue.get()
                
                # 避免重复加载
                if resource_id in self.cache:
                    continue
                    
                # 加载资源
                resource_info = self.resource_manifest[resource_id]
                
                # 先加载依赖
                for dep_id in resource_info.dependencies:
                    if dep_id not in self.cache:
                        await self.load_resource(dep_id)
                        
                # 根据类型选择加载器
                loader = self.loaders.get(resource_info.type)
                if loader:
                    resource_data = await loader(resource_info)
                    
                    # 添加到缓存
                    self._add_to_cache(resource_id, resource_data)
                    
                    # 触发回调
                    if resource_id in self.load_callbacks:
                        callback = self.load_callbacks.pop(resource_id)
                        callback(resource_data)
                        
            except Exception as e:
                print(f"Error loading resource: {e}")
                
    def _add_to_cache(self, resource_id: str, data: Any):
        """添加资源到缓存"""
        # 实现 LRU 缓存策略
        if len(self.cache) >= self.cache_size:
            # 移除最旧的资源
            oldest = next(iter(self.cache))
            del self.cache[oldest]
            
        self.cache[resource_id] = data
        
    async def _load_texture(self, info: ResourceInfo) -> np.ndarray:
        """加载纹理资源"""
        file_path = os.path.join(self.base_path, info.path)
        
        # 异步读取图像文件
        async with aiofiles.open(file_path, 'rb') as f:
            image_data = await f.read()
            
        # 在线程池中处理图像
        loop = asyncio.get_event_loop()
        texture = await loop.run_in_executor(
            None, 
            self._process_texture, 
            image_data
        )
        
        return texture
        
    def _process_texture(self, image_data: bytes) -> np.ndarray:
        """处理纹理数据"""
        from io import BytesIO
        
        # 解码图像
        image = Image.open(BytesIO(image_data))
        
        # 转换为 RGBA
        if image.mode != 'RGBA':
            image = image.convert('RGBA')
            
        # 生成 mipmap
        mipmaps = []
        current = image
        
        while current.width > 1 and current.height > 1:
            mipmaps.append(np.array(current))
            current = current.resize(
                (current.width // 2, current.height // 2),
                Image.LANCZOS
            )
            
        return mipmaps
        
    async def _load_model(self, info: ResourceInfo) -> Dict:
        """加载3D模型"""
        file_path = os.path.join(self.base_path, info.path)
        
        async with aiofiles.open(file_path, 'r') as f:
            model_data = await f.read()
            
        # 解析模型数据（简化示例）
        return json.loads(model_data)
        
    async def _load_audio(self, info: ResourceInfo) -> bytes:
        """加载音频资源"""
        file_path = os.path.join(self.base_path, info.path)
        
        async with aiofiles.open(file_path, 'rb') as f:
            return await f.read()
            
    async def _load_shader(self, info: ResourceInfo) -> str:
        """加载着色器代码"""
        file_path = os.path.join(self.base_path, info.path)
        
        async with aiofiles.open(file_path, 'r') as f:
            return await f.read()
            
    async def _load_config(self, info: ResourceInfo) -> Dict:
        """加载配置文件"""
        file_path = os.path.join(self.base_path, info.path)
        
        async with aiofiles.open(file_path, 'r') as f:
            content = await f.read()
            return json.loads(content)
            
    async def preload_resources(self, resource_ids: list):
        """预加载资源列表"""
        tasks = [self.load_resource(rid) for rid in resource_ids]
        await asyncio.gather(*tasks)
        
    def get_cache_stats(self) -> Dict:
        """获取缓存统计信息"""
        total_size = sum(
            self.resource_manifest[rid].size 
            for rid in self.cache.keys()
            if rid in self.resource_manifest
        )
        
        return {
            "cached_resources": len(self.cache),
            "total_size_mb": total_size / (1024 * 1024),
            "cache_hit_rate": self._calculate_hit_rate()
        }
        
    def _calculate_hit_rate(self) -> float:
        """计算缓存命中率"""
        # 实际实现中应该记录命中和未命中次数
        return 0.85  # 示例值
 
# 使用示例
async def main():
    loader = ResourceLoader("/game/assets")
    await loader.initialize()
    
    # 预加载关键资源
    await loader.preload_resources([
        "player_texture",
        "player_model",
        "main_theme_audio"
    ])
    
    # 异步加载资源
    texture = await loader.load_resource("enemy_texture")
    
    # 带回调的加载
    def on_level_loaded(data):
        print(f"Level loaded: {data}")
        
    await loader.load_resource("level_1", callback=on_level_loaded)
    
    # 获取缓存统计
    stats = loader.get_cache_stats()
    print(f"Cache stats: {stats}")
 
if __name__ == "__main__":
    asyncio.run(main())

// TypeScript 实现的高级缓存系统
interface CacheEntry<T> {
    data: T;
    timestamp: number;
    accessCount: number;
    size: number;
    priority: number;
}
 
enum CacheStrategy {
    LRU = 'lru',
    LFU = 'lfu',
    FIFO = 'fifo',
    TTL = 'ttl'
}
 
class AdvancedCache<T> {
    private cache: Map<string, CacheEntry<T>> = new Map();
    private accessOrder: string[] = [];
    private maxSize: number;
    private currentSize: number = 0;
    private strategy: CacheStrategy;
    private ttl: number;
    
    constructor(
        maxSize: number,
        strategy: CacheStrategy = CacheStrategy.LRU,
        ttl: number = Infinity
    ) {
        this.maxSize = maxSize;
        this.strategy = strategy;
        this.ttl = ttl;
    }
    
    async get(key: string): Promise<T | undefined> {
        const entry = this.cache.get(key);
        
        if (!entry) {
            return undefined;
        }
        
        // 检查 TTL
        if (this.strategy === CacheStrategy.TTL) {
            const age = Date.now() - entry.timestamp;
            if (age > this.ttl) {
                this.remove(key);
                return undefined;
            }
        }
        
        // 更新访问信息
        entry.accessCount++;
        entry.timestamp = Date.now();
        
        // 更新访问顺序（LRU）
        if (this.strategy === CacheStrategy.LRU) {
            this.updateAccessOrder(key);
        }
        
        return entry.data;
    }
    
    async set(
        key: string, 
        data: T, 
        size: number, 
        priority: number = 0
    ): Promise<void> {
        // 如果已存在，先移除旧的
        if (this.cache.has(key)) {
            this.remove(key);
        }
        
        // 确保有足够空间
        while (this.currentSize + size > this.maxSize && this.cache.size > 0) {
            this.evict();
        }
        
        // 添加新条目
        const entry: CacheEntry<T> = {
            data,
            timestamp: Date.now(),
            accessCount: 1,
            size,
            priority
        };
        
        this.cache.set(key, entry);
        this.currentSize += size;
        this.accessOrder.push(key);
    }
    
    private evict(): void {
        let keyToEvict: string | undefined;
        
        switch (this.strategy) {
            case CacheStrategy.LRU:
                keyToEvict = this.accessOrder[0];
                break;
                
            case CacheStrategy.LFU:
                keyToEvict = this.findLeastFrequent();
                break;
                
            case CacheStrategy.FIFO:
                keyToEvict = this.cache.keys().next().value;
                break;
                
            case CacheStrategy.TTL:
                keyToEvict = this.findOldest();
                break;
        }
        
        if (keyToEvict) {
            this.remove(keyToEvict);
        }
    }
    
    private findLeastFrequent(): string | undefined {
        let minCount = Infinity;
        let keyToEvict: string | undefined;
        
        for (const [key, entry] of this.cache.entries()) {
            if (entry.accessCount < minCount) {
                minCount = entry.accessCount;
                keyToEvict = key;
            }
        }
        
        return keyToEvict;
    }
    
    private findOldest(): string | undefined {
        let oldestTime = Infinity;
        let keyToEvict: string | undefined;
        
        for (const [key, entry] of this.cache.entries()) {
            if (entry.timestamp < oldestTime) {
                oldestTime = entry.timestamp;
                keyToEvict = key;
            }
        }
        
        return keyToEvict;
    }
    
    private updateAccessOrder(key: string): void {
        const index = this.accessOrder.indexOf(key);
        if (index > -1) {
            this.accessOrder.splice(index, 1);
        }
        this.accessOrder.push(key);
    }
    
    private remove(key: string): void {
        const entry = this.cache.get(key);
        if (entry) {
            this.currentSize -= entry.size;
            this.cache.delete(key);
            
            const index = this.accessOrder.indexOf(key);
            if (index > -1) {
                this.accessOrder.splice(index, 1);
            }
        }
    }
    
    getStats(): object {
        return {
            entries: this.cache.size,
            currentSize: this.currentSize,
            maxSize: this.maxSize,
            utilization: (this.currentSize / this.maxSize) * 100,
            strategy: this.strategy
        };
    }
}
 
// 带预取功能的 Loader
class PrefetchLoader<T> {
    private cache: AdvancedCache<T>;
    private prefetchQueue: Set<string> = new Set();
    private loadFunction: (key: string) => Promise<T>;
    private sizeFunction: (data: T) => number;
    
    constructor(
        loadFunction: (key: string) => Promise<T>,
        sizeFunction: (data: T) => number,
        cacheSize: number = 100 * 1024 * 1024 // 100MB
    ) {
        this.cache = new AdvancedCache<T>(cacheSize, CacheStrategy.LRU);
        this.loadFunction = loadFunction;
        this.sizeFunction = sizeFunction;
    }
    
    async load(key: string, prefetchKeys?: string[]): Promise<T> {
        // 尝试从缓存获取
        let data = await this.cache.get(key);
        
        if (!data) {
            // 加载数据
            data = await this.loadFunction(key);
            
            // 添加到缓存
            const size = this.sizeFunction(data);
            await this.cache.set(key, data, size);
        }
        
        // 预取相关资源
        if (prefetchKeys && prefetchKeys.length > 0) {
            this.prefetch(prefetchKeys);
        }
        
        return data;
    }
    
    private async prefetch(keys: string[]): Promise<void> {
        for (const key of keys) {
            if (!this.prefetchQueue.has(key)) {
                this.prefetchQueue.add(key);
                
                // 异步预取
                this.loadFunction(key).then(data => {
                    const size = this.sizeFunction(data);
                    this.cache.set(key, data, size, -1); // 低优先级
                    this.prefetchQueue.delete(key);
                }).catch(error => {
                    console.error(`Prefetch failed for ${key}:`, error);
                    this.prefetchQueue.delete(key);
                });
            }
        }
    }
}

package configloader
 
import (
    "context"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "sync"
    "time"
    
    "github.com/fsnotify/fsnotify"
    "gopkg.in/yaml.v3"
)
 
// ConfigSource 定义配置源接口
type ConfigSource interface {
    Load(ctx context.Context) (map[string]interface{}, error)
    Watch(ctx context.Context, callback func(map[string]interface{})) error
    Name() string
}
 
// FileSource 文件配置源
type FileSource struct {
    path   string
    format string
}
 
func NewFileSource(path, format string) *FileSource {
    return &FileSource{
        path:   path,
        format: format,
    }
}
 
func (fs *FileSource) Load(ctx context.Context) (map[string]interface{}, error) {
    data, err := ioutil.ReadFile(fs.path)
    if err != nil {
        return nil, fmt.Errorf("failed to read file: %w", err)
    }
    
    var config map[string]interface{}
    
    switch fs.format {
    case "json":
        err = json.Unmarshal(data, &config)
    case "yaml":
        err = yaml.Unmarshal(data, &config)
    default:
        return nil, fmt.Errorf("unsupported format: %s", fs.format)
    }
    
    if err != nil {
        return nil, fmt.Errorf("failed to parse config: %w", err)
    }
    
    return config, nil
}
 
func (fs *FileSource) Watch(ctx context.Context, callback func(map[string]interface{})) error {
    watcher, err := fsnotify.NewWatcher()
    if err != nil {
        return err
    }
    defer watcher.Close()
    
    err = watcher.Add(fs.path)
    if err != nil {
        return err
    }
    
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        case event := <-watcher.Events:
            if event.Op&fsnotify.Write == fsnotify.Write {
                config, err := fs.Load(ctx)
                if err == nil {
                    callback(config)
                }
            }
        case err := <-watcher.Errors:
            return err
        }
    }
}
 
func (fs *FileSource) Name() string {
    return fmt.Sprintf("file:%s", fs.path)
}
 
// HTTPSource HTTP 配置源
type HTTPSource struct {
    url      string
    interval time.Duration
    headers  map[string]string
}
 
func NewHTTPSource(url string, interval time.Duration) *HTTPSource {
    return &HTTPSource{
        url:      url,
        interval: interval,
        headers:  make(map[string]string),
    }
}
 
func (hs *HTTPSource) Load(ctx context.Context) (map[string]interface{}, error) {
    req, err := http.NewRequestWithContext(ctx, "GET", hs.url, nil)
    if err != nil {
        return nil, err
    }
    
    for key, value := range hs.headers {
        req.Header.Set(key, value)
    }
    
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
    }
    
    var config map[string]interface{}
    err = json.NewDecoder(resp.Body).Decode(&config)
    if err != nil {
        return nil, err
    }
    
    return config, nil
}
 
func (hs *HTTPSource) Watch(ctx context.Context, callback func(map[string]interface{})) error {
    ticker := time.NewTicker(hs.interval)
    defer ticker.Stop()
    
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        case <-ticker.C:
            config, err := hs.Load(ctx)
            if err == nil {
                callback(config)
            }
        }
    }
}
 
func (hs *HTTPSource) Name() string {
    return fmt.Sprintf("http:%s", hs.url)
}
 
// ConfigLoader 配置加载器主体
type ConfigLoader struct {
    sources   []ConfigSource
    config    map[string]interface{}
    mu        sync.RWMutex
    listeners []func(map[string]interface{})
    ctx       context.Context
    cancel    context.CancelFunc
}
 
func NewConfigLoader() *ConfigLoader {
    ctx, cancel := context.WithCancel(context.Background())
    return &ConfigLoader{
        sources:   make([]ConfigSource, 0),
        config:    make(map[string]interface{}),
        listeners: make([]func(map[string]interface{}), 0),
        ctx:       ctx,
        cancel:    cancel,
    }
}
 
func (cl *ConfigLoader) AddSource(source ConfigSource) {
    cl.sources = append(cl.sources, source)
}
 
func (cl *ConfigLoader) Load() error {
    mergedConfig := make(map[string]interface{})
    
    // 按顺序加载所有配置源
    for _, source := range cl.sources {
        config, err := source.Load(cl.ctx)
        if err != nil {
            return fmt.Errorf("failed to load from %s: %w", source.Name(), err)
        }
        
        // 合并配置（后面的源会覆盖前面的）
        for key, value := range config {
            mergedConfig[key] = value
        }
    }
    
    cl.mu.Lock()
    cl.config = mergedConfig
    cl.mu.Unlock()
    
    // 通知监听器
    cl.notifyListeners(mergedConfig)
    
    return nil
}
 
func (cl *ConfigLoader) StartWatching() {
    for _, source := range cl.sources {
        go func(s ConfigSource) {
            s.Watch(cl.ctx, func(config map[string]interface{}) {
                cl.Load() // 重新加载所有配置
            })
        }(source)
    }
}
 
func (cl *ConfigLoader) Get(key string) (interface{}, bool) {
    cl.mu.RLock()
    defer cl.mu.RUnlock()
    
    value, exists := cl.config[key]
    return value, exists
}
 
func (cl *ConfigLoader) GetString(key string) (string, bool) {
    value, exists := cl.Get(key)
    if !exists {
        return "", false
    }
    
    str, ok := value.(string)
    return str, ok
}
 
func (cl *ConfigLoader) OnChange(listener func(map[string]interface{})) {
    cl.listeners = append(cl.listeners, listener)
}
 
func (cl *ConfigLoader) notifyListeners(config map[string]interface{}) {
    for _, listener := range cl.listeners {
        go listener(config)
    }
}
 
func (cl *ConfigLoader) Stop() {
    cl.cancel()
}
 
// 使用示例
func Example() {
    loader := NewConfigLoader()
    
    // 添加文件配置源
    loader.AddSource(NewFileSource("/etc/app/config.yaml", "yaml"))
    
    // 添加 HTTP 配置源
    loader.AddSource(NewHTTPSource(
        "http://config-server/api/config",
        30 * time.Second,
    ))
    
    // 加载配置
    if err := loader.Load(); err != nil {
        panic(err)
    }
    
    // 监听配置变化
    loader.OnChange(func(config map[string]interface{}) {
        fmt.Println("Configuration updated:", config)
    })
    
    // 开始监控
    loader.StartWatching()
    
    // 使用配置
    if dbHost, ok := loader.GetString("database.host"); ok {
        fmt.Printf("Database host: %s\n", dbHost)
    }
}