¿Cómo subir archivos al servidor usando JSP / Servlet?

¿Cómo puedo subir archivos al servidor usando JSP / Servlet? Intenté esto:

<form action="upload" method="post">
    <input type="text" name="description" />
    <input type="file" name="file" />
    <input type="submit" />
</form>

Sin embargo, solo obtengo el nombre del archivo, no el contenido del archivo. Cuando agrego enctype="multipart/form-data"a la <form>, entoncesrequest.getParameter() regresa null.

Durante la investigación me topé con Apache Common FileUpload . Intenté esto:

FileItemFactory factory = new DiskFileItemFactory();
ServletFileUpload upload = new ServletFileUpload(factory);
List items = upload.parseRequest(request); // This line is where it died.

Desafortunadamente, el servlet arrojó una excepción sin un mensaje claro y una causa. Aquí está el stacktrace:

SEVERE: Servlet.service() for servlet UploadServlet threw exception
javax.servlet.ServletException: Servlet execution threw an exception
    at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:313)
    at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
    at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:233)
    at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:191)
    at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:127)
    at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:102)
    at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:109)
    at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:298)
    at org.apache.coyote.http11.Http11Processor.process(Http11Processor.java:852)
    at org.apache.coyote.http11.Http11Protocol$Http11ConnectionHandler.process(Http11Protocol.java:588)
    at org.apache.tomcat.util.net.JIoEndpoint$Worker.run(JIoEndpoint.java:489)
    at java.lang.Thread.run(Thread.java:637)

Introducción

Para examinar y seleccionar un archivo para cargar, necesita un <input type="file">campo HTML en el formulario. Como se indica en la especificación HTML , debe usar el POSTmétodo y el enctypeatributo del formulario debe establecerse en "multipart/form-data".

<form action="upload" method="post" enctype="multipart/form-data">
    <input type="text" name="description" />
    <input type="file" name="file" />
    <input type="submit" />
</form>

Después de enviar dicho formulario, los datos del formulario multiparte binario están disponibles en el cuerpo de la solicitud en un formato diferente al que enctypeno está configurado.

Antes de Servlet 3.0, la API de Servlet no era compatible de forma nativa multipart/form-data. Solo admite el tipo de formulario predeterminado de application/x-www-form-urlencoded. El request.getParameter()y consortes habría todos regresan nullal utilizar los datos del formulario de varias partes. Aquí es donde el conocido Apache Commons FileUpload entró en escena la .

¡No lo analices manualmente!

En teoría, puede analizar el cuerpo de la solicitud en función de ServletRequest#getInputStream(). Sin embargo, este es un trabajo preciso y tedioso que requiere un conocimiento preciso de RFC2388 . No debe intentar hacer esto por su cuenta o copiar un código sin biblioteca propio que se encuentre en otra parte de Internet. Muchas fuentes en línea han fallado mucho en esto, como roseindia.net. Consulte también carga de archivo pdf . Debería utilizar una biblioteca real que millones de usuarios usan (¡y se prueban implícitamente!) Durante años. Dicha biblioteca ha demostrado su robustez.

Cuando ya esté en Servlet 3.0 o más reciente, use API nativa

Si está utilizando al menos Servlet 3.0 (Tomcat 7, Jetty 9, JBoss AS 6, GlassFish 3, etc.), puede usar la API estándar provista HttpServletRequest#getPart()para recopilar los elementos de datos de formularios individuales (la mayoría de las implementaciones de Servlet 3.0 en realidad usan Apache Commons FileUpload debajo de las cubiertas para esto!). Además, los campos de formulario normales están disponibles de getParameter()la manera habitual.

Primero anote su servlet con el @MultipartConfigfin de permitirle reconocer y admitir multipart/form-datasolicitudes y así ponerse getPart()a trabajar:

@WebServlet("/upload")
@MultipartConfig
public class UploadServlet extends HttpServlet {
    // ...
}

Luego, implemente doPost()lo siguiente:

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    String description = request.getParameter("description"); // Retrieves <input type="text" name="description">
    Part filePart = request.getPart("file"); // Retrieves <input type="file" name="file">
    String fileName = Paths.get(filePart.getSubmittedFileName()).getFileName().toString(); // MSIE fix.
    InputStream fileContent = filePart.getInputStream();
    // ... (do your job here)
}

Tenga en cuenta el Path#getFileName(). Esta es una solución de MSIE para obtener el nombre del archivo. Este navegador envía incorrectamente la ruta completa del archivo a lo largo del nombre en lugar de solo el nombre del archivo.

En caso de que tenga una <input type="file" name="file" multiple="true" />carga de varios archivos, recójalos de la siguiente manera (desafortunadamente no existe tal método request.getParts("file")):

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    // ...
    List<Part> fileParts = request.getParts().stream().filter(part -> "file".equals(part.getName()) && part.getSize() > 0).collect(Collectors.toList()); // Retrieves <input type="file" name="file" multiple="true">

    for (Part filePart : fileParts) {
        String fileName = Paths.get(filePart.getSubmittedFileName()).getFileName().toString(); // MSIE fix.
        InputStream fileContent = filePart.getInputStream();
        // ... (do your job here)
    }
}

Cuando aún no esté en Servlet 3.1, obtenga manualmente el nombre del archivo enviado

Tenga en cuenta que Part#getSubmittedFileName()se introdujo en Servlet 3.1 (Tomcat 8, Jetty 9, WildFly 8, GlassFish 4, etc.). Si aún no está en Servlet 3.1, necesita un método de utilidad adicional para obtener el nombre del archivo enviado.

private static String getSubmittedFileName(Part part) {
    for (String cd : part.getHeader("content-disposition").split(";")) {
        if (cd.trim().startsWith("filename")) {
            String fileName = cd.substring(cd.indexOf('=') + 1).trim().replace("\"", "");
            return fileName.substring(fileName.lastIndexOf('/') + 1).substring(fileName.lastIndexOf('\\') + 1); // MSIE fix.
        }
    }
    return null;
}

String fileName = getSubmittedFileName(filePart);

Tenga en cuenta la corrección de MSIE para obtener el nombre del archivo. Este navegador envía incorrectamente la ruta completa del archivo a lo largo del nombre en lugar de solo el nombre del archivo.

Cuando aún no esté en Servlet 3.0, use Apache Commons FileUpload

Si aún no está en Servlet 3.0 (¿no es hora de actualizar?), La práctica común es utilizar Apache Commons FileUpload para analizar las solicitudes de datos de formularios de varias partes. Tiene una excelente Guía del usuario y preguntas frecuentes ( revise cuidadosamente ambas). También está el O'Reilly (" cos ") MultipartRequest, pero tiene algunos errores (menores) y ya no se mantiene activamente durante años. No recomendaría usarlo. Apache Commons FileUpload todavía se mantiene activamente y actualmente es muy maduro.

Para utilizar Apache Commons FileUpload, debe tener al menos los siguientes archivos en su aplicación web /WEB-INF/lib:

• commons-fileupload.jar
• commons-io.jar

Su intento inicial falló muy probablemente porque olvidó los IO comunes.

Aquí hay un ejemplo inicial de cómo puede ser doPost()tu UploadServletcuando usas Apache Commons FileUpload:

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    try {
        List<FileItem> items = new ServletFileUpload(new DiskFileItemFactory()).parseRequest(request);
        for (FileItem item : items) {
            if (item.isFormField()) {
                // Process regular form field (input type="text|radio|checkbox|etc", select, etc).
                String fieldName = item.getFieldName();
                String fieldValue = item.getString();
                // ... (do your job here)
            } else {
                // Process form file field (input type="file").
                String fieldName = item.getFieldName();
                String fileName = FilenameUtils.getName(item.getName());
                InputStream fileContent = item.getInputStream();
                // ... (do your job here)
            }
        }
    } catch (FileUploadException e) {
        throw new ServletException("Cannot parse multipart request.", e);
    }

    // ...
}

Es muy importante que usted no llama getParameter(), getParameterMap(), getParameterValues(), getInputStream(), getReader(), etc en la misma solicitud de antemano. De lo contrario, el contenedor de servlet leerá y analizará el cuerpo de la solicitud y, por lo tanto, Apache Commons FileUpload obtendrá un cuerpo de solicitud vacío. Consulte también ao ServletFileUpload # parseRequest (request) devuelve una lista vacía .

Tenga en cuenta el FilenameUtils#getName(). Esta es una solución de MSIE para obtener el nombre del archivo. Este navegador envía incorrectamente la ruta completa del archivo a lo largo del nombre en lugar de solo el nombre del archivo.

Alternativamente, también puede envolver todo esto de manera Filterque lo analice todo automáticamente y vuelva a colocar el material en el mapa de parámetros de la solicitud para que pueda continuar utilizando request.getParameter()la forma habitual y recuperar el archivo cargado request.getAttribute(). Puedes encontrar un ejemplo en este artículo de blog .

Solución alternativa para el error GlassFish3 de getParameter()volver aúnnull

Tenga en cuenta que las versiones de Glassfish anteriores a 3.1.2 tenían un error en el que getParameter()aún se devuelve null. Si está apuntando a dicho contenedor y no puede actualizarlo, entonces necesita extraer el valor getPart()con la ayuda de este método de utilidad:

private static String getValue(Part part) throws IOException {
    BufferedReader reader = new BufferedReader(new InputStreamReader(part.getInputStream(), "UTF-8"));
    StringBuilder value = new StringBuilder();
    char[] buffer = new char[1024];
    for (int length = 0; (length = reader.read(buffer)) > 0;) {
        value.append(buffer, 0, length);
    }
    return value.toString();
}

String description = getValue(request.getPart("description")); // Retrieves <input type="text" name="description">

Guardando el archivo cargado (¡no use getRealPath()ni part.write()!)

Diríjase a las siguientes respuestas para obtener detalles sobre cómo guardar correctamente el obtenido InputStream(la fileContentvariable como se muestra en los fragmentos de código anteriores) en el disco o la base de datos:

• Forma recomendada de guardar archivos cargados en una aplicación de servlet
• ¿Cómo cargar una imagen y guardarla en la base de datos?
• ¿Cómo convertir parte a blob para poder almacenarlo en MySQL?

Sirviendo archivos cargados

Diríjase a las siguientes respuestas para obtener detalles sobre cómo servir correctamente el archivo guardado desde el disco o la base de datos al cliente:

• Cargue imágenes desde fuera de la carpeta webapps / webcontext / deploy usando la etiqueta <h: graphicImage> o <img>
• ¿Cómo recuperar y mostrar imágenes de una base de datos en una página JSP?
• La forma más sencilla de servir datos estáticos desde fuera del servidor de aplicaciones en una aplicación web Java
• Plantilla abstracta para servlet de recursos estáticos que admite almacenamiento en caché HTTP

Ajaxificando el formulario

Diríjase a las siguientes respuestas sobre cómo cargar usando Ajax (y jQuery). ¡Tenga en cuenta que el código de servlet para recopilar los datos del formulario no necesita ser cambiado para esto! Solo se puede cambiar la forma en que responde, pero esto es bastante trivial (es decir, en lugar de reenviar a JSP, simplemente imprima JSON o XML o incluso texto sin formato dependiendo de lo que el script responsable de la llamada Ajax esté esperando).

• ¿Cómo subir archivos al servidor usando JSP / Servlet y Ajax?
• Enviar un archivo como multiparte a través de xmlHttpRequest
• Carga de archivos HTML5 a Java Servlet

Espero que todo esto ayude :)

Si usa Spring MVC, así es como: (Dejo esto aquí en caso de que alguien lo encuentre útil).

Utilice un formulario con el enctypeatributo establecido en " multipart/form-data" (igual que la respuesta de BalusC)

<form action="upload" method="post" enctype="multipart/form-data">
    <input type="file" name="file" />
    <input type="submit" value="Upload"/>
</form>

En su controlador, asigne el parámetro de solicitud filepara MultipartFileescribir de la siguiente manera:

@RequestMapping(value = "/upload", method = RequestMethod.POST)
public void handleUpload(@RequestParam("file") MultipartFile file) throws IOException {
    if (!file.isEmpty()) {
            byte[] bytes = file.getBytes(); // alternatively, file.getInputStream();
            // application logic
    }
}

Puede obtener el nombre de archivo y el tamaño usando MultipartFile's getOriginalFilename()y getSize().

He probado esto con la versión Spring 4.1.1.RELEASE.

Necesita que el common-io.1.4.jararchivo se incluya en sulib directorio, o si está trabajando en cualquier editor, como NetBeans, debe ir a las propiedades del proyecto y simplemente agregar el archivo JAR y listo.

Para obtener el common.io.jararchivo, simplemente búscalo en Google o simplemente ve al sitio web de Apache Tomcat , donde obtienes la opción de descargarlo gratuitamente. Pero recuerde una cosa: descargue el archivo ZIP binario si es un usuario de Windows.

Sin componente o biblioteca externa en Tomcat 6 o 7

Habilitar la carga en el archivo web.xml :

http://joseluisbz.wordpress.com/2014/01/17/manually-installing-php-tomcat-and-httpd-lounge/#Enabling%20File%20Uploads .

<servlet>
    <servlet-name>jsp</servlet-name>
    <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
    <multipart-config>
      <max-file-size>3145728</max-file-size>
      <max-request-size>5242880</max-request-size>
    </multipart-config>
    <init-param>
        <param-name>fork</param-name>
        <param-value>false</param-value>
    </init-param>
    <init-param>
        <param-name>xpoweredBy</param-name>
        <param-value>false</param-value>
    </init-param>
    <load-on-startup>3</load-on-startup>
</servlet>

COMO PUEDES VER :

    <multipart-config>
      <max-file-size>3145728</max-file-size>
      <max-request-size>5242880</max-request-size>
    </multipart-config>

Carga de archivos usando JSP. Archivos:

En el archivo html

<form method="post" enctype="multipart/form-data" name="Form" >

  <input type="file" name="fFoto" id="fFoto" value="" /></td>
  <input type="file" name="fResumen" id="fResumen" value=""/>

En el archivo JSP o Servlet

    InputStream isFoto = request.getPart("fFoto").getInputStream();
    InputStream isResu = request.getPart("fResumen").getInputStream();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    byte buf[] = new byte[8192];
    int qt = 0;
    while ((qt = isResu.read(buf)) != -1) {
      baos.write(buf, 0, qt);
    }
    String sResumen = baos.toString();

Edite su código según los requisitos del servlet, como max-file-size , max-request-size y otras opciones que puede configurar ...

Estoy usando Servlet común para cada formulario HTML, ya sea que tenga archivos adjuntos o no. Este Servlet devuelve un lugar TreeMapdonde las claves son jsp name Los parámetros y los valores son Entradas de usuario y guarda todos los archivos adjuntos en un directorio fijo y luego cambia el nombre del directorio de su elección. Aquí Connections es nuestra interfaz personalizada que tiene un objeto de conexión. Creo que esto te ayudará

public class ServletCommonfunctions extends HttpServlet implements
        Connections {

    private static final long serialVersionUID = 1L;

    public ServletCommonfunctions() {}

    protected void doPost(HttpServletRequest request,
            HttpServletResponse response) throws ServletException,
            IOException {}

    public SortedMap<String, String> savefilesindirectory(
            HttpServletRequest request, HttpServletResponse response)
            throws IOException {
        // Map<String, String> key_values = Collections.synchronizedMap( new
        // TreeMap<String, String>());
        SortedMap<String, String> key_values = new TreeMap<String, String>();
        String dist = null, fact = null;
        PrintWriter out = response.getWriter();
        File file;
        String filePath = "E:\\FSPATH1\\2KL06CS048\\";
        System.out.println("Directory Created   ????????????"
            + new File(filePath).mkdir());
        int maxFileSize = 5000 * 1024;
        int maxMemSize = 5000 * 1024;
        // Verify the content type
        String contentType = request.getContentType();
        if ((contentType.indexOf("multipart/form-data") >= 0)) {
            DiskFileItemFactory factory = new DiskFileItemFactory();
            // maximum size that will be stored in memory
            factory.setSizeThreshold(maxMemSize);
            // Location to save data that is larger than maxMemSize.
            factory.setRepository(new File(filePath));
            // Create a new file upload handler
            ServletFileUpload upload = new ServletFileUpload(factory);
            // maximum file size to be uploaded.
            upload.setSizeMax(maxFileSize);
            try {
                // Parse the request to get file items.
                @SuppressWarnings("unchecked")
                List<FileItem> fileItems = upload.parseRequest(request);
                // Process the uploaded file items
                Iterator<FileItem> i = fileItems.iterator();
                while (i.hasNext()) {
                    FileItem fi = (FileItem) i.next();
                    if (!fi.isFormField()) {
                        // Get the uploaded file parameters
                        String fileName = fi.getName();
                        // Write the file
                        if (fileName.lastIndexOf("\\") >= 0) {
                            file = new File(filePath
                                + fileName.substring(fileName
                                        .lastIndexOf("\\")));
                        } else {
                            file = new File(filePath
                                + fileName.substring(fileName
                                        .lastIndexOf("\\") + 1));
                        }
                        fi.write(file);
                    } else {
                        key_values.put(fi.getFieldName(), fi.getString());
                    }
                }
            } catch (Exception ex) {
                System.out.println(ex);
            }
        }
        return key_values;
    }
}

Para Spring MVC , he estado intentando durante horas hacer esto y logré tener una versión más simple que funcionó para tomar la entrada de datos y la imagen.

<form action="/handleform" method="post" enctype="multipart/form-data">
  <input type="text" name="name" />
  <input type="text" name="age" />
  <input type="file" name="file" />
  <input type="submit" />
</form>

Controlador para manejar

@Controller
public class FormController {
    @RequestMapping(value="/handleform",method= RequestMethod.POST)
    ModelAndView register(@RequestParam String name, @RequestParam int age, @RequestParam MultipartFile file)
            throws ServletException, IOException {

        System.out.println(name);
        System.out.println(age);
        if(!file.isEmpty()){
            byte[] bytes = file.getBytes();
            String filename = file.getOriginalFilename();
            BufferedOutputStream stream =new BufferedOutputStream(new FileOutputStream(new File("D:/" + filename)));
            stream.write(bytes);
            stream.flush();
            stream.close();
        }
        return new ModelAndView("index");
    }
}

Espero eso ayude :)

Otra fuente de este problema ocurre si está utilizando Geronimo con su Tomcat incorporado. En este caso, después de muchas iteraciones de probar commons-io y commons-fileupload, el problema surge de un cargador de clases padre que maneja los frascos commons-xxx. Esto tiene que ser prevenido. El choque siempre ocurrió a las:

fileItems = uploader.parseRequest(request);

Tenga en cuenta que el tipo de lista de elementos de archivo ha cambiado con la versión actual de commons-fileupload para ser específicamente List<FileItem>opuesta a las versiones anteriores donde era genérica List.

Agregué el código fuente de commons-fileupload y commons-io en mi proyecto Eclipse para rastrear el error real y finalmente obtuve una idea. Primero, la excepción lanzada es de tipo Throwable, no la FileIOException establecida ni la Excepción (estas no quedarán atrapadas). En segundo lugar, el mensaje de error es ofuscatorio porque indica que la clase no se encuentra porque axis2 no pudo encontrar commons-io. Axis2 no se utiliza en mi proyecto, pero existe como una carpeta en el subdirectorio del repositorio de Geronimo como parte de la instalación estándar.

Finalmente, encontré 1 lugar que planteaba una solución de trabajo que resolvió con éxito mi problema. Debe ocultar los archivos jar del cargador principal en el plan de implementación. Esto se puso en geronimo-web.xml con mi archivo completo que se muestra a continuación.

Pasted from <http://osdir.com/ml/user-geronimo-apache/2011-03/msg00026.html> 



<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<web:web-app xmlns:app="http://geronimo.apache.org/xml/ns/j2ee/application-2.0" xmlns:client="http://geronimo.apache.org/xml/ns/j2ee/application-client-2.0" xmlns:conn="http://geronimo.apache.org/xml/ns/j2ee/connector-1.2" xmlns:dep="http://geronimo.apache.org/xml/ns/deployment-1.2" xmlns:ejb="http://openejb.apache.org/xml/ns/openejb-jar-2.2" xmlns:log="http://geronimo.apache.org/xml/ns/loginconfig-2.0" xmlns:name="http://geronimo.apache.org/xml/ns/naming-1.2" xmlns:pers="http://java.sun.com/xml/ns/persistence" xmlns:pkgen="http://openejb.apache.org/xml/ns/pkgen-2.1" xmlns:sec="http://geronimo.apache.org/xml/ns/security-2.0" xmlns:web="http://geronimo.apache.org/xml/ns/j2ee/web-2.0.1">
    <dep:environment>
        <dep:moduleId>
            <dep:groupId>DataStar</dep:groupId>
            <dep:artifactId>DataStar</dep:artifactId>
            <dep:version>1.0</dep:version>
            <dep:type>car</dep:type>
        </dep:moduleId>

<!--Don't load commons-io or fileupload from parent classloaders-->
        <dep:hidden-classes>
            <dep:filter>org.apache.commons.io</dep:filter>
            <dep:filter>org.apache.commons.fileupload</dep:filter>
        </dep:hidden-classes>
        <dep:inverse-classloading/>        


    </dep:environment>
    <web:context-root>/DataStar</web:context-root>
</web:web-app>

Aquí hay un ejemplo usando apache commons-fileupload:

// apache commons-fileupload to handle file upload
DiskFileItemFactory factory = new DiskFileItemFactory();
factory.setRepository(new File(DataSources.TORRENTS_DIR()));
ServletFileUpload fileUpload = new ServletFileUpload(factory);

List<FileItem> items = fileUpload.parseRequest(req.raw());
FileItem item = items.stream()
  .filter(e ->
  "the_upload_name".equals(e.getFieldName()))
  .findFirst().get();
String fileName = item.getName();

item.write(new File(dir, fileName));
log.info(fileName);

La forma más sencilla podría ser para archivos y controles de entrada, sin un billón de bibliotecas:

  <%
  if (request.getContentType()==null) return;
  // for input type=text controls
  String v_Text = 
  (new BufferedReader(new InputStreamReader(request.getPart("Text1").getInputStream()))).readLine();    

  // for input type=file controls
  InputStream inStr = request.getPart("File1").getInputStream();
  char charArray[] = new char[inStr.available()];
  new InputStreamReader(inStr).read(charArray);
  String contents = new String(charArray);
  %>

puedes subir archivos usando jsp / servlet.

<form action="UploadFileServlet" method="post">
  <input type="text" name="description" />
  <input type="file" name="file" />
  <input type="submit" />
</form>

por otro lado del servidor. use el siguiente código.

     package com.abc..servlet;

import java.io.File;
---------
--------


/**
 * Servlet implementation class UploadFileServlet
 */
public class UploadFileServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    public UploadFileServlet() {
        super();
        // TODO Auto-generated constructor stub
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        response.sendRedirect("../jsp/ErrorPage.jsp");
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub

            PrintWriter out = response.getWriter();
            HttpSession httpSession = request.getSession();
            String filePathUpload = (String) httpSession.getAttribute("path")!=null ? httpSession.getAttribute("path").toString() : "" ;

            String path1 =  filePathUpload;
            String filename = null;
            File path = null;
            FileItem item=null;


            boolean isMultipart = ServletFileUpload.isMultipartContent(request);

            if (isMultipart) {
                FileItemFactory factory = new DiskFileItemFactory();
                ServletFileUpload upload = new ServletFileUpload(factory);
                String FieldName = "";
                try {
                    List items = upload.parseRequest(request);
                    Iterator iterator = items.iterator();
                    while (iterator.hasNext()) {
                         item = (FileItem) iterator.next();

                            if (fieldname.equals("description")) {
                                description = item.getString();
                            }
                        }
                        if (!item.isFormField()) {
                            filename = item.getName();
                            path = new File(path1 + File.separator);
                            if (!path.exists()) {
                                boolean status = path.mkdirs();
                            }
                            /* START OF CODE FRO PRIVILEDGE*/

                            File uploadedFile = new File(path + Filename);  // for copy file
                            item.write(uploadedFile);
                            }
                        } else {
                            f1 = item.getName();
                        }

                    } // END OF WHILE 
                    response.sendRedirect("welcome.jsp");
                } catch (FileUploadException e) {
                    e.printStackTrace();
                } catch (Exception e) {
                    e.printStackTrace();
                } 
            }   
    }

}

DiskFileUpload upload=new DiskFileUpload();

De este objeto, debe obtener elementos de archivo y campos, luego puede almacenarlos en el servidor de la siguiente manera:

String loc="./webapps/prjct name/server folder/"+contentid+extension;
File uploadFile=new File(loc);
item.write(uploadFile);

Enviar múltiples archivos por archivo que tenemos que usar enctype="multipart/form-data"
y enviar el uso de múltiples archivos multiple="multiple"en la etiqueta de entrada

<form action="upload" method="post" enctype="multipart/form-data">
 <input type="file" name="fileattachments"  multiple="multiple"/>
 <input type="submit" />
</form>

PÁGINA HTML

<html>
<head>
<title>File Uploading Form</title>
</head>
<body>
<h3>File Upload:</h3>
Select a file to upload: <br />
<form action="UploadServlet" method="post"
                        enctype="multipart/form-data">
<input type="file" name="file" size="50" />
<br />
<input type="submit" value="Upload File" />
</form>
</body>
</html> 

ARCHIVO DE SERVLET

// Import required java libraries
import java.io.*;
import java.util.*;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.io.output.*;

public class UploadServlet extends HttpServlet {

   private boolean isMultipart;
   private String filePath;
   private int maxFileSize = 50 * 1024;
   private int maxMemSize = 4 * 1024;
   private File file ;

   public void init( ){
      // Get the file location where it would be stored.
      filePath = 
             getServletContext().getInitParameter("file-upload"); 
   }
   public void doPost(HttpServletRequest request, 
               HttpServletResponse response)
              throws ServletException, java.io.IOException {
      // Check that we have a file upload request
      isMultipart = ServletFileUpload.isMultipartContent(request);
      response.setContentType("text/html");
      java.io.PrintWriter out = response.getWriter( );
      if( !isMultipart ){
         out.println("<html>");
         out.println("<head>");
         out.println("<title>Servlet upload</title>");  
         out.println("</head>");
         out.println("<body>");
         out.println("<p>No file uploaded</p>"); 
         out.println("</body>");
         out.println("</html>");
         return;
      }
      DiskFileItemFactory factory = new DiskFileItemFactory();
      // maximum size that will be stored in memory
      factory.setSizeThreshold(maxMemSize);
      // Location to save data that is larger than maxMemSize.
      factory.setRepository(new File("c:\\temp"));

      // Create a new file upload handler
      ServletFileUpload upload = new ServletFileUpload(factory);
      // maximum file size to be uploaded.
      upload.setSizeMax( maxFileSize );

      try{ 
      // Parse the request to get file items.
      List fileItems = upload.parseRequest(request);

      // Process the uploaded file items
      Iterator i = fileItems.iterator();

      out.println("<html>");
      out.println("<head>");
      out.println("<title>Servlet upload</title>");  
      out.println("</head>");
      out.println("<body>");
      while ( i.hasNext () ) 
      {
         FileItem fi = (FileItem)i.next();
         if ( !fi.isFormField () )  
         {
            // Get the uploaded file parameters
            String fieldName = fi.getFieldName();
            String fileName = fi.getName();
            String contentType = fi.getContentType();
            boolean isInMemory = fi.isInMemory();
            long sizeInBytes = fi.getSize();
            // Write the file
            if( fileName.lastIndexOf("\\") >= 0 ){
               file = new File( filePath + 
               fileName.substring( fileName.lastIndexOf("\\"))) ;
            }else{
               file = new File( filePath + 
               fileName.substring(fileName.lastIndexOf("\\")+1)) ;
            }
            fi.write( file ) ;
            out.println("Uploaded Filename: " + fileName + "<br>");
         }
      }
      out.println("</body>");
      out.println("</html>");
   }catch(Exception ex) {
       System.out.println(ex);
   }
   }
   public void doGet(HttpServletRequest request, 
                       HttpServletResponse response)
        throws ServletException, java.io.IOException {

        throw new ServletException("GET method used with " +
                getClass( ).getName( )+": POST method required.");
   } 
}

web.xml

Compile el servlet UploadServlet anterior y cree la entrada requerida en el archivo web.xml de la siguiente manera.

<servlet>
   <servlet-name>UploadServlet</servlet-name>
   <servlet-class>UploadServlet</servlet-class>
</servlet>

<servlet-mapping>
   <servlet-name>UploadServlet</servlet-name>
   <url-pattern>/UploadServlet</url-pattern>
</servlet-mapping>