Implementando UserDetailsService Spring Security

 

Olá Pessoal,

No post de hoje veremos como implementar a interface UserDetailsService do Spring. Mas para que serve ela, Camilo? É o que vamos ver logo a seguir…

Lets go…

Starting…

Este post será bem pontual e vou considerar que você já usa e conhece o Spring Security. Uma das opções mais comum de validar autenticação do usuário seria algo mais ou menos assim:

<jdbc-user-service data-source-ref="dataSource"

users-by-username-query="SELECT email, password, 'true' as enable FROM user WHERE email=?;"

authorities-by-username-query="select distinct u.email,ro.role_description from user u, user_role r, role ro where u.id = r.role_id and ro.id=r.role_id and u.email=?;" />

 

Independente de como está seu relacionamento no banco, a questão é que você usaria o jdbc-user-service />

Mas você pode estar perguntando “e se quiser usar minha classe de serviço (service) ou meu DAO, se nessas classes eu já tenha a implementação de busca de um usuário, como fazer?”.

Implementando UserDetailsService

Por default, o Spring a implementa. O que vamos fazer é  um override dessa implementação e dizer que é pra chamar um serviço de busca customizado.

Vou mostrar a seguir apenas o código principal e o que você precisa fazer.  Será bem pontual.

Step 1

Crie uma classe para esse tratamento (chamei de AuthenticationService). Veja :

@Service

public class AuthenticationService implements UserDetailsService {

       @Autowired

       @Qualifier("userServiceImpl")

       private UserService userServiceImpl;      

       @Override

       public UserDetails loadUserByUsername(String email)   throws UsernameNotFoundException, DataAccessException {

List<GrantedAuthority> listGrantAuthority = new ArrayList<GrantedAuthority>();

                    User user = userServiceImpl.getByEmail(email);

                    checkGrantAuthorities(user, listGrantAuthority);

                    UserDetails userDetails = validateUser(email, listGrantAuthority,user);

             return userDetails;

       }

 

O método que vamos trabalhar não é difícil de saber, já que tem anotação @Override. É nele que vamos realizar a busca usando as classes de serviço que chama o DAO. No caso acima o username é o email do usuário, por isso realizo a busca por email.  O método checkGrantAuthorities(…) verifica a role do usuário e adiciona em uma lista de Grant:

private void checkGrantAuthorities(User user, List<GrantedAuthority> listGrantAuthority) {

if(user!=null && user.getRoles()!=null && user.getRoles().isEmpty()==false)

             for(Role roleUser : user.getRoles()){

                    final String PREFIX = "ROLE_";

                    String role = PREFIX + roleUser.getRoleDescription();

                    listGrantAuthority.add(new GrantedAuthorityImpl(role));    

             }

       }

 

Precisamos fazer isso para que o Spring Security possa validar se o usuário passado possui Role de permissão para a página que deseja. O PREFIX que criamos é que no BD você não salva ROLE_ADMIN, daí precisamos fazer isso. Caso já salve como prefixo, você deve remover essa concatenação do código. Uma vantagem de não salvar o prefixo é que se amanhã você mudar de framework que faça essa parte de segurança, terá que fazer update em todo banco. Então é melhor deixar a aplicação tratar isso para seu banco ficar transparente.

Em seguida criei um método que valida se o usuário retornado é válido:

private UserDetails validateUser(String email,List<GrantedAuthority> listGrantAuthority, User user) {

             UserDetails userDetails= null;

             if(user!=null){

                    boolean accountNonLocked=true;

                    boolean enabledUser=true;

                    boolean accountNonExpired=true;

                    boolean credentialsNonExpired=true;

userDetails = new  org.springframework.security.core.userdetails.User(email, user.getPassword(), enabledUser, accountNonExpired, credentialsNonExpired, accountNonLocked, listGrantAuthority);

              }     

             return userDetails;

       }

 

 

Eu tive que colocar o caminho completo do User referente ao Spring  devido já ter um import para minha classe User.

Altere o arquivo de contexto do SpringSecurity. No meu caso, tenho um arquivo XML chamado de springsecurity.xml e no authenticationManager preciso dizer como vamos validar o usuário. Para usar a implementação acima precisamos dizer isso:

 

<authentication-manager alias="authenticationManager">

       <authentication-provider user-service-ref="authenticationService">      

             </authentication-provider>

       </authentication-manager>

 

Pronto. Feito isso, agora basta testar sua aplicação e ver que vai funcionar da mesma forma que o jdbc default, porém agora os dados vem de um serviço de pesquisa que você implementou, que pode ser em HQL, Criteria etc.

A documentação do Spring é muito bacana:

http://docs.spring.io/spring-security/site/docs/3.1.4.RELEASE/reference/ns-config.html

Abraços. Vou ficando por aqui e espero que tenham gostado

See ya!!

Criptografando senha com Spring Security

Olá Pessoal,

No post de hoje vamos ver como criptografar senha usando o Spring Security. O objetivo é que a senha do usuário não seja salva no seu BD, e já sabemos o motivo de fazer isso. Não vou entrar nos detalhes.

Lets go

Requisitos

  • Baixe a versão mais recente do SpringSecurity. (Para o post estou usando a versão 3.2.x)

Starting

Há várias soluções na internet, desde usando o Java puro ou usando APIs, Frameworks para criptografar a senha, e para quem está usando o SpringSecurity no projeto tem uma vantagem: já tem uma classe implementada pelo pessoal do Spring que faz isso em 1 linha. Vejamos a classe que criei a seguir para fazer isso. Vejam como é simples:

public abstract class GenerateHashPasswordUtil {       

        private static Object salt; 

        public static String generateHash(String password) {

                MessageDigestPasswordEncoder digestPasswordEncoder = getInstanceMessageDisterPassword();

                String encodePassword = digestPasswordEncoder.encodePassword(password, salt);

                return encodePassword;

        } 

        private static MessageDigestPasswordEncoder getInstanceMessageDisterPassword() {

//informo tipo de enconding que desejo

MessageDigestPasswordEncoder   digestPasswordEncoder = new MessageDigestPasswordEncoder("MD5");

                return digestPasswordEncoder;

        }

        //método que faz a validação  como não usamos salt deixei em null

        public static boolean isPasswordValid(String password, String hashPassword) {

        MessageDigestPasswordEncoder digestPasswordEncoder = getInstanceMessageDisterPassword();

                return digestPasswordEncoder.isPasswordValid(hashPassword, password, salt);

        }

}

 

E aqui a classe de teste que valida alguns cenários:

public class GenerateHashPasswordUtilTest { 

       @Test

       public void testHashWasGenerateWithSuccess() {

             String password="1234";

             assertNotNull(GenerateHashPasswordUtil.generateHash(password));

       }

       @Test

       public void testValidIfPasswordIsValidAfterHashed(){

             String password="brazil";

              String hashPassword =GenerateHashPasswordUtil.generateHash(password);

 boolean expectedValidPassword = GenerateHashPasswordUtil.isPasswordValid(password, hashPassword);

             assertTrue(expectedValidPassword);

       }

       @Test

       public void testPassWordIsNotEqualToHashCodeGenerated(){

             String password = "XPto";

             String passwordhash = GenerateHashPasswordUtil.generateHash(password);

             String passwordTyped = "xPto";

             boolean expectedInvalidPassword = GenerateHashPasswordUtil.isPasswordValid(passwordTyped, passwordhash);

             assertFalse(expectedInvalidPassword);

       } 

}

 

 Simples, não? Se quiser ver o código hash basta imprimir no console.

Abraços, vou ficando por aqui.

Usando Spring Core com múltiplos projects

Olá Pessoal,

O post hoje é bem rápido e a ideia é compartilhar com vocês um problema comum quando temos mais de um projeto com dependência e precisamos usar o applicationContext que está em outro projeto.  São coisas que a gente não decora e que normalmente faz uma vez a cada novo projeto e que certamente esquecemos com o passar do tempo. E se algum livro fala sobre o assunto, certamente nem damos atenção à esse detalhe, pois estamos ansiosos em querer meter a mão na massa.

lets go…

 

Contexto

Recentemente tive que criar um projeto com module do maven. Veja a estrutura para ficar mais claro: 

—parent

—core

—web

–dependecy of core

 

Com o desenho simples acima estou dizendo que tenho um projeto parent (pai) que tem dois filhos: core e web. E o filho web depende do projeto core. 

No projeto core temos o back-end da aplicação, ou seja, regras de negócio e persistência vão estar nesse projeto. O projeto web vai cuidar do front-end. É nele que teremos o controller, os arquivos .html, xhtml, jsp, js etc. 

Então na prática o projeto web tem um .jar do projeto core: 

<dependency>

<groupId>com.handson.core</groupId>

<artifactId>xxx-core</artifactId>

<version>1.0.0</version>

</dependency>

 

Até aqui tudo bem. Nenhum problema, certo? 

Como falei, o projeto core tem o applicationContext do Spring, já que é lá que fazemos IoC, dizemos para o spring cuidar da sessionFactory etc. 

E qual o problema?

Quando precisamos usar o ApplicationContext no web. Esse é o problema. O código a seguir não vai funcionar quando aplicação subir:

 

 @Controller

@Path(“/user”)

public class UserController {

@Autowired

@Qualifier(“userServiceImpl”)

private UserService userService;

//código omitido

}

 

Por que não vai funcionar? Porque o applicationContext está dentro de .jar de outro projeto e ao subir a aplicação precisamos dizer isso para web.xml. Uma forma simples  é criar um arquivo applicationContext em web e importar o que temos no applicationContext no projeto core. Portanto, crie um app-context.xml em resource do projeto web:

 

springprojectwebresource

E no arquivo app-context que está no projeto web, faça isso:

<beans xmlns=”http://www.springframework.org/schema/beans”

xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”

xsi:schemaLocation=”http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.5.xsd”> 

<import resource=”classpath*:/META-INF/app-context.xml”/>

</beans> 

Esse caminho acima é porque o arquivo no projeto core está assim:

springappcontextcore

 

Agora no arquivo web.xml no projeto xx-web deixe assim:

 springwebxml

Assim, ao subir a aplicação o arquivo que está dentro do .jar do projeto core será carregado. E no import que fizemos anteriormente dizemos para importar esse arquivo para o contexto da aplicação web que está sendo carregada. 

Pronto. Salve as alterações e execute mvn install. Suba a aplicação. Se o Spring não conseguir fazer o @Autowired ele irá reclamar logo que subir. Mas o esperado é que não tenha problemas. 

Abraços! Vou ficando por aqui. Espero que tenham gostado da dica de hoje.

Converter JSF com Spring

 

Olá Pessoal,

O post de hoje será bem rápido. Se você está  precisando criar um Converter e fazer com que este seja gerenciado pelo Spring, o que fazer? Ao olhar a documentação do Spring não há nenhuma anotação direta para o Converter. Lets go! Vamos ver na prática como fazer isso…

 

Converter

Um resumo rápido: Sabemos que quando precisamos carregar um selectOneMenu, por exemplo, um valor customizado, é preciso ter um converter, como por exemplo se preciso carregar cidade, estado, status,  etc é necessário ter um converter, e para implementarmos um converter temos que criar uma classe que implementa a interface Converter do JSF. Nada de especial até aqui, certo?

@FacesConverter( value= “com.camilolopes.readerweb.TypeConverter”,forClass=Type.class)

public class TypeConverter implements Converter {

       @Override

public Object getAsObject(FacesContext context, UIComponent component, String value) {

 

return null;

       } 

       @Override

public String getAsString(FacesContext arg0, UIComponent arg1, Object value) {

             

return null;

       } 

}

Mas você está usando o Spring e quer que seu Converter seja gerenciado por ele, e ainda assim poder chamar as classes de serviços, como fazer? Veja o código alterado com Spring e chamando um método na classe de serviço: 

@Component(“typeConverter”)

public class TypeConverter implements Converter {

       @Autowired

       private TypeServiceImpl typeServiceImpl;

       @Override

public Object getAsObject(FacesContext context, UIComponent component, String value) { 

              Type type = typeServiceImpl.searchById(Long.valueOf(value));

              return type;

       } 

       @Override

       public String getAsString(FacesContext arg0, UIComponent arg1, Object value) {

                     if(value!=null){

                           return ((Type)value).getId().toString();

                     }

              return null;

       } 

       public TypeServiceImpl getTypeServiceImpl() {

              return typeServiceImpl;

       } 

       public void setTypeServiceImpl(TypeServiceImpl typeServiceImpl) {

              this.typeServiceImpl = typeServiceImpl;

       } 

}

Basta anotar com @Component e definir um id para o converter. Na página XHTML chamaremos o id usando EL, veja:

<p:selectOneMenu value=“#{userController.selectedType}” converter=“#{typeConverter}”>

<f:selectItems  itemLabel=“#{type.description}” itemValue=“#{type}” var=“type”  value=“#{typeController.listTypes}” />

</p:selectOneMenu>

Pronto, assim temos o converter via Spring. Claro que você precisar ter no seu face-config.xml na tag <application />

<el-resolver>org.springframework.web.jsf.el.SpringBeanFacesELResolver</el-resolver>

 Dizendo para o JSF que o Spring vai cuidar da instanciação dos objetos etc. Veja nesse post.

Por hoje é isso. See ya!!

Troubleshooting PersistenceExceptionTranslationInterceptor Spring

 

Olá Pessoal,

O troubleshooting de hoje é para qume está sobrendo com o Hibernate e Spring.  Vamos ver os erros e como podemos resolver. 

Caused by: java.lang.IllegalStateException: No persistence exception translators found in bean factory. Cannot perform exception translation.

                at org.springframework.dao.support.PersistenceExceptionTranslationInterceptor.detectPersistenceExceptionTranslators

Esse erro acontece normalmente quando estamos usando a versão do Hibernate 4 no Spring, porém usando as configurações do Hibernate 3. A resolução é simples, veja:

No hibernate 3 usamos o translation assim:

<bean class=”org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor”/>

No Hibernate 4.x deve ser assim:

<bean class=”org.springframework.orm.hibernate4.HibernateExceptionTranslator”/>

O sessionFactory também deve ser alterado, veja:

No Hibernate 3 é assim:

<bean id=”sessionFactory” class=”org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean”>

Mas no Hibernate 4 deve ser assim:

<bean id=”sessionFactory” class=”org.springframework.orm.hibernate4.LocalSessionFactoryBean”>

Pronto! Assim resolvemos a exception de translation com Hibernate. Fiquem espertos com esses detalhes para não gastar tanto tempo.

Abracos, see ya!!