Documentazione Contatti      
Documentazione > Tutorial > Upload di file tramite protocollo http
Hide
Best Practices
EJB
Frameworks
Howto
J2EE
J2ME and Wireless
J2SE
JSP e Servlet
Java Application Server
Java IDE/Tools
Java Media
Java Security
Java Sys Admin
Java e XML
Java e SQL
OpenSource Java
Patterns
Repository
Tesi
UML
Web Services
Slide
White Paper di jws.it
project management
Eventi
Groovy



Promozione K-Tech per il Javaday


Chi controlla il passato controlla il futuro..
..Chi controlla il presente controlla il passato. George Orwell


MQSQL - Driver JDBC



  Visualizza Commenti (1) Aggiungi Commento    
 
Upload di file tramite protocollo http
By Alessandro Sellini
7 giugno 2005

  Upload di file tramite protocollo http
Program L'upload con Struts
Program L'upload mediante Servlet
Program Conclusioni
Program Risorse

Con questo articolo si vuole illustrare il meccanismo di upload di file da un client ad un server utilizzando il protocollo http (Hyper Text Tranfer Protocol).
Per fare ciò, seguiremo due strade diverse: utilizzeremo il framework STRUTS (download disponibile all'url http://www.apache.inetcosmos.org/dist/jakarta/struts/binaries/jakarta-struts-1.1.zip , tutorial: http://www.javaportal.it/docs/struts1.htm), il quale mette a disposizione delle librerie che permettono di effettuare l'operazione mediante una Action, un Bean ed una JSP per poi passare alla realizzazione della medesima operazione utilizzando esclusivamente JSP, SERVLET e librerie gratuite.
In entrambi i casi avremo bisogno di particolari classi che possano gestire dei dati codificati in modalità "multipart/form-data" e che non sono presenti nei package standard del JDK.



L'upload con Struts top

Le librerie che useremo sono contenute nell'archivio "commons-fileupload.jar" che dovrà essere presente, assieme alle librerie di base di Struts, all'interno della cartella "lib" della nostra web application. Il package che ci interessa, e che dovremo importare nella nostra action è "org.apache.struts.upload".
Cominciamo con lo scrivere il codice html che ci serve per visualizzare un form utilizzando i custom tag di Struts:

<!-- Il form deve avere l'Encoding Type settato a "multipart/form-data" affinchè si possa manipolare un file -->
<html:form action="/uploadAction" enctype="multipart/form-data">
  <table align="center" border="2" style="border-collapse: collapse">
     <tr>
        <td align="center"><font size="4" color="yellow">Descrizione</font></td>
        <td colspan="2">
           <!-- Inseriamo una textarea nella quale inserire una breve descrizione del file -->
           <html:textarea property="text" cols="33" rows="2" />
        </td>
    </tr>
    <tr>
        <td align="center">File</td>
        <td>
           <!-- Inseriamo un campo "file" che permetterà di scegliere un file dal filesystem locale -->
           <html:file property="myFile"/>
       </td>
       <td>
           <!-- Infine inseriamo il pulsante di submit che invierà i dati all'action "uploadAction" -->
          <html:submit value="SALVA"/>
       </td>
     </tr>
  </table>
</html:form>

Naturalmente, affinchè sia possibile utilizzare i custom tag di Struts, dovremo porre in testa alla jsp la seguente riga:

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


Per ricavare i dati dal form ci servirà un Bean che abbia tante variabili di classe quanti sono i campi del form e i relativi accessors:

public final class UploadBeanForm extends ActionForm {
    private String text = null;
    private FormFile myFile = null;
    public void setText(String text){
    this.text=text;
    }
 public String getText(){
    return text;
    }
 public void setMyFile(FormFile myFile){
    this.myFile=myFile;
    }
    public FormFile getMyFile(){
         return myFile;
    }

 public void reset(ActionMapping mapping, HttpServletRequest request){
    this.text=null;
    this.myFile=null;
    }
 public ActionErrors validate(ActionMapping mapping, HttpServletRequest request){
    ActionErrors errors = new ActionErrors();
    return errors;
    }
}

A questo punto andiamo a vedere il codice relativo alla Action che manipolerà i dati provenienti dal form:

import java.io.*;

import javax.servlet.*;
import javax.servlet.http.*;

import org.apache.struts.action.*;
import org.apache.struts.upload.*;

public class UploadAction extends Action {

  public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
HttpServletResponse response) throws Exception {
    try {
        // istanziamo il nostro ActionForm
        UploadBeanForm theForm = (UploadBeanForm) form;

        // ricaviamo il testo inserito dall'utente
        String text = theForm.getText();

        // ricaviamo l'immagine del file di cui si vuole fare l'upload
        FormFile file = theForm.getMyFile();

        // ricaviamo il nome del file
        String fileName= file.getFileName();

        // ricaviamo il MIME type del file
        String contentType = file.getContentType();

        // ricaviamo le dimensioni del file (in Bytes)
        int sizeTemp = file.getFileSize();

        String size = (sizeTemp + " Bytes");
         // costruiamo una stringa che indicherà il percorso assoluto sul server nel quale
        // sarà salvato il file, ad         
        // esempio C:\files\mioFile.txt
        String path = "C:\\files\\" + fileName;

        try {
            // ricaviamo i dati del file mediante un InputStream
            InputStream inStream = file.getInputStream();
            FileOutputStream outStream = new FileOutputStream(path);

            // salviamo il file nel percorso specificato
            while (inStream.available()>0) {
                  outStream.write(inStream.read());
            }
         }
            catch (FileNotFoundException fnfe) {
            return null;
            }
    catch (IOException ioe) {
    return null;
     }

    // eliminiamo il file temporaneo che abbiamo creato
    file.destroy();

    // mettiamo nella request i dati così da poterli ricavare dalla jsp
    request.setAttribute("text",text);
    request.setAttribute("path",path);
    request.setAttribute("contentType",contentType);
    request.setAttribute("size",size);

    // forwardiamo alla jsp mappata come "Success" nel file struts-config.xml
    return mapping.findForward("Success");
    }catch(Exception e){e.printStackTrace();}
        return null;
    }
}

In questo esempio abbiamo scelto di salvare i dati nella request e forwardare ad un'altra jsp che li presentasse, ma avremmo potuto, ad esempio, inserire questi dati in un DataBase in modo tale da mantenere un elenco di tutti i file caricati sul server ed eventualmente consentirne il download.



L'upload mediante Servlet top

Innanzi tutto dovremo scaricare delle librerie che servano allo scopo. Per questo esempio utilizzeremo le librerire della O'Reilly, reperibili all'url:http://www.servlets.com/cos/index.html
Queste librerie sono molto semplici da utilizzare ed hanno il non trascurabile pregio di avere a corredo una esauriente documentazione.
Una volta scaricato lo zip, preso il jar al suo interno e posto quest'ultimo nella cartella lib della nostra web application, avremo a disposizione la classe MultipartRequest, che è tutto ciò che ci serve per effettuare l'upload.

Questa volta non avremo a disposizione i custom tag di Struts per scrivere il codice relativo al form, che quindi modificheremo in questo modo:

<form align="center" method="POST" action="files" enctype="multipart/form-data">
    <table align="center" border="2" style="border-collapse: collapse">
        <tr>
            <td align="center"><font size="4" color="yellow">Descrizione</font></td>
            <td colspan="2">
                    <textarea name="text" cols="33" rows="2"></textarea>
            </td>
        </tr>
        <tr>
            <td align="center">File</td>
            <td>
                    <input name="myFile" type="file">
            </td>
            <td align="center">
                    <input type="submit" name="salva" value="SALVA">
            </td>
        </tr>
    </table>
</form>

Ora possiamo stendere il codice della servlet che manipolerà i dati in arrivo dal form:

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import com.oreilly.servlet.*;

public class ControllerFiles extends HttpServlet {

public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
    // Istanziamo le variabili
    // Il ServletContext sevirà per ricavare il MIME type del file uploadato
    ServletContext context = getServletContext();
    String forw = null;
    try {
    // Stabiliamo la grandezza massima del file che vogliamo uploadare
        int maxUploadSize = 50000000;
        MultipartRequest multi = new MultipartRequest(request,".",maxUploadSize);
        String descrizione = multi.getParameter("text");
        File myFile = multi.getFile("myFile");
        String filePath = multi.getOriginalFileName("myFile");
        String path = "C:\\files\\";

        try {
            // ricaviamo i dati del file mediante un InputStream
            FileInputStream inStream = new FileInputStream(myFile);
            // stabiliamo dove andrà scritto il file
            FileOutputStream outStream = new FileOutputStream(path+myFile.getName());

            // salviamo il file nel percorso specificato
            while (inStream.available()>0) {
                outStream.write(inStream.read());
            }
            // chiudiamo gli stream
            inStream.close();
            outStream.close();
        }
        catch (FileNotFoundException fnfe) {
            fnfe.printStackTrace();
        }
        catch (IOException ioe) {
            ioe.printStackTrace();
        }

        forw = "/done.jsp";

        // mettiamo nella request i dati così da poterli ricavare dalla jsp
        request.setAttribute("contentType",context.getMimeType(path+myFile.getName()));
        request.setAttribute("text",descrizione);
        request.setAttribute("path",path+myFile.getName());
        request.setAttribute("size",Long.toString(myFile.length())+" Bytes");

        RequestDispatcher rd =request.getRequestDispatcher(forw);
        rd.forward(request,response);
        }catch(Exception e) {e.printStackTrace();}
        }
}

A questo punto non ci resta che scrivere una JSP che prenda i dati dalla Request e li presenti e che sia utilizzabile con entrambe le tecniche utilizzate:

<%
    String text = (String)request.getAttribute("text");
    String path = (String)request.getAttribute("path");
    String contentType = (String)request.getAttribute("contentType");
    String size = (String)request.getAttribute("size");
%>

<html>
    <body bgcolor="#6A95B2">
        <center><font face="Tahoma" size="4">UPLOAD ESEGUITO!!!</font></center><br><br>
            <table border="1">
            <tr>
                <td>
                    <font face="Tahoma" size="3">Descrizione:</font>
                </td>
                <td>
                    <font face="Tahoma" size="3"><%=text%></font>
                </td>
            </tr>
            <tr>
                <td>
                    <font face="Tahoma" size="3">Percorso sul server:</font>
                </td>
                <td>
                    <font face="Tahoma" size="3"><%=path%></font>
                </td>
            </tr>
            <tr>
                <td>
                    <font face="Tahoma" size="3">MIME type:</font>
                </td>
                <td>
                    <font face="Tahoma" size="3"><%=contentType%></font>
                </td>
                </tr>
                <tr>
                <td>
                    <font face="Tahoma" size="3">Dimensioni</font>
                </td>
                <td>
                    <font face="Tahoma" size="3"><%=size%></font>
                </td>
             </tr>
        </table>
     <br><br><br><a href="upload.jsp">Torna alla pagina Upload</a>
    </body>
</html>



Conclusioni top
Abbiamo visto, come, utilizzando delle librerie completamente gratuite, sia possibile eseguire l'upload di un file con poche righe di codice utilizzando un protocollo, l'HTTP, che non supporta nativamente questo tipo di operazione, di solito delegata ad un altro protocollo, l'FTP (File Transfer Protocol).
In un successivo articolo parleremo di come effettuare la medesima operazione utilizzando quest'ultimo protocollo e, naturalmente, un server FTP.


Risorse top
  • I sorgenti di strutsUpload.zip
  • I sorgenti di servletUpload.zip
Alessandro "minosandro" Sellini


 Attachments List
Generic DocumentstrutsUpload
Generic DocumentservletUpload



JavaPortal è ideato da:    
K-Tech Logo










LICENZA



Eccetto dove diversamente specificato, i contenuti di questo sito sono rilasciati sotto licenza Creative Commons

Sitemap  © 2002-2004 Copyright Information. Privacy . Today is sabato 19 giugno 2010