Ako funguje Spring Framework 'pod kapotou'?

Spring Framework funguje na základe niekoľkých kľúčových princípov a mechanizmov:

1. Inverzia riadenia (Inversion of Control - IoC):

   • Kontajner Spring (najbežnejší je ApplicationContext) riadi životný cyklus objektov (beanov).
   • Namiesto toho, aby si objekty samy vytvárali svoje závislosti, deklarujú ich a kontajner ich vkladá (Dependency Injection - DI).
   • To sa dosahuje pomocou:
     • Konfigurácie: XML, anotácie (@Autowired, @Inject), JavaConfig (@Configuration, @Bean).
     • Reflexie: Spring skenuje triedy, anotácie a meta informácie na určenie beanov a ich závislostí.

2. Aspektovo-orientované programovanie (Aspect-Oriented Programming - AOP):

   • Umožňuje modulárne spracovanie concernov (ako je logovanie, bezpečnosť, správa transakcií).
   • Tieto concerny sú implementované vo forme aspektov, ktoré môžu byť aplikované na rôzne body spojenia v vykonávaní aplikácie.
   • Spring AOP používa proxy (JDK Dynamic Proxies alebo CGLIB) na zachytávanie volaní metód a aplikovanie aspektov.
   • Používa sa počas behu (runtime weaving).

3. Abstrakcia:

   • Spring poskytuje vysokú úroveň abstrakcií nad nízkoúrovňovými API, čím zjednodušuje vývoj. Príklady:
     • Riadenie transakcií (PlatformTransactionManager) abstrahuje nad rôznymi implementáciami (JTA, JDBC, JPA).
     • Prístup k dátam (JDBC, JPA/Hibernate) poskytuje zjednodušené šablóny (JdbcTemplate, JpaTemplate) a spracovanie výnimiek.
     • MVC framework abstrahuje nad spracovaním HTTP požiadaviek.

4. Kontajner Spring (ApplicationContext):

   • Hlavná zložka, ktorá riadi beany.
   • Skenuje triedy, číta meta informácie (konfiguráciu), vytvára, konfiguruje a riadi životný cyklus beanov.
   • Registruje definície beanov a vytvára inštancie beanov na požiadanie alebo pri štarte (v závislosti od oblasti viditeľnosti a lazy init).
   • Vykonáva Dependency Injection.
   • Poskytuje služby, ako lokalizácia, publikovanie udalostí, načítanie zdrojov.

5. Reflexia:

   • Široko sa používa na:
     • Skenovanie classpath na prítomnosť tried s anotáciami (@Component, @Service, @Repository, @Controller).
     • Čítanie meta informácií anotácií (@Autowired, @Value, @Transactional).
     • Získavanie konštruktorov a metód na vytváranie inštancií beanov a vkladanie závislostí.
     • Dynamické vytváranie proxy objektov pre AOP.

6. Životný cyklus beana:

   • Kontajner Spring riadi životný cyklus beana, ktorý zahŕňa:
     • Vytvorenie inštancie.
     • Vloženie závislostí.
     • Vykonanie BeanNameAware, BeanFactoryAware, ApplicationContextAware.
     • Vykonanie BeanPostProcessor (metóda postProcessBeforeInitialization).
     • Vykonanie @PostConstruct alebo afterPropertiesSet.
     • Vykonanie inicializačnej metódy uvedenej v @Bean alebo XML.
     • Použitie beana.
     • Vykonanie BeanPostProcessor (metóda postProcessAfterInitialization).
     • Vykonanie @PreDestroy alebo destroyableBean.
     • Vykonanie metódy zániku uvedenej v @Bean alebo XML.

// Príklad použitia anotácie @Autowired na vkladanie závislosti
@Component // Bean je riadený Springom
public class OrderService {

    private final ProductRepository productRepository; // Závislosť

    @Autowired // Spring sem vloží inštanciu ProductRepository
    public OrderService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    // ... metódy služby
}

// Príklad použitia anotácie @Aspect pre AOP
@Aspect // Tento trieda je aspekt
@Component
public class LoggingAspect {

    // Body spojenia: vykonanie ľubovoľnej metódy v ľubovoľnej triede v balíku com.example.service
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceLayer() {}

    // Porada: pred vykonaním metódy v body spojenia serviceLayer
    @Before("serviceLayer()")
    public void logMethodCall(JoinPoint joinPoint) {
        System.out.println("Calling method: " + joinPoint.getSignature().getName());
    }
}

Spring pôsobí ako rámec, ktorý riadi štruktúru a vykonávanie aplikácie, využívajúc IoC, DI a AOP na zabezpečenie modularity, testovateľnosti a jednoduchosti údržby kódu. Abstrahuje mnohé zložité aspekty Java EE a iných technológií.