[J2EE][SERVLET] Récupérer un champ <input type='file'>

Version imprimable

03/06/2005, 14h41
zev

[J2EE][SERVLET] Récupérer un champ <input type='file'>

Bonjour.

J'ai toutes sorte de pb pour émettre (="uploader" :)) un fichier d'un client vers un serveur.
Pour commencer, comment récupérer dans ma servlet le champ <input type="file"> de ma JSP ? :oops:

Merci.
03/06/2005, 15h11
fabszn

Hello,

Tu peux utiliser l'API FileUpload du projet Jakarta!

FileUpload

:D

Merci :) ça marche.Voilà le code :

Dans la JSP :

Code:

1
2
3
4
5
6
7
8
9
10
 
		<h1><p>Emettre un fichier (Upload)</p></h1>
		<form action="<%= request.getContextPath() + "/EmettreServlet"%>" enctype="multipart/form-data" method="post">
			<p>Emission du fichier:<input type="file" name="source" size="30"></p>
 
			<p>
				<input type="submit" name="submitFichier" value="Annuler" title="Annuler l'émission">
				<input type="submit" name="submitFichier" value="Emettre" title="Emettre le fichier vers le serveur">
			</p>
		</form>

et dans la servlet :
Pb: le streaming ne marche pas. qqun voit-il pourquoi ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
					System.out.println ("EmettreServlet");
 
					// Create a new file upload handler
					DiskFileUpload upload = new DiskFileUpload();
 
					// Set upload parameters
					int  yourMaxMemorySize = 512 * 1024 * 8; // en bytes
					int  yourMaxRequestSize = 1024 * 1024 * 8;
					String yourTempDirectory = "/home/temp/"; // un répertoire ou tomcat a le droit d'écrire
 
					upload.setSizeThreshold(yourMaxMemorySize);
					upload.setSizeMax(yourMaxRequestSize);
					upload.setRepositoryPath(yourTempDirectory);
 
					// Parse the request -on recupère tous les champs du formulaire
					List items = upload.parseRequest(req);
 
					// Process the uploaded items
					Iterator iter = items.iterator();
					while (iter.hasNext()) {
 
					    FileItem item = (FileItem) iter.next();
 
					    //	Process a regular form field
					    if (item.isFormField()) {
					        String name = item.getFieldName();
					        String value = item.getString();
 
					    }
						// Process a file upload
						else {
						    String fieldName = item.getFieldName();
						    String fileName = item.getName();
						    String contentType = item.getContentType();
						    boolean isInMemory = item.isInMemory();
						    long sizeInBytes = item.getSize();
 
						    boolean writeToFile = true;
						    // Copie directe pour les petits fichiers, sinon streaming (le streaming ne marche pas)
						    if (sizeInBytes > 512 * 1024 * 8) writeToFile = false;
 
						    // Process a file upload
						    if ((writeToFile) & (fieldName.equals("source"))) { // Ecriture directe
						    	System.out.println("Ecriture directe");
						        File uploadedFile = new File(yourTempDirectory + fileName);
						        item.write(uploadedFile);
						    } else { // Streaming
						    	System.out.println("Streaming");
						        InputStream uploadedStream = item.getInputStream();					        
						        uploadedStream.close();
						    }
 
						}
					}
				} catch (ServletException e) {
					e.printStackTrace();
				} catch (IOException e) {
					e.printStackTrace();
				} catch (FileUploadException e) {
					e.printStackTrace();
				} catch (Exception e) {
					e.printStackTrace();
				}

J'essaie d'en faire un sujet bien rédigé pour la FAQ :)
Si qqun qui s'y connait bien voulait bien checker ça et commenter.
En particulier comment traiter proprement le cas ou le ficher envoyé est trop gros,etc...

D'abord, avec enctype="multipart/form-data", la méthode POST ne marche pas. Pour envoyer les paramètres, il faut soit les envoyer par un GET, soit ne pas préciser method et les récupérer grâce au parseRequest.

JSP :

Code:

1
2
3
4
5
6
7
8
9
<h1><p>Emettre un fichier (Upload)</p></h1>
      <form action="<%= request.getContextPath() + "/EmettreServlet"%>" enctype="multipart/form-data">
         <p>Emission du fichier:<input type="file" name="source" size="30"></p>
 
         <p>
            <input type="submit" name="submitFichier" value="Annuler" title="Annuler l'émission">
            <input type="submit" name="submitFichier" value="Emettre" title="Emettre le fichier vers le serveur">
         </p>
      </form>

La liste obtenue par parseRequest contient 2 types de champs: les parametres habituellement envoyés par POST et les fichiers.
Pour les fichiers, 2 traitements possibles: envoyer le fichier d'un coup ou le streaming, selon la taille.

Servlet:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
System.out.println ("EmettreServlet");
 
// Create a new file upload handler
DiskFileUpload upload = new DiskFileUpload();
 
// Set upload parameters
int  yourMaxMemorySize = 512 * 1024 * 8; // en bytes
int  yourMaxRequestSize = 1024 * 1024 * 8;
String yourTempDirectory = "/home/temp/"; // un répertoire ou tomcat a le droit d'écrire
 
upload.setSizeThreshold(yourMaxMemorySize);
upload.setSizeMax(yourMaxRequestSize);
upload.setRepositoryPath(yourTempDirectory);
 
// Parse the request -on recupère tous les champs du formulaire
List items = upload.parseRequest(req);
 
// Process the uploaded items
Iterator iter = items.iterator();
while (iter.hasNext()) {
 
    FileItem item = (FileItem) iter.next();
 
    //   Process a regular form field
    if (item.isFormField()) {
        String name = item.getFieldName();
        String value = item.getString();
 
    }
   // Process a file upload
   else {
       String fieldName = item.getFieldName();
       String fileName = item.getName();
       String contentType = item.getContentType();
       boolean isInMemory = item.isInMemory();
       long sizeInBytes = item.getSize();
 
       boolean writeToFile = true;
       // Copie directe pour les petits fichiers, sinon streaming (le streaming ne marche pas)
       if (sizeInBytes > 512 * 1024 * 8) writeToFile = false;
 
       // Process a file upload
       if ((writeToFile) & (fieldName.equals("source"))) { // Ecriture directe
          System.out.println("Ecriture directe");
           File uploadedFile = new File(yourTempDirectory + fileName);
           item.write(uploadedFile);
       } else { // Streaming
			File uploadedFile = new File(yourTempDirectory + fileName); // ou sinon un nouveau nom de fichier à la place de fileName
			InputStream sourceFile = item.getInputStream();   
			OutputStream destinationFile = new FileOutputStream(uploadedFile);
			byte buffer[]=new byte[512*1024];
			int nbLecture;
			while( (nbLecture = sourceFile.read(buffer)) != -1 ) {
			destinationFile.write(buffer, 0, nbLecture);
			}
			sourceFile.close();
       }
 
   }
}
} catch (ServletException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (FileUploadException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}

05/07/2005, 17h43
ShinJava

Re salut,

Alors j'ai bien regardé le code, il est tres instructif mais j'ai une question, ou est-ce que tu defini le repertoire d'arrivé du fichier ?
Je ne le trouve pas...

Merci
++
ShinJava
06/07/2005, 17h53
zev

Ici :

Code:

String yourTempDirectory = "/home/temp/"; // un répertoire ou tomcat a le droit d'écrire

Je sais pas pourquoi ils appellent ça un repertoire temporaire, pour moi il est definitif: c'est le repertoire ou j'enregistre le fichier selectionné.
Peut etre pour checker le fichier avant de le deplacer ailleurs.
enfin de toutes manieres c la qu'il sera telechargé.
06/07/2005, 19h04
ShinJava
Ok je vois.
Apparement le repertoire temporaire doit servir pour les gros fichiers.
Je crois que c'est ici que tout ce passe :
Code:

1 2 File uploadedFile = new File(yourTempDirectory + fileName);
Si j'ai d'autres questions je reviens ici :) Merci.

++
ShinJava

Bonjour, j'ai repris le code hier pour faire un upload et je me suis aperçue qu'il utilisait des méthodes deprecated. J'ai donc modifié le code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
		System.out.println( "Upload" );
 
		// Create a new file upload handler
		DiskFileItemFactory fileItemFactory = new DiskFileItemFactory( );
 
		ServletFileUpload upload = new ServletFileUpload( fileItemFactory );
 
		// Set upload parameters
		int yourMaxMemorySize = 512 * 1024 * 8; // en bytes
		int yourMaxRequestSize = 1024 * 1024 * 8;
		String yourTempDirectory = "/home/monuser/tmp/"; // un répertoire ou tomcat
																											// a
		// le droit d'écrire
 
		fileItemFactory.setSizeThreshold( yourMaxMemorySize );
 
		// upload.setSizeThreshold(yourMaxMemorySize);
		upload.setSizeMax( yourMaxRequestSize );
		// upload.setRepositoryPath(yourTempDirectory);
 
		// Parse the request -on recupère tous les champs du formulaire
		List items;
		try
		{
			items = upload.parseRequest(req);
 
			// Process the uploaded items
			Iterator iter = items.iterator( );
			while ( iter.hasNext( ) )
			{
 
				FileItem item = (FileItem) iter.next( );
 
				// Process a regular form field
				if ( item.isFormField( ) )
				{
					String name = item.getFieldName( );
					String value = item.getString( );
 
				}
				// Process a file upload
				else
				{
					String fieldName = item.getFieldName( );
					String fileName = item.getName( );
					String contentType = item.getContentType( );
					boolean isInMemory = item.isInMemory( );
					long sizeInBytes = item.getSize( );
 
					boolean writeToFile = true;
					// Copie directe pour les petits fichiers, sinon streaming (le
					// streaming ne marche pas)
					if ( sizeInBytes > 512 * 1024 * 8 ) writeToFile = false;
 
					// Process a file upload
					if ( ( writeToFile ) & ( fieldName.equals( "source" ) ) )
					{ // Ecriture directe
						System.out.println( "Ecriture directe" );
						File uploadedFile = new File( yourTempDirectory + fileName );
						item.write( uploadedFile );
					}
					else
					{ // Streaming
						File uploadedFile = new File( yourTempDirectory + fileName ); // ou
																																					// sinon
						// un	nouveau nom de fichier à la place de fileName
						InputStream sourceFile;
						try
						{
							sourceFile = item.getInputStream( );
							OutputStream destinationFile;
							try
							{
								destinationFile = new FileOutputStream( uploadedFile );
								byte buffer[] = new byte[512 * 1024];
								int nbLecture;
								while ( ( nbLecture = sourceFile.read( buffer ) ) != -1 )
								{
									destinationFile.write( buffer, 0, nbLecture );
								}
								sourceFile.close( );
							}
							catch ( FileNotFoundException e )
							{
								// TODO Auto-generated catch block
								e.printStackTrace( );
							}
							catch ( IOException e )
							{
								// TODO Auto-generated catch block
								e.printStackTrace( );
							}
						}
						catch ( IOException e )
						{
							// TODO Auto-generated catch block
							e.printStackTrace( );
						}
					}
 
				}
			}
		}
		catch ( FileUploadException e )
		{
			// TODO Auto-generated catch block
			e.printStackTrace( );
		}
		catch ( Exception e )
		{
			// TODO Auto-generated catch block
			e.printStackTrace( );
		}

Je voulais aussi signaler qu'il fallait penser à prendre la dépendance sur le site d'Apache : common.io

Bon courage au suivant ;)

15/12/2006, 11h22
ptr83
Citation:

Envoyé par Mascotte

Bon courage au suivant ;)

Merci c'est moi :).

En fait je n'ai qu'une petite rectification à proposer, le code ci-dessus fonctionne très bien (même le streaming contrairement à ce que les commentaires annoncent -apparemment en tout cas- ) sur Firefox. Mais sur IE (7 chez moi) cela ne fonctionnait pas du tout.
J'ai trouvé pourquoi : la fonction item.getName(); sous FF renvoie le nom du fichier (test.txt par exemple) alors que sous IE elle renvoie le path tout entier (C:\temp\test.txt).

J'ai ajouté ces deux petites lignes :
Code:

1 2 String [] temp = STR.split(fileName,"\\"); fileName = temp[temp.length-1];
Juste après celle-ci :

Code:

String fileName = item.getName();

Comme le nom d'un fichier ne peut contenir un \ je pense que cela résoud le problème. Cela fonctionne aussi sous IE7 chez moi en tout cas...

Tout le monde est sous FF ici :mouarf: ? (je ne m'en suis pas non plus rendu compte desuite, juste a la fin de mes tests car mon application doit être compatible FF et IE...).
15/12/2006, 11h25
Invité

Merci car mes users sont, eux, sous IE !!!
15/12/2006, 16h24
rousseso

Bonjour,

Je suis nouvelle dans les FileUpLoad.
alors petit pb qui me bloque pas mal.

situation : utilisation d'une JSP et d'une servlet
dans la JSP :
<form name="adminprolog" action="prologservlet" method="post"
enctype="multipart/form-data" >
<p>
<input type="file" name="fileBP" size="40"/>
</p>
<p>
<input type="hidden" name="action" value="validerChargement" />
<input type="submit" name="submit" value="Valider"/>
</p>
</form>

dans la servlet :
plusieurs action doivent être possibles... celles-ci sont determinées par
l'input type="hidden"

la servlet récupère alors le name de l'action et doit exécuter le programme correspondant.

seulement voilà le pb :
le fait d'ajouter < enctype="multipart/form-data" > - qui est nécessaire pour l'upload de fichier d'après ce que j'ai compris - fait que la servlet ne trouve pas l'action "validerChargement"...

quelqu'un aurait-il une idée de la provenance de ce pb ?

d'avance merci
08/08/2007, 17h18
lem01

Bonjour,

Je suis loin d'etre expert en jsp et j'ai également besoin de permettre l'upload de fichier depuis une application web.
Votre solution semble vraiment parfaite mais je n'arrive pas a la mettre en place.

Que dois je exactement faire?
Le code que je vois est-ce du code a mettre dans une méthode d'un fichier java, ou alors est ce un script que je met dans un fichier jsp ?
J'ai cru comprendre que je devais télécharger ceci commons-fileupload-1.2, ce que j'ai fais, j'ai lié le jar a mon projet mais je ne parvient pas a faire de référence a celui ci.

J'ai mis ce code au début de ma JSP, mais j'ai toujours des erreur (DiskFileItemFactory,ServletFileUpload, ...)

Code:

<%@ page import="org.apache.commons.fileupload.*, java.util.List, java.io.File, java.util.Iterator" %>

Que me manque t'il?

Il y a un println au début du script, me semble que ça ne s'interpretepas en jsp ou en java..

Merci de votre aide!!
08/08/2007, 17h27
lem01

Ok j'ai pt'etre posté un peu rapidement.

J'ai mis ce script dans une methode d'une classe java, les imports semblent
bien fait. J'ai uniquement une erreur à cette ligne:

Code:

items = upload.parseRequest(req);

Le req n'est défini nulle part avant... Me semble que ce sont les informations provenant du formulaire mais il me semble que pour les récuperer il faut faire qqchose comme request.getAttribute ...

Je suis un peu ds le flou la :)
06/09/2007, 10h35
ptr83

Tu ne dois pas en faire une classe mais une méhode dans un servlet.

Et le req c'est la request du servlet...
08/05/2011, 12h27
simohamed10

Nouveaute

bonjour

:ccool:

Svp cette méthode de récupération est dépasser, donc si vous pouvez proposer une autre sera le bienvenu est merci d'avance.
09/05/2011, 10h35
m1987

salut,
SVP je suis nouvelle en dev j2ee et je veux savoir quelle est la différence entre l'utlisation d'un "tomcat project" et "dynamic web project"
merci d'avance
29/05/2016, 19h45
Jouryflower

problème d'upload

bonjour, je veux Upload un fichier pdf dans une page jsp , j'ai utiliser votre méthode avec l'api

mais je trouve un erreur dans le servlet , l'erreur signifie que req est inconnu

Code:

List items = upload.parseRequest(req);

est ce que vous pouvez dire comment déclarer req ?parce que je n'ai trouvé pas son déclaration dans votre code

est ce qu' il y a d'autre méthode pour Upload? un méthode pou afficher un fichier pdf que l'on upload?

merci