Understanding Framework Internals Through Implementation

The most effective method to grasp the architecture of a complex framework like Spring is to implement a simplified version of its core features. While reproducing the entire ecosystem is impractical, building a minimal Inversion of Control (IoC) container clarifies how beans are managed, dependencies are injected, and aspects are weaved. This guide walks through constructing a basic container that handles component scanning, bean lifecycle management, and proxy generation.

Core Capabilities

The objective is to replicate key Spring mechanisms without the overhead of the full framework. The implementation focuses on the following areas:

• Initialization of the application context via configuraton classes.
• Management of bean definitions and metadata.
• Processing of configuration annotations such as component scanning.
• Execution of dependency injection and awareness callbacks.
• Integration of AOP logic for transactional simulation.

Rather than attempting to cover every edge case, the focus remains on the primary execution flow: scanning, defining, instantiating, and enhancing beans.

Execution Workflow

The container lifecycle mimics the standard Spring bootstrapping process. The sequence of operations is as follows:

1. Parse the configuration class to extract base packages from the @ComponentScan annotation.
2. Traverse the specified packages to identify classes marked for management.
3. Store metadata for eligible classes in a definition registry, capturing scope and lazy-loading settings.
4. Iterate through the registry to instantiate singleton beans immediately unless marked as lazy.
5. During instantiation, resolve dependencies by retrieving required beans from the cache or creating them on demand.
6. Invoke awareness interfaces to inject context information into the bean instances.
7. Check for aspect annotations. If present, generate a proxy using CGLIB and wrap the original instance.

Implementation Details

The project structure separates configuration, business logic, and the container core. The following examples demonstrate the core container logic and a sample business component.

Sample Business Component

This class represents a standard service bean that requires dependency injection and context awareness. It also simulates a transactional boundary.

package com.example.demo.service;

@Component
public class OrderProcessingService implements ApplicationContextAware, BeanNameAware {

    @Autowired
    private InventoryService inventoryService;

    private MinimalSpringContext context;
    private String identifier;

    public void processOrder() {
        inventoryService.checkStock();
        System.out.println("Context Hash: " + context.hashCode());
        System.out.println("Bean ID: " + identifier);
    }

    @Override
    public void setApplicationContext(MinimalSpringContext context) {
        this.context = context;
    }

    @Override
    public void setBeanName(String name) {
        this.identifier = name;
    }
}

Container Core Logic

The MinimalSpringContext class orchestrates the lifecycle. It handles scanning, definition registration, and bean creation.

package com.example.demo.core;

public class MinimalSpringContext {

    private final Class<?> configurationClass;
    private final Map<String, BeanDefinition> definitionRegistry = new HashMap<>();
    private final Map<String, Object> singletonCache = new HashMap<>();

    public MinimalSpringContext(Class<?> configClass) {
        this.configurationClass = configClass;
        initializeContext();
    }

    private void initializeContext() {
        extractScanPath();
        // Instantiate non-lazy singletons
        for (Map.Entry<String, BeanDefinition> entry : definitionRegistry.entrySet()) {
            String name = entry.getKey();
            BeanDefinition def = entry.getValue();
            if (!def.isLazyInit() && "singleton".equals(def.getScope())) {
                Object bean = instantiateBean(name);
                singletonCache.put(name, bean);
            }
        }
    }

    private void extractScanPath() {
        ComponentScan scanAnnotation = configurationClass.getDeclaredAnnotation(ComponentScan.class);
        String basePackage = scanAnnotation.basePackages();
        performScan(basePackage);
    }

    private void performScan(String packagePath) {
        String resourcePath = packagePath.replace(".", "/");
        ClassLoader loader = this.getClass().getClassLoader();
        URL resourceUrl = loader.getResource(resourcePath);
        
        if (resourceUrl == null) return;
        
        File rootDir = new File(resourceUrl.getFile());
        List<File> classFiles = new ArrayList<>();
        collectClassFiles(rootDir, classFiles);

        for (File file : classFiles) {
            String fullPath = file.getAbsolutePath();
            String className = fullPath.substring(fullPath.indexOf("com"), fullPath.indexOf(".class"))
                    .replace("\\", ".");
            
            try {
                Class<?> clazz = loader.loadClass(className);
                if (clazz.isAnnotationPresent(Component.class)) {
                    registerBeanDefinition(clazz);
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

    private void collectClassFiles(File dir, List<File> collector) {
        if (dir.isDirectory()) {
            for (File child : dir.listFiles()) {
                collectClassFiles(child, collector);
            }
        } else if (dir.getName().endsWith(".class")) {
            collector.add(dir);
        }
    }

    private void registerBeanDefinition(Class<?> clazz) {
        BeanDefinition def = new BeanDefinition();
        def.setType(clazz);
        def.setLazyInit(clazz.isAnnotationPresent(Lazy.class));
        
        Scope scope = clazz.getAnnotation(Scope.class);
        def.setScope(scope != null ? scope.value() : "singleton");

        Component comp = clazz.getAnnotation(Component.class);
        String beanName = comp.value();
        if (beanName.isEmpty()) {
            beanName = Introspector.decapitalize(clazz.getSimpleName());
        }
        definitionRegistry.put(beanName, def);
    }

    public Object instantiateBean(String beanName) {
        BeanDefinition def = definitionRegistry.get(beanName);
        Class<?> type = def.getType();

        try {
            Object instance = type.getDeclaredConstructor().newInstance();
            injectDependencies(instance);

            if (instance instanceof ApplicationContextAware) {
                ((ApplicationContextAware) instance).setApplicationContext(this);
            }
            if (instance instanceof BeanNameAware) {
                ((BeanNameAware) instance).setBeanName(beanName);
            }

            // Apply AOP proxy if transactional annotation exists
            if (type.isAnnotationPresent(Transactional.class)) {
                Enhancer enhancer = new Enhancer();
                enhancer.setSuperclass(type);
                enhancer.setCallback(new MethodInterceptor() {
                    @Override
                    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                        System.out.println("[Transaction] Begin");
                        Object result = method.invoke(instance, args);
                        System.out.println("[Transaction] Commit");
                        return result;
                    }
                });
                return enhancer.create();
            }
            return instance;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    private void injectDependencies(Object target) {
        Field[] fields = target.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(Autowired.class)) {
                String dependencyName = field.getName();
                Object dependency = getBean(dependencyName);
                field.setAccessible(true);
                try {
                    field.set(target, dependency);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public Object getBean(String name) {
        if (!definitionRegistry.containsKey(name)) {
            throw new NoSuchElementException("Bean not found: " + name);
        }
        
        BeanDefinition def = definitionRegistry.get(name);
        if ("singleton".equals(def.getScope())) {
            if (singletonCache.containsKey(name)) {
                return singletonCache.get(name);
            }
            Object newBean = instantiateBean(name);
            singletonCache.put(name, newBean);
            return newBean;
        }
        return instantiateBean(name);
    }
}

Key Mechanisms Explained

The scanning process converts package names into file system paths to locate compiled class files. Once identified, annotations are inspected to determine if the class should be managed. The BeanDefinition acts as a metadata holder, storing scope and initialization preferences before any object is created.

Dependency injection occurs immediately after instantiation but before awareness callbacks. This ensures that fields annotated with @Autowired are populated by retrieving existing instances from the singleton cache or triggering a nested creation process. The AOP logic utilizes CGLIB to generate a subclass at runtime. If a transactional annotation is detected, method calls are intercepted to simulate begin/commit logic around the actual business method invocation.

While this implementation omits complex features like circular dependency resolution and thread-safe caching locks found in the production framework, it accurately reflects the fundamental sequence of bean lifecycle management.