Redirecionar para páginas diferentes após o login com o Spring Security

1. Visão geral

Um requisito comum para um aplicativo da Web é* redirecionar diferentes tipos de usuários para páginas diferentes após o login *. Um exemplo disso seria redirecionar usuários padrão para uma página /homepage.html e administrar usuários para uma página /console.html, por exemplo.

Este artigo mostrará como implementar esse mecanismo de maneira rápida e segura usando o Spring Security. O artigo também está construindo no topo do link:/spring-mvc-tutorial [tutorial do Spring MVC], que trata da configuração do material principal do MVC necessário para o projeto.

2. A configuração de segurança do Spring

O Spring Security fornece um componente que tem a responsabilidade direta de decidir o que fazer após uma autenticação bem-sucedida - o AuthenticationSuccessHandler.

Vamos ver como podemos configurar isso em uma classe _ @ Configuration_:

@Configuration
@EnableWebSecurity
public class SecSecurityConfig extends WebSecurityConfigurerAdapter {
    @Bean("authenticationManager")
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
            return super.authenticationManagerBean();
    }

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
       //@formatter:off
        auth.inMemoryAuthentication()
            .withUser("user1").password("{noop}user1Pass").roles("USER")
            .and()
            .withUser("admin1").password("{noop}admin1Pass").roles("ADMIN");
       //@formatter:on
    }

    @Bean
    public AuthenticationSuccessHandler myAuthenticationSuccessHandler(){
        return new MySimpleUrlAuthenticationSuccessHandler();
    }

    @Override
    protected void configure(final HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/anonymous*").anonymous()
            .antMatchers("/login*").permitAll()
            .anyRequest().authenticated()

            .and()
            .formLogin()
            .loginPage("/login.html")
            .loginProcessingUrl("/login")
            .successHandler(myAuthenticationSuccessHandler())
           //...
    }
}

As partes desta configuração a serem focadas são a definição do * manipulador de êxito da autenticação customizada e o uso do método _successHandler () _ para adicionar o bean à configuração de segurança. *

O restante da configuração é bastante padrão: um elemento http único e simples que protege tudo e apenas permite acesso não autenticado a _/login* _, e o provedor de autenticação padrão na memória para simplificar as coisas.

E a configuração xml equivalente:

<http use-expressions="true" >
    <intercept-url pattern="/login*" access="permitAll"/>
    <intercept-url pattern="/**" access="isAuthenticated()"/>

    <form-login login-page='/login.html'
      authentication-failure-url="/login.html?error=true"
      authentication-success-handler-ref="myAuthenticationSuccessHandler"/>
    <logout/>
</http>

<beans:bean id="myAuthenticationSuccessHandler"
  class="org..security.MySimpleUrlAuthenticationSuccessHandler"/>

<authentication-manager id="authenticationManager">
    <authentication-provider>
        <user-service>
            <user name="user1" password="{noop}user1Pass" authorities="ROLE_USER"/>
            <user name="admin1" password="{noop}admin1Pass" authorities="ROLE_ADMIN"/>
        </user-service>
    </authentication-provider>
</authentication-manager>

3. O manipulador de sucesso da autenticação personalizada

Além da interface AuthenticationSuccessHandler, o Spring também fornece um padrão sensato para esse componente de estratégia - o AbstractAuthenticationTargetUrlRequestHandler e uma implementação simples - o SimpleUrlAuthenticationSuccessHandler. Normalmente, essas implementações determinam o URL após o login e executam um redirecionamento para esse URL.

Embora um pouco flexível, o mecanismo para determinar esse URL de destino não permite que a determinação seja feita programaticamente - portanto, implementaremos a interface e forneceremos uma implementação personalizada do manipulador de sucesso.* Esta implementação determinará a URL para redirecionar o usuário após o login, com base na função do usuário: *

public class MySimpleUrlAuthenticationSuccessHandler
  implements AuthenticationSuccessHandler {

    protected Log logger = LogFactory.getLog(this.getClass());

    private RedirectStrategy redirectStrategy = new DefaultRedirectStrategy();

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request,
      HttpServletResponse response, Authentication authentication)
      throws IOException {

        handle(request, response, authentication);
        clearAuthenticationAttributes(request);
    }

    protected void handle(HttpServletRequest request,
      HttpServletResponse response, Authentication authentication)
      throws IOException {

        String targetUrl = determineTargetUrl(authentication);

        if (response.isCommitted()) {
            logger.debug(
              "Response has already been committed. Unable to redirect to "
              + targetUrl);
            return;
        }

        redirectStrategy.sendRedirect(request, response, targetUrl);
    }

    protected String determineTargetUrl(Authentication authentication) {
        boolean isUser = false;
        boolean isAdmin = false;
        Collection<? extends GrantedAuthority> authorities
         = authentication.getAuthorities();
        for (GrantedAuthority grantedAuthority : authorities) {
            if (grantedAuthority.getAuthority().equals("ROLE_USER")) {
                isUser = true;
                break;
            } else if (grantedAuthority.getAuthority().equals("ROLE_ADMIN")) {
                isAdmin = true;
                break;
            }
        }

        if (isUser) {
            return "/homepage.html";
        } else if (isAdmin) {
            return "/console.html";
        } else {
            throw new IllegalStateException();
        }
    }

    protected void clearAuthenticationAttributes(HttpServletRequest request) {
        HttpSession session = request.getSession(false);
        if (session == null) {
            return;
        }
        session.removeAttribute(WebAttributes.AUTHENTICATION_EXCEPTION);
    }

    public void setRedirectStrategy(RedirectStrategy redirectStrategy) {
        this.redirectStrategy = redirectStrategy;
    }
    protected RedirectStrategy getRedirectStrategy() {
        return redirectStrategy;
    }
}

O determineTargetUrl - que é o núcleo da estratégia - simplesmente analisa o tipo de usuário (determinado pela autoridade) e* escolhe o URL de destino com base nessa função *.

Portanto, um usuário administrador - determinado pela autoridade ROLE_ADMIN - será redirecionado para a página do console após o login, enquanto o usuário padrão - conforme determinado por ROLE_USER - será redirecionado para a página inicial.

4. Conclusão

Como sempre, o código apresentado neste artigo está disponível over no Github. Este é um projeto baseado em Maven, portanto, deve ser fácil importar e executar como está.

TOC

Redirecionar para páginas diferentes após o login com o Spring Security