Dans un projet, les exigences suivantes s'appliquent :

1. Le fichier téléchargé est validé par la plateforme de l'entreprise. Une fois la validation réussie, l'interface retourne un flux de fichier.
2. Le flux est ensuite manipulé. Dans ce cas, le flux est copié dans un répertoire temporaire du projet, tel que WEB-INF/temp. Après utilisation, le fichier est supprimé.

Voici un exemple de code illustrant cette logique :

TempFileCopier.java :

package com.example.util;

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.io.UnsupportedEncodingException;
import java.net.URLDecoder;

public class TempFileCopier {
    
    private static final int CHUNK_SIZE = 10240; // Taille de lecture par morceaux de 10 Ko
    
    /**
     * Copie un flux d'entrée dans un fichier temporaire dans le répertoire WEB-INF/temp.
     * @param inputStream Le flux source à copier
     * @param tempFileName Le nom du fichier temporaire
     * @return Le fichier temporaire créé
     * @throws IOException En cas d'erreur d'entrée/sortie
     */
    public static File copyStreamToTempFile(InputStream inputStream, String tempFileName) throws IOException {
        String tempDirPath = resolveTempDirectoryPath();
        File tempFile = new File(tempDirPath, tempFileName);
        
        try (BufferedInputStream bufferedIn = new BufferedInputStream(inputStream);
             BufferedOutputStream bufferedOut = new BufferedOutputStream(new FileOutputStream(tempFile))) {
            
            byte[] buffer = new byte[CHUNK_SIZE];
            int bytesRead;
            while ((bytesRead = bufferedIn.read(buffer)) != -1) {
                bufferedOut.write(buffer, 0, bytesRead);
            }
            bufferedOut.flush();
        }
        
        return tempFile;
    }
    
    /**
     * Supprime un fichier temporaire spécifié.
     * @param file Le fichier à supprimer
     */
    public static void removeTempFile(File file) {
        if (file != null && file.exists()) {
            file.delete();
        }
    }
    
    private static String resolveTempDirectoryPath() {
        String path = "";
        try {
            String resourcePath = TempFileCopier.class.getClassLoader().getResource("../temp").getPath();
            path = URLDecoder.decode(resourcePath, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("Erreur lors du décodage du chemin", e);
        }
        return path;
    }
}

Simulation d'appel via Servlet :

1. Simualtion de lecture d'un fichier local pour créer un flux d'entrée.
2. Copie de ce flux dans le répertoire temporaire WEB-INF/temp.
3. Suppresssion du fichier après son utilisation.

package com.example.servlet;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

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

import com.example.util.TempFileCopier;

public class FileCopyServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // Simulation d'un flux à partir d'un fichier local
        InputStream fileInputStream = new FileInputStream(new File("chemin/vers/fichier.zip"));
        
        // Copie dans le répertoire temporaire
        File temporaryFile = TempFileCopier.copyStreamToTempFile(fileInputStream, "temp_archive.zip");
        
        // Utilisation du fichier ici...
        
        // Suppression après utilisation
        TempFileCopier.removeTempFile(temporaryFile);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
}