Hoe werkt het Spring Framework 'onder de motorkap'?

Spring Framework werkt door gebruik te maken van verschillende kernprincipes en mechanismen:

1. Inversie van Controle (Inversion of Control - IoC):

   • De Spring-container (meest gebruikelijk is ApplicationContext) beheert de levenscyclus van objecten (beans).
   • In plaats van dat objecten hun afhankelijkheden zelf creëren, declareren ze deze, en de container injecteert ze (Dependency Injection - DI).
   • Dit wordt bereikt door:
     • Configuratie: XML, annotaties (@Autowired, @Inject), JavaConfig (@Configuration, @Bean).
     • Reflectie: Spring scant klassen, annotaties en meta-informatie om beans en hun afhankelijkheden te bepalen.

2. Aspectgericht Programmeren (Aspect-Oriented Programming - AOP):

   • Maakt het modulair maken van cross-cutting concerns mogelijk (zoals logging, beveiliging, transactiebeheer).
   • Deze concerns worden geïmplementeerd als aspecten, die kunnen worden toegepast op verschillende join points in de uitvoering van de applicatie.
   • Spring AOP gebruikt proxies (JDK Dynamic Proxies of CGLIB) om method calls te onderscheppen en aspecten toe te passen.
   • Toegepast tijdens runtime (runtime weaving).

3. Abstractie:

   • Spring biedt high-level abstracties boven low-level API's, wat de ontwikkeling vereenvoudigt. Voorbeelden:
     • Transactiebeheer (PlatformTransactionManager) abstractieert over verschillende implementaties (JTA, JDBC, JPA).
     • Toegang tot data (JDBC, JPA/Hibernate) biedt vereenvoudigde sjablonen (JdbcTemplate, JpaTemplate) en foutafhandeling.
     • MVC-framework abstractieert HTTP-verzoeken.

4. Spring Container (ApplicationContext):

   • Belangrijkste component dat beans beheert.
   • Scant klassen, leest meta-informatie (configuratie), creëert, configureert en beheert de levenscyclus van beans.
   • Registreert bean-definities en creëert bean-instanties op aanvraag of bij opstarten (afhankelijk van scope en lazy initialization).
   • Voert Dependency Injection uit.
   • Biedt services zoals lokalisatie, publicatie van events, resource loading.

5. Reflectie:

   • Wordt veel gebruikt voor:
     • Scannen van classpath op klassen met annotaties (@Component, @Service, @Repository, @Controller).
     • Lezen van annotatie-meta-informatie (@Autowired, @Value, @Transactional).
     • Verkrijgen van constructors en methoden voor het maken van bean-instanties en injectie.
     • Dynamisch maken van proxy-objecten voor AOP.

6. Levenscyclus van een bean:

   • Spring beheert de levenscyclus van een bean, inclusief:
     • Aanmaken van instantie.
     • Injectie van afhankelijkheden.
     • Uitvoeren van BeanNameAware, BeanFactoryAware, ApplicationContextAware.
     • Uitvoeren van BeanPostProcessor (method postProcessBeforeInitialization).
     • Uitvoeren van @PostConstruct of afterPropertiesSet.
     • Uitvoeren van initialisatiemethode gedefinieerd in @Bean of XML.
     • Gebruik van de bean.
     • Uitvoeren van BeanPostProcessor (method postProcessAfterInitialization).
     • Uitvoeren van @PreDestroy of destroyableBean.
     • Uitvoeren van de destroy-methode gedefinieerd in @Bean of XML.

// Voorbeeld van het gebruik van @Autowired voor afhankelijkheidsinjectie
@Component // Bean wordt beheerd door Spring
public class OrderService {

    private final ProductRepository productRepository; // Afhankelijkheid

    @Autowired // Spring injecteert hier een instantie van ProductRepository
    public OrderService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    // ... service-methoden
}

// Voorbeeld van het gebruik van @Aspect voor AOP
@Aspect // Deze klasse is een aspect
@Component
public class LoggingAspect {

    // Join point: uitvoering van elke methode in elke klasse in package com.example.service
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceLayer() {}

    // Advies: vóór de uitvoering van een methode in het join point serviceLayer
    @Before("serviceLayer()")
    public void logMethodCall(JoinPoint joinPoint) {
        System.out.println("Method aanroep: " + joinPoint.getSignature().getName());
    }
}

Spring fungeert als een raamwerk dat de structuur en uitvoering van de applicatie beheert, gebruikmakend van IoC, DI en AOP om modulariteit, testbaarheid en onderhoudsgemak te waarborgen. Het abstraheert veel complexiteit van Java EE en andere technologieën.