Cómo utilizar REST con la autenticación básica en la primavera de arranque

Elvis:

Helllo, estoy usando REST con la autenticación básica y este código es una parte de la RestController:

@GetMapping("/jpa/users/{username}/goals")
public List<Goal> getAllGoals(@PathVariable String username) {
    userId = getUserIdFromUsername(username);
    return goalJpaRepository.findByUserId(userId); 
}

public Long getUserIdFromUsername(String username) {
    User user = userJpaRepository.findByUsername(username);
    userId = user.getId(); 
    return userId;
}

Y tengo un problema, por ejemplo estoy usando cartero para recuperar las metas para un usuario speciffic como esto:

http: // localhost: 8080 / APP / usuarios / John / metas con petición GET

Luego utilizo la autenticación básica para el nombre de usuario y la contraseña john para este nombre de usuario y recibo de los objetivos de john.

Después de que si hago una petición GET para este enlace http: // localhost: 8080 / APP / usuarios / tom / metas recibo las metas para Tom, pero yo estoy conectado con john en este momento del tiempo, por lo que Juan puede ver a sus objetivos y también puede ver los objetivos de tom.

La pregunta es ¿cómo puedo acceder al nombre de usuario de inicio de sesión en el RestController, porque quiero hacer algo como esto:

if (loginUsername == username) {
    return goalJpaRepository.findByUserId(userId);
} 

return "Access denied!";

Por eso quiero saber si es posible tener acceso al nombre de usuario de inicio de sesión de encabezado HTTP?

¡Gracias!

---

ACTUALIZACIÓN - Sí, el marco es la primavera de arranque, también estoy usando Spring Security con autenticación Dao porque quiero conseguir que el usuario de una base de datos MySQL. De todos modos yo no soy un experto en la primavera de Seguridad.

Ahora entiendo cómo utilizar Principal en mis métodos de controlador, pero no sé cómo utilizar la primavera de Seguridad para este caso concreto. ¿Cómo debo ponerlo en práctica? Por ejemplo, el usuario John debe ver y modificar sólo sus objetivos.

Configuración de seguridad de primavera:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

import com.dgs.restful.webservices.goaltrackerservice.user.MyUserDetailsService;

@Configuration
@EnableWebSecurity
public class SpringSecurityConfigurationBasicAuth extends WebSecurityConfigurerAdapter {

    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Autowired
    private MyUserDetailsService userDetailsService;

    @Bean
    public DaoAuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider authProvider
          = new DaoAuthenticationProvider();
        authProvider.setUserDetailsService(userDetailsService);
        authProvider.setPasswordEncoder(bCryptPasswordEncoder());
        return authProvider;
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {

        http
            .csrf().disable()
            .authorizeRequests()
            .antMatchers(HttpMethod.OPTIONS, "/**").permitAll()
            .antMatchers("/allusers").permitAll()
                .anyRequest().authenticated()
                .and()
            // .formLogin().and()
            .httpBasic();
        }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.authenticationProvider(authenticationProvider());
    }
}

gervais.b:

Tenga en cuenta que usted no está haciendo ningún tipo de seguridad en este momento.

Según lo dicho por @ Matt "Depende de qué marco está utilizando" . Pero supongo que está utilizando la primavera. A continuación, debería echar un vistazo a la documentación del módulo de primavera-securuty.

Básicamente se puede inyectar el usuario autenticado en su parámetro de método:

   @GetMapping("/jpa/users/{username}/goals")
   public List<Goal> getAllGoals(@PathVariable String username, Principal principal) {
     if ( username.equals(principal.getName()) ) {
       userId = getUserIdFromUsername(username);
       return goalJpaRepository.findByUserId(userId); 
     } else {
       throw new SomeExceptionThatWillBeMapped();
     }
   } 

Pero la primavera-seguridad y muchos marcos proporcionan mejores patrones para gestionar la seguridad.