A partir del proyecto en el que nos autentificamos usando Basic Auth, vamos a añadir JWT.

application.properties

jwt.secret=jwtSecret

pom.xml

<dependency>
 <groupId>io.jsonwebtoken</groupId>
 <artifactId>jjwt</artifactId>
 <version>0.9.1</version>
</dependency>
<dependency>
 <groupId>javax.xml.bind</groupId>
 <artifactId>jaxb-api</artifactId>
 <version>2.3.0</version>
</dependency>

@CrossOrigin
@RestController
@RequestMapping("/mensajeria")
public class BasicAuthController {

 @Autowired
 private JwtTokenUtil jwtTokenUtil;

 @PostMapping(path = "/login")
 public ResponseEntity<String> basicauth(Principal principal) {
  final String token = jwtTokenUtil.generateToken(principal.getName());
  return ResponseEntity.ok().body("{\"resp\":\""+token+"\"}");
 }

package com.pablomonteserin.prueba.utils;

@Component
public class JwtTokenUtil implements Serializable {

 private static final long serialVersionUID = -2550185165626007488L;

 public static final long JWT_TOKEN_VALIDITY = 5 * 60 * 60;

 @Value("${jwt.secret}")
 private String secret;

 //retrieve username from jwt token
 public String getUsernameFromToken(String token) {
  return getClaimFromToken(token, Claims::getSubject);
 }

 //retrieve expiration date from jwt token
 public Date getExpirationDateFromToken(String token) {
  return getClaimFromToken(token, Claims::getExpiration);
 }

 public <T> T getClaimFromToken(String token, Function<Claims, T> claimsResolver) {
  final Claims claims = getAllClaimsFromToken(token);
  return claimsResolver.apply(claims);
 }
    //for retrieveing any information from token we will need the secret key
 private Claims getAllClaimsFromToken(String token) {
  return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
 }

 //check if the token has expired
 private Boolean isTokenExpired(String token) {
  final Date expiration = getExpirationDateFromToken(token);
  return expiration.before(new Date());
 }

 //generate token for user
 public String generateToken(String username) {
         Map<String, Object> claims = new HashMap<>();
         return doGenerateToken(claims, username);
 }

 //while creating the token -
 //1. Define  claims of the token, like Issuer, Expiration, Subject, and the ID
 //2. Sign the JWT using the HS512 algorithm and secret key.
 //3. According to JWS Compact Serialization(https://tools.ietf.org/html/draft-ietf-jose-json-web-signature-41#section-3.1)
 //   compaction of the JWT to a URL-safe string 
 private String doGenerateToken(Map<String, Object> claims, String subject) {
  return Jwts.builder().setClaims(claims).setSubject(subject).setIssuedAt(new Date(System.currentTimeMillis()))
  .setExpiration(new Date(System.currentTimeMillis() + JWT_TOKEN_VALIDITY * 1000))
  .signWith(SignatureAlgorithm.HS512, secret).compact(); 
 }

 //validate token
 public Boolean validateToken(String token, UserDetails userDetails) {
  final String username = getUsernameFromToken(token);
  return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
 }
}

Validamos el token en cada petición

com.app.prueba.config.SecurityConfig.java

...
@Bean
SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    http.csrf(csrf -> csrf.disable())
    .cors(withDefaults())
    .authorizeHttpRequests((requests) -> {
         try {              requests.requestMatchers("/login").permitAll().anyRequest().authenticated();                                    ;
         } catch (Exception e) {
            e.printStackTrace();
         }
    //Added this line  
    }).addFilterBefore(jwtRequestFilter,UsernamePasswordAuthenticationFilter.class).httpBasic(withDefaults());
    return http.build();
}

package com.app.prueba.config;

@Component
public class JwtRequestFilter extends OncePerRequestFilter {

    @Autowired
    private JwtUserDetailsService jwtUserDetailsService;

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {

        final String requestTokenHeader = request.getHeader("Authorization");

        String username = null;
        String jwtToken = null;
        // JWT Token is in the form "Bearer token". Remove Bearer word and get
        // only the Token
        if (requestTokenHeader != null && requestTokenHeader.startsWith("Bearer ")) {
            jwtToken = requestTokenHeader.substring(7);
            try {
                username = jwtTokenUtil.getUsernameFromToken(jwtToken);
            } catch (IllegalArgumentException e) {
                System.out.println("Unable to get JWT Token");
            } catch (ExpiredJwtException e) {
                System.out.println("JWT Token has expired");
            }
        } else {
            logger.warn("JWT Token does not begin with Bearer String");
        }

        // Once we get the token validate it.
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {

            UserDetails userDetails = this.jwtUserDetailsService.loadUserByUsername(username);

            // if token is valid configure Spring Security to manually set
            // authentication
            if (jwtTokenUtil.validateToken(jwtToken, userDetails)) {

                UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());

                usernamePasswordAuthenticationToken
                        .setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                // After setting the Authentication in the context, we specify
                // that the current user is authenticated. So it passes the
                // Spring Security Configurations successfully.
                SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);

            }
        }
        chain.doFilter(request, response);
    }
}

En el front debemos especificar el tipo de autentificación:

export const setAuth = async (token) => {
    i.defaults.headers.common.Authorization = `Bearer ${token}`;
};