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!!

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.

Série Spring: Aplicação JEE com JSF 2.0 + Spring 3.0

 

Olá Pessoal,

No post de hoje veremos como usar Spring em nossas aplicações JEE tendo o JSF no nosso front-end. Vou considerar que você já conhece o básico e configuração de cada um dos frameworks, mas na hora de fazer a integração, veio aquela pergunta: “E agora como faço?”.

Lets go… 

Starting…

Primeiramente precisamos ter nosso ambiente de desenvolvimento pronto, para isso  você precisa ter os .jars do JSF 2.x e do Spring core 3.x.  No nosso exemplo estou usando a versão do Spring 3.2 e o JSF 2.0.9 e como IDE optei pelo STS Tools. O motivo que ele  vem com vários plugins já por default  e é uma mão  na roda.

Nossos .jars:

  • – JSF 2.X
  • – Spring 3.x
  • -commons-logging-1.1.1.jar

Note: como Servidor app estou usando o Tomcat 7.0

Garanta que você já tem tudo isso antes de começar a desenvolver.

Desenvolvimento

Agora vamos meter mão na massa. Primeiro crie um Spring template Project  na lista de opções escolha Spring Hibernate Utility Apesar que não vamos usar nada de Hibernate, o template já vem com a estrutura do projeto para web e precisamos apenas dar uns tapas para ficar como queremos, para isso o projeto vai está “quebrando” ou seja, com uma exclamação:

helloSpringJSFProject

Note: se vc já tem um projeto JEE, só vai precisar adicionar suporte ao Spring.

Note 2: você também poderia criar um JSF Project e adicionar o Spring, enfim há N possibilidades.

Vamos deletar os arquivos que veio no template que não precisamos:

hellospringjsfdelete

Agora vamos adicionar suporte ao JSF para o projeto. Basta clicar com o botão direito do mouse no projeto e escolher:

 

configurejsfhellospringproject

Na tela a seguir bastar dar ok:

jsfscreenspringhello

Adicione os .jars na pasta lib:

 

jarslibhellopspring

Crie os packages a seguir:

hellospringpackages

A nossa aplicação será bem simples, daremos um Hello para um determinado usuário que será criado quando o método getUserInformation é invocado pelo controller.

User.java

public class User {

    private String name;

    private String lastName;

    private Integer age; 

//getters/setters  omitidos

}

Criaremos uma interface para o serviço

UserService.java

public interface UserService {

    public User getUserDetails();

}

 Agora temos a implementação da interface:

@Service

public class UserServiceImpl implements UserService {

     private User user;   

    public UserServiceImpl() {

     user = new User();

     user.setName(“camilo”);

     user.setLastName(“lopes”);

     user.setAge(10);

    }

    @Override

    public User getUserDetails() {       

        return user;

    } 

}

 Antes de criarmos a classe de controller precisamos fazer umas configurações no arquivo web.xml e também criarmos o nosso arquivo de configuração do Spring. Primeiro vamos alterar o web.xml

Adicione o cara que carrega as configurações do Spring

<listener>

  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

 </listener>

 

Vamos dizer para ele onde pegar as configurações do Spring:

<context-param>

  <param-name>contextConfigLocation</param-name>

  <param-value>/WEB-INF/springconfiguration.xml</param-value>

 </context-param>

 Apesar que não criamos  o arquivo springconfiguration.xml , mas não há problemas algum.

E agora vamos colocar o cara que permitirá utilizar os escopos padrões de uma aplicação web

<listener>

  <listener-class>org.springframework.web.context.request.RequestContextListener

</listener-class>

 </listener>

 E assim terminamos a configuração do web.xml

Face-config.xml

E agora vamos dizer ao JSF para delegar a criação do ManagedBeans para o Spring, mas para isso vamos alterar o arquivo face-config.xml

<face-config>

<application>

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

 </application>

</faces-config>

Criando o  arquivo de configuração do Spring

Aqui chamei meu arquivo de configuração do Spring de springconfiguration.xml e como vimos anteriormente informamos ele no web.xml para que ao iniciar aplicação o application context saiba onde e quem buscar.

hellpspringconfigurationfile

Portanto crie um arquivo .xml conforme a seguir:

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

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

xmlns:context=“http://www.springframework.org/schema/context”

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

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd”> 

<context:component-scan base-package=“*”/> 

</beans>

 

Só isso que precisamos. 

Criando a classe controller

UserController.java

@Controller

@Scope(“request”)

public class UserController {

    @Autowired

    private UserService userServ; 

    public User getUserInformation(){       

        return userServ.getUserDetails();

    }

    public void setUserServ(final UserService userServ) {

        this.userServ = userServ;

    }

}

Se você já conhece o Spring nada de especial aqui, apenas trocamos as anotações do JSF pela dos Spring.

Criando a página .xhtml

Vamos criar uma página home.xhtml que terá o código JSF. Para isso crie uma .xhtml withou facets.

E no body da página adiicone:

Hello <h:outputText value=“#{userController.userInformation.name}” />

 Agora clique com o botão direito do mouse no projeto e escolha Run On Server e o resultado será:

<img hellospringresultado>

Acessando http://localhost:8080/nomedoprojet/home.jsf

Note: lembrando que para dar suporte .jsf você precisa dizer isso no web.xml, assim:

<servlet-mapping>

  <servlet-name>Faces Servlet</servlet-name>

  <url-pattern>*.jsf</url-pattern>

 </servlet-mapping>

 

Pronto. Agora temos o nosso projeto JEE integrado com o Spring e tirar todo o beneficio que o framework nos traz. Simples não?

Abraços, 

Série Spring: Transaction via Annotation Spring 3 + Hibernate

Olá Pessoal,

No post de hoje veremos como usar Annotations nas nossas transaction. Para isso teremos como exemplo uma aplicação bem simples para irmos direto ao ponto.

Lets go…

 Starting…

Primeiro ponto é iniciarmos pelo arquivo de configuração do Spring. Antes disso,  vou assumir que você tem os .jars necessário: mysql 5, hibernate 3.x, spring 3.x, aop, aspectJ.

Esse é o projeto:

springannotationtransactionproject

Configurando o Spring

A seguir segue a configuração do Spring, aproveitei e coloquei o comentário in line para facilitar o entendimento:

Cabeçalho

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

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

xmlns:context=“http://www.springframework.org/schema/context”

xmlns:tx=“http://www.springframework.org/schema/tx”

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

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx-3.0.xsd”>

 

E o restante:

<context:component-scan base-package=“*”/>

<!– declarando a transation por default busca pelo id transactionManager –>

<tx:annotation-driven/> 

<!– faz o translate das exception para Spring Exception –>

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

<bean id=“transactionManager” class=“org.springframework.orm.hibernate3.HibernateTransactionManager”>

<property name=“sessionFactory” ref=“sessionFactory”/>

</bean>

 

<!– criando meu datasource –>

<bean id=“dataSource” class=“org.springframework.jdbc.datasource.DriverManagerDataSource”>

<property name=“driverClassName” value=“com.mysql.jdbc.Driver”/>

<property name=“url” value=“jdbc:mysql://localhost/test”/>

<property name=“username” value=“root”/>

<property name=“password” value=“camilo2593”/>

</bean> 

<!– configurando o sessionFactory  –>

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

<property name=“dataSource” ref=“dataSource”/>

<!– informando o package onde estão os beans annotated –>

<property name=“packagesToScan” value=“br.com.camilolopes.model.bean”/>

<!– aqui o Hibernate properties –>

<property name=“hibernateProperties”>

      <props>

      <prop key=“hibernate.dialect”>org.hibernate.dialect.MySQL5InnoDBDialect</prop>

      <prop key=“hibernate.hbm2ddl.auto”>update</prop>

      </props>

</property>

</bean>

</beans>

 

Onde está o segredo?

Exatamente nessa linha:

<!– declarando a transation por default busca pelo id transactionManager –>

<tx:annotation-driven/>

Pronto essa linha habilita reconhecer annotation @Transactional. Que faremos logo a seguir

Desenvolvendo

Vamos meter mão na massa na parte Java:

Entidade

@Entity

public class ProductTech implements Serializable{

      private static final long serialVersionUID = -206121128264026525L;

      @Id

      @GeneratedValue

      private Long id;

      private String nameProduct;

                //getters/setters omitidos

 

Interface DAO

public interface ProductDAO {

      void save(ProductTech product);

}

 

Implementação da Interface 

@Repository

public class ProductDAOImpl implements ProductDAO {

      private SessionFactory sessionFactory;

      @Autowired

      public ProductDAOImpl(SessionFactory sessionFactory) {

            this.sessionFactory = sessionFactory;

      }

      private Session currentSession(){

            return sessionFactory.getCurrentSession();

      } 

      @Override  //para execução deste método é requerido uma transação, é isso que estamos dizendo aqui

      @Transactional(propagation=Propagation.REQUIRED,readOnly=false)

      public void save(ProductTech product) {

            currentSession().save(product);

            System.out.println(“product saved with sucess”);

      }

}

Testando

E para testar vamos fazer dessa vez com uma classe que tem o método main, caso você ainda não esteja tão acostumado com unit test (deveria):

public class MainTestDAO {

      public static void main(String[] args) {

            ApplicationContext applicationContext = new ClassPathXmlApplicationContext(“config/springconfiguration.xml”);

            ProductDAO bean = (ProductDAO) applicationContext.getBean(“productDAOImpl”);

            ProductTech product= new ProductTech();

            product.setNameProduct(“tablet samsung galaxy”);

            bean.save(product);

      }

}

Resultado:

springtransactionannotationresult

É isso ia. Simples e fácil usar anotações para transações no Spring.

Abracos! Vou ficando por aqui.

See ya!!!

Série Spring: Spring AOP com annotations

 

Olá Pessoal,

No post de hoje vamos ver como usar annotations   para AOP é bem simples.Já vimos aqui  com XML e agora vamos para o que há de melhor  desde do Java 5 que é o uso de Annotations.

Lets go…

 Starting

O post é bem curto e procurei  ser bem objetivo, então considerando que você já tem seu arquivo de spring configurado  para usar aop, vamos apenas atualizar para habilitar o recurso de annotations  e aproveitei removi os beans  usando auto-discovering do Spring. Vamos começar pela configuração do arquivo springconfiguration.xml (o nome que dei ao meu arquivo de configuração).

Antes disso, crie um projeto novo e dê o nome que quiser.

Note: lembre-se de adicionar os .jars do Spring, AOP e AspectJ ao projeto:

 springaopannotationsproject

Configurando .xml do Spring

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

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

xmlns:context=“http://www.springframework.org/schema/context”

xmlns:aop=“http://www.springframework.org/schema/aop”

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

http://www.springframework.org/schema/beans/spring-beans-3.2.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-3.2.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.2.xsd”>

 <context:component-scan base-package=“*”/>

<aop:aspectj-autoproxy/>

 </beans>

 

Deixei seu arquivo de configuração assim. A única coisa nova de aop, foi que adicionar a linha <aop:aspectj-autorproxy/>  que nos permite usar annotations.

Criando o bean

A seguir vamos criar o bean , nada demais neles:

@Component

@Scope(value=”prototype”)

public class Student {

      private String name;

//    this is DI via annotations

      @Autowired

      private Course course;

      public String getName() {

            return name;

      }

      public void setName(String name) {

            if (name==null) {

                  throw new IllegalArgumentException();

            }

            this.name = name;

      }

      public Course getCourse() {

            return course;

      }

      public void setCourse(Course course) {

            this.course = course;

      }     

      public void teste(){           

      }

}

O outro bean:

@Component

public class Course {

      private String nameCourse; 

      public String getNameCourse() {

            return nameCourse;

      } 

      public void setNameCourse(String nameCourse) {

            this.nameCourse = nameCourse;

      } 

}

 

Agora vamos criar uma classe que será responsável  por registrar uma mensagem antes;após de determinados métodos, ou seja, as regras do AOP estarão aqui:

@Aspect

@Component

public class Audit {

//    aqui com o metodo especifico

      @Pointcut(“execution(* br.com.camilolopes.bean.Student.setName(..))”)

      public void aopteste(){} 

      @Pointcut(“execution(* br.com.camilolopes.bean.Course.setNameCourse(..))”)

      public void aopcourse(){}     

      @Pointcut(“execution(* *.*test*(..))”)

      public void aopanywhere(){}     

      @AfterReturning(“aopteste()”)

      public void register(){

            System.out.println(“Student registred”);

      }

      @After(“aopcourse()”)

      public void finished(){

            System.out.println(“Course finished”);

      }

      @AfterThrowing(“aopteste()”)

      public void problem(){

            System.out.println(“Happened problem here”);

      }

      @Before(“aopteste()”)

      public void starting(){

            System.out.println(“application is starting…”);

      }

      @AfterReturning(“aopanywhere()”)

      public void anywhere(){

            System.out.println(“anywhere test”);

      }

}

Observe que anotei a classe com @Component para que o Spring saiba que precisa registrar ela no contexto. Caso contrário, nada rola. Agora vamos entender os pointcuts criados:

  • Primeiro: criamos um pointcut que sempre será chamado quando um método especifico for chamado nesse caso o método  setName da classe Student.
  • Segundo: o mesmo que acima, exceto que para a classe Course.
  • Terceiro :  agora criamos um que estou dizendo: “de qualquer lugar da aplicação e qualquer método que comece com test e terminar com qualquer coisa.

E  os métodos a seguir é o que serão chamados  com base no que tipo de anotação que definimos, observe que temos um que será chamado apenas no caso de acontecer uma exceção quando no método setName da classe Student.

Testando

Para testar aplicação criei uma classe de teste

Classe de Test

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations={“classpath:config/springconfiguration.xml”})

public class StudentTest {

      @Autowired

      private Student student;

      @Before

      public void setUp() throws Exception {

      } 

      @Test

      public void testNameCourse() {

            student.getCourse().setNameCourse(“TDD”);

            assertEquals(“TDD”,student.getCourse().getNameCourse());

      }     

      @Test

      public void testNameStudent(){

            student.setName(“Camilo”);

            assertEquals(“Camilo”, student.getName());

            student.teste();

      }

      @Test(expected=IllegalArgumentException.class)

      public void testNameIsNullException(){

            student.setName(null);

      }

}

Resultado:

resultaopunittest

Classe com o método main

Fiz uma pequena classe com método main, para quem não sabe unit test:

public class MainTest {

      public static void main(String[] args) {

            ApplicationContext  applicationContext = new ClassPathXmlApplicationContext(“config/springconfiguration.xml”);

            Student bean = (Student) applicationContext.getBean(“student”);

            bean.setName(“lopes”);

            bean.teste();           

      }

} 

O resultado será diferente pq as inovações são diferentes:

resultadoaopmaintest

 

Bom, pessoal. Vou ficando por aqui e espero que tenham gostado do post.

Abraços,