Problème de chemin

**momjunior** · 24/06/2015, 15h34

Bonjour

Je viens de créer mon application JEE qui permet entre autre de charger une image et d'insérer son chemin dans la base de données. Jusqu'ici tout va bien. Mais lorsque j'héberge le site, j'ai le message d'erreur suivant:

Fichier endommagé ou non supporté.Veuillez en choisir un autre!

Voici mon fichier web.xml:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<servlet>
        <servlet-name>AjouterPhoto</servlet-name>
        <servlet-class>servlets.AjouterPhoto</servlet-class>
        <init-param>
            <param-name>chemin</param-name>
            <param-value>/fichiers/images/</param-value>
        </init-param>
        <multipart-config>
            <location>/home/monsite/fichiers/images</location>
            <max-file-size>2097152</max-file-size>
            <!-- 2 Mo -->
            <max-request-size>10485760</max-request-size>
            <!-- 5 x 2Mo -->
            <file-size-threshold>1048576</file-size-threshold>
            <!-- 1 Mo -->
        </multipart-config>
    </servlet>

En fait lorsque j'accéde à mon cpanel, j'ai /home/monsite à la racine. C'est pour cela qu'au niveau de </location> j'ai écrit ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

<location>/home/monsite/fichiers/images</location>

Mais en local j'avai ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

<location>c:/fichiers/images</location>

Et voici la Class qui effectue le traitement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
package forms;
 
import java.util.Collection;
import javax.servlet.ServletException;
import eu.medsea.mimeutil.MimeUtil;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.Part;
import beans.Candidat;
import dao.CandidatDao;
import dao.DAOException;
 
public final class AjouterPhotoForm {
 
    private static final String CHAMP_EMAIL     = "email"; 
    private static final String CHAMP_PHOTO     = "photo";
    private static final String CHAMP_CHEMIN_PHOTO     = "chemin_photo";
 
    private static final int    TAILLE_TAMPON   = 10240;                        // 10ko
    private String              resultat;
    private Map<String, String> erreurs         = new HashMap<String, String>();
    private CandidatDao           candidatDao;
 
 
 
    public AjouterPhotoForm( CandidatDao candidatDao ) {
        this.candidatDao = candidatDao;
    }
 
    public Map<String, String> getErreurs() {
        return erreurs;
    }
    public String getResultat() {
        return resultat;
    }
    public Candidat ajouterPhoto( HttpServletRequest request, String chemin ) {
 
 
        String email = getValeurChamp( request, CHAMP_EMAIL );
        System.out.println("le mail est vraiment: "+email);
        String cheminPhoto = getValeurChamp( request, CHAMP_CHEMIN_PHOTO );
        System.out.println("la photo est : "+cheminPhoto);
 
        System.out.println("le chemin est : "+chemin);
 
 
        Candidat candidat = new Candidat();
 
        candidat.setEmail(email);
        traiterPhoto( candidat, request, chemin );
 
 
        try {
            if ( erreurs.isEmpty() ) {
 
                File file = new File("home\\monsite\\fichiers\\images\\"+cheminPhoto);
                file.delete();
 
                candidatDao.insererPhoto( candidat,email );
 
                candidat = candidatDao.trouver(email);
                resultat = "Votre photo a été ajoutée avec succés.";
            } else {
                resultat = "<div class=\"resultat_echec\">Échec de chargement de votre photo. Corrigez les erreurs ci-dessous!</div> <br><br>";
            }
        } catch ( DAOException e ) {
            setErreur( "imprévu", "Erreur imprévue lors de la création." );
            resultat = "<div class=\"resultat_echec2\">Échec de chargement de votre photo : une erreur imprévue est survenue, merci de réessayer dans quelques instants.</div><br><br>";
            e.printStackTrace();
        }
        return candidat;
    }
 
 
      private void traiterPhoto( Candidat candidat, HttpServletRequest request, String chemin ) {
        String photo = null;
        try {
            photo = validationPhoto( request, chemin );
        } catch ( FormValidationException e ) {
            setErreur( CHAMP_PHOTO, e.getMessage() );
        }
        candidat.setPhoto( photo );
    }
 
       private String validationPhoto( HttpServletRequest request, String chemin ) throws FormValidationException {
        /*
         * Récupération du contenu du champ image du formulaire. Il faut ici
         * utiliser la méthode getPart().
         */
 
        String nomFichier = null;
 
        InputStream contenuFichier = null;
        try {
            Part part = request.getPart( CHAMP_PHOTO );
 
 
            nomFichier = getNomFichier( part );
 
            /*
             * Si la méthode getNomFichier() a renvoyé quelque chose, il s'agit
             * donc d'un champ de type fichier (input type="file").
             */
            if ( nomFichier != null && !nomFichier.isEmpty() ) {
 
                nomFichier = nomFichier.substring( nomFichier.lastIndexOf( '/' ) + 1 )
                        .substring( nomFichier.lastIndexOf( '\\' ) + 1 );
                /* Récupération du contenu du fichier */
                contenuFichier = part.getInputStream();
 
                /* Extraction du type MIME du fichier depuis l'InputStream */
                MimeUtil.registerMimeDetector( "eu.medsea.mimeutil.detector.MagicMimeMimeDetector" );
 
                try {
 
                    Collection<?> mimeTypes = MimeUtil.getMimeTypes( contenuFichier );
               // String mimeTypes =   request.getServletContext().getMimeType( nomFichier );
                /*
                 * Si le fichier est bien une image, alors son en-tête MIME
                 * commence par la chaîne "image"
                 */
                if ( mimeTypes.toString().startsWith( "image" )  ) {
                    /* Écriture du fichier sur le disque */
                    ecrireFichier( contenuFichier, nomFichier, chemin );
                } else {
                    throw new FormValidationException( "Le fichier envoyé doit être une image." );
                }
 
                } catch ( Exception e ) {
 
            e.printStackTrace();
            throw new FormValidationException( "Fichier endommagé ou non supporté.Veuillez en choisir un autre!" );
        }
 
            }
            else
            {
             throw new FormValidationException( "Vous n'avez sélectionné aucune photo." );
            }
        } catch ( IllegalStateException e ) {
            /*
             * Exception retournée si la taille des données dépasse les limites
             * définies dans la section <multipart-config> de la déclaration de
             * notre servlet d'upload dans le fichier web.xml
             */
            e.printStackTrace();
            throw new FormValidationException( "Le fichier envoyé ne doit pas dépasser 2Mo." );
        } catch ( IOException e ) {
            /*
             * Exception retournée si une erreur au niveau des répertoires de
             * stockage survient (répertoire inexistant, droits d'accès
             * insuffisants, etc.)
             */
            e.printStackTrace();
            throw new FormValidationException( "Erreur de configuration du serveur." );
        } catch ( ServletException e ) {
            /*
             * Exception retournée si la requête n'est pas de type
             * multipart/form-data.
             */
            e.printStackTrace();
            throw new FormValidationException(
                    "Ce type de requête n'est pas supporté, merci d'utiliser le formulaire prévu pour envoyer votre fichier." );
        }
        return nomFichier;
    }
    /*
     * Ajoute un message correspondant au champ spécifié à la map des erreurs.
     */
    private void setErreur( String champ, String message ) {
        erreurs.put( champ, message );
    }
    /*
     * Méthode utilitaire qui retourne null si un champ est vide, et son contenu
     * sinon.
     */
    private static String getValeurChamp( HttpServletRequest request, String nomChamp ) {
        String valeur = request.getParameter( nomChamp );
        if ( valeur == null || valeur.trim().length() == 0 ) {
            return null;
        } else {
            return valeur;
        }
    }
    /*
     * Méthode utilitaire qui a pour unique but d'analyser l'en-tête
     * "content-disposition", et de vérifier si le paramètre "filename" y est
     * présent. Si oui, alors le champ traité est de type File et la méthode
     * retourne son nom, sinon il s'agit d'un champ de formulaire classique et
     * la méthode retourne null.
     */
  private static String getNomFichier( Part part ) {
        /* Boucle sur chacun des paramètres de l'en-tête "content-disposition". */
        for ( String contentDisposition : part.getHeader( "content-disposition" ).split( ";" ) ) {
            /* Recherche de l'éventuelle présence du paramètre "filename". */
            if ( contentDisposition.trim().startsWith( "filename" ) ) {
                /*
                 * Si "filename" est présent, alors renvoi de sa valeur,
                 * c'est-à-dire du nom de fichier sans guillemets.
                 */
                return contentDisposition.substring( contentDisposition.indexOf( '=' ) + 1 ).trim().replace( "\"", "" );
            }
        }
        /* Et pour terminer, si rien n'a été trouvé... */
        return null;
    }
    /*
     * Méthode utilitaire qui a pour but d'écrire le fichier passé en paramètre
     * sur le disque, dans le répertoire donné et avec le nom donné.
     */
    private void ecrireFichier( InputStream contenuFichier, String nomFichier, String chemin )
            throws FormValidationException {
        /* Prépare les flux. */
        BufferedInputStream entree = null;
        BufferedOutputStream sortie = null;
        try {
            /* Ouvre les flux. */
            entree = new BufferedInputStream( contenuFichier, TAILLE_TAMPON );
            sortie = new BufferedOutputStream( new FileOutputStream( new File( chemin + nomFichier ) ),
                    TAILLE_TAMPON );
            /*
             * Lit le fichier reçu et écrit son contenu dans un fichier sur le
             * disque.
             */
            byte[] tampon = new byte[TAILLE_TAMPON];
            int longueur = 0;
            while ( ( longueur = entree.read( tampon ) ) > 0 ) {
                sortie.write( tampon, 0, longueur );
            }
        } catch ( Exception e ) {
            throw new FormValidationException( "Erreur lors de l'écriture du fichier sur le disque." );
        } finally {
            try {
                sortie.close();
            } catch ( IOException ignore ) {
            }
            try {
                entree.close();
            } catch ( IOException ignore ) {
            }
        }
    }
}

Merci

**joel.drigo** · 26/06/2015, 18h52

Salut,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
catch ( Exception e ) {
 
            e.printStackTrace();
            throw new FormValidationException( "Fichier endommagé ou non supporté.Veuillez en choisir un autre!" );
        }

Avec ce genre d'expression, tu perds l'exception d'origine pour en générer une autre. L'affichage de la stacktrace dans la sortie standard fait que tu dois au moins retrouver cette stacktrace dans la console de ton serveur, ou dans son log. Cette stacktrace est indispensable pour comprendre ce qu'il se passe et où. Mais, manque de bol, l'exception est probablement soulevée par la méthode ecrireFichier() qui elle-même masque l'exception d'origine dans une FormValidationException. Tu perd don toutes informations utiles à la résolution de ton problème.

Je comprends bien que tu utilises cette exception FormValidationException pour fair eun rendu du message d'erreur plus adapté à une interprétation par un utilisateur non technique. Mais, les messages d'erreurs sont également utiles au développeur, pour corriger les erreurs. Pour ça, un moyen simple : la cause. Il s'agit juste de stocker l'exception d'origine, comme le font beaucoup de classe d'exception standard.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
public class FormValidationException extends Exception { // ou peut-être est-ce une RuntimeException ?
 
	public FormValidationException(String message, Throwable cause) {
		super(message, cause); 
	}
 
}

Sinon, logue au moins l'exception que tu perds au dernier endroit où tu l'as encore. C'est la seule qui te permettra de corriger l'erreur, ou nous permettra, le cas échéant, de t'aider à la résoudre.

A noter, qu'il faut que tu évites les catch généraux (genre catch(Exception e)) : fais des catchs ciblés. Dans ton code, tu attrapes de la même façon des IOException, des NullPointerException ,des FormValidationException (que tu encapsules dans un FormValidationException), etc : du coup, non seulement tu emboites des FormValidationException à la manière des poupées russes, masquant et remasquant les causes de l'erreur, mais en plus tu prends toutes les exceptions, y compris celles que tu ne peux soupçonner d'exister et donc que tu n'es pas censé pouvoir traiter toi-même.

[code]catch(FormValidationException e) {
throw e; // on ne encapsule pas des FormValidationException le sunes dans le sautres
}
catch(IOException e) { // on catche les exceptions dont on sait qu'elles sont soulevées dans notre code, pas les autres
throw new FormValidationException (..., e);
}
// les autres exceptions, on ne devrait pas avoir à les traiter ici. Soit, une correction doit être fait plus bas dans le code qui en est responsable, soit elles devraient être traitées justement dans ce code (qui les génère)

Aussi, faut-il traiter les exceptions au bon niveau : il vaut mieux souvent faire mieux un throws qu'un catch (surtout un catch qui rethrow une nouvelle exception). Si tu ne sais pas quoi faire à ce niveau de l'exception, tu saura peut-être mieux au dessus. Il vaut mieux avoir un ecrireFichier qui throws une IOException, qui affiche à l'utilisateur un message "Problème d'écriture de fichier", mais qui logue la cascade de stacktrace, afin de savoir exactement le problème (dossier non trouvé, erreur d'accès à un fichier interdit, erreur disque, etc.). La seule information pertinente dans ton système est qu'on sait que ça s'est passer dans ecrireFichier : l'utilisateur lui à un message peut-être plus précis, quoique je pense que vu son intitulé, il soit le plus souvent hors sujet, donc inutile.

Après avoir fait les modifications qui s'imposent, donne-nous justement la stacktrace complète

**momjunior** · 28/06/2015, 00h49

Où avais-je la tête. Voici l'erreur que j'ai:

ERROR ajp-bio-127.0.0.1-9550-exec-3533 org.apache.catalina.core.ContainerBase.[Catalina].[jobprofils.com].[/].[AjouterPhoto] - Servlet.service() for servlet [AjouterPhoto] in context with path [] threw exception
java.lang.NullPointerException
at forms.AjouterPhotoForm.ecrireFichier(AjouterPhotoForm.java:237)
at forms.AjouterPhotoForm.validationPhoto(AjouterPhotoForm.java:131)
at forms.AjouterPhotoForm.traiterPhoto(AjouterPhotoForm.java:85)
at forms.AjouterPhotoForm.ajouterPhoto(AjouterPhotoForm.java:57)
at servlets.AjouterPhoto.doPost(AjouterPhoto.java:49)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:647)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:728)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:305)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:210)
at filters.PrechargementFilter.doFilter(PrechargementFilter.java:383)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:243)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:210)
at org.apache.catalina.filters.SetCharacterEncodingFilter.doFilter(SetCharacterEncodingFilter.java:108)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:243)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:210)
at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:222)
at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:123)
at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:472)
at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:171)
at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:99)
at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:118)
at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:407)
at org.apache.coyote.ajp.AjpProcessor.process(AjpProcessor.java:200)
at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:589)
at org.apache.tomcat.util.net.JIoEndpoint$SocketProcessor.run(JIoEndpoint.java:310)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1110)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
at java.lang.Thread.run(Thread.java:722)

**joel.drigo** · 28/06/2015, 04h18

Il y a une NullPointerException à la ligne 237, dans ecrireFichier. Il m'est difficile de savoir qu'elle est exactement cette ligne (le code dans le message peut être décalé), mais je pense que c'est une exception masquante : je pense qu'il y a une exception à la création d'entree ou sortie, donc que l'un des deux est null, ou les deux sont nulls, et donc l'appel de close() provoque cette exception NullPointerException, masquant la vraie exception.

Pour en être sûr, tu peux faire ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
try {
            /* Ouvre les flux. */
            entree = new BufferedInputStream( contenuFichier, TAILLE_TAMPON );
            sortie = new BufferedOutputStream( new FileOutputStream( new File( chemin + nomFichier ) ),
                    TAILLE_TAMPON );
            /*
             * Lit le fichier reçu et écrit son contenu dans un fichier sur le
             * disque.
             */
            byte[] tampon = new byte[TAILLE_TAMPON];
            int longueur = 0;
            while ( ( longueur = entree.read( tampon ) ) > 0 ) {
                sortie.write( tampon, 0, longueur );
            }
        } catch ( Exception e ) {
            throw new FormValidationException( "Erreur lors de l'écriture du fichier sur le disque." );
        } finally {
            if ( sortie!=null ) {
                try {
                   sortie.close();
                } catch ( IOException ignore ) {
                   // c'est une pratique courante de faire ça, mais ça ne mange pas de pain de tracer l'exception ici, on ne sait jamais, ça peut être intéressant de savoir que les flux ne se ferment pas correctement
                }
            }
            if ( entree!=null ) {
                try {
                    entree.close();
                } catch ( IOException ignore ) {
                     // même remarque
                }
            }
        }

Ou encore, mieux, utiliser un try-with-resource (ce qui en plus te permet de limiter la portée des variables au bloc où tu les utilises) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
try (BufferedInputStream entree = new BufferedInputStream( contenuFichier, TAILLE_TAMPON );
            BufferedOutputStream sortie = new BufferedOutputStream( new FileOutputStream( new File( chemin + nomFichier ) ),
                    TAILLE_TAMPON );
            ) {
            /*
             * Lit le fichier reçu et écrit son contenu dans un fichier sur le
             * disque.
             */
            byte[] tampon = new byte[TAILLE_TAMPON];
            int longueur = 0;
            while ( ( longueur = entree.read( tampon ) ) > 0 ) {
                sortie.write( tampon, 0, longueur );
            }
        } catch ( Exception e ) {
            throw new FormValidationException( "Erreur lors de l'écriture du fichier sur le disque." );
        }

**momjunior** · 29/06/2015, 15h48

Ok je viens d'insérer le code que tu m'as donné:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
try {
            /* Ouvre les flux. */
            entree = new BufferedInputStream( contenuFichier, TAILLE_TAMPON );
            sortie = new BufferedOutputStream( new FileOutputStream( new File( chemin + nomFichier ) ),
                    TAILLE_TAMPON );
            /*
             * Lit le fichier reçu et écrit son contenu dans un fichier sur le
             * disque.
             */
            byte[] tampon = new byte[TAILLE_TAMPON];
            int longueur = 0;
            while ( ( longueur = entree.read( tampon ) ) > 0 ) {
                sortie.write( tampon, 0, longueur );
            }
        } catch ( Exception e ) {
            throw new FormValidationException( "Erreur lors de l'écriture du fichier sur le disque." );
        } finally {
            if ( sortie!=null ) {
                try {
                   sortie.close();
                } catch ( IOException ignore ) {
                   // c'est une pratique courante de faire ça, mais ça ne mange pas de pain de tracer l'exception ici, on ne sait jamais, ça peut être intéressant de savoir que les flux ne se ferment pas correctement
                }
            }
            if ( entree!=null ) {
                try {
                    entree.close();
                } catch ( IOException ignore ) {
                     // même remarque
                }
            }
        }

Et là j'ai le message d'erreur:

Erreur lors de l'écriture du fichier sur le disque.

Le problème est que je ne sais comment utiliser les flux sans les try et catch et je ne sais pas comment faire pour afficher l'erreur dans le fichier catalina.log.

Merci

**joel.drigo** · 29/06/2015, 16h28

Non, non et non. Tu n'as pas du tout fais ce que j'ai dit. Tu perds toujours l'exception d'origine, celle qui dit ce qu'il se passe.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
catch ( Exception e ) {
            throw new FormValidationException( "Erreur lors de l'écriture du fichier sur le disque." );
        }

Ici, quelque soit l'exception, NullPointerException, FileNotFoundException, IOException de type "denied access" ou autre, ParseException, ou n'importe quoi, on ne sait rien d'autre que "Erreur lors de l'écriture du fichier sur le disque". Ce qui est peut^être juste, mais vague, mais peut être complètement faux !

Fais au minimum le crapoteux :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
catch ( Exception e ) {
            e.printStackTrace();
            throw new FormValidationException( "Erreur lors de l'écriture du fichier sur le disque." );
        }

Le mieux étant de passer la cause en paramètre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
catch ( Exception e ) {
            throw new FormValidationException( "Erreur lors de l'écriture du fichier sur le disque.", e );
        }

Avec une stackTrace dans l'appelant (dans laquelle on verra la cause !)

**momjunior** · 30/06/2015, 01h11

Oui je connaissais cette façon d'afficher l'erreur dans la servlet ou la jsp mais je pensais trouver une façon de l'afficher dans le log. Mais bon, j'ai fait ce que tu m'as dit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
catch ( Exception e ) {
            throw new FormValidationException( "Erreur lors de l'écriture du fichier sur le disque.", e );
        }

Et voici le message d'erreur:

Fichier endommagé ou non supporté.Veuillez en choisir un autre!forms.FormValidationException: Erreur lors de l'écriture du fichier sur le disque.java.io.FileNotFoundException: /fichiers/images/photo.png (No such file or directory)

C'est bien ça?

**joel.drigo** · 30/06/2015, 01h52

Oui, c'est ça. Tu as ta réponse maintenant : tu essayes d'écrire dans le fichier "/fichiers/images/photo.png", et tu obtiens l'erreur FileNotFoundException (No such file or directory).

Le problème maintenant est de savoir s'il s'agit de la source, ou de la destination (puisque le try/catch traite les deux dans le même catch). Ce n'est pas la source, puisqu'il s'agit d'un inputStream obtenu depuis un part.
Donc il s'agit de la destination. Ce n'est pas le fichier : on l'écrit donc il n'a pas de raison d'exister avant. C'est donc le dossier de destination qui n'existe pas. S'agit-il bien du dossier que tu vises ? Si oui, tu peux faire un "mkdirs" au début de la méthode pour l'éviter :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
File targerFile = new File( chemin , nomFichier );
targetFile.getParentFile().mkdirs();
 
/* ... */
 
try {
            /* Ouvre les flux. */
            entree = new BufferedInputStream( contenuFichier, TAILLE_TAMPON );
            sortie = new BufferedOutputStream( new FileOutputStream( targetFile ),
                    TAILLE_TAMPON );
/*...*/

(n'oublie pas le try-with-resource, que je t'ai indiqué, qui te simplifierais le code, sans vouloir te forcer)

**joel.drigo** · 30/06/2015, 02h02

Envoyé par momjunior

Oui je connaissais cette façon d'afficher l'erreur dans la servlet ou la jsp mais je pensais trouver une façon de l'afficher dans le log.

Je ne vois pas trop le rapport avec une servlet : printStackTrace() affiche la stack trace de l'exception dans la sortie standard System.err. Normalement, celle-ci devrait être redirigée vers le log de ton conteneur de servlet. Dans une jsp, la trace peut effectivement s'afficher "dans le navigateur" si on ne l'intercepte pas ou si on le fait à dessein, mais le code dont tu parles n'est pas exécutée dans une jsp, n'est-ce-pas ?
Par ailleurs, si tu veux contrôler le logging de façon plus précise, tu peux utiliser une API de logging, mais c'est un autre problème.

**momjunior** · 30/06/2015, 15h47

En fait si, c'est une application web que je viens d'héberger. Le code est affiché dans une jsp. et quand je fais:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

System.err.println("l'Erreur est:"+e);

L'erreur n'est pas affichée dans le log. C'est pour ça que je l'affiche dans le navigateur.

Sinon je pense que l'erreur vient du paramètre "chemin" que j'ai déclaré dans mon xml:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<servlet>
        <servlet-name>AjouterPhoto</servlet-name>
        <servlet-class>servlets.AjouterPhoto</servlet-class>
        <init-param>
            <param-name>chemin</param-name>
            <param-value>/fichiers/images/</param-value>
        </init-param>
        <multipart-config>
            <location>/home/jobprofi/fichiers/images</location>
            <max-file-size>2097152</max-file-size>
            <!-- 2 Mo -->
            <max-request-size>10485760</max-request-size>
            <!-- 5 x 2Mo -->
            <file-size-threshold>1048576</file-size-threshold>
            <!-- 1 Mo -->
        </multipart-config>
    </servlet>

Je dis ça parce que en local je n'ai pas ce genre d'erreur. C'est lorsque j'héberge le site que j'ai tous ces messages d'erreur.

Normalement sur un système Windows, la ligne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

<param-value>/fichiers/images/</param-value>

fait référence au répertoire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 C:\fichiers\images\

Mais quand est-il sur un système Linux? Parce que mon application tourne sur un système Linux.

J'ai aussi créé le répertoire fichiers/images dans home/monsite. Donc le chemin /home/monsite/fichiers/images existe.

Merci

**joel.drigo** · 30/06/2015, 17h18

Non, "/fichiers/images/" ne fait pas nécessairement référence à "c:/fichiers/images/" : lorsqu'on passe un chemin relatif, il y'a une résolution du chemin absolu faite par rapport au dossier d'exécution du programme (le dossier dans lequel on lance, ou qu'on indique comme étant dossier d'exécution (dans les raccourcis par exemple)).

Sur linux/unix/macosx, les chemins ne commencent pas par un c: ou d:, etc., mais directement par un / : /fichiers/images est un chemin absolu d'un dossier image dans un dossier fichier, lui-même directement à la racine.

Il serait préférable que tu construises tes chemins directement à partir d'un chemin absolu (en paramètre d'application). Comme tu es dans une application web et que ton dossier est interne à ton webcontent (si ce ne sont pas des fichiers temporaires, il est préférable de les stocker ailleurs pour ne pas avoir de problème d'écrasement lors des déploiements), tu peux te positionner relativement au chemin dans ton application (ServletContext.getRealPath(), Anciennement HttpServletRequest.getRealPath()),

**momjunior** · 04/07/2015, 16h46

Bon finalement ça a marché...

Tu avais raison concernant les chemins sur linux, je l'avais oublié. J'ai donc juste modifié la valeur de param-value:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

<param-value>/home/monsite/fichiers/images/</param-value>

En plus de ça j'ai découvert que mon hébergeur a créé deux fichiers juste à coté du catalina.log: stderr.log et stdout.log qui contiennent respectivement toutes les erreurs provenant du System.err et System.out. Et dire que j'ai galéré tout ce temps à afficher les erreurs.

Bref je me suis précipité sans avoir bien compris les Exceptions. Je dois relire mon cours.

Encore merci pour ton aide et si t'as d'autres conseils à me donner je suis preneur joel.drigo

Problème de chemin

Servlets/JSP Java

Discussions similaires

Partager

Partager