1. Fondamentaux et Avantages de l'Écosystème Spring

Spring s'est imposé comme le standard de fait pour le développement d'applications Java Entreprise (Java EE) en raison de sa capacité à simplifier la complexité architecturlae.

• Découplage et Simplification : Grâce au conteneur IoC (Inversion of Control), les dépendances entre objets ne sont plus codées en dur, facilitant ainsi les tests unitaires et la maintenance.
• Support AOP (Aspect-Oriented Programming) : Il permet d'isoler les préoccupations transversales comme la gestion des transactions, la journalisation ou la sécurité.
• Gestion Déclarative des Transactions : Une simple configuration ou annotation suffit pour gérer des transactions complexes sans manipuler l'API JDBC directement.
• Intégration Facilitée : Spring offre des abstractions pour intégrer nativement des frameworks tiers comme MyBatis, Hibernate ou JPA.
• Abstraction des API Java EE : Il réduit la verbosité lors de l'utilisation de JDBC, JavaMail ou des services distants.

2. Maîtriser l'IoC et l'Injection de Dépendances (DI)

L'Inversion de Contrôle (IoC) est un principe architectural où le flux de contrôle d'un programme est inversé : ce n'est plus l'objet qui crée ses dépendances, mais une entité externe (le conteneur Spring).

L'Injection de Dépendances (DI) est l'implémentation concrète de l'IoC. Au lieu qu'une classe instancie elle-même un service, le service lui est "injecté" via le constructeur ou un mutateur (setter). Cela transforme une dépendance interne forte en une dépendance externe faible.

3. Programmation Orientée Aspect (AOP)

L'AOP permet de modulariser des fonctionnalités qui traversent plusieurs couches de l'application (Cross-cutting concerns). Au lieu de dupliquer du code de log ou de sécurité dans chaque méthode, on définit un "Aspect" qui sera "tissé" (weaved) dynamiquement au point d'exécution souhaité.

Mécanisme : Spring utilise des proxies dynamiques (JDK Dynamic Proxy pour les interfaces, CGLIB pour les classes concrètes) pour intercepter les appels de méthodes et injecter le comportement supplémentaire.

4. Scopes des Beans Spring

Spring propose cinq portées principales pour gérer le cycle de vie des objets :

• singleton : (Par défaut) Une seule instance par conteneur IoC.
• prototype : Une nouvelle instance est créée à chaque demande.
• request : Une instance par requête HTTP (contexte Web).
• session : Une instance par session utilisateur HTTP.
• global-session : Utilisé principalement dans les contextes de portlets.

5. Architecture Spring MVC

Spring MVC est un framework Web structuré autour du DispatcherServlet, qui agit comme contrôleur frontal (Front Controller). Le flux typique d'une requête est le suivant :

1. Réception de la requête par le DispatcherServlet.
2. Consultation du HandlerMapping pour identifier le contrôleur approprié.
3. Exécution du contrôleur via un HandlerAdapter.
4. Le contrôleur retourne un objet ModelAndView.
5. Résolution de la vue logique en vue physique via le ViewResolver.
6. Rendu de la vue avec les données du modèle et réponse au client.

6. Configuration et Intégration (Exemple MyBatis)

La configuration moderne privilégie les annotations, mais la structure XML reste cruciale pour comprendre l'intégration des composants.

<!-- Exemple de configuration du DataSource et de la SessionFactory -->
<bean id="appDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="${db.driver}" />
    <property name="url" value="${db.url}" />
    <property name="username" value="${db.user}" />
    <property name="password" value="${db.password}" />
</bean>

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="appDataSource" />
    <property name="configLocation" value="classpath:mybatis-config.xml" />
</bean>

<!-- Scanner les mappers MyBatis -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.tech.app.repository" />
</bean>

7. Gestion des Transactions

Spring permet de définir des politiques de transaction de manière déclarative via l'AOP. On définit un gestionnaire de transactions qui sera lié au DataSource.

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="appDataSource" />
</bean>

<tx:advice id="serviceAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="create*" propagation="REQUIRED" />
        <tx:method name="modify*" propagation="REQUIRED" />
        <tx:method name="get*" read-only="true" />
    </tx:attributes>
</tx:advice>

<aop:config>
    <aop:advisor advice-ref="serviceAdvice" pointcut="execution(* com.tech.app.service.*.*(..))" />
</aop:config>

8. Stratégies de Retour dans les Contrôleurs

Les méthodes des contrôleurs Spring MVC sont flexibles et peuvent retourner différents types de données :

• ModelAndView : Pour spécifier explicitement le modèle et la vue.
• String : Interprété comme le nom logique de la vue (ou via redirect: / forward:).
• void : Si la réponse est gérée directement via l'objet HttpServletResponse (utile pour les flux de données ou JSON manuel).
• @ResponseBody : Pour sérialiser l'objet directement en JSON ou XML dans le corps de la réponse.

9. Liaison de Données et Validation

Spring facilite la capture des données utilisateur :

• @RequestParam : Pour lier les paramètres de requête simples.
• @PathVariable : Pour extraire des données des segments d'URL (style REST).
• POJO Binding : Spring mappe automatiquement les champs d'un formulaire HTML aux propriétés d'un objet Java si les noms correspondent.
• Validation : Intégration de Bean Validation (JSR-303) pour valider les données en amont du traitement métier.

10. Intercepteurs et Gestion des Exceptions

Pour des traitements globaux, Spring propose l'interface HandlerInterceptor permettant d'exécuter du code avant (preHandle), après (postHandle) ou après le rendu final (afterCompletion).

La gestion des erreurs est centralisée via des classes annotées @ControllerAdvice ou en implémentant HandlerExceptionResolver, garantissant que l'utilisateur reçoit une réponse cohérente même en cas de défaillance système.