Spring Security est un puissant framework pour sécuriser les applications Spring.
Voici un exemple pour intégrer Spring Security dans votre projet Spring Boot. Cet
exemple implémente une authentification simple en mémoire (avec utilisateurs et
rôles) et protège vos endpoints REST.
---
### Étape 1 : Ajouter Spring Security au projet
1. Accédez à [Spring Initializr]([Link]
2. Ajoutez **Spring Security** comme dépendance.
3. Importez le projet ou ajoutez la dépendance suivante dans `[Link]` si elle
n'existe pas :
```xml
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
```
---
### Étape 2 : Configurer Spring Security
#### Classe de configuration
Créez une classe pour configurer Spring Security :
```java
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
@Configuration
public class SecurityConfig {
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws
Exception {
http
.csrf().disable() // Désactiver CSRF pour simplifier les tests des APIs
.authorizeHttpRequests(authorize -> authorize
.requestMatchers("/api/public/**").permitAll() // Accessible à tous
.anyRequest().authenticated() // Authentification requise pour le
reste
)
.httpBasic(); // Utiliser HTTP Basic Authentication pour simplifier
return [Link]();
}
@Bean
public UserDetailsService userDetailsService(PasswordEncoder passwordEncoder) {
UserDetails user = User
.withUsername("user")
.password([Link]("password"))
.roles("USER")
.build();
UserDetails admin = User
.withUsername("admin")
.password([Link]("admin"))
.roles("ADMIN")
.build();
return new InMemoryUserDetailsManager(user, admin);
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder(); // Encodeur pour sécuriser les mots de
passe
}
}
```
---
### Étape 3 : Créer des Endpoints REST sécurisés
Ajoutez un contrôleur avec des endpoints sécurisés :
```java
package [Link];
import [Link];
import [Link];
import [Link];
@RestController
@RequestMapping("/api")
public class DemoController {
@GetMapping("/public")
public String publicEndpoint() {
return "This is a public endpoint, accessible to everyone!";
}
@GetMapping("/user")
public String userEndpoint() {
return "This is a user-protected endpoint, accessible to authenticated
users!";
}
@GetMapping("/admin")
public String adminEndpoint() {
return "This is an admin-protected endpoint, accessible to admins only!";
}
}
```
---
### Étape 4 : Testez l'application
1. **Lancez l'application.**
2. Accédez aux endpoints avec Postman ou cURL :
- **Endpoint public** :
```bash
curl [Link]
```
Réponse : `"This is a public endpoint, accessible to everyone!"`
- **Endpoint utilisateur** (authentification requise) :
```bash
curl -u user:password [Link]
```
Réponse : `"This is a user-protected endpoint, accessible to authenticated
users!"`
- **Endpoint admin** (authentification avec rôle admin) :
```bash
curl -u admin:admin [Link]
```
Réponse : `"This is an admin-protected endpoint, accessible to admins only!"`
---
### Étape 5 : Étendre la configuration
Pour des besoins plus complexes, vous pouvez :
- Connecter à une base de données avec **Spring Data JPA**.
- Intégrer **JWT** pour les APIs REST.
- Ajouter **OAuth2** pour la gestion des identités externes (Google, GitHub, etc.).
Si vous avez besoin d’exemples supplémentaires, n’hésitez pas à demander ! 😊
