Guide Complet du Framework Spring

Home PDF

Cet article de blog a été rédigé avec l’assistance de ChatGPT-4o.

Table des matières

Introduction
Framework Spring Boot
Gestion des données avec Spring
Création de services RESTful
- Clients REST Spring
- FeignClient
E-mail, tâches et planification
- Support des e-mails
- Exécution et planification des tâches
Tests dans Spring
- Tests avec Mockito
- Tests avec MockMvc
Surveillance et gestion
- Spring Boot Actuator
Sujets avancés
- API Spring Advice
Conclusion

Introduction

Spring est l’un des frameworks les plus populaires pour la création d’applications de niveau entreprise en Java. Il offre une infrastructure complète pour le développement d’applications Java. Dans ce blog, nous aborderons divers aspects de l’écosystème Spring, notamment Spring Boot, la gestion des données, la création de services RESTful, la planification, les tests, ainsi que des fonctionnalités avancées comme l’API Spring Advice.

Framework Spring Boot

Premiers pas avec Spring Boot

Spring Boot facilite la création d’applications Spring autonomes et de qualité production. Il adopte une vision orientée de la plateforme Spring et des bibliothèques tierces, vous permettant de démarrer avec un minimum de configuration.

Configuration Initiale : Commencez par créer un nouveau projet Spring Boot en utilisant Spring Initializr. Vous pouvez choisir les dépendances dont vous avez besoin, telles que Spring Web, Spring Data JPA et Spring Boot Actuator.
Annotations : Familiarisez-vous avec les annotations clés comme @SpringBootApplication, qui est une combinaison de @Configuration, @EnableAutoConfiguration et @ComponentScan.
Serveur Intégré : Spring Boot utilise des serveurs intégrés comme Tomcat, Jetty ou Undertow pour exécuter votre application, ce qui signifie que vous n’avez pas besoin de déployer des fichiers WAR sur un serveur externe.

Injection de Dépendances

L’injection de dépendances (Dependency Injection, DI) est un principe fondamental de Spring. Elle permet la création de composants faiblement couplés, rendant votre code plus modulaire et plus facile à tester.

@Autowired : Cette annotation est utilisée pour injecter automatiquement des dépendances. Elle peut être appliquée aux constructeurs, aux champs et aux méthodes. La fonctionnalité d’injection de dépendances de Spring résoudra et injectera automatiquement les beans collaboratifs dans votre bean.

Exemple d’injection de champ :
```
@Component
public class UserService {
      
    @Autowired
    private UserRepository userRepository;
      
    // méthodes métier
}
```
Exemple d’injection par constructeur :
```
@Component
public class UserService {
      
    private final UserRepository userRepository;
```

      @Autowired
      public UserService(UserRepository userRepository) {
          this.userRepository = userRepository;
      }
      
      // méthodes métier
  }

Exemple d’injection de méthode :

  @Component
  public class UserService {
      
      private UserRepository userRepository;

      @Autowired
      public void setUserRepository(UserRepository userRepository) {
          this.userRepository = userRepository;
      }
      
      // méthodes métier
  }

@Component, @Service, @Repository : Ce sont des spécialisations de l’annotation @Component, utilisées pour indiquer qu’une classe est un bean Spring. Elles servent également d’indices sur le rôle que joue la classe annotée.
- @Component : Il s’agit d’un stéréotype générique pour tout composant géré par Spring. Il peut être utilisé pour marquer n’importe quelle classe comme un bean Spring.
  
  Exemple :
```
@Component
public class EmailValidator {
        
    public boolean isValid(String email) {
        // logique de validation
        return true;
    }
}
```
- @Service : Cette annotation est une spécialisation de @Component et est utilisée pour marquer une classe comme un service. Elle est généralement utilisée dans la couche de service, où vous implémentez la logique métier.
  
  Exemple :
```
@Service
public class UserService {
        
    @Autowired
    private UserRepository userRepository;
```

    public User findUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

@Repository : Cette annotation est également une spécialisation de @Component. Elle est utilisée pour indiquer que la classe fournit le mécanisme de stockage, de récupération, de recherche, de mise à jour et de suppression d’objets. Elle traduit également les exceptions de persistance dans la hiérarchie des DataAccessException de Spring.

Exemple :
```
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // méthodes de requête personnalisées
}
```

Ces annotations rendent votre configuration Spring plus lisible et concise, et elles aident le framework Spring à gérer et à relier les dépendances entre les différents beans.

Événements dans Spring

Le mécanisme d’événements de Spring vous permet de créer et d’écouter des événements d’application.

Événements personnalisés : Créez des événements personnalisés en étendant ApplicationEvent. Par exemple :
```
public class MyCustomEvent extends ApplicationEvent {
    private String message;
```

public MyCustomEvent(Object source, String message) {
    super(source);
    this.message = message;
}

      public String getMessage() {
          return message;
      }
  }

Écouteurs d’événements : Utilisez @EventListener ou implémentez ApplicationListener pour gérer les événements. Par exemple :
```
@Component
public class MyEventListener {
```

      @EventListener
      public void handleMyCustomEvent(MyCustomEvent event) {
          System.out.println("Événement personnalisé Spring reçu - " + event.getMessage());
      }
  }

Publication d’événements : Publiez des événements en utilisant ApplicationEventPublisher. Par exemple :

@Component
public class MyEventPublisher {
      
    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

      public void publishCustomEvent(final String message) {
          System.out.println("Publication d'un événement personnalisé. ");
          MyCustomEvent customEvent = new MyCustomEvent(this, message);
          applicationEventPublisher.publishEvent(customEvent);
      }
  }

Gestion des données avec Spring

Spring Data JDBC

Spring Data JDBC offre un accès JDBC simple et efficace.

Repositories : Définissez des repositories pour effectuer des opérations CRUD. Par exemple :
```
public interface UserRepository extends CrudRepository<User, Long> {
}
```
Requêtes : Utilisez des annotations comme @Query pour définir des requêtes personnalisées. Par exemple :
```
@Query("SELECT * FROM users WHERE username = :username")
User findByUsername(String username);
```

Spring Data JPA

Spring Data JPA facilite la mise en œuvre de référentiels basés sur JPA.

Mapping des Entités : Définissez les entités en utilisant @Entity et mappez-les aux tables de la base de données. Par exemple :

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;
    // getters et setters
}

Repositories : Créez des interfaces de repository en étendant JpaRepository. Par exemple :
```
public interface UserRepository extends JpaRepository<User, Long> {
}
```
Méthodes de requête : Utilisez des méthodes de requête pour effectuer des opérations sur la base de données. Par exemple :
```
List<User> findByUsername(String username);
```

Spring Data Redis

Spring Data Redis fournit l’infrastructure pour l’accès aux données basé sur Redis.

RedisTemplate : Utilisez RedisTemplate pour interagir avec Redis. Par exemple :
```
@Autowired
private RedisTemplate<String, Object> redisTemplate;
```

public void save(String key, Object value) {
    redisTemplate.opsForValue().set(key, value);
}

  public Object find(String key) {
      return redisTemplate.opsForValue().get(key);
  }

Repositories : Créez des repositories Redis en utilisant @Repository. Par exemple :

@Repository
public interface RedisRepository extends CrudRepository<RedisEntity, String> {
}

Transactions et Support DAO

Spring simplifie la gestion des transactions et le support des DAO (Data Access Object).

Gestion des transactions : Utilisez @Transactional pour gérer les transactions. Par exemple :

@Transactional
public void saveUser(User user) {
    userRepository.save(user);
}

Modèle DAO : Implémentez le modèle DAO pour séparer la logique de persistance. Par exemple :
```
public class UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
```

      public User findById(Long id) {
          return jdbcTemplate.queryForObject("SELECT * FROM users WHERE id = ?", new Object[]{id}, new UserRowMapper());     
      }
  }

JDBC et ORM

Spring offre un support complet pour JDBC et ORM (Object-Relational Mapping).

JdbcTemplate : Simplifiez les opérations JDBC avec JdbcTemplate. Par exemple :
```
@Autowired
private JdbcTemplate jdbcTemplate;
```
public List findAll() { return jdbcTemplate.query("SELECT * FROM users", new UserRowMapper()); } ```

Hibernate : Intégrez Hibernate avec Spring pour la prise en charge de l’ORM. Par exemple :

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;
    // getters et setters
}

Création de services RESTful

Clients REST avec Spring

Spring facilite la création de clients RESTful.

RestTemplate : Utilisez RestTemplate pour effectuer des requêtes HTTP. Par exemple :
```
@Autowired
private RestTemplate restTemplate;
```

  public String getUserInfo(String userId) {
      return restTemplate.getForObject("https://api.example.com/users/" + userId, String.class);
  }

WebClient : Utilisez le WebClient réactif pour des requêtes non bloquantes. Par exemple :
```
@Autowired
private WebClient.Builder webClientBuilder;
```

  public Mono<String> getUserInfo(String userId) {
      return webClientBuilder.build()
              .get()
              .uri("https://api.example.com/users/" + userId)
              .retrieve()
              .bodyToMono(String.class);
  }

FeignClient

Feign est un client de service web déclaratif.

Configuration : Ajoutez Feign à votre projet et créez des interfaces annotées avec @FeignClient. Par exemple :

@FeignClient(name = "user-service", url = "https://api.example.com")
public interface UserServiceClient {
    @GetMapping("/users/{id}")
    String getUserInfo(@PathVariable("id") String userId);
}

Configuration : Personnalisez les clients Feign avec des intercepteurs et des décodeurs d’erreurs. Par exemple :

@Bean
public RequestInterceptor requestInterceptor() {
    return requestTemplate -> requestTemplate.header("Authorization", "Bearer token");
}

E-mail, Tâches et Planification

Assistance par e-mail

Spring offre une prise en charge pour l’envoi d’e-mails.

JavaMailSender : Utilisez JavaMailSender pour envoyer des e-mails. Par exemple :
```
@Autowired
private JavaMailSender mailSender;
```

  public void sendEmail(String to, String subject, String body) {
      SimpleMailMessage message = new SimpleMailMessage();
      message.setTo(to);
      message.setSubject(subject);
      message.setText(body);
      mailSender.send(message);
  }

MimeMessage : Créez des e-mails riches avec des pièces jointes et du contenu HTML. Par exemple :
```
@Autowired
private JavaMailSender mailSender;
```

  public void sendRichEmail(String to, String subject, String body, File attachment) throws MessagingException {
      MimeMessage message = mailSender.createMimeMessage();
      MimeMessageHelper helper = new MimeMessageHelper(message, true);
      helper.setTo(to);
      helper.setSubject(subject);
      helper.setText(body, true);
      helper.addAttachment(attachment.getName(), attachment);
      mailSender.send(message);
  }

Exécution et Planification des Tâches

La prise en charge de l’exécution et de la planification des tâches de Spring facilite l’exécution des tâches.

@Scheduled : Planifiez des tâches avec @Scheduled. Par exemple :

@Scheduled(fixedRate = 5000)
public void performTask() {
    System.out.println("Tâche planifiée exécutée toutes les 5 secondes");
}

Tâches asynchrones : Exécutez des tâches de manière asynchrone avec @Async. Par exemple :

@Async
public void performAsyncTask() {
    System.out.println("Tâche asynchrone en cours d'exécution en arrière-plan");
}

Tests dans Spring

Tests avec Mockito

Mockito est une bibliothèque de simulation puissante pour les tests.

Simulation des Dépendances : Utilisez @Mock et @InjectMocks pour créer des objets simulés. Par exemple :

@RunWith(MockitoJUnitRunner.class)
public class UserServiceTest {
    @Mock
    private UserRepository userRepository;

@InjectMocks
private UserService userService;

@Test
public void testFindUserById() {
    User user = new User();
    user.setId(1L);
    Mockito.when(userRepository.findById(1L)).thenReturn(Optional.of(user));
}

          User result = userService.findUserById(1L);
          assertNotNull(result);
          assertEquals(1L, result.getId().longValue());
      }
  }

Vérification du comportement : Vérifiez les interactions avec les objets simulés. Par exemple :
```
Mockito.verify(userRepository, times(1)).findById(1L);
```

Tester avec MockMvc

MockMvc permet de tester les contrôleurs Spring MVC.

Configuration : Configurez MockMvc dans vos classes de test. Par exemple :

@RunWith(SpringRunner.class)
@WebMvcTest(UserController.class)
public class UserControllerTest {
    @Autowired
    private MockMvc mockMvc;

@Test
public void testGetUser() throws Exception {
    mockMvc.perform(get("/users/1"))
        .andExpect(status().isOk())
        .andExpect(content().contentType(MediaType.APPLICATION_JSON))
        .andExpect(jsonPath("$.id").value(1));
}
}

Constructeurs de requêtes : Utilisez des constructeurs de requêtes pour simuler des requêtes HTTP. Par exemple :

mockMvc.perform(post("/users")
    .contentType(MediaType.APPLICATION_JSON)
    .content("{\"username\":\"john\",\"password\":\"secret\"}"))
    .andExpect(status().isCreated());

Surveillance et Gestion

Spring Boot Actuator

Spring Boot Actuator fournit des fonctionnalités prêtes pour la production pour surveiller et gérer votre application.

Endpoints : Utilisez des endpoints comme /actuator/health et /actuator/metrics pour surveiller la santé et les métriques de l’application. Par exemple :
```
curl http://localhost:8080/actuator/health
```

Points de terminaison personnalisés : Créez des points de terminaison d’actuateur personnalisés. Par exemple :

@RestController
@RequestMapping("/actuator")
public class CustomEndpoint {
    @GetMapping("/custom")
    public Map<String, String> customEndpoint() {
        Map<String, String> response = new HashMap<>();
        response.put("status", "Point de terminaison d'actuateur personnalisé");
        return response;
    }
}

Sujets avancés

API de conseils Spring

L’API Advice de Spring offre des fonctionnalités avancées de programmation orientée aspect (AOP).

@Aspect : Définissez des aspects en utilisant @Aspect. Par exemple :

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Avant la méthode : " + joinPoint.getSignature().getName());
    }

      @After("execution(* com.example.service.*.*(..))")
      public void logAfter(JoinPoint joinPoint) {
          System.out.println("Après la méthode : " + joinPoint.getSignature().getName());
      }
  }

Points de jonction (Join Points) : Utilisez des points de jonction pour définir où les aspects doivent être appliqués. Par exemple :
```
@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceMethods() {}
```

  @Around("serviceMethods()")
  public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
      System.out.println("Avant la méthode : " + joinPoint.getSignature().getName());
      Object result = joinPoint.proceed();
      System.out.println("Après la méthode : " + joinPoint.getSignature().getName());
      return result;
  }

Conclusion

Spring est un framework puissant et polyvalent qui peut simplifier le développement d’applications de niveau entreprise. En tirant parti des fonctionnalités de Spring Boot, Spring Data, Spring REST et d’autres projets Spring, les développeurs peuvent construire des applications robustes, évolutives et maintenables de manière efficace. Avec l’ajout d’outils comme Spring Boot Actuator et des frameworks de test, vous pouvez vous assurer que vos applications sont prêtes pour la production et bien testées.

Back 2025.01.18 Donate