Where do I configure the path where a file is uploaded using GWT Uploader?

Question

I'm using this library: http://www.moxiegroup.com/moxieapps/gwt-uploader/, to upload files within my Web Application. I followed the steps explained here: http://www.moxiegroup.com/moxieapps/gwt-uploader/userguide.jsp, and use the first example in their showcase: http://www.moxiegroup.com/moxieapps/gwt-uploader/showcase/index.jsp, I modified the parameter in the method Upload.setUploadURL() with the information of my servlet and it seems that everything works fine. The server log even says that the file was succesfully uploaded. My problem is that I can't find it (the file). Where should I look for it or where can I set the path where files should be uploaded?

Here is the client code:

package org.moxieapps.gwt.uploader.showcase.client;

import com.google.gwt.core.client.EntryPoint;  
import com.google.gwt.i18n.client.NumberFormat;  
import com.google.gwt.user.client.Window;  
import com.google.gwt.user.client.ui.HorizontalPanel;  
import com.google.gwt.user.client.ui.Label;  
import com.google.gwt.user.client.ui.RootPanel;  
import com.google.gwt.user.client.ui.VerticalPanel;  
import org.moxieapps.gwt.uploader.client.Uploader;  
import org.moxieapps.gwt.uploader.client.events.*;  

/** 
 * Simple Text Link and Progress text label example of GWT Uploader 
 */  
public class TextButtonAndProgressText implements EntryPoint {  

    private Label progressLabel;  
    private Uploader uploader;  

    public void onModuleLoad() {  
        progressLabel = new Label();  
        progressLabel.setStyleName("progressLabel");  

        uploader = new Uploader();  
        uploader.setUploadURL("/DevNullUploadServlet")  
            .setButtonText("<span class=\"buttonText\">Click to Upload</span>")  
            .setButtonTextStyle(".buttonText {font-family: Arial, sans-serif; font-size: 14px; color: #BB4B44}")  
            .setFileSizeLimit("50 MB")  
            .setButtonWidth(150)  
            .setButtonHeight(22)  
            .setButtonCursor(Uploader.Cursor.HAND)  
            .setButtonAction(Uploader.ButtonAction.SELECT_FILE)  
            .setUploadProgressHandler(new UploadProgressHandler() {  
                public boolean onUploadProgress(UploadProgressEvent uploadProgressEvent) {  
                    progressLabel.setText(NumberFormat.getPercentFormat().format(  
                        (double)uploadProgressEvent.getBytesComplete() / (double)uploadProgressEvent.getBytesTotal()  
                    ));  
                    return true;  
                }  
            })  
            .setUploadSuccessHandler(new UploadSuccessHandler() {  
                public boolean onUploadSuccess(UploadSuccessEvent uploadSuccessEvent) {  
                    resetText();  
                    StringBuilder sb = new StringBuilder();  
                    sb.append("File ").append(uploadSuccessEvent.getFile().getName())  
                        .append(" (")  
                        .append(NumberFormat.getDecimalFormat().format(uploadSuccessEvent.getFile().getSize() / 1024))  
                        .append(" KB)")  
                        .append(" uploaded successfully at ")  
                        .append(NumberFormat.getDecimalFormat().format(  
                            uploadSuccessEvent.getFile().getAverageSpeed() / 1024  
                        ))  
                        .append(" Kb/second");  
                    progressLabel.setText(sb.toString());  
                    return true;  
                }  
            })  
            .setFileDialogCompleteHandler(new FileDialogCompleteHandler() {  
                public boolean onFileDialogComplete(FileDialogCompleteEvent fileDialogCompleteEvent) {  
                    if (fileDialogCompleteEvent.getTotalFilesInQueue() > 0 && uploader.getStats().getUploadsInProgress() <= 0) {  
                        progressLabel.setText("0%");  
                        uploader.setButtonText("<span class=\"buttonText\">Uploading...</span>");  
                        uploader.startUpload();  
                    }  
                    return true;  
                }  
            })  
            .setFileQueueErrorHandler(new FileQueueErrorHandler() {  
                public boolean onFileQueueError(FileQueueErrorEvent fileQueueErrorEvent) {  
                    resetText();  
                    Window.alert("Upload of file " + fileQueueErrorEvent.getFile().getName() + " failed due to [" +  
                        fileQueueErrorEvent.getErrorCode().toString() + "]: " + fileQueueErrorEvent.getMessage()  
                    );  
                    return true;  
                }  
            })  
            .setUploadErrorHandler(new UploadErrorHandler() {  
                public boolean onUploadError(UploadErrorEvent uploadErrorEvent) {  
                    resetText();  
                    Window.alert("Upload of file " + uploadErrorEvent.getFile().getName() + " failed due to [" +  
                        uploadErrorEvent.getErrorCode().toString() + "]: " + uploadErrorEvent.getMessage()  
                    );  
                    return true;  
                }  
            });  

        VerticalPanel verticalPanel = new VerticalPanel();  
        verticalPanel.add(uploader);  
        verticalPanel.add(progressLabel);  
        verticalPanel.setCellHorizontalAlignment(uploader, HorizontalPanel.ALIGN_LEFT);  
        verticalPanel.setCellHorizontalAlignment(progressLabel, HorizontalPanel.ALIGN_LEFT);  

        //noinspection GwtToHtmlReferences  
        RootPanel.get("TextButtonAndProgressText").add(verticalPanel);  
    }  

    private void resetText() {  
        progressLabel.setText("");  
        uploader.setButtonText("<span class=\"buttonText\">Click to Upload</span>");  
    }  
}  

Here is the server code:

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

public class FileUploadServlet extends HttpServlet {

  private long FILE_SIZE_LIMIT = 20 * 1024 * 1024; // 20 MiB
  private final Logger logger = Logger.getLogger("UploadServlet");

  protected void doPost(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException {

    try {
      DiskFileItemFactory fileItemFactory = new DiskFileItemFactory();
      ServletFileUpload fileUpload = new ServletFileUpload(fileItemFactory);
      fileUpload.setSizeMax(FILE_SIZE_LIMIT);

      List<FileItem> items = fileUpload.parseRequest(req);

      for (FileItem item : items) {
        if (item.isFormField()) {
          logger.log(Level.INFO, "Received form field:");
          logger.log(Level.INFO, "Name: " + item.getFieldName());
          logger.log(Level.INFO, "Value: " + item.getString());
        } else {
          logger.log(Level.INFO, "Received file:");
          logger.log(Level.INFO, "Name: " + item.getName());
          logger.log(Level.INFO, "Size: " + item.getSize());
        }

        if (!item.isFormField()) {
          if (item.getSize() > FILE_SIZE_LIMIT) {
            resp.sendError(HttpServletResponse.SC_REQUEST_ENTITY_TOO_LARGE,
              "File size exceeds limit");

            return;
          }

          // Typically here you would process the file in some way:
          // InputStream in = item.getInputStream();
          // ...

          if (!item.isInMemory())
            item.delete();
        }
      }
    } catch (Exception e) {
      logger.log(Level.SEVERE, "Throwing servlet exception for unhandled exception", e);
      throw new ServletException(e);
    }
  }

}  

Answer 1

Although the log is showing you that the file is successfully being uploaded, you are never actually saving the file to your local disk.

  for (FileItem item : items) {
    if (item.isFormField()) {
      logger.log(Level.INFO, "Received form field:");
      logger.log(Level.INFO, "Name: " + item.getFieldName());
      logger.log(Level.INFO, "Value: " + item.getString());
    } else {
      logger.log(Level.INFO, "Received file:");
      logger.log(Level.INFO, "Name: " + item.getName());
      logger.log(Level.INFO, "Size: " + item.getSize());
    }

Above is the relevant code that shows the logger being able to find FileItems and log their details.

A few lines later, there is the following comment:

      // Typically here you would process the file in some way:
      // InputStream in = item.getInputStream();
      // ...

This is where I am guessing that the tutorial leaves it up to you to decide how to write the file to your disk. Look into writing files to disk using InputStream and you should have no problems. The upload part seems to be working fine, you just need to write the uploaded files to disk.

EDIT: It appears that the Apache FileUpload library you are using has some simple ways to attempt to write files to disk. Replacing the comments with the following lines should work:

File newFile= new File("C:/path/to/directory");
item.write(newFile);