DefaultClassLoader class

The default system implementation of ClassLoader with comprehensive caching.

Provides efficient class loading and caching for the JetLeaf reflection system. This implementation uses multiple specialized caches to optimize different types of reflection queries and maintains detailed statistics for monitoring.

Cache Architecture

The DefaultClassLoader employs a multi-tier caching strategy:

Primary Caches

• Class Cache: Maps qualified names to Class instances
• Subclass Cache: Maps parent classes to their direct classes
• Interface Cache: Maps classes to their implemented interfaces
• Mixin Cache: Maps classes to their applied mixins

Declared Caches (Non-transitive)

• Declared Interface Cache: Direct interface implementations only
• Declared Mixin Cache: Direct mixin applications only

Performance Characteristics

• Class Loading: O(1) for cached, O(log n) for new classes
• Hierarchy Queries: O(1) for cached relationships
• Memory Usage: Configurable with automatic cleanup
• Thread Safety: Full concurrent access support

Example Usage

// Create system class loader
final loader = DefaultClassLoader();

// Load classes with caching
final stringClass = await loader.loadClass<String>('dart:core/string.dart.String');
final listClass = await loader.loadClass<List>('dart:core/list.dart.List');

// Query relationships (cached)
final classes = await loader.findSubclasses(stringClass);
final interfaces = await loader.findInterfaces(listClass);

// Monitor performance
final stats = loader.getCacheStats();
print('Hit rate: ${stats.hitRate}');

// Cleanup
await loader.flush(); // Clear caches
await loader.close(); // Release resources

Configuration Options

The loader supports various configuration parameters:

• Max Cache Size: Prevents unbounded memory growth
• Auto-flush Threshold: Automatic cache cleanup triggers
• Statistics Collection: Detailed performance monitoring
• Security Domains: Fine-grained access control

Thread Safety

All operations are thread-safe and support concurrent access:

• Multiple threads can load classes simultaneously
• Cache updates are atomic and consistent
• Statistics are accurately maintained under concurrency
• Resource cleanup is coordinated across threads