Comment configurer plusieurs HttpSecurity avec UserDetailsService en utilisant la sécurité de démarrage de printemps?

Question

Je travaille sur une couche de sécurité de démarrage du printemps pour authentifier et autoriser le user.Now, je voudrais faire quelques exemple d'application utilisant configuration.I de sécurité multi http ont le scénario comme il y aura deux pages de connexion avec différentes applications d'URL ("/ managementLogin", "/ othersLogin").

Je peux comprendre comment configurer les configurations multi httpsecurity mais j'ai besoin de valider les utilisateurs de deux tables.Si les utilisateurs de gestion connecté, je dois valider l'utilisateur de la table de gestion par DAO couche UserDetailsService sinon si d'autres utilisateurs sont connectés i besoin de valider à partir de la table other_users.

Quelqu'un pourrait me aider à savoir comment configurer la configuration multi http et dao couche à l'aide UserDetailsService avec la sécurité de démarrage du printemps?

Voici mon extrait de code de base,

@Order(SecurityProperties.ACCESS_OVERRIDE_ORDER) 
public class ApplicationSecurity extends WebSecurityConfigurerAdapter { 


    @Autowired 
    @Qualifier("userDetailsService") 
    UserDetailsService userDetailsService; 

    @Autowired 
    private RESTAuthenticationEntryPoint authenticationEntryPoint; 

    @Autowired 
    private RESTAuthenticationFailureHandler authenticationFailureHandler; 
    @Autowired 
    private RESTAuthenticationSuccessHandler authenticationSuccessHandler; 

    @Override 
    protected void configure(AuthenticationManagerBuilder auth) throws Exception { 
     // for testing authentication purpose using inMemory db 
     /* 
     * auth.inMemoryAuthentication().withUser("user").password("user").roles 
     * ("USER").and().withUser("admin") .password("admin").roles("ADMIN"); 
     */ 

     // Dao based authentication 
     auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder()); 
    } 

    @Override 
    protected void configure(HttpSecurity http) throws Exception { 
     http.authorizeRequests().antMatchers("/", "/home").permitAll(); 
     http.authorizeRequests().antMatchers("/rest/**").authenticated(); 
     http.exceptionHandling().authenticationEntryPoint(authenticationEntryPoint); 
     http.formLogin().successHandler(authenticationSuccessHandler); 
     http.formLogin().failureHandler(authenticationFailureHandler); 
     http.logout().logoutSuccessUrl("/"); 

     // CSRF tokens handling 
     http.addFilterAfter(new CsrfTokenResponseHeaderBindingFilter(), CsrfFilter.class); 
    } 

    @Override 
    public void configure(WebSecurity web) throws Exception { 
     web 
      .ignoring() 
      .antMatchers("/registerUser","/register.html"); 
    } 

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

TIA ..,

Answer 1

Mettre en oeuvre un UserDetailsService personnalisé comme celui-ci:

@Service 
public class CustomUserDetailsService implements UserDetailsService { 

    @Autowired 
    private UserDaoTableOne userDaoTableOne; 

    @Autowired 
    private UserDaoTableTwo userDaoTableTwo; 

    @Override 
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { 

    UserDetails user = userDaoTableOne.find(username); 

    if(user == null){ 
     user = userDaoTableTwo.find(username); 
    } 

    if (user == null) { 
     throw new UsernameNotFoundException(String.format("Username '%s' not found", username)); 
    } 

    return user; 
    } 
} 

Answer 2

Mettre en oeuvre deux DaoAuthenticationProvider avec son propre UserDetailsService et injectent à la fois fournisseurs à authenticationManager.

Je ne sais pas ce qui est la condition pour deux points d'extrémité de connexion distincts, mais d'abord je pense est une mauvaise idée. Vous pouvez créer différents objets Authentication et laisser AuthenticationManager choisir le AuthenticationProvider correct basé sur la méthode des supports.

Answer 3

En effet, vous aurez besoin d'utiliser, deux services de détail de l'utilisateur. Mais, ce ne sera pas suffisant. Je vous suggère de créer une autre classe ApplicationSecurity2 avec un ordre différent.

La sécurité de printemps est construite sur une liste ordonnée de chaînes de filtres.

Voir le answer donné ici par Dave Sayer. Ensuite, vous pouvez gérer différentes URL, comme vous le souhaitez.