Artigos Java Testando um FTP Wrapper com JavaServer Faces

Neste artigo construiremos um wrapper para um cliente FTP básico, com funções apenas de conectar, mudar o diretório e listar os arquivos presentes. Nosso wrapper poderá ser utilizado através de interface JSF que construiremos com ajuda do Primefaces, para que não tenhamos muito trabalho com layout e componentes customizados.

Um Wrapper pode servir para adicionar mais funcionalidades a determinado objeto ou mesmo encapsular as funcionalidades já existentes fornecendo um menor nível de acoplamento, o que é muito bom para sistemas extensíveis.

Temos no Java diversos exemplos de Wrappers nativos, por exemplo, a classe Double é um Wrapper para o tipo primitivo double, pois ela adiciona diversas funcionalidades a este tipo primitivo. Projeto

Em nosso projeto usaremos JSF para que o usuário posso executar os comandos básicos no cliente FTP, para isso precisamos primeiro configurar nosso projeto, e na Figura 1 temos a estrutura de diretório usado.

Estrutura do Projeto

Figura 1. Estrutura do Projeto

Perceba que estamos usando Maven como gerenciador de dependências e nosso pom.xml contém as bibliotecas necessárias para funcionamento do nosso projeto, tais como JSF e Primefaces, como mostra a Listagem 1. Usamos o Primefaces apenas para dar um visual melhor a nossa interface, mas você poderá usar o JSF puro apenas para efeito didático.

Listagem 1. pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <groupId>br.com</groupId>
       <artifactId>lab</artifactId>
       <packaging>war</packaging>
       <version>0.0.1-SNAPSHOT</version>
       <name>lab Maven Webapp</name>
       <url>http://maven.apache.org</url>
       <dependencies>

       <dependency>
       <groupId>commons-net</groupId>
       <artifactId>commons-net</artifactId>
       <version>2.0</version>
</dependency>


             <dependency>
                    <groupId>org.omnifaces</groupId>
                    <artifactId>omnifaces</artifactId>
                    <version>1.11-M1</version>
             </dependency>

             <dependency>
                    <groupId>com.sun.faces</groupId>
                    <artifactId>jsf-api</artifactId>
                    <version>2.1.6</version>
             </dependency>

             <dependency>
                    <groupId>com.sun.faces</groupId>
                    <artifactId>jsf-impl</artifactId>
                    <version>2.1.6</version>
             </dependency>

             <dependency>
                    <groupId>org.primefaces.extensions</groupId>
                    <artifactId>primefaces-extensions</artifactId>
                    <version>0.7.1</version>
             </dependency>

             <dependency>
                    <groupId>org.primefaces</groupId>
                    <artifactId>primefaces</artifactId>
                    <version>3.5</version>
             </dependency>

             <dependency>
                    <groupId>org.primefaces.themes</groupId>
                    <artifactId>bootstrap</artifactId>
                    <version>1.0.9</version>
             </dependency>
       </dependencies>
       <build>
             <finalName>lab</finalName>
       </build>
</project>

Vamos explicar o uso das bibliotecas importadas:

  • omnifaces: A importação do omnifaces, em nosso caso específico, serve apenas para uso da classe UnmappedResourceHandler.

Quando vamos mapear um recurso em nossa aplicação (por recurso entenda imagens, CSS, JavaScript e quaisquer outros arquivos externos), nós precisamos definir o caminho onde o mesmo se encontra, mas em se tratando de um projeto web, os recursos geralmente ficam alocados na pasta “WeContent/resources”. Por isso, vamos apontar este caminho em um arquivo CSS por exemplo, usando a seguinte estrutura:

body {
     background: url("#{resource['css/images/background.png']}");
}

Agora imagine se tivéssemos um layout Bootstrap, com mais de 500 imagens dispersas por vários arquivos CSS: pense no trabalho que você teria em mudar caminho por caminho. Pensando nisso, a classe UnmappedResourceHandler faz automaticamente o mapeamento de todos esses arquivos, adicionando o caminho “javax.faces.resource” ao seu caminho, que é exatamente o que o EL Expression #{resource} produz. Isso só é possível porque no arquivo web.xml adicionamos o url-pattern “/javax.faces.resource/*” e no faces-config.xml temos o resource-handler mapeado para a classe UnmappedResourceHandler.

Então, ao invés de usarmos o EL Expression no background:url, podemos deixar no padrão comumente utilizado:

body {
 background: url("images/background.png");
}

  • Com.sun.faces: Para uso do JSF;
  • Primefaces: Para usar componentes customizados e ter um melhor design;
  • Commons-net: O principal import para nosso artigo é este, pois é através deste jar que faremos uso da classe FTPClient fornecida pelo Apache.

Já que citamos o faces-config.xml, segue na Listagem 2 como realizamos sua declaração.

Listagem 2. faces-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<faces-config version="2.1" xmlns="http://java.sun.com/xml/ns/javaee"
       xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_2_1.xsd">
       <application>
             <resource-handler>org.omnifaces.resourcehandler.UnmappedResourceHandler</resource-handler>
       </application>
</faces-config>

Para configuração do projeto falta apenas o web.xml então podemos começar a desenvolver nosso wrapper, como mostra a Listagem 3.

Listagem 3. web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
       xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
 http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
       id="WebApp_ID">
       <display-name>LAB</display-name>

       <welcome-file-list>
             <welcome-file>index.xhtml</welcome-file>
       </welcome-file-list>

       <context-param>
    <param-name>primefaces.THEME</param-name>
    <param-value>bootstrap</param-value>
       </context-param>

       <!-- Configuracao DO JSF -->
       <servlet>
             <servlet-name>Faces Servlet</servlet-name>
             <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
             <load-on-startup>1</load-on-startup>
       </servlet>
       <servlet-mapping>
             <servlet-name>Faces Servlet</servlet-name>
             <url-pattern>*.xhtml</url-pattern>
             <url-pattern>/javax.faces.resource/*</url-pattern>
       </servlet-mapping>
</web-app>

São três pontos específicos configurados em nosso web.xml, primeiramente o arquivo inicial que será carregado ao acessar o link do projeto, em nosso caso o index.xhtml, em segundo lugar o tema usado pelo Primefaces, que é o BOOTSTRAP, e por último e mais importante são os arquivos que o JSF irá renderizar, neste caso, todos os com final *.xhml ou que tenham javax.faces.resource em seu path.

Vamos começar a construir a classe FtpWrapper, presente na Listagem 4.

Listagem 4. FtpWrapper.java

package br.com.lab;

import java.io.IOException;
import java.net.SocketException;

import org.apache.commons.net.ftp.FTPClient;

public class FtpWrapper {

         private static FtpWrapper instance;
         private FTPClient ftp;

         private FtpWrapper(){
                   this.ftp = new FTPClient();
         }

         public static FtpWrapper getInstance(){
                   if (instance == null){
                            instance = new FtpWrapper();
                   }
                   return instance;
         }

         public String currentDirectory(){
                   try {
                            checkIfConected();
                            return ftp.printWorkingDirectory();
                   } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                            return null;
                   }
         }

         private void checkIfConected(){
                   if (!ftp.isConnected()){
                            throw new RuntimeException("Não está conectado ao FTP");
                   }
         }

         public void connect(String hostname){
                   try {
                            if (ftp.isConnected()){
                                      throw new RuntimeException("Já conectado");
                            }
                            ftp.connect(hostname);
                   } catch (SocketException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                   } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                   }
         }

         public void login(String username, String password){
                   try {
                            ftp.login(username, password);
                   } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                   }
         }

         public void changeWorkingDirectory(String targetDir){
                   try {
                            checkIfConected();
                            ftp.changeWorkingDirectory(targetDir);
                   } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                   }
         }

         public String[] listNames(){
                   try {
                            checkIfConected();
                            return ftp.listNames();
                   } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                            return null;
                   }
         }
}

Nessa classe a ideia é que todos os métodos de um FTP sejam encapsulados pelo nosso wrapper, deixando transparente para quem o usa qual provider FTP está sendo usado, seja do pacote Apache ou do pacote “sun”. Assim, se decidirmos mais à frente mudar por algum motivo o provider do FTP então o único trabalho será refazer os pontos da classe FtpWrapper, mas para todo o resto da aplicação isso será totalmente transparente.

Para aqueles que usavam a classe FtpClient do pacote sun.net.ftp desde o Java 6, devem ter percebido que ouve uma mudança drástica desta classe a partir do Java 7 em diante, tornando-se quase impossível reaproveitar desenvolvimentos já realizados. Para quem teve a genialidade de usar um wrapper desde o começo então o impacto será menor.

Perceba que estamos usando um padrão de projeto Singleton para garantir apenas uma instância desta classe durante toda a aplicação. O atributo “ftp” é quem de fato faz a conexão com o provider que escolhemos, em nosso caso, o FTPClient do pacote “org.apache.commons.net.ftp”.

Todas as chamadas dos nossos métodos farão referência para o atributo “ftp”. Por exemplo, o método checkIfConected método checa se estamos conectados ao FTP, caso contrário, é lançada uma exceção para evitar qualquer tarefa com o FTP desconectado.

O método String currentDirectory primeiro faz chamada ao checkIfConected, que irá interromper a execução imediatamente se o FTP não estiver conectado, depois chamamos o printWorkingDirectory(), que irá retornar o diretório atual que estamos conectados no FTP, lembrando que esse comando pode alterar de acordo com o provider (classe FTP) utilizado.

De acordo com o “hostname” passado (por exemplo: ftp.seudominio.com.br) realizamos a conexão a este host, mas antes checamos se já não temos uma conexão estabelecida.

Depois de conectado realizamos o login através do usuário e senha passados.

Podemos também mudar o diretório que estamos visualizando, passando como parâmetro o “targetDir” que corresponde ao diretório destino.

Por último retornamos uma lista com o nome dos arquivos do diretório atual.

A alteração do provider implicará na mudança dos métodos obviamente, mas será muito menos impactante do que mudar toda a aplicação.

Vamos agora iniciar a criação do ManagedBean que irá fazer a interface entre a página HTML (em JSF) e o FtpWrapper, como mostra a Listagem 5.

Listagem 5. FtpMB.java

package br.com.lab;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;

@ManagedBean(name = "ftpMB")
@ViewScoped
public class FtpMB {

         private String hostName, username, password, newDir;
         private List<String> arquivos;

         private void showMessage(String message) {
                   FacesContext fc = FacesContext.getCurrentInstance();
                   fc.addMessage(null, new FacesMessage(message));
         }

         public void conectar() {
                   try {
                            FtpWrapper.getInstance().connect(hostName);
                            FtpWrapper.getInstance().login(username, password);
                            newDir = FtpWrapper.getInstance().currentDirectory();
                            showMessage("Conectado com sucesso em " + hostName);
                   } catch (Exception e) {
                            showMessage(e.getMessage());
                  }
         }

         public void mudarDiretorio() {
                   try {
                            FtpWrapper.getInstance().changeWorkingDirectory(newDir);
                            showMessage("Diretório alterado para "+newDir);
                   } catch (Exception e) {
                            showMessage(e.getMessage());
                   }
         }

         public void listarArquivos() {
                   try {
                            arquivos = new ArrayList<String>(Arrays.asList(FtpWrapper
                                               .getInstance().listNames()));
                            showMessage("Arquivos carregados com sucesso");
                   } catch (Exception e) {
                            showMessage(e.getMessage());
                   }
         }

         public String getHostName() {
                   return hostName;
         }

         public void setHostName(String hostName) {
                   this.hostName = hostName;
         }

         public String getUsername() {
                   return username;
         }

         public void setUsername(String username) {
                   this.username = username;
         }

         public String getPassword() {
                   return password;
         }

         public void setPassword(String password) {
                   this.password = password;
         }

         public String getNewDir() {
                   return newDir;
         }

         public void setNewDir(String newDir) {
                   this.newDir = newDir;
         }

         public List<String> getArquivos() {
                   return arquivos;
         }

         public void setArquivos(List<String> arquivos) {
                   this.arquivos = arquivos;
         }

}

O nosso ManagedBean usa o nome “ftpMB” para ser referenciado na página JSF, além disso, usamos o @ViewScoped para garantir que o estado do objeto seja mantido enquanto o usuário não mudar de página.

São cinco os atributos que usaremos durante toda a aplicação:

  • o hostName, username e password servem para conexão ao FTP;
  • o atributo newDir irá possuir o diretório atual que estamos trabalhando e também possibilitará a mudança para um novo diretório caso o usuário deseje;
  • o atributo “arquivos” do tipo “List” possuirá a lista com o nome de todos os arquivos do diretório atual, quando requisitado pelo usuário.

O método showMEssage() irá mostrar determinada mensagem na localização da tag <h:messages> que veremos na página XHTML.

O método conectar() faz a conexão e login no FTP usando o FtpWrapper sempre com o método getInstance(), que retorna à instância atual do nosso wrapper, ou cria uma nova caso ainda não exista. Perceba que além da conexão ao FTP ainda retornamos o diretório atual através do método currentdirectory(), finalizando mostramos a mensagem através do showMessage().

O método mudarDiretorio permite a mudança do diretório atual para um novo diretório escolhido pelo usuário.

No método listarArquivos chamamos o “listNames()” do nosso Wrapper para capturar a lista com o nome dos arquivos no diretório atual, como precisamos de um List, então fazemos a conversão para tal usando o Arrays.asList(), pois o listNames() retorna um vetor do tipo String[]. Os últimos métodos são os getters e setters necessários para que o JSF consiga fazer o binding entre o valor do XHTML e o ManagedBean.

Enfim podemos criar a página XHTML que irá realizar as operações de conexão ao FTP, mudança de diretório e listagem de arquivos, como mostra a Listagem 6. Lembrando que nosso objetivo não é criar um cliente FTP completo, mas mostrar como o encapsulamento pode ser realizado e acessado através de uma interface JSF.

Listagem 6. index.xhtml

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
       xmlns:h="http://java.sun.com/jsf/html"
       xmlns:f="http://java.sun.com/jsf/core"
       xmlns:ui="http://java.sun.com/jsf/facelets"
       xmlns:p="http://primefaces.org/ui">

<h:head>
       <title>LAB</title>
</h:head>
<h:body>
       <h:form prependId="false">


             <h:messages />

             <p:panelGrid columns="2">
                    <label>Host</label>
                    <p:inputText value="#{ftpMB.hostName}" />

                    <label>Usuário</label>
                    <p:inputText value="#{ftpMB.username}" />

                    <label>Senha</label>
                    <p:password value="#{ftpMB.password}" />

                    <label>Diretório</label>
                    <p:inputText value="#{ftpMB.newDir}" />

             </p:panelGrid>

             <p:commandButton value="Conectar" actionListener="#{ftpMB.conectar}"
                    update="@form" />
             <p:commandButton value="Mudar diretório"
                    actionListener="#{ftpMB.mudarDiretorio}" update="@form" />
             <p:commandButton value="Listar Arquivos"
                    actionListener="#{ftpMB.listarArquivos}" update="@form" />

             <h:dataTable value="#{ftpMB.arquivos}" var="arq" id="dataTable">
                    <h:column>
                           #{arq}
                </h:column>
             </h:dataTable>

       </h:form>
</h:body>
</html>

Dentro da tag <h:form> temos a tag <h:messages> que será responsável por mostrar as mensagens que estão vindo no ManagedBean, através do método showMessage() que mostramos anteriormente. O panelGrid contém quatro campos (host, usuário, senha e diretório) onde todos os valores digitados só são submetidos ao managedbean quando um dos botões a seguir são acionados:

  • Botão Conectar: Usa um componente commandButton do Primefaces que chama um actionListener do ManagedBean ftpMB, que é o método conectar(). Após a requisição é realizado um update em todo formulário, pois trata-se de uma requisição ajax. Optamos por usar o @form no update para que todo conteúdo dentro da tag “<form>” seja atualizado, mas você poderia especificar campo a campo que deseja atualizar.
  • Botão Mudar Diretório: Usa a mesma estrutura do botão Conectar porém este captura o valor digitado no campo “Diretório” e realiza a mudança do diretório atual para este novo diretório.
  • Botão Listar Arquivos: Quando acionado o atributo “arquivos” é populado e o dataTable do JSF mostra os valores contidos nesta List. Assim que a propriedade update=@form é chamado o dataTable é imediatamente atualizado com os valores que foram populados no ManagedBean.

O objetivo principal deste artigo foi demonstrar como é útil utilizar um wrapper para manter um menor nível de acoplamento no seu projeto. Em nosso caso usamos o JSF para fazer uso desse Wrapper, mas você poderia usar uma interface Android, Swing ou qualquer outro que sua regra de negócio exigir.