Arquivos de sites

Novidades do Java 8

Só alguns poucos (6) anos atrasado, venho publicar esse post com as principais novidades do Java 8 que foi lançado em Março de 2014 através da especificação JSR 337.

Esse post é o primeiro da série onde pretendo centralizar as melhorias de cada uma das versões que vieram após o Java 7.

Lambda Expression

Também conhecida como funções anônimas, acredito que essa seja maior mudança na versão 8, as expressões lambdas podem causar estranhesa a primeira vista por quem apenas programou utilizando Java. Mas elas já são bem comuns para programadores que tiveram contato com linguagens como C#, Clojure, Go, Groovy, Javascript, Kotlin, Ruby, Scala e muitas outras.

Essas expressões facilitam a implementação dos comportamentos de inferfaces funcionais, que são aquelas interfaces que possuem apenas um único método abstrato.

Como por exemplo a clássica interface java.util.Comparator, comumente utilizada para ordenar coleções. Anteriormente precisaríamos implementar essa interface em uma classe ou instância-la como classe anonima como no exemplo abaixo:

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

Comparator<String> comparadorPorTamanho = new Comparator() {
	public int compare(String s1, String s2) {
		return Integer.compare(s1.length(), s2.length());
	}};

Collections.sort(linguagens, comparadorPorTamanho);

Agora abaixo um código equivalente ao de cima, substituindo a instanciação da classe anonima pela expressão lambda:

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

Comparator<String> comparadorPorTamanho = (s1, s2) -> Integer.compare(s1.length(), s2.length());

Collections.sort(linguagens, comparadorPorTamanho);

Podemos fazer uma versão mais enxuta ainda, passando a expressão lambda direto como argumento para o método sort:

List <String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

Collections.sort(linguagens, (s1, s2) -> Integer.compare(s1.length(), s2.length()));

Detalhando um pouco mais a sintaxe da expressão lambda apresentada:

(s1, s2) -> Integer.compare(s1.length(), s2.length())

É iniciada com a declaração dos parametros do método que estamos implementando. O método da interface Comparator aguarda 2 parametros do tipo String, a tipagem dos parâmetros é opcional, já que temos apenas um único método na interface, o compilador ja sabe com quais tipos ele está lidando, por isso declaramos apenas o nome que desejamos para as variáveis:

(s1, s2) ...

Se o método aguardasse apenas 1 parametro, então declaramos somente o nome do parametro, sendo que neste cenário os parênteses passam a ser opcionais.

s1 ...

Caso o método não tivesse parametros, seria declarado com parenteses vazios:

() ...

Após a declaração dos parametros colocamos o arrow token, que é composto por um hífen, seguido por um sinal de maior (->):

(s1, s2) -> ...

Em seguida devemos colocar o conteúdo do nosso método, no exemplo que estamos utilizando é { return Integer.compare(s1.length(), s2.length()); }, como o nosso corpo é simples e tem apenas uma única linha (instrução), podemos suprimir as chaves, o return e o ponto e vírgula (;), pois nesse caso tornan-se opcionais:

(s1, s2) -> Integer.compare(s1.length(), s2.length())

Caso o nosso conteúdo fosse ‘mais complexo’, com mais de uma linha (instrução), necessitaríamos da utilização das chaves, do return (caso o método não seja void, claro :D) e do ponto e vírgula (;) no final de cada comando, como por exemplo:

(s1, s2) -> {
    // imagine qualquer comando aqui
    int resultado = Integer.compare(s1.length(), s2.length());
    // imagine qualquer comando aqui
    return resultado;
}

Ordenando Collections

Como vimos no exemplo acima, ordenavamos nossas coleções utilizando o método utiitário Collections.sort (Classe), agora no java 8 temos outra maneira mais simples de efetuar tal ação, temos o método Collection.sort (Interface), que espera como parâmetro apenas um Comparator compatível com o tipo da lista, o qual está disponível em todas as nossas coleções, como por exemplo na interface List.

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

linguagens.sort((s1, s2) -> Integer.compare(s1.length(), s2.length()));

A interface Comparator ganhou um método estático (sim! agora é possível :D) Comparator.comparing, que facilitar a criação de uma instância de um comparador simples:

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

linguagens.sort(Comparator.comparing(s -> s.length()));

Podemos simplificar ainda mais com outra novidade, o Method Reference, que nos permite fazer referência a um método específico de uma classe:

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

linguagens.sort(Comparator.comparing(String::length));

Novos métodos nas Collections

Nas nossas coleções tivemos algumas mudanças, ganhamos diversos métodos novos como o Collection.sort visto acima, muitos deles esperam com parâmetro implementações de interfaces funcionais (assunto que veremos a seguir), segue mais alguns:

Iterable.forEach(Consumer)
Iterator.forEachRemaining(Consumer)
Collection.removeIf(Predicate)
Collection.spliterator()
Collection.stream()
Collection.parallelStream()
List.sort(Comparator)
List.replaceAll(UnaryOperator)
Map.forEach(BiConsumer)
Map.replaceAll(BiFunction)
Map.putIfAbsent(K, V)
Map.remove(Object, Object)
Map.replace(K, V, V)
Map.replace(K, V)
Map.computeIfAbsent(K, Function)
Map.computeIfPresent(K, BiFunction)
Map.compute(K, BiFunction)
Map.merge(K, V, BiFunction)
Map.getOrDefault(Object, V)

Interface

Ocorreram melhorias também nas interfaces, como a possibilidade de declarar métodos concretos, chamados de Default Method, fazendo com que as interfaces tenham uma grande similaridade com as classes abstratas, que até então eram um meio termo entre interfaces e classes concretas. Esse tipo de método necessita do operador default em sua declaração.

Solução criada para possibilitar a evolução das interfaces já existentes, assim quando criarmos novos métodos em interfaces que já estão em uso, essas alterações não irão causar erros de compilação nas outras interfaces e/ou classes que as implementam.

Por exemplo, o novo método sort da interface List:

default void sort(Comparator<? super E> c) {
    Collections.sort(this, c);
}

Outra novidade também, como vimos na interface Comparator.comparing, agora podemos declarar métodos estáticos, o que não era possível anteriormente:

Interfaces funcionais

Como ja vimos no começo do post, inferfaces funcionais, que são aquelas interfaces que possuem apenas um único método abstrato.

Antes dessa nova versão ja tinhamos outras interfaces funcionais, é isso mesmo! Um exemplo seria a interface Runnable, que é implementada pela famosa classe Thread.

Agora as interfaces funcionais ganharam mais destaque, e também novas interfaces localizadas no pacote java.util.function:

Function<T, R> − recebe T como entrada, retorna R como saída;
Predicate<T> − recebe T como entrada, retorna um valor booleano como saída;
Consumer<T> − recebe T como entrada, não retorna nada como saída;
Supplier<T> − não recebe entrada, retorna T como saída;
BinaryOperator<T> − recebe duas entradas T, retorna um T como saída.

Também temos uma nova anotação @FunctionalInterface, que deve ser utilizada para indicar que uma interface é funcional. O que obriga o compilador a verificar se existe apenas um método declarado na interface. Em caso negativo, ocorrerá um erro de compilação. Todas as antigas interfaces que são consideradas funcionais, receberam essa anotação.

Optional

Nova classe que nos ajuda a evitar a má prática de retornar null em nosso métodos, e espalhar comparações do tipo if (resultado != null), deixando o nosso código muito mais elegante. Estamos falando da classe java.util.Optional que usufrui de Generics, possibilitando uma codificação tipada. Segue algumas maneira de aplica-la:

Retornando resutado não-nulo:

public Optional<String> buscar() {
    String resultado = "XPTO";
    return Optional.of(resultado);
}

Retornando resutado que é vazio, antigo return null:

public Optional<String> buscar() {
    return Optional.empty();
}

Retornando resultado que tem a possibilidade de ser nulo:

public Optional<String> buscar() {
    String resultado = null;
    return Optional.ofNullable(resultado);
}

Internamente o método acima verifica o parametro passado e decide se prossegue com o método of ou empty.

Agora segue alguns exemplos do lado de quem recebeu o Optional como retorno, como o utilizamos:

Verificando se temos um resultado preenchido:

Optional<String> opt = buscar();
boolean preenchido = opt.isPresent();

Obtendo o resultado encapsulado, devemos verificar com o método isPresent para evitar receber uma exceção:

Optional<String> opt = buscar();
String resultadoEsperado = opt.get();

Se o resultado estiver presente, você pode ja passar uma função para consumi-lo:

Optional<String> opt = buscar();
opt.ifPresent(r -> System.out.println(r));

Você ja pode deixar seu código preparado para receber outro valor caso o resutado não esteja presente:

Optional<String> opt = buscar();
String outroResultado = opt.orElse("Vazio!");

Lançando exceção caso o resutado não esteja presente:

Optional<String> opt = buscar();
opt.orElseThrow(IllegalStateException::new);

Stream

Uma grande novidade que nos ajuda muito no dia a dia, é o pacote java.util.stream, que nos possibilita uma programação no estilo funcional. Simplificando a forma de iterar, filtrar, transformar, consolidar e coletar os dados.

A forma mais comum de ter acesso a uma instância de Stream é através de collections já populadas, através do método Collection.stream, que nos devolve uma instância de java.util.stream.Stream, possibilitando o uso de uma infinidade de métodos que esperam como parâmetro a implementação de diversas interfaces funcionais (ex.: as que mostramos acima) de acordo com o tipo de operação.

Iterando (ex.: Imprimindo as linguagens):

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

linguagens.stream()
    .forEach( l -> System.out.println("Imprimindo linguagem "+l ));

Obs.: Também podemos ter acesso a esse método de forma mais prática, diretamente na coleção com Iterable.forEach.

Transformando (ex.: Obtendo as iniciais de cada linguagem):

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

List<Character> iniciais = linguagens.stream()
    .map(l -> l.charAt(0))
    .collect(Collectors.toList());

Nesse exemplo fizemos chamadas sequenciais/encadeadas de 2 métodos, o map e o collect, onde um faz a transformação de cada objeto e o outro é responsável por obter o resultado da operação anterior.

Ordenando (ex.: Ordem alfabetica)

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

List<String> novaListaOrdenada = linguagens.stream()
    .sorted(Comparator.comparing(String::toString))
    .collect(Collectors.toList());

Nesse exemplo ordenamos com sorted e em seguida obtivemos a lista ordenada com o collect.

Removendo duplicados

List<Integer> numeros = Arrays.asList(1, 1, 2, 3, 4, 4, 5);

numeros.stream()
    .distinct()
    .forEach(n -> System.out.println(n));

Removemos os duplicados através do distinct, o qual se utiliza do método equals do objeto para distinguir os valores, e para variar, não coletamos o resutado, e sim, imprimimos cada um deles com o forEach.

Filtrando (ex.: Linguagens que começam com “J”)

List<String> linguagens = Arrays.asList("Java", "C#", "JavaScript", "Html");

linguagens.stream()
    .filter(l -> l.startsWith("J"))
    .forEach(l -> System.out.println(l));

Filtramos utilizando o filter e imprimimos utilizando forEach.

Temos muitas outras possibilidades para trabalhar com Stream, para descobrir todas elas, basta dar uma olhada na documentação oficinal 😀

Também temos Streams para trabalhar com tipos primitivos, como IntStream, LongStream e DouleStream, que nos oferecem métodos específicos para trabalhar com números, como average, sum, reduce e muito mais.

Além de tudo isso, podemos efetuar esses processamentos de forma paralela de maneira bem simples, com o uso do método Collection.parallelStream ao invés de Collection.stream, possibilitando um possível ganho de performance.

Datas e horas

Finalmente ganhamos uma nova API para trabalhar com data e hora, baseada no JodaTime, o JodaTime ja era uma biblioteca bastante utilizada pelos desenvolvedores, agora nossa vida será muito mais fácil quando o assunto for lidar com data e hora.

As antigas classes java.util.Date, java.sql.Date, java.util.GregorianCalendar e cia, dão espaço para as classes dos pacotes java.time, como por exemplo LocalDate para trabalhar apenas com data, LocalTime para trabalhar apenas com horas, LocalDateTime para trabalhar com data e hora. Também temos a classe java.time.format.DateTimeFormatter para ajudar na formatação e muitas outras.

Segue um breve exemplo do uso das classes citadas:

System.out.println("Hoje: " + LocalDate.now());

System.out.println("Agora: " + LocalTime.now());

LocalDate nascimento = LocalDate.of(1989, Month.MAY, 22);
System.out.println("Nascimento: " + nascimento);

String nascimentoFormatado = nascimento.format(DateTimeFormatter.ofPattern("dd/MM/yy"));
System.out.println("Nascimento formatado: " + nascimentoFormatado);

A nova API tem muitas classes e muitos métodos, não irei abordar tudo aqui pois não é o intuito desse post. Para ver todas as funcionalidades dê uma olhadinha nesse post da oracle!

Essas classes ja são suportadas pelo JDBC e JPA, então você pode mapear seu modelo utilizando-as sem medo! 😀

Outras mudanças

Melhorias na própria JVM relacionado ao uso da memória disponível (Metaspace);
Melhorias na API de Concorrência;
Melhorias na API de IO/NIO;
Melhorias para trabalhar com Reflection;
Nova implementação para utilizar JavaScript dentro do Java: Nashhorn;
Nova implementações para unir Strings como o método String.join e a classe java.util.StringJoiner;
Conexão com Banco de dados via JDBC-ODBC foi removida;
Não roda no Windows XP;

Fontes:
Caelum, Matera, Feltex, Infoq, Oracle – Docs, Oracle – Specs, Wikipedia

jQuery – Pegando e atribuindo classes CSS

Assim como é fácil manipular o conteúdo e atributos dos elementos, como nós vimos no capítulo anterior, é igualmente fácil manipular o CSS dos elementos. O jQuery lhe dá acesso fácil para mudança tanto do atributo de estilo, que você manipula usando o método css(), como a(s) classe(s) de um elemento, onde vários métodos diferentes permitem você modificar isso.

Vamos começar olhando a mudança do atributo class (classe). O atributo class recebe um ou vários nomes de classes, que pode ou não referenciar a uma classe CSS definida no seu stylesheet. Geralmente faz, mas você pode de tempos em tempos adicionar nomes de classes aos seus elementos simplesmente para estar apto para alcançar eles facilmente pelo jQuery, já que o jQuery tem um excelente suporte para seleção de elementos baseado nos  nomes da classe.

Eu defini alguns seletores CSS bem simples no meu stylesheet, principalmente para propósitos de teste:

.bold {
        font-weight: bold;
}
.blue {
        color: blue;
}

No seguinte exemplo nós vamos usar três dos métodos mais interessantes relacionados à classe: hasClass(), que checa se um ou vários elementos já tem uma classe específica definida, addClass(), que simplesmente adiciona um nome de classe a um ou vários elementos e o método removeClass(), que  irá… bem, você provavelmente já adivinhou isso.

<a href="javascript:void(0);" onclick="ToggleClass(this);">Toggle class</a>
<script type="text/javascript">
function ToggleClass(sender)
{
        if($(sender).hasClass("bold"))
                $(sender).removeClass("bold");
        else
                $(sender).addClass("bold");
}
</script>

O exemplo é na realidade muito simples. Quando o link é clicado, nós enviamos o próprio link (this) como um parâmetro ao método ToggleClass() que nós temos definido. Nele, nós checamos se o remetente já tem a classe “bold” – se ele tiver nós o removemos, caso contrário nós o adicionamos. Isso é uma coisa muito comum de se fazer, então obviamente o pessoal do jQuery não quer  que nós escrevemos todas essas três linhas de código para isso. É por isso que eles implementaram o método toggleClass(), com o qual nós podemos transformar todo nosso exemplo avima dentro de uma única linha de código:

<a href="javascript:void(0);" onclick="$(this).toggleClass('bold');">Toggle class</a>

Com certeza, nós podemos selecionar multiplos elementos, onde nós podemos adicionar ou remover múltiplas classes, também. Aqui está um exemplo disso:

<div id="divTestArea1">
        <span>Test 1</span><br />
        <div>Test 2</div>
        <b>Test 3</b><br />
</div>
<script type="text/javascript">
$(function()
{
        $("#divTestArea1 span, #divTestArea1 b").addClass("blue");
        $("#divTestArea1 div").addClass("bold blue");
});
</script>

Primeiro nós selecionamos as tags span e a b, a qual nós adicionamos uma única classe para: classe blue. Então nós selecionamos a tags div, que nós adicionamos duas classes, separadas por espaço: classe bold e a blue. O método removeClass() funciona apenas do mesmo jeito, permitindo você especificar várias classes para serem removidas, separadas por espaços.

Fonte: jquery-tutorial.net

Parte 6 – Tutorial de Upload e Gravação de Arquivos do Struts 2 com Exemplo

Bem vindos a parte 6 de uma série de 7 partes do framework Struts2. Na parte anterior nós passamos pelo básico dos Interceptadores do Struts2. Também criamos um interceptador customizado e o integramos a aplicação Struts2.

É bastante recomendável passar pelos artigos anteriores no caso de você ser novo no framework Struts2.

Hoje vamos ver como fazer um Upload de Arquivos no Struts2. Nós vamos utilizar o interceptador FileUploadInterceptor que vem embutido no Struts2, no nosso exemplo para fazer o upload do arquivo. O interceptador de upload de arquivos do Struts2 é baseado no MultiPartRequestWrapper, o qual é automaticamente aplicado a requisição se ela contém um elemento de arquivo.

Arquivo JAR Necessário

Antes de começar, você precisa ter certeza que o arquivo commons-io.jar está presente no classpath. Segue a lista de arquivos JAR necessários.
struts2-file-upload-jar-files

Primeiros passos

A fim de adicionar a funcionalidade de upload de arquivos, nós vamos adicionar uma classe action FileUploadAction ao nosso projeto. Crie o arquivo FileUploadAction.java no pacote net.viralpatel.struts2
FileUploadAction.java

package net.viralpatel.struts2;

 

import java.io.File;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.io.FileUtils;

import org.apache.struts2.interceptor.ServletRequestAware;

import com.opensymphony.xwork2.ActionSupport;

 

public class FileUploadAction extends ActionSupport implements

        ServletRequestAware {

    private File userImage;

    private String userImageContentType;

    private String userImageFileName;

 

    private HttpServletRequest servletRequest;

 

    public String execute() {

        try {

            String filePath = servletRequest.getSession().getServletContext().getRealPath(“/”);

            System.out.println("Server path:" + filePath);

            File fileToCreate = new File(filePath, this.userImageFileName);

 

            FileUtils.copyFile(this.userImage, fileToCreate);

        } catch (Exception e) {

            e.printStackTrace();

            addActionError(e.getMessage());

 

            return INPUT;

        }

        return SUCCESS;

    }

 

    public File getUserImage() {

        return userImage;

    }

 

    public void setUserImage(File userImage) {

        this.userImage = userImage;

    }

 

    public String getUserImageContentType() {

        return userImageContentType;

    }

 

    public void setUserImageContentType(String userImageContentType) {

        this.userImageContentType = userImageContentType;

    }

 

    public String getUserImageFileName() {

        return userImageFileName;

    }

 

    public void setUserImageFileName(String userImageFileName) {

        this.userImageFileName = userImageFileName;

    }

 

    @Override

    public void setServletRequest(HttpServletRequest servletRequest) {

        this.servletRequest = servletRequest;

 

    }

}

No arquivo da classe acima, nós declaramos alguns atributos:

  • private File userImage; -> Isso irá armazenar o arquivo carregado
  • private String userImageContentType; -> Essa string conterá o Content Type do arquivo carregado.
  • private String userImageFileName; -> Essa string irá conter o nome do arquivo carregado.

Os campos userImageContentType e userImageFileName são opcionais. Se o método setter desse campos for fornecido, o Struts2 irá setar o dado. Isso é apenas para pegar alguma informação extra do arquivo carregado. Segue também o padrão de nomeação, se você fornecer o tipo do conteúdo e o nome do arquivo. O nome deve ser ContentType e FileName. Por exemplo, se o atributo arquivo (File) na action for private File uploadedFile, o tipo do conteúdo será uploadedFileContentType e o nome do arquivo uploadedFileFileName.

Observe também na classe action acima, nós implementamos a interface org.apache.struts2.interceptor.ServletRequestAware. Isto é para pegar o objeto servletRequest. Nós estamos usando esse path para salvar o arquivo carregado no método execute(). Nós usamos o método FileUtil.copyFile() do pacote commons-io para copiar o arquivo carregado na pasta root. Esse arquivo será recuperado na página JSP e exibido ao usuário.

Os JSPs

Crie dois arquivos JSP na pasta WebContent. UserImage.jsp irá exibir um formulário para o usuário carregar a imagem. Ao submeter, o arquivo será carregado e salvo no servidor. O usuário será enviado ao arquivo SuccessUserImage.jsp aonde terá os detalhes do arquivo serão exibidos. Copie o seguinte código dentro dele.
UserImage.jsp

<%@ page contentType="text/html; charset=UTF-8"%>

<%@ taglib prefix="s" uri="/struts-tags"%>

<html>

<head>

<title>Upload User Image</title>

</head>

 

<body>

<h2>Struts2 File Upload & Save Example</h2>

<s:actionerror />

<s:form action="userImage" method="post" enctype="multipart/form-data">

    <s:file name="userImage" label="User Image" />

    <s:submit value="Upload" align="center" />

</s:form>

</body>

</html>

SuccessUserImage.jsp

<%@ page contentType="text/html; charset=UTF-8"%>

<%@ taglib prefix="s" uri="/struts-tags"%>

<html>

<head>

<title>Success: Upload User Image</title>

</head>

<body>

    <h2>Struts2 File Upload Example</h2>

    User Image: <s:property value="userImage"/>

    <br/>

    Content Type: <s:property value="userImageContentType"/>

    <br/>

    File Name: <s:property value="userImageFileName"/>

    <br/>

    Uploaded Image:

    <br/>

    <img src="<s:property value="userImageFileName"/>"/>

</body>

</html>

Entrada no Struts.xml

Adicione a seguinte entrada da classe FileUploadAction  ao arquivo struts.xml.

<action name="userImage"

    class="net.viralpatel.struts2.FileUploadAction">

    <interceptor-ref name="fileUpload">

        <param name="maximumSize">2097152</param>

        <param name="allowedTypes">

            image/png,image/gif,image/jpeg,image/pjpeg

        </param>

    </interceptor-ref>

    <interceptor-ref name="defaultStack"></interceptor-ref>

    <result name="success">SuccessUserImage.jsp</result>

    <result name="input">UserImage.jsp</result>

</action>

Observe que na entrada acima nós especificamos dois parâmetros ao interceptador fileUpload, maximumSize e allowedTypes. Estes são parâmetros opcionais que nós podemos especificar ao interceptador. O parâmetro maximumSize setará o tamanho máximo do arquivo que poderá ser carregado. Por padrão é 2MB. E o parâmetro allowedTypes especifica os tipos de conteúdos permitidos do arquivo que será carrregado. Aqui nós o especificamos para ser um arquivo de imagem (image/png,image/gif,image/jpeg,image/pjpeg).

O interceptador de carga de arquivo também faz a validação e adiciona erros, essas mensagens de erros são armazenadas dentro do arquivo struts-messsages.properties. Os valores das mensagens podem ser sobrescritos fornecendo texto/valor para as seguintes chaves:

  • struts.messages.error.uploading – erro quando a carga do arquivo falha
  • struts.messages.error.file.too.large – erro ocorrido quando o tamanho do arquivo é grande
  • struts.messages.error.content.type.not.allowed – quando o tipo do conteúdo não é permitido

Isso é tudo pessoal

Compile e execute o projeto no eclipse e vá ao link http://localhost:8080/StrutsHelloWorld/UserImage.jsp

Tela de carga de imagem
struts2-file-upload-example

Tela de carga de imagem no caso de erro
struts2-file-upload-error

Tela de carga de imagem em sucesso
struts2-file-upload-success

Download do código fonte

Clique aqui para fazer o download do código fonte sem os JARs (20KB)

Fonte: viralpatel.net – Viral Patel

Parte 5 – Tutorial de Interceptadores (Interceptors) do Struts2 com Exemplo

Sejam vem vindos a parte 5 de uma série de 7 partes aonde nós vamos examinar aspectos diferentes do framework Struts2. No artigo anterior nós vimos como integrar o framework Tile com o Struts2.

Hoje vamos explorer o mundo dos Interceptadores(Interceptors) no Struts2. Nós vamos ver o que os interceptadores são e como configura-los em uma aplicação web baseada em Struts2.

Interceptadores do Struts 2: Fundamentos

O Struts2 fornece um mecanismo poderoso para controlar uma requisição usando Interceptadores. Interceptadores são responsáveis pela maior parte do processamento de requisições. Eles são invocados pelo controller (controlador) antes e depois de invocar uma action, assim eles ficam entre o controller e a action. Interceptadores executam tarefas como Logging, Validation, File Upload, Double-submit guard e etc.
struts2 request processing lifecycle
O ciclo de vida de processamento do framework Struts2 é bastante discutido na parte 1 do tutorial.

  1. A requisição é gerada pelo usuário e enviada ao Servlet container.
  2. Servlet container invoca o filtro FilterDispatcher que por sua vez determina a ação apropriada.
  3. Um por um dos Intercetors são aplicados ante de chamar a Action. Interceptors executam tarefas como Logging, Validation, File Upload, Double-submit guard e etc.
  4. Action é executada e o Result é gerado pela Action.
  5. A saída da Action é renderizada na view (JSP, Velocity, etc) e o resultado é retornado ao usuário.

Portanto os interceptadores do Struts2 removem funções cross cutting como logging de componentes action e cria uma separação mais limpa do MVC.

O Struts2 vem com uma lista padrão de interceptadores já configurada na aplicação, no arquivo struts-default.xml. Nós podemos criar nossas próprios interceptadores e pluga-los dentro de uma aplicação web baseada em Struts2.

O framework cria um objeto de ActionInvocation que encapsula a action e todos os interceptadores configurados para aquela action. Cada interceptador é chamado antes da action ser chamada. Uma vez que a action é chamada e o resultado é gerado, cada interceptador é chamado de novo na ordem contrária para executar o trabalho de pós-processamento. Interceptadores podem alterar o workflow (fluxo de trabalho) da action. Isso talvez impessa a execução da action.

Nossa Meta

Nossa meta sera criar um interceptador customer MyLoggingInterceptor, o qual irá logar a requisição antes de qualquer action ser chamada. Ele também irá imprimir o nome da classe Action e o tempo de execução em milisegundos.

Criando o Interceptador de Log

Crie uma classe java MyLoggingInterceptor no pacote net.viralpatel.struts2.interceptors e copie o seguinte conteúdo dentro dela.
struts2-logging-interceptors

package net.viralpatel.struts2.interceptor;import com.opensymphony.xwork2.ActionInvocation;

import com.opensymphony.xwork2.interceptor.Interceptor;

public class MyLoggingInterceptor implements Interceptor{

    private static final long serialVersionUID = 1L;

    public String intercept(ActionInvocation invocation) throws Exception {

        String className = invocation.getAction().getClass().getName();

        long startTime = System.currentTimeMillis();

        System.out.println("Before calling action: " + className);

        String result = invocation.invoke();

        long endTime = System.currentTimeMillis();

        System.out.println("After calling action: " + className

                + " Time taken: " + (endTime - startTime) + " ms");

        return result;

    }

    public void destroy() {

        System.out.println("Destroying MyLoggingInterceptor...");

    }

    public void init() {

        System.out.println("Initializing MyLoggingInterceptor...");

    }

}

Configurando o interceptador no struts.xml

Uma vez que nós criamos uma classe interceptadora, tudo o que precisamos fazer é configurar ela no arquivo struts.xml e usa-la com as actions.

Para configurar o interceptador criado há pouco, adicione o seguinte código dentro do struts.xml

<interceptors>    <interceptor name="mylogging"

        class="net.viralpatel.struts2.interceptor.MyLoggingInterceptor">

    </interceptor>

    <interceptor-stack name="loggingStack">

        <interceptor-ref name="mylogging" />

        <interceptor-ref name="defaultStack" />

    </interceptor-stack>

</interceptors>

Esse código deve ser adicionado depois da tag <result-types >  no <package ></package>. Aqui nós configuramos um novo interceptador mylogging com a tag <interceptor >. Também veja que nós definimos um interceptor-stack com o nome de loggingStack. Isso é para ter certeza de que o Struts2 chamará todos os interceptadores padrões assim como chamará o nosso interceptador customizado. Isso é muito importante como por exemplo a lógica de validação não será chamada na nossa aplicação Struts2 se nós ignorarmos o stack padrão (defaultStack) dos interceptadores.

Nós podemos fazer o novo loggingStack como interceptador padrão ou podemos configurar ele em cada nível de action. A fim de faze-lo um stack padrão, nós devemos adicionar o seguinte no struts.xml

<default-interceptor-ref name="loggingStack"></default-interceptor-ref>

Uma vez que nós adicionamos o código acima no Struts.xml, o logginStack será aplicado à todas as action daquele pacote.

Também nós talvez quiséssemos aplicar o interceptador customizado para apenas determinadas actions. Para fazer isso, nós precisamos adicionar a tag interceptor-ref na action.

<action name="login"    class="net.viralpatel.struts2.LoginAction">

    <interceptor-ref name="loggingStack"></interceptor-ref>

    <result name="success" type="tiles">/welcome.tiles</result>

    <result name="error">Login.jsp</result>

</action>

Isso é tudo pessoal

Se nós executarmos nossa aplicação StrutsHelloWorld no ecplipse e olharmos os logs do console, nós vamos encontrar as declarações de log que nós imprimimos no nosso interceptador.

Initializing MyLoggingInterceptor.....

..

..

Before calling action: net.viralpatel.struts2.LoginAction

..

..

After calling action: net.viralpatel.struts2.LoginAction Time taken: 313 ms

..

..

..

Destroying MyLoggingInterceptor...

Download do código fonte

Clique aqui para fazer o download do código fonte sem os JARs (17KB)

Fonte: viralpatel.net – Viral Patel