quinta-feira, 7 de abril de 2016

Garantindo o encoding UTF-8 em aplicações com o Spring Boot

       Uma das formas mais eficientes de tratar a questão de caracteres estranhos e setar o encoding UTF-8 é através de um Filtro que intercepta a requisição ao servidor e antes de qualquer coisa atribui o encoding na request, e faz o mesmo com o response. O Spring Boot tem um filter para isso e basta usarmos esse filter para garantir que a nossa aplicação irá tratar corretamente os dados.

       Ao criar um projeto usando o Spring Boot duas classes são criadas, uma o o nome ServletInitializer.java e outra com o nome-da-aplicaçãoApplication.java. Esta segunda classe, se o nome da minha aplicação fosse teste, seu nome seria então TesteApplication.java, que é o que vamos considerar para o exemplo.

        Esta classe é responsável por configurações do projeto antes feitas no arquivo web.xml, de forma que declarações de filtros, servlets e listeners são declarados nela.

         No momento da criação do projeto, ele é muito simples, veja o código:

@SpringBootApplication
public class CobrancaApplication {

      public static void main(String[] args) {
            SpringApplication.run(CobrancaApplication.class, args);
      }
     
}

O que precisa ser feito é adicionar o seguinte trecho de código:

@Bean
public Filter getCharacterEncodingFilter() {

    CharacterEncodingFilter encodingFilter = new encodingFilter();

    encodingFilter.setEncoding("UTF-8");
    encodingFilter.setForceEncoding(true);

    return encodingFilter;

}

Os pacotes relacionados a esse trecho de código são:

import javax.servlet.Filter;
import org.springframework.context.annotation.Bean;
import org.springframework.web.filter.CharacterEncodingFilter;


Pronto! Dessa forma  sua aplicação com o Spring Boot está livre dos caracteres estranhos...

Instalando plugin do Thymeleaf no eclipse para autocomplete

      O autocomplete é uma mão na roda né? Afinal, usamos diversas linguagens e frameworks diferentes, e sem uma ajudinha as coisas se enrolam. Por isso, o Thymeleaf tem um plugin para ser adicionado ao eclipse que permite o autocomplete desse framework.

        Para instalar basta acessar no eclipse o menu help -> Install New Software e no campo Work with a seguinte URI:


         Vai demorar um pouco para o eclipse varrer o endereço e trazer o que está disponível para instalação, após ele carregar, basta selecionar e clicar em next, os próximos passos são bem intuitivos ;)


Referência: 

quarta-feira, 6 de abril de 2016

Usando o Thymeleaf para mapear automaticamente recursos estáticos (Imagens, scripts, estilos CSS, etc...)

     O Thymeleaf é um substituto do JSP que tem total integração com o Spring, trabalhando com layouts e fazendo a integração das páginas XHTML, HTML5 e XML com o Java no lado servidor.

      Dito isto, para quem usa Spring MVC com Spring Boot precia adicionar as dependências no pom.xml  da seguinte forma:

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

         Quem não usa o Spring Boot deve colocar:

<dependency>
    <groupId>org.thymeleaf</groupId>
    <artifactId>thymeleaf</artifactId>
    <version>3.0.0.BETA02</version>
</dependency>
<dependency>
    <groupId>org.thymeleaf</groupId>
    <artifactId>thymeleaf-spring4</artifactId>
    <version>3.0.0.BETA02</version>
</dependency>

         E adicionar o seguinte namespace no layout principal e das páginas:

xmlns:th="http://www.thymeleaf.org"

Desta forma, já possível usar as TAGS do Thymeleaf nos arquivos XHTML, HTML5 e XML. Porém o foco desse post é o uso do Thymeleaf para encapsular a chamada de recursos estáticos como imagens, arquivos Javascript e CSS, etc., fazendo com que o Thymeleaf mapeie de forma dinâmica o caminho absoluto desses recursos. Isso é muito útil, principalmente para quem usa o Spring Boot com o Tomcat embutido, no desenvolvimento, porém vai fazer o deploy em um servidor de aplicação mais robusto ou mesmo em um Tomcat externo, pois o context-path (caminho do contexto) muda e causa vários transtornos.

Vou apresentar a maneira com e sem o Thymeleaf para percebermos a diferença. Primeiro vamos à maneira comum, sem o uso do Thymeleaf, onde nós somos responsáveis por mapear o caminho dos recursos:

<a class="btn btn-link link-panel" href="/carros">Carros</a>
<form class="form-horizontal" method="POST" action="/carro">
<script src="/js/jquery-2.2.2.min.js"></script>
<link rel="stylesheet" type="text/css" th:href="/css/estyle.css"/>
<img  src="/images/logo.png" width="200dp" />

      E agora vamos ver como ficam esses recursos com o Thymeleaf:

<a class="btn btn-link link-panel" th:href="@{/titulos}">Carros</a>
<form class="form-horizontal" method="POST" th:action="@{/carro}">
<script th:src="@{/js/jquery-2.2.2.min.js}"></script>
<link rel="stylesheet" type="text/css" th:href="@{/css/estyle.css}"/>
<img  th:src="@{/images/logo.png}" width="200dp" />

Veja que praticamente todos os casos foram abordados: imagens, scripts, action de forms, e estilos CSS. Tudo o que apresenta um caminho, pode ser encapsulado com o Thymeleaf. O que tivemos que acrescentar foi o namespace  th: antes das propriedades que guardam o caminho dos recursos, e englobar os caminhos com @{}. Muito simples não é mesmo? Dessa forma, mudando o context-path, não é preciso me preocupar, pois os recursos serão trazidos da mesma maneira.


Espero ter ajudado. Abraços.

domingo, 3 de abril de 2016

Usando o Spring Boot no Wildfly 8.1.0

         Nesse post eu vou falar sobre rodar o Spring Boot no Wildfly. Bom, como o wildfly é um container de aplicações JavaEE completo, espera-se que não seja nenhum problema rodar o Spring Boot, certo? Pois é, mas algumas configurações são válidas para melhorar isso, que devem ser feitas no pom.xml.

         O Spring Boot carrega um Tomcat incorporado através da seguinte configuração no pom.xml:

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <scope>provided</scope>
</dependency>

         Esta dependência não é necessária pois o Wildfly tem um Toncat Servidor Web chamado Undertow rodando em suas entranhas (O Tomcat era usado nas versões antigas quando era chamado JBoss). Comente esta dependência e no lugar dela deve ficar:

<dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <scope>provided</scope>
</dependency>

      Pelo que pesquisei, para garantir que não irá ser carregado o Toncat, é bom alterar também a seguinte dependência:

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
</dependency>

         Deixando da seguinte forma:

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <exclusions>
            <exclusion>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-starter-tomcat</artifactId>
                  </exclusion>
            </exclusions>
</dependency>

Outra coisa importante é garantir que o Mavem vai exportar um arquivo do tipo war:

<packaging>war</packaging>

Basicamente, com essas configurações o projeto que usa Spring Boot vai rodar muito bem no Wildfly, porém deixará de funcionar no modo que usava o Tomcat embutido, e a aplicação terá que ser sempre iniciada através do Wildfly, por isso indiquei que comentasse a configuração antiga, assim pode revezar a configuração quando necessário, comentando as configurações referentes ao wildfly e retirando o comentário a respeito do Tomcat.

Outra dica importante é que a URI quando usamos o Tomcat embutido não necessita do nome da aplicação, bastando digitar apenas o endereço local, a porta e o caminho definido no controller através da annotetion @RequestMapping, por exemplo:

http://localhost:8080/carros/novo  //tomcat embutido

Já com a aplicação no wildfly será necessário acrescentar o nome da aplicação ficando:

http://localhost:8080/loccar/carros/novo  //wildfly


E acrescentar a seguinte configuração no arquivo application.properties:

server.context-path=/loccar   //loccar é o nome da minha aplicação, subtitua pelo nome dado ao pacote war da sua aplicação.

       Se você usava o Tomcat embutido, terá que fazer várias alterações nos links de páginas, imagens, arquivos CSS, arquivos JavaScript, etc... Para isso não ser uma grande dor de cabeça, recomenda-se o uso do Thymeleaf (http://www.thymeleaf.org/) nos projetos, pois ele oferece meios de mapear de forma automática estes recursos.

Veja o link de um post sobre o Thymeleaf usado para este fim AQUI!

       Espero ter ajudado, qualquer dúvida, deixa nos comentários que eu tento da uma força...


Links úteis:

sexta-feira, 1 de abril de 2016

Trabalhando com enum no JSF/Primefaces

      O JSF / Primefaces consegue trabalhar com enum de forma simples, sem precisarmos implementar conversores, basta passarmos para o componente uma lista com os valores da classe enum para o componente JSF / Primefaces. Segue o código do ManagedBean:

public class CadastroModeloCarroBean {
     
... //outros atributos da classe
      private List<Categoria> categorias;
           
      @PostConstruct
      public void init(){
            ... //outras inicializações necessárias
            categorias = Arrays.asList(Categoria.values());
      }
     
      ... //outros métodos da classe  
     
      public List<Categoria> getCategorias(){
            return categorias;
      }
     

}
         O atributo categorias trata-se de uma lista de itens da própria enum Categoria. Note que para pegar todos os atributos e devolve-los em forma de lista foi usado o seguinte código:

categorias = Arrays.asList(Categoria.values());

         Dessa forma eu posso usar a lista criada a partir do enum como qualquer outra lista. Veja no arquivo XHTML como fica:

<p:outputLabel value="Categoria" for="categoria"/>
<p:selectOneMenu id="categoria" value="#{cadastroModeloCarroBean.modeloCarro.categoria}">
     
<f:selectItem itemLabel="Selecione uma categoria"/>
     
<f:selectItems value="#{cadastroModeloCarroBean.categorias}" var="categoria" itemLabel="#{categoria}" itemValue="#{categoria}"/>

</p:selectOneMenu>

E olha o código da classe Categoria que é um enum:

public enum Categoria {
      
       SEDAN("Sedan"), HATCH("Hatch"), SUV("SUV");
      
       private String descricao;
      
       public String getDescricao(){
             return this.descricao;
       }
      
       private Categoria(String descricao){
             this.descricao = descricao;
       }

}