Olá Pessoal!
Depois de muito tempo sem postar (diríamos meses...), resolvi escrever sobre um tema que a algum tempo muitas pessoas vinham me pedindo sobre isso, e como eu consegui fazer uma solução para este "problema" resolvi escrever aqui, (não sei se é a forma certa, mas é funcional)!
O tema de hoje é sobre como ter um campo a mais no form de login utilizando o Spring Security, imagino eu que tenha uma forma mais simples de fazer... mas enquanto não descubro, vamos àquela que funciona.
Antes de começar o nosso projeto, é de total importância que você já conheça ou já tenha utilizado o Spring Security, caso não conheça, leia esta postagem.
Antes de começar o nosso projeto, é de total importância que você já conheça ou já tenha utilizado o Spring Security, caso não conheça, leia esta postagem.
* Começando *
Inicialmente a minha estrutura do banco de dados (básico):
Neste caso, eu tenho duas tabelas: uma de empresa onde a coluna regra será para dizer se é ROLE_ADM, ROLE_USER... entre outras, e tenho o usuário que está ligado diretamente a empresa, fiz o mais básico possível apenas para mostrar como que pode estar colocando um campo a mais no login, neste caso: o usuário terá que colocar seu login, senha e escolher a qual empresa pertence.
Neste caso, eu tenho duas tabelas: uma de empresa onde a coluna regra será para dizer se é ROLE_ADM, ROLE_USER... entre outras, e tenho o usuário que está ligado diretamente a empresa, fiz o mais básico possível apenas para mostrar como que pode estar colocando um campo a mais no login, neste caso: o usuário terá que colocar seu login, senha e escolher a qual empresa pertence.
Para entender direito, esta será a nossa tela de login:
O projeto completo terá esta estrutura:
Não dê tanta atenção quanto ao pacotes que se encontram as classes, pois esta apenas foi uma organização minha, acredito que cada um tenha uma forma melhor de organizar.
A primeira coisa a se fazer é baixar a biblioteca do Spring Security na versão 3.1.4 (pode baixar clicando aqui), juntamente com o Spring Framework 3.1.4. As bibliotecas que eu uso são:
O projeto completo terá esta estrutura:
Não dê tanta atenção quanto ao pacotes que se encontram as classes, pois esta apenas foi uma organização minha, acredito que cada um tenha uma forma melhor de organizar.
A primeira coisa a se fazer é baixar a biblioteca do Spring Security na versão 3.1.4 (pode baixar clicando aqui), juntamente com o Spring Framework 3.1.4. As bibliotecas que eu uso são:
Inicialmente é necessário fazer as classes de modelo, que estão no pacote javasemcafe.model, observo que fiz este projeto utilizando JPA, mas pra quem quiser usar apenas JDBC é só fazer as adaptações, utilizei o JPA por ser mais rápido, então de acordo com a estrutura de banco de dados teremos duas classes, uma é Empresa e a outra é Usuário:
Classe Empresa.java:
@Entity @Table(name = "empresa") public class Empresa implements Serializable { private static final long serialVersionUID = 1L; @Id @Basic(optional = false) @NotNull @Column(name = "codigo") private Integer codigo; @Size(max = 45) @Column(name = "descricao") private String descricao; @Size(max = 45) @Column(name = "regra") private String regra; // Getters e Setters }
Classe Usuario.java:
@Entity @Table(name = "usuario") public class Usuario implements Serializable { @Id @Basic(optional = false) @NotNull @Column(name = "codigo") private Integer codigo; @Size(max = 45) @Column(name = "login") private String login; @Size(max = 45) @Column(name = "senha") private String senha; @JoinColumn(name = "empresa_codigo", referencedColumnName = "codigo") @ManyToOne(optional = false, fetch = FetchType.LAZY) private Empresa empresa; // Getters e Setters }
No pacote javasemcafe.dao, temos a classe EmpresaDAO.java:
@Stateless public class EmpresaDAO { @PersistenceContext(unitName = "LoginCustomizadoPU") private EntityManager em; public List<Empresa> listar() { List<Empresa> empresas = null; try { Query query = em.createQuery("Select e from Empresa e order by e.descricao"); empresas = query.getResultList(); } catch (Exception e) { e.printStackTrace(); } return empresas; } }
Nesta classe, apenas temos um método que retorna uma lista de empresas que será utilizada com o EmpresaBean.java para popular o combo de empresas na página de login.
Classe EmpresaBean.java:
@ManagedBean @ViewScoped public class EmpresaBean implements Serializable { @EJB private EmpresaDAO empresaDAO; private List<Empresa> empresas; public List<Empresa> getEmpresas() { empresas = empresaDAO.listar(); return empresas; } public void setEmpresas(List<Empresa> empresas) { this.empresas = empresas; } }Neste caso apenas preenche uma Collection que aqui é o List.
Voltando ao pacote javasemcafe.dao, temos praticamente a classe mais importante:
AutenticacaoFilter.java, é nela que fazemos a verificação de login, senha e se o usuário pertence ou não a empresa selecionada no login, abaixo explico os detalhes dela:
public class AutenticacaoFilter extends UsernamePasswordAuthenticationFilter { private EntityManagerFactory factory = Persistence.createEntityManagerFactory("LoginCustomizadoPU"); private EntityManager em; private String mensagem; public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException, BadCredentialsException { String login = request.getParameter("j_login"); String senha = request.getParameter("j_senha"); Integer codigoEmpresa = Integer.parseInt(request.getParameter("j_empresa")); try { Usuario usuario = buscarUsuario(login, senha); if (usuario != null) { if (usuario.getEmpresa().getCodigo().equals(codigoEmpresa)) { Collection<GrantedAuthority> regras = new ArrayList<GrantedAuthority>(); regras.add(new SimpleGrantedAuthority(usuario.getEmpresa().getRegra())); request.getSession().setAttribute("usuarioLogado", usuario); mensagem = "Bem vindo: " + usuario.getLogin(); return new UsernamePasswordAuthenticationToken(usuario.getLogin(), usuario.getSenha(), regras); } else { mensagem = "Acesso negado a empresa selecionada!"; throw new BadCredentialsException(mensagem); } } else { mensagem = "Dados Incorretos"; throw new BadCredentialsException(mensagem); } } catch (Exception e) { throw new BadCredentialsException(e.getMessage()); } } protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, Authentication authResult) throws IOException, ServletException { SecurityContextHolder.getContext().setAuthentication(authResult); request.getSession().setAttribute("msg", mensagem); response.sendRedirect("index.jsf"); } protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException { request.getSession().setAttribute("msg", mensagem); response.sendRedirect("login.jsf"); } /** * Metodos de acesso ao BD * */ public Usuario buscarUsuario(String login, String senha) { em = factory.createEntityManager(); Usuario usuario = null; try { Query query = em.createQuery("SELECT u FROM Usuario u WHERE u.login = :login AND u.senha = :senha"); query.setParameter("login", login); query.setParameter("senha", senha); usuario = (Usuario) query.getSingleResult(); } catch (NoResultException e) { System.out.println("DAO: Não foi encontrado resultado!"); } catch (Exception e) { e.printStackTrace(); } finally { em.close(); } return usuario; } }
Vamos entender o que acontece nessa classe: os métodos attemptAuthentication. successfulAuthentication e unsuccessfulAuthentication são métodos criados automaticamente quando se utiliza o extends UsernamePasswordAuthenticationFilter. O primeiro método é onde ocorre a verificação do usuário, é o comando executado quando o usuário clica no botão de "Acessar" (conforme tela no início da postagem), nesse método tem um detalhe importante, que é a linha 23 onde ele dá o return com os dados do usuário, no caso das regras são aqueles ROLE_ADM, ROLE_USER.... isso é necessário para o applicationContext.xml saber se deve liberar a pagina ou não, veremos mais pra frente isso, o que você precisa saber é que, dependendo a lógica que você utilizar para montar a estrutura do BD, será possível que um usuário pertença a diferentes filiais com diferentes regras para cada uma, mas aí teria que fazer uma tabela N-N, o que prologaria ainda mais essa postagem que já vai ficar enorme. Só mais um detalhe antes de continuar, na linha 21, nós jogamos o usuário para a sessão da aplicação, assim podemos recuperar ele a qualquer momento. Continuando, se no primeiro método ocorrer o return ele vai para o método de sucesso (successfulAuthentication), onde eu digo para o Spring Security que há uma autenticação e redireciono o usuário para a página inicial. No caso de não ocorrer um return, por dados incorretos, pelo usuário não ter acesso a empresa, automaticamente cairá no método unsuccessfulAuthentication, onde eu redireciono ele para a página de login novamente.
Vamos a uma observação nessa classe: percebam que eu tenho uma String mensagem, pois bem, ela não seria necessária se caso não quisesse mostrar ao usuário os avisos de dados incorretos e outros... então eu coloco essa String na sessão da aplicação, e recupero por uma outra classe que é a AutenticacaoPhaseListener.java, que se encontra no pacote javasemcafe.controller.
public class AutenticacaoPhaseListener implements PhaseListener { @Override public void afterPhase(PhaseEvent event) { //não implementado } @Override public void beforePhase(PhaseEvent event) { FacesContext context = FacesContext.getCurrentInstance(); HttpSession session = (HttpSession) context.getExternalContext().getSession(false); if (session != null) { String mensagem = (String) session.getAttribute("msg"); if (mensagem != null) { context.addMessage(null, new FacesMessage(FacesMessage.SEVERITY_INFO, mensagem, null)); session.setAttribute("msg", null); } } } @Override public PhaseId getPhaseId() { return PhaseId.RESTORE_VIEW; } }
Esta classe implementa um PhaseListener que vai pegar a mensagem na sessão da aplicação e vai mandá-la por por um FacesMessage para o JSF.
Utilizando a classe UsuarioBean.java, do pacote javasemcafe.controller(esta classe não está aparecendo na imagem da estrutura do projeto, mas deve estar no projeto), vamos pegar o usuário na sessão:
@ManagedBean @ViewScoped public class UsuarioBean { private Usuario usuarioLogado; public Usuario getUsuario() { FacesContext context = FacesContext.getCurrentInstance(); HttpSession session = (HttpSession) context.getExternalContext().getSession(false); usuarioLogado = (Usuario) session.getAttribute("usuarioLogado"); return usuarioLogado; } public void setUsuario(Usuario usuario) { this.usuarioLogado = usuario; } }
Veja que é utilizado o atributo "usuarioLogado" que foi setado lá na classe AutenticacaoFilter.java, é através dela que conseguimos pegar esse usuário. Ou você pode estar pegando o usuário diretamente do Spring Security, porém neste caso ele não te trás muitas informações de usuário, mas sei que o login é uma delas, veja um exemplo (isto não está no projeto, é apenas uma outra forma de um outro projeto meu):
public ConfiguracaoBean() { Authentication authentication = (Authentication) SecurityContextHolder.getContext().getAuthentication(); if (authentication != null) { usuario = authentication.getName(); } }
Agora vamos para as páginas do JSF, começando pela index.xhtml (também conhecida: index.jsf) que será a página para onde o usuário será redirecionado se logar o sistema:
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://java.sun.com/jsf/html"> <h:head> <title>Facelet Title</title> </h:head> <h:body> <h:outputText value="Olá #{usuarioBean.usuario.login}!"/><br/> <h:outputText value="Você está na empresa: #{usuarioBean.usuario.empresa.descricao}!"/><br/> <a href="./logout">Sair</a> </h:body> </html>
Não tem nada de mais, só estou usando a classe UsuarioBean.java para mostrar o usuário que está logado na sessão da aplicação. Ficando desta forma:
Página de login, login.xhtml:
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://java.sun.com/jsf/html" xmlns:f="http://java.sun.com/jsf/core"> <h:head> <title>Login Customizado</title> </h:head> <h:body> <form action="j_spring_security_check" method="post" style="text-align: right;"> <fieldset> <legend>Login</legend> <h:panelGrid columns="2"> <h:outputText value="Login:" /> <h:inputText id="j_login" /> <h:outputText value="Senha:" /> <h:inputSecret id="j_senha" /> <h:outputText value="Empresa:" /> <h:selectOneMenu id="j_empresa" style="width: 155px" > <f:selectItems value="#{empresaBean.empresas}" var="e" itemLabel="#{e.descricao}" itemValue="#{e.codigo}" /> </h:selectOneMenu> <h:outputText /> <h:commandButton value="Acessar" id="btnAcessar" /> </h:panelGrid> <h:message for="btnAcessar" /> </fieldset> </form> </h:body> </html>
A única coisa diferente do normal das páginas de login do Spring Security, é o caso de ter adicionado o h:selectOneMenu para fazer o combo, fora isso, o restante já foi explicado na postagem que eu indico para leitura no começo do post. No caso da h:message serve para mostrar as mensagens enviadas pelo FacesMessage, aparecendo dessa forma:
Vamos ver agora os arquivos de configuração que ficam dentro do WEB-INF.
Começando com a configuração básica no web.xml para o Spring Security ser identificado (já explicado na postagem indicada):
Começando com a configuração básica no web.xml para o Spring Security ser identificado (já explicado na postagem indicada):
<!-- Spring security --> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <filter> <filter-name>springSecurityFilterChain</filter-name> <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class> </filter> <filter-mapping> <filter-name>springSecurityFilterChain</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> <!-- Fim spring security -->
Bom, como devem saber na versão JEE 6, o faces-config.xml é opcional, ou seja é utilizado em alguns casos, como o caso agora, onde eu preciso "registrar" o PhaseListener (a classe AutenticacaoPhaseListener.java):
<faces-config version="2.1" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_2_1.xsd"> <lifecycle> <phase-listener>javasemcafe.controller.AutenticacaoPhaseListener</phase-listener> </lifecycle> </faces-config>
Agora vamos para toda a "mágica" da customização do login, o applicationContext.xml:
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:security="http://www.springframework.org/schema/security" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd"> <security:http auto-config="false" use-expressions="true" access-denied-page="/index.jsf" entry-point-ref="authenticationEntryPoint" > <security:intercept-url pattern="/index.jsf" access="hasRole('ROLE_ADM')"/> <security:logout invalidate-session="true" logout-success-url="/login.jsf" logout-url="/logout"/> <security:custom-filter ref="authenticationFilter" position="FORM_LOGIN_FILTER"/> </security:http> <bean id="authenticationFilter" class="javasemcafe.dao.AutenticacaoFilter" p:authenticationManager-ref="authenticationManager"/> <bean id="authenticationEntryPoint" class="org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint" p:loginFormUrl="/login.jsf"/> <security:authentication-manager alias="authenticationManager" /> </beans>
O que vemos de diferente na configuração do applicationContext, é a partir da 15º linha, onde de uma forma geral, estou dizendo que a autenticação deverá ser feita pela classe: javasemcafe.dao.AutenticacaoFilter, como pode ver na linha 18.
Bom pessoal, acabei deixando de explicar muitas classes (do Spring Security) porque senão essa postagem iria ficar bem mais longa!
Até a próxima :)
andii.brunetta