Top Posts

Criando Cliente WebService SOAPUI

Continue lendo

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

Posted by camilolopes | Posted in JSF, Series, Spring | Posted on 23-05-2013

6

 

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

Posted by camilolopes | Posted in Series, Spring | Posted on 17-05-2013

0

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