Java Servlet: delete temporary file

Question

I am working on a Java Servlet which creates a temporary file to use in a session. At the end of the session (ie, user "logout"), I need to remove the temporary file, and then redirect the user to the initial ("login") page. The redirection works fine, but the temporary file remains intact.

I presume it has something to do with the path to the file, but I am not quite sure as to what. I create the file when the session initiates:

String path = request.getSession().getServletContext().getRealPath("/");
File file = File.createTempFile("getter", ".html", new File(path + "/tmp/"));

Then, when closing the session, I do:

file.delete();

I know about file.deleteOnExit(), but... when do I exit a servlet? Perhaps I am confused, but I would surely appreciate any help! :)

Thank you in advance!

EDIT

So, here come some details:

I am using a servlet, as I said, for the time being without handling sessions. I agree with @Joop that I will need to implement sessions, but for the time being just wanted to do some simple testing.

So, my servlet hagles GET and POST requests. I use a flag in the POST request to call an internal function which instantiates the file (declared in the class as private File file;) to a new temp file. On consecutive calls, the file gets populated and saved. In the page the user sees, I have an anchor referring to the servlet (to 'this', that is), passing a flag as a parameter, a flag that indicates the 'logout'. Then I call another internal function which deletes the file previously instantiated.

If it is a matter of sesions, I will implement the manager and post my findings.

EDIT 2

I implemented an HttpSessionListener, and all seems to work fine. Now, on creating the session, I instantiate a file in my previously declared directory (note that it is not a temp file, I use File file = new File(path + "/tmp/" + req.getSession().getId() + ".html"); so the name of the file equals the session ID). Then I add an attribute to the session, whose value is the full path to the file. I proceed to populate my file as always, and when the user selects to log out, I invalidate the session. Then, inside the listener, I retrieve the path to the file, hence I can acquire the pointer to it:

String fname = ev.getSession().getAttribute("filename").toString();
File f = new File(fname);
f.delete();

So, now the messages I am getting are positive, I mean f.delete() returns true, and after this I do f.exists() and I get false. So it should be OK. However, the files physically exist, that is they are still present on the disk.

I can try the example so kindly provided by @A4L. Have I done something wrong..?

Answer 1

Please stop writing arbitrary files to deploy folder during runtime. Just write to a real temp folder instead. Get rid of the following line altogether:

path = request.getSession().getServletContext().getRealPath("/");

and just use

File file = File.createTempFile("getter", ".html");

Your concrete problem is likely caused because the files in the deploy folder are usually locked by the servletcontainer. You can't delete files therein.

A hint for the future: whenever you occur to think that the getRealPath() could solve a problem, you should immediately stop writing code and think twice about whether it's the right tool to fix the concrete problem. In the decade I developed Servlet based web applications, there was no one sensible real world use case for that method. See also What does servletcontext.getRealPath("/") mean and when should I use it

---

I know about file.deleteOnExit(), but... when do I exit a servlet?

You don't. The container does. The "exit" here basically means the shutdown of the whole JVM. This is even literally mentioned in the javadoc (emphasis mine).

Requests that the file or directory denoted by this abstract pathname be deleted when the virtual machine terminates.

Answer 2

Make sure you have closed the file before attempting to delete it when the user logs out and check what File#delete() returns.

@Test
public void createTempFile() throws IOException {
    File tf = File.createTempFile("hello", ".tmp", new File("."));
    FileOutputStream fos = new FileOutputStream(tf);
    fos.write("Hello, Temp!".getBytes());
    Assert.assertTrue(tf.delete()); // fails because the file could not be deleted
                                    // and delete() returns false
}

vs.

@Test
public void createTempFile() throws IOException {
    File tf = File.createTempFile("hello", ".tmp", new File("."));
    FileOutputStream fos = new FileOutputStream(tf);
    fos.write("Hello, Temp!".getBytes());
    fos.close();
    Assert.assertTrue(tf.delete()); // passes, file deleted
}

With File#deleteOnExit() the file will be deleted twhen the VM exits, this happen when your tomcat is shutdown. So it won't help on user logout.

EDIT

Make sure you have only one file per user and across mutiple requests. I suggest you use a SessionListener as Joop suggested, create the file when HttpSessionListener#sessionCreated is called and put it into the session with a well known key, you can get the session object using HttpSessionEvent#getSession(). When you logout call HttpSession.#invalidate(), the Listner method HttpSessionListener#sessionDestroyed will be called, then you can get the file from the session and delete it.

Simple example, (doGet only and without SessionListener)

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@WebServlet(urlPatterns = "/ptf.html")
public class PopulateTempFile extends HttpServlet { 
    private static final long serialVersionUID = -144949663400032218L;

    private static class TempFilePopulator {
        private File tf = null;
        public TempFilePopulator(String rootDir) throws IOException {
            tf = File.createTempFile("hello", ".tmp", new File(rootDir));
        }

        public void populate(String line) throws IOException {
            FileWriter fw = new FileWriter(tf, true);
            fw.write(line + "\n");
            fw.close();
        }

        public List<String> getContent() throws IOException {
            List<String> lines = new ArrayList<String>();
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(tf)));
            String line;
            while(null != (line = br.readLine())) {
                lines.add(line);
            }
            br.close();
            return lines;
        }

        public boolean deleteTempFile() { return tf.delete(); }
        public String toString() { return tf.getAbsolutePath(); }
    }


    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {

        HttpSession session = request.getSession();
        TempFilePopulator tfp = (TempFilePopulator) session.getAttribute("tempfilepopulator");

        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<html>");

        out.println("<a href=\"" + request.getServletContext().getContextPath()
            + request.getServletPath() + "\">Refresh</a>");
        out.println("&nbsp;|&nbsp;");
        out.println("<a href=\"" + request.getServletContext().getContextPath()
            + request.getServletPath() + "?logout=true\">Logout</a>");

        String logout = request.getParameter("logout");
        if("true".equals(logout)) {
            if(tfp != null) {
                if(tfp.deleteTempFile()) {
                    log("Temp file '" + tfp + "' deleted.");
                } else {
                    log("Unable to delete temp file '" + tfp + "'");
                }
            }
            session.invalidate();
        } else {
            if(tfp == null) {
                tfp = new TempFilePopulator(request.getServletContext().getRealPath("/"));
                log("Temp file '" + tfp + "' created.");
                session.setAttribute("tempfilepopulator", tfp);
            }
            tfp.populate(new Date().toString());
            out.println("<p>Content of temp file</p>");
            List<String> lines = tfp.getContent();
            for(String line : lines) {
                out.write(line);
                out.write("<br/>");
            }
        }
        out.println("</html>");
    }
}

Answer 3

Every call to createTempFile gives another path, so the path has to be stored.

See SessionListener. Example - if session timeout is involved.

Maybe use the JSESSIONID as directory with temp files and delete the directory.

BTW I presume you invalidate the session after file.delete() as otherwise getSession() would create a new session. I would log file.getPath().

Answer 4

You can also use the deleteOnExit() method ... please have a look at the java doc of the createTempFile() -

Creates a new empty file in the specified directory, using the given prefix and 
suffix strings to generate its name. If this method returns successfully then 
it is guaranteed that:

The file denoted by the returned abstract pathname did not exist before this 
method was invoked and , 

Neither this method nor any of its variants will return the same abstract 
pathname again in the current invocation of the virtual machine. 

This method provides only part of a temporary-file facility. To arrange 
for a file created by this method to be deleted automatically, use the
deleteOnExit() method.