CLEANUP: Simplify MetaDataLoader Registry Architecture and Eliminate Dead Code

• Removed 4 dead code classes (495 lines eliminated):
  - DatabaseAttributeRegistration.java (unused flag setter)
  - MetaDataType.java (obsolete annotation)
  - MetaDataRegistryExtension.java (unused interface)
  - MetaDataLoaderProvider.java (unused interface)

• Simplified MetaDataLoaderRegistry by removing auto-discovery complexity
  while maintaining core dynamic loader management functionality

• Enhanced MetaDataUtil with dual pattern support:
  - Simple pattern: findMetaObject(loader, obj) for single-loader scenarios
  - Complex pattern: findMetaObject(obj, context) for multi-loader scenarios

• Updated examples to demonstrate appropriate usage patterns:
  - BasicExample: Simple pattern with direct loader access
  - SpringExample: Complex pattern with service wrapper and registry
  - Enhanced pattern documentation throughout

• Fixed compilation issues: removed obsolete imports, corrected method signatures

• Architecture now provides clear guidance for simple vs complex usage scenarios
  while maintaining 100% backward compatibility and reducing overall complexity

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: dmealing

examples/basic-example/src/main/java/com/draagon/meta/examples/basic/BasicMetaObjectsExample.java

@@ -6,18 +6,22 @@
 import com.draagon.meta.field.MetaField;
 import com.draagon.meta.generator.mustache.MustacheTemplateGenerator;
 import com.draagon.meta.MetaData;
+import com.draagon.meta.util.MetaDataUtil;
 
 import java.net.URI;
 import java.util.Arrays;
 
 /**
- * Basic example demonstrating MetaObjects core functionality without any framework integration.
- * 
- * This example shows:
- * 1. Loading metadata from JSON files
- * 2. Generating Java POJO classes using Mustache templates
- * 3. Working with metadata directly
- * 4. Creating and validating objects using metadata
+ * Basic example demonstrating SIMPLE PATTERN MetaObjects usage without framework integration.
+ *
+ * This example demonstrates the simple pattern for single-loader scenarios:
+ * 1. Direct SimpleLoader usage (no registry complexity)
+ * 2. MetaDataUtil.findMetaObject*(loader, ...) methods
+ * 3. Single-loader metadata operations
+ * 4. Basic object creation and validation
+ * 5. Code generation capabilities
+ *
+ * Use this pattern when you have one MetaDataLoader and don't need multi-loader registry features.
  */
 public class BasicMetaObjectsExample {
 
@@ -73,21 +77,22 @@ public static void main(String[] args) {
                 System.out.println("     - " + obj.getName() + " (package: " + obj.getPackage() + ")");
             }
 
-            // Try to get User MetaObject
+            // SIMPLE PATTERN: Direct loader MetaObject lookup using utility methods
             MetaObject userMeta = null;
             try {
-                userMeta = loader.getMetaObjectByName("User");
-                System.out.println("   Found MetaObject: " + userMeta.getName());
+                // Use MetaDataUtil simple pattern method (recommended)
+                userMeta = MetaDataUtil.findMetaObjectByName(loader, "com_example_model::User");
+                System.out.println("   Found User MetaObject via MetaDataUtil: " + userMeta.getName());
                 System.out.println("   Fields: " + userMeta.getMetaFields().size());
             } catch (Exception e) {
-                System.out.println("   Error finding User: " + e.getMessage());
-                // Try with package qualification
+                System.out.println("   Error finding User via MetaDataUtil: " + e.getMessage());
+                // Fallback to direct loader access
                 try {
                     userMeta = loader.getMetaObjectByName("com_example_model::User");
-                    System.out.println("   Found User with package: " + userMeta.getName());
+                    System.out.println("   Found User via direct loader: " + userMeta.getName());
                     System.out.println("   Fields: " + userMeta.getMetaFields().size());
                 } catch (Exception e2) {
-                    System.out.println("   Error finding User with package: " + e2.getMessage());
+                    System.out.println("   Error with direct loader access: " + e2.getMessage());
                 }
             }
 
@@ -148,10 +153,28 @@ public static void main(String[] args) {
                 System.out.println("   Cannot create user object - User MetaObject not found");
             }
 
-            // 6. Demonstrate metadata registry functionality
-            System.out.println("\n6. Registry information...");
+            // 6. SIMPLE PATTERN: Demonstrate utility methods for single-loader scenarios
+            System.out.println("\n6. Simple pattern utility methods...");
             System.out.println("   Loader name: " + loader.getName());
-            System.out.println("   Total MetaObjects: " + loader.getChildren(MetaObject.class).size());
+
+            // Use MetaDataUtil simple pattern method to get all MetaObjects
+            java.util.List<MetaObject> allObjects = MetaDataUtil.getAllMetaObjects(loader);
+            System.out.println("   Total MetaObjects via utility: " + allObjects.size());
+
+            for (MetaObject obj : allObjects) {
+                System.out.println("     - " + obj.getName() + " (package: " + obj.getPackage() + ")");
+            }
+
+            // 7. Simple vs Complex pattern comparison
+            System.out.println("\n7. When to use simple vs complex patterns...");
+            System.out.println("   SIMPLE PATTERN (this example):");
+            System.out.println("     - Single MetaDataLoader");
+            System.out.println("     - Direct loader.getMetaObjectByName() or MetaDataUtil.findMetaObjectByName(loader, ...)");
+            System.out.println("     - No registry complexity needed");
+            System.out.println("   COMPLEX PATTERN (see spring-example, osgi-example):");
+            System.out.println("     - Multiple MetaDataLoaders in registry");
+            System.out.println("     - MetaDataLoaderRegistry or MetaDataService");
+            System.out.println("     - Multi-tenant, plugin, or framework scenarios");
 
             System.out.println("\n=== Example completed successfully ===");
 

examples/spring-example/src/main/java/com/draagon/meta/examples/spring/SpringMetaObjectsExample.java

@@ -5,6 +5,7 @@
 import com.draagon.meta.loader.simple.SimpleLoader;
 import com.draagon.meta.registry.MetaDataLoaderRegistry;
 import com.draagon.meta.object.MetaObject;
+import com.draagon.meta.util.MetaDataUtil;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.CommandLineRunner;
@@ -27,15 +28,15 @@
 @SpringBootApplication
 public class SpringMetaObjectsExample implements CommandLineRunner {
 
-    // Option 1: Convenient service wrapper (recommended)
+    // COMPLEX PATTERN: Convenient service wrapper for multi-loader scenarios (recommended)
     @Autowired
     private MetaDataService metaDataService;
-    
-    // Option 2: Backward compatible loader injection
+
+    // SIMPLE PATTERN: Direct loader injection for single-loader scenarios
     @Autowired
     private MetaDataLoader primaryMetaDataLoader;
-    
-    // Option 3: Full registry access for advanced operations
+
+    // COMPLEX PATTERN: Full registry access for advanced multi-loader operations
     @Autowired
     private MetaDataLoaderRegistry metaDataLoaderRegistry;
 
@@ -54,61 +55,48 @@ public static void main(String[] args) {
      * Simple test of Spring integration without Spring Boot complexity
      */
     private static void testSpringIntegrationManually() throws Exception {
-        System.out.println("\n1. Manual Spring integration test...");
-        
-        // Test direct Spring class usage
-        com.draagon.meta.spring.MetaDataService service = null;
-        com.draagon.meta.spring.MetaDataAutoConfiguration config = null;
-        
+        System.out.println("\n1. Spring class loading verification...");
+
+        // Test Spring class availability
         try {
-            // Test that Spring classes can be loaded
-            config = new com.draagon.meta.spring.MetaDataAutoConfiguration();
-            System.out.println("   MetaDataAutoConfiguration class loaded: SUCCESS");
-            
-            // Test MetaDataService class loading
-            Class<?> serviceClass = Class.forName("com.draagon.meta.spring.MetaDataService");
-            System.out.println("   MetaDataService class loaded: SUCCESS");
-            
-            // Test MetaDataLoaderConfiguration class loading
-            Class<?> configClass = Class.forName("com.draagon.meta.spring.MetaDataLoaderConfiguration");
-            System.out.println("   MetaDataLoaderConfiguration class loaded: SUCCESS");
-            
+            Class.forName("com.draagon.meta.spring.MetaDataAutoConfiguration");
+            Class.forName("com.draagon.meta.spring.MetaDataService");
+            Class.forName("com.draagon.meta.spring.MetaDataLoaderConfiguration");
+            System.out.println("   Spring integration classes: SUCCESS");
         } catch (Exception e) {
             System.out.println("   Spring class loading failed: " + e.getMessage());
         }
-        
-        // Test basic metadata functionality (same as other examples)
+
+        // Test basic metadata functionality using simple pattern
         System.out.println("\n2. Basic MetaObjects functionality...");
-        
-        com.draagon.meta.loader.simple.SimpleLoader loader = new com.draagon.meta.loader.simple.SimpleLoader("spring-test");
-        
-        // Load from classpath (same approach as other examples)
+
+        // Simple pattern: Create one loader for single-loader scenario
+        SimpleLoader loader = new SimpleLoader("spring-test");
+
         java.net.URL resourceUrl = SpringMetaObjectsExample.class.getResource("/metadata/examples-metadata.json");
         if (resourceUrl == null) {
-            throw new RuntimeException("Could not find metadata resource: /metadata/examples-metadata.json");
+            throw new RuntimeException("Could not find metadata resource");
         }
-        
-        // Create temporary file and copy resource content
+
         java.nio.file.Path tempFile = java.nio.file.Files.createTempFile("examples-metadata", ".json");
         try (java.io.InputStream is = resourceUrl.openStream()) {
             java.nio.file.Files.copy(is, tempFile, java.nio.file.StandardCopyOption.REPLACE_EXISTING);
         }
-        
-        java.net.URI metadataUri = tempFile.toUri();
-        loader.setSourceURIs(java.util.Arrays.asList(metadataUri));
+
+        loader.setSourceURIs(java.util.Arrays.asList(tempFile.toUri()));
         loader.init();
-        
+
         System.out.println("   Loaded " + loader.getChildren().size() + " metadata items");
-        
-        // Test MetaObject access
+
+        // Simple pattern: Direct loader access instead of registry
         try {
-            com.draagon.meta.object.MetaObject userMeta = loader.getMetaObjectByName("com_example_model::User");
+            MetaObject userMeta = com.draagon.meta.util.MetaDataUtil.findMetaObjectByName(loader, "com_example_model::User");
             System.out.println("   Found User MetaObject: " + userMeta.getName());
             System.out.println("   User has " + userMeta.getMetaFields().size() + " fields");
         } catch (Exception e) {
             System.out.println("   MetaObject lookup failed: " + e.getMessage());
         }
-        
+
         System.out.println("\n=== Manual Spring integration test completed ===");
     }
 
@@ -155,38 +143,54 @@ private void demonstrateSpringIntegration() {
         boolean hasProduct = metaDataService.metaObjectExists("com_example_model::Product");
         System.out.println("   User exists: " + hasUser + ", Product exists: " + hasProduct);
 
-        // 3. Backward compatible loader access
-        System.out.println("\n3. Backward compatible loader access...");
+        // 3. SIMPLE PATTERN: Direct loader access for single-loader scenarios
+        System.out.println("\n3. Simple pattern - direct loader access...");
         System.out.println("   Primary loader name: " + primaryMetaDataLoader.getName());
-        System.out.println("   Primary loader objects: " + 
+        System.out.println("   Primary loader objects: " +
             primaryMetaDataLoader.getChildren(MetaObject.class).size());
+
+        // Demonstrate simple pattern utility methods
+        try {
+            MetaObject directUser = MetaDataUtil.findMetaObjectByName(primaryMetaDataLoader, "com_example_model::User");
+            System.out.println("   Direct loader lookup: " + directUser.getName());
+        } catch (Exception e) {
+            System.out.println("   Direct lookup failed: " + e.getMessage());
+        }
 
-        // 4. Advanced registry operations
-        System.out.println("\n4. Advanced registry operations...");
-        System.out.println("   Total registered loaders: " + 
+        // 4. COMPLEX PATTERN: Advanced registry operations for multi-loader scenarios
+        System.out.println("\n4. Complex pattern - registry operations...");
+        System.out.println("   Total registered loaders: " +
             metaDataLoaderRegistry.getDataLoaders().size());
-        
+
         for (MetaDataLoader loader : metaDataLoaderRegistry.getDataLoaders()) {
-            System.out.println("     - Loader: " + loader.getName() + 
+            System.out.println("     - Loader: " + loader.getName() +
                 " (" + loader.getChildren().size() + " children)");
         }
+
+        // Demonstrate complex pattern utility methods
+        try {
+            MetaObject registryUser = MetaDataUtil.findMetaObjectByName("com_example_model::User", this);
+            System.out.println("   Registry utility lookup: " + registryUser.getName());
+        } catch (Exception e) {
+            System.out.println("   Registry utility lookup failed: " + e.getMessage());
+        }
 
-        // 5. Demonstrate service convenience methods
-        System.out.println("\n5. Service convenience methods...");
-        
+        // 5. COMPLEX PATTERN: Service convenience methods (best for most Spring applications)
+        System.out.println("\n5. Service convenience methods (recommended for most Spring apps)...");
+
         try {
-            // Direct lookup
+            // Service wrapper with Optional support
             MetaObject user = metaDataService.findMetaObjectByName("com_example_model::User");
-            System.out.println("   Direct lookup successful: " + user.getName());
-            
+            System.out.println("   Service lookup successful: " + user.getName());
+
             // Field details
             user.getMetaFields().forEach(field -> {
-                System.out.println("     Field: " + field.getName() + 
+                System.out.println("     Field: " + field.getName() +
                     " (" + field.getSubType() + ")");
             });
-            
+
         } catch (Exception e) {
-            System.out.println("   MetaObject lookup failed: " + e.getMessage());
+            System.out.println("   Service lookup failed: " + e.getMessage());
         }
 
         System.out.println("\n=== Spring Example completed ===");

metadata/src/main/java/com/draagon/meta/field/DoubleField.java

@@ -14,7 +14,6 @@
 // Constraint registration now handled by consolidated MetaDataRegistry
 import com.draagon.meta.constraint.PlacementConstraint;
 import com.draagon.meta.registry.MetaDataRegistry;
-import com.draagon.meta.registry.MetaDataType;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 

metadata/src/main/java/com/draagon/meta/field/IntegerField.java

@@ -12,7 +12,6 @@
 // Constraint registration now handled by consolidated MetaDataRegistry
 import com.draagon.meta.constraint.PlacementConstraint;
 import com.draagon.meta.registry.MetaDataRegistry;
-import com.draagon.meta.registry.MetaDataType;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 

metadata/src/main/java/com/draagon/meta/field/LongField.java

@@ -12,7 +12,6 @@
 // Constraint registration now handled by consolidated MetaDataRegistry
 import com.draagon.meta.constraint.PlacementConstraint;
 import com.draagon.meta.registry.MetaDataRegistry;
-import com.draagon.meta.registry.MetaDataType;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 

metadata/src/main/java/com/draagon/meta/field/StringField.java

@@ -13,7 +13,6 @@
 import com.draagon.meta.constraint.PlacementConstraint;
 // Constraint registration now handled by consolidated MetaDataRegistry
 import com.draagon.meta.registry.MetaDataRegistry;
-import com.draagon.meta.registry.MetaDataType;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import static com.draagon.meta.field.MetaField.SUBTYPE_BASE;