Kuidas töötab Spring Framework 'kapoti all'?

Spring Framework töötab, kasutades mitmeid põhialuseid ja mehhanisme:

1. Juhtimise pööramine (Inversion of Control - IoC):

   • Spring konteiner (tavaliselt ApplicationContext) haldab objektide (bean'ide) elutsüklit.
   • Selle asemel, et objektid ise loovad oma sõltuvused, nad deklarivad need ja konteiner sisestab need (Dependency Injection - DI).
   • Seda saavutatakse järgmiste vahenditega:
     • Konfiguratsioon: XML, annotatsioonid (@Autowired, @Inject), JavaConfig (@Configuration, @Bean).
     • Refleksioon: Spring skaneerib klasse, annotatsioone ja metaandmeid, et määrata bean'id ja nende sõltuvused.

2. Aspekt-õpetatud programmeerimine (Aspect-Oriented Programming - AOP):

   • Võimaldab moodustada ühiseid aspekte (nagu logimine, turvalisus, tehingute haldamine).
   • Need aspektid realiseeritakse kui aspektid, mida saab rakendada erinevatesse ühenduspunktidesse programmi täitmisel.
   • Spring AOP kasutab proxy'd (JDK Dynamic Proxies või CGLIB), et püüda meetodite väljakutseid ja rakendada aspekte.
   • Rakendatakse jooksvalt (runtime weaving).

3. Abstraktsioon:

   • Spring pakub kõrgetasemelisi abstraktsioone madala taseme API-dele, lihtsustades arendust. Näited:
     • Tehingute haldus (PlatformTransactionManager) abstraktsioon erinevate rakenduste (JTA, JDBC, JPA) jaoks.
     • Andmetele juurdepääs (JDBC, JPA/Hibernate) pakub lihtsustatud malle (JdbcTemplate, JpaTemplate) ja erandite käsitlemist.
     • MVC raamistik abstractib HTTP-päringute töötlemise.

4. Spring konteiner (ApplicationContext):

   • Peamine komponent, mis haldab bean'e.
   • Skaneerib klasse, loeb metaandmeid (konfiguratsioon), loob, konfigureerib ja haldab bean'ide elutsüklit.
   • Registreerib bean'i definitsioone ja loob bean'ide eksemplare nõudmisel või käivitamisel (sõltuvalt nähtavuse piirkonnast ja hilisest initsialiseerimisest).
   • Teostab Dependency Injection.
   • Pakub teenuseid nagu lokaliseerimine, sündmuste avaldamine, ressursside laadimine.

5. Refleksioon:

   • Laialdaselt kasutatakse:
     • classpath'i skaneerimiseks annotatsioonidega klasside leidmiseks (@Component, @Service, @Repository, @Controller).
     • annotatsioonide metaandmete lugemiseks (@Autowired, @Value, @Transactional).
     • konstruktorite ja meetodite saamiseks, et luua bean'e ja sisestada sõltuvused.
     • Dynaamiliste proxy objektide loomine AOP jaoks.

6. Bean'i elutsükkel:

   • Spring konteiner haldab bean'i elutsüklit, mis hõlmab:
     • Objekti loomist.
     • Sõltuvuste sisestamist.
     • BeanNameAware, BeanFactoryAware, ApplicationContextAware täitmist.
     • BeanPostProcessor täitmist (postProcessBeforeInitialization).
     • @PostConstruct või afterPropertiesSet täitmist.
     • Initsialiseerimismeetodi täitmist, mis on määratud @Bean või XML-is.
     • Bean'i kasutamist.
     • BeanPostProcessor täitmist (postProcessAfterInitialization).
     • @PreDestroy või destroyableBean täitmist.
     • Kustutamise meetodi täitmist, mis on määratud @Bean või XML-is.

// Näide @Autowired kasutamisest sõltuvuse sisestamiseks
@Component // Bean on Springi poolt hallatav
public class OrderService {

    private final ProductRepository productRepository; // Sõltuvus

    @Autowired // Spring sisestab siia ProductRepository eksemplari
    public OrderService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    // ... teenuse meetodid
}

// Näide @Aspect kasutamisest AOP jaoks
@Aspect // See klass on aspekt
@Component
public class LoggingAspect {

    // Punktkoht: iga meetod mis tahes klassis paketis com.example.service
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceLayer() {}

    // Nõuanne: enne meetodi täitmist punktkohas serviceLayer
    @Before("serviceLayer()")
    public void logMethodCall(JoinPoint joinPoint) {
        System.out.println("Calling method: " + joinPoint.getSignature().getName());
    }
}

Spring toimib raamistikuna, mis haldab rakenduse struktuuri ja täitmist, kasutades IoC, DI ja AOP, et tagada modulaarsus, testitavus ja koodi hooldusmugavus. Ta abstraktsioon paljudest Java EE ja teiste tehnoloogiate keerukustest.