Fazendo Upload de Arquivos com Servlets e JSP

1. Introdução

Neste tutorial rápido, veremos como fazer upload de um arquivo de um servlet.

Para conseguir isso, veremos primeiro a solução Java EE simples com recursos de upload de arquivo fornecidos pela anotação nativa@MultipartConfig.

Em seguida, examinaremos a biblioteca Apache CommonsFileUpload, para versões anteriores da API Servlet.

2. Usando Java EE@MultipartConfig

A partir da versão 6, o Java EE tem a capacidade de suportar uploads de várias partes prontos para uso.

Como tal, é provavelmente uma opção padrão ao enriquecer um aplicativo Java EE com suporte para upload de arquivo.

Primeiro, vamos adicionar um formulário ao nosso arquivo HTML:


    Choose a file:

O formulário deve ser definido usando o atributoenctype=”multipart/form-data” para sinalizar um upload de várias partes.

A seguir,we’ll want to annotate our HttpServlet with the correct information using the @MultipartConfig annotation:

@MultipartConfig(fileSizeThreshold = 1024 * 1024,
  maxFileSize = 1024 * 1024 * 5,
  maxRequestSize = 1024 * 1024 * 5 * 5)
public class MultipartServlet extends HttpServlet {
    //...
}

Então, vamos ter certeza de que nossa pasta de upload de servidor padrão está definida:

String uploadPath = getServletContext().getRealPath("") + File.separator + UPLOAD_DIRECTORY;
File uploadDir = new File(uploadPath);
if (!uploadDir.exists()) uploadDir.mkdir();

Por fim,we can easily retrieve our inbound File from the request using the getParts() method, e salve no disco:

for (Part part : request.getParts()) {
    fileName = getFileName(part);
    part.write(uploadPath + File.separator + fileName);
}

Observe que, neste exemplo, estamos usando um método auxiliar getFileName ():

private String getFileName(Part part) {
    for (String content : part.getHeader("content-disposition").split(";")) {
        if (content.trim().startsWith("filename"))
            return content.substring(content.indexOf("=") + 2, content.length() - 1);
        }
    return Constants.DEFAULT_FILENAME;
}

Para Servlet 3.1. projetos, podemos usar alternativamente o métodoPart.getSubmittedFileName():

fileName = part.getSubmittedFileName();

3. Usando Apache Commons FileUpload

Se não estivermos em um projeto Servlet 3.0, podemos usar a biblioteca Apache Commons FileUpload diretamente.

3.1. Configuração

Queremos usar as seguintes dependênciaspom.xml para fazer nosso exemplo funcionar:


    commons-fileupload
    commons-fileupload
    1.3.3


    commons-io
    commons-io
    2.6

As versões mais recentes podem ser encontradas com uma pesquisa rápida no Repositório Central do Maven:commons-fileuploadecommons-io.

3.2. Carregar servlet

As três partes principais para incorporar a bibliotecaFileUpload do Apache são as seguintes:

Um formulário de upload em uma página.jsp.
Configurando seu objetoDiskFileItemFactoryeServletFileUpload.
Processando o conteúdo real de um upload de arquivo com várias partes.

O formulário de upload é igual ao da seção anterior.

Vamos continuar criando nosso servlet Java EE.

Em nosso método de processamento de solicitação, podemos envolver osHttpRequest recebidos com uma verificação para ver se é um upload de várias partes.

Também especificaremos quais recursos alocar para o upload do arquivo temporariamente (enquanto está sendo processado) em nossoDiskFileItemFactory.

Por fim,we’ll create a ServletFileUpload object which will represent the actual file itself. Exporá o conteúdo do upload em várias partes para o servidor final de persistência final:

if (ServletFileUpload.isMultipartContent(request)) {

    DiskFileItemFactory factory = new DiskFileItemFactory();
    factory.setSizeThreshold(MEMORY_THRESHOLD);
    factory.setRepository(new File(System.getProperty("java.io.tmpdir")));

    ServletFileUpload upload = new ServletFileUpload(factory);
    upload.setFileSizeMax(MAX_FILE_SIZE);
    upload.setSizeMax(MAX_REQUEST_SIZE);
    String uploadPath = getServletContext().getRealPath("")
      + File.separator + UPLOAD_DIRECTORY;
    File uploadDir = new File(uploadPath);
    if (!uploadDir.exists()) {
        uploadDir.mkdir();
    }
    //...
}

E, então, podemos extrair esses conteúdos e gravá-los no disco:

if (ServletFileUpload.isMultipartContent(request)) {
    //...
    List formItems = upload.parseRequest(request);
    if (formItems != null && formItems.size() > 0) {
        for (FileItem item : formItems) {
        if (!item.isFormField()) {
            String fileName = new File(item.getName()).getName();
            String filePath = uploadPath + File.separator + fileName;
                File storeFile = new File(filePath);
                item.write(storeFile);
                request.setAttribute("message", "File "
                  + fileName + " has uploaded successfully!");
        }
        }
    }
}

4. Executando o Exemplo

Depois de compilar nosso projeto em.war, podemos soltá-lo em nossa instância local do Tomcat e iniciá-lo.

A partir daí, podemos abrir a visualização de upload principal, onde é apresentado um formulário:

Após o upload bem-sucedido do arquivo, devemos ver a mensagem:

Por fim, podemos verificar o local especificado em nosso servlet:

5. Conclusão

É isso aí! Aprendemos como fornecer uploads de arquivos de várias partes usando Java EE, bem como a biblioteca CommonFileUpload do Apache!

Trechos de código, como sempre, podem ser encontradosover on GitHub.

TOC

Fazendo Upload de Arquivos com Servlets e JSP