Étape 1 : Création des modèles (entités)

Création de l'entité Role

1. Créez un package `model` :

`src/main/java/com/example/securitytp/model`

2. Créez une classe `[Link]` dans ce package :

```java
package [Link];

import [Link].*;
import lombok.*;

@Entity
@Table(name = "roles")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Role {
​ @Id
​ @GeneratedValue(strategy = [Link])
​ private Long id;

​ @Column(unique = true, nullable = false)

​ private String name;
}
```

Création de l'entité User

Créez une classe `[Link]` dans le package `model` :

```java
package [Link];

import [Link].*;
import lombok.*;
import [Link];

@Entity
@Table(name = "users")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
​ @Id
​ @GeneratedValue(strategy = [Link])
​ private Long id;

​ @Column(unique = true, nullable = false)

​ private String username;

​ @Column(nullable = false)
​ private String password;

​ @ManyToMany(fetch = [Link])
​ @JoinTable(name = "user_roles",
​ joinColumns = @JoinColumn(name = "user_id"),
​ inverseJoinColumns = @JoinColumn(name = "role_id"))
​ private Set<Role> roles;
}
```
 Étape 2 : Création des repositories

Création du RoleRepository

1. Créez un package `repository` :

`src/main/java/com/example/securitytp/repository`

2. Créez une interface `[Link]` :

```java
package [Link];

import [Link];
import [Link];
import [Link];

public interface RoleRepository extends JpaRepository<Role, Long> {

​ Optional<Role> findByName(String name);
}
```

Création du UserRepository

Créez une interface `[Link]` :

```java
package [Link];

import [Link];
import [Link];
import [Link];

public interface UserRepository extends JpaRepository<User, Long> {

​ Optional<User> findByUsername(String username);
}
```

Étape 3 : Création des DTOs (Data Transfer

Objects)

Création du LoginRequest

1. Créez un package `dto` : `src/main/java/com/example/securitytp/dto`

2. Créez une classe `[Link]` :

```java
package [Link];

import [Link];
import [Link];

@Data
public class LoginRequest {
​ @NotBlank
​ private String username;

​ @NotBlank
​ private String password;
}
```

Création du JwtResponse

Créez une classe `[Link]` :

```java
package [Link];

import [Link];
import [Link];
import [Link];

@Data
@AllArgsConstructor
public class JwtResponse {
​ private String token;
​ private String type = "Bearer";
​ private Long id;
​ private String username;
​ private Set<String> roles;
}
```

Étape 4 : Implémentation de la sécurité JWT

Création de l'utilitaire JWT

1. Créez un package `security/jwt` :

`src/main/java/com/example/securitytp/security/jwt`

2. Créez une classe `[Link]` :

```java
package [Link];

import [Link].*;
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];

@Component
public class JwtUtils {
​ private static final Logger logger = [Link]([Link]);

​ @Value("${[Link]}")
​ private String jwtSecret;

​ @Value("${[Link]-in-ms}")
​ private int jwtExpirationMs;

​ public String generateJwtToken(Authentication authentication) {

​ UserDetails userPrincipal = (UserDetails) [Link]();

​ return [Link]()
​ .setSubject([Link]())
​ .setIssuedAt(new Date())
​ .setExpiration(new Date((new Date()).getTime() + jwtExpirationMs))
​ .signWith(SignatureAlgorithm.HS512, jwtSecret)
​ .compact();
​ }

​ public String getUserNameFromJwtToken(String token) {

​ return
[Link]().setSigningKey(jwtSecret).parseClaimsJws(token).getBody().getSubject();
​ }

​ public boolean validateJwtToken(String authToken) {

​ try {
​ [Link]().setSigningKey(jwtSecret).parseClaimsJws(authToken);
​ return true;
​ } catch (SignatureException e) {
​ [Link]("Invalid JWT signature: {}", [Link]());
​ } catch (MalformedJwtException e) {
​ [Link]("Invalid JWT token: {}", [Link]());
​ } catch (ExpiredJwtException e) {
​ [Link]("JWT token is expired: {}", [Link]());
​ } catch (UnsupportedJwtException e) {
​ [Link]("JWT token is unsupported: {}", [Link]());
​ } catch (IllegalArgumentException e) {
​ [Link]("JWT claims string is empty: {}", [Link]());
​ }

​ return false;
​ }
}
```
Création du service UserDetails

1. Créez un package `security/service` :

`src/main/java/com/example/securitytp/security/service`

2. Créez une classe `[Link]` :

```java
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link];

public class UserDetailsImpl implements UserDetails {

​ private static final long serialVersionUID = 1L;

​ private Long id;

​ private String username;

​ @JsonIgnore
​ private String password;

​ private Collection<? extends GrantedAuthority> authorities;

​ public UserDetailsImpl(Long id, String username, String password,

​Collection<? extends GrantedAuthority> authorities) {
​ [Link] = id;
​ [Link] = username;
​ [Link] = password;
​ [Link] = authorities;
​ }

​ public static UserDetailsImpl build(User user) {

​ List<GrantedAuthority> authorities = [Link]().stream()
​ .map(role -> new SimpleGrantedAuthority([Link]()))
​ .collect([Link]());
 ​ return new UserDetailsImpl(
​ [Link](),
​ [Link](),
​ [Link](),
​ authorities);
​ }

​ public Long getId() {

​ return id;
​ }

​ @Override
​ public Collection<? extends GrantedAuthority> getAuthorities() {
​ return authorities;
​ }

​ @Override
​ public String getPassword() {
​ return password;
​ }

​ @Override
​ public String getUsername() {
​ return username;
​ }

​ @Override
​ public boolean isAccountNonExpired() {
​ return true;
​ }

​ @Override
​ public boolean isAccountNonLocked() {
​ return true;
​ }

​ @Override
​ public boolean isCredentialsNonExpired() {
​ return true;
​ }

​ @Override
​ public boolean isEnabled() {
​ return true;
​ }

​ @Override
​ public boolean equals(Object o) {
​ if (this == o) return true;
​ if (o == null || getClass() != [Link]()) return false;
​ UserDetailsImpl user = (UserDetailsImpl) o;
​ return [Link](id, [Link]);
​ }
}
```

3. Créez une classe `[Link]` :

```java
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
​ @Autowired
​ private UserRepository userRepository;

​ @Override
​ @Transactional
​ public UserDetails loadUserByUsername(String username) throws
UsernameNotFoundException {
​ User user = [Link](username)
​ .orElseThrow(() -> new UsernameNotFoundException("User Not Found with
username: " + username));

​ return [Link](user);
​ }
}
```
Création du filtre JWT

1. Créez un package `security/filter` :

`src/main/java/com/example/securitytp/security/filter`

2. Créez une classe `[Link]` :

```java
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class JwtAuthenticationFilter extends OncePerRequestFilter {

​ private static final Logger logger =
[Link]([Link]);

​ @Autowired
​ private JwtUtils jwtUtils;

​ @Autowired
​ private UserDetailsService userDetailsService;

​ @Override
​ protected void doFilterInternal(HttpServletRequest request, HttpServletResponse
response, FilterChain filterChain)
​ throws ServletException, IOException {
​ try {
​ String jwt = parseJwt(request);
​ if (jwt != null && [Link](jwt)) {
​ String username = [Link](jwt);
 ​ UserDetails userDetails =
[Link](username);
​ UsernamePasswordAuthenticationToken authentication = new
UsernamePasswordAuthenticationToken(
​ userDetails, null, [Link]());
​ [Link](new
WebAuthenticationDetailsSource().buildDetails(request));

​ [Link]().setAuthentication(authentication);
​ }
​ } catch (Exception e) {
​ [Link]("Cannot set user authentication: {}", [Link]());
​ }

​ [Link](request, response);
​ }

​ private String parseJwt(HttpServletRequest request) {

​ String headerAuth = [Link]("Authorization");

​ if ([Link](headerAuth) && [Link]("Bearer ")) {

​ return [Link](7);
​ }

​ return null;
​ }
}
```

Configuration de Spring Security

Créez une classe `[Link]` dans le package `security` :

```java
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import
[Link]
erBuilder;
import
[Link]
ecurity;
import [Link];
import
[Link];
import
[Link]
apter;
import [Link];
import [Link];
import [Link];
import
[Link];

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
​ @Autowired
​ UserDetailsServiceImpl userDetailsService;

​ @Bean
​ public JwtAuthenticationFilter authenticationJwtTokenFilter() {
​ return new JwtAuthenticationFilter();
​ }

​ @Override
​ public void configure(AuthenticationManagerBuilder authenticationManagerBuilder)
throws Exception {
​
[Link](userDetailsService).passwordEncoder(pa
sswordEncoder());
​ }

​ @Bean
​ @Override
​ public AuthenticationManager authenticationManagerBean() throws Exception {
​ return [Link]();
​ }

​ @Bean
​ public PasswordEncoder passwordEncoder() {
 ​ return new BCryptPasswordEncoder();
​ }

​ @Override
​ protected void configure(HttpSecurity http) throws Exception {
​ [Link]().and().csrf().disable()
​
.sessionManagement().sessionCreationPolicy([Link]).and()
​ .authorizeRequests()
​ .antMatchers("/api/auth/**").permitAll()
​ .antMatchers("/h2-console/**").permitAll()
​ .antMatchers("/api/test/all").permitAll()
​ .antMatchers("/api/test/user").hasRole("USER")
​ .antMatchers("/api/test/admin").hasRole("ADMIN")
​ .anyRequest().authenticated();

​ // Fix for H2 console

​ [Link]().frameOptions().sameOrigin();

​ [Link](authenticationJwtTokenFilter(),
[Link]);
​ }
}
```

Étape 5 : Création des contrôleurs

Contrôleur d'authentification

Créez un package `controller` :

`src/main/java/com/example/securitytp/controller`

Créez une classe `[Link]` :

```java
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link].*;

import [Link];
import [Link];
import [Link];

@RestController
@RequestMapping("/api/auth")
@CrossOrigin(origins = "*", maxAge = 3600)
public class AuthController {
​ @Autowired
​ private AuthenticationManager authenticationManager;

​ @Autowired
​ private JwtUtils jwtUtils;

​ @PostMapping("/login")
​ public ResponseEntity<?> authenticateUser(@Valid @RequestBody LoginRequest
loginRequest) {
​ Authentication authentication = [Link](
​ new UsernamePasswordAuthenticationToken([Link](),
[Link]()));

​ [Link]().setAuthentication(authentication);
​ String jwt = [Link](authentication);
​
​ UserDetailsImpl userDetails = (UserDetailsImpl) [Link]();
​ Set<String> roles = [Link]().stream()
​ .map(item -> [Link]())
​ .collect([Link]());

​ return [Link](new JwtResponse(

​ jwt,
​ "Bearer",
​ [Link](),
​ [Link](),
​ roles));
​ }
}
```

Contrôleur de test

Créez une classe `[Link]` :

```java
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

@RestController
@RequestMapping("/api/test")
@CrossOrigin(origins = "*", maxAge = 3600)
public class TestController {

​ @GetMapping("/all")
​ public String allAccess() {
​ return "Public Content.";
​ }

​ @GetMapping("/user")
​ @PreAuthorize("hasRole('USER') or hasRole('ADMIN')")
​ public String userAccess() {
​ return "User Content.";
​ }

​ @GetMapping("/admin")
​ @PreAuthorize("hasRole('ADMIN')")
​ public String adminAccess() {
​ return "Admin Content.";
​ }
}
```
 Étape 6 : Initialisation des données

Modifiez la classe principale `[Link]` pour initialiser

des utilisateurs et des rôles :

```java
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link];

import [Link];

@SpringBootApplication
public class SecurityTpApplication {
​ public static void main(String[] args) {
​ [Link]([Link], args);
​ }

​ @Bean
​ CommandLineRunner init(RoleRepository roleRepo, UserRepository userRepo,
PasswordEncoder encoder) {
​ return args -> {
​ // Create roles if they don't exist
​ Role userRole = [Link]("ROLE_USER")
​ .orElse(new Role(null, "ROLE_USER"));
​ Role adminRole = [Link]("ROLE_ADMIN")
​ .orElse(new Role(null, "ROLE_ADMIN"));
​
​ [Link](userRole);
​ [Link](adminRole);
​
​ // Create test users if they don't exist
​ if ([Link]("user").isEmpty()) {
 ​ User user = new User(null, "user", [Link]("password"),
[Link](userRole));
​ [Link](user);
​ }
​
​ if ([Link]("admin").isEmpty()) {
​ User admin = new User(null, "admin", [Link]("adminpass"),
[Link](adminRole));
​ [Link](admin);
​ }
​ };
​ }
}
```