UPLOAD A FILE USING LIBRARY

In my previous post I mentioned how to write the code that will upload a file to the server using servlet 3.0. But the main headache comes when you're not so lucky and somehow You don't work in an environment which supports servlet 3.0. For eg, if u try to run a webserver that supports servlet 3.0 like APACHE TOMCAT 7.0 along with netbeans or eclipse IDE in our low configured college laptop on windows environment..it'll definitely crash!! So, this tutorial might be specially useful for my friends and to those who're facing almost a similar situation.

For the introductory knowledge read my previous post on file upload introduction before servlet 3.0 came to rescue...It is advisable to read it thoroughly or if u avoid the basics, you might spend 50 minutes on a bug trying to skip a 5 min.

Libraries to the rescue.....

There are a lot of libraries that are available free to download that eases your file upload coding task!..the 2 libraries I found to be pretty flexible are

1. Apache Commons File upload API
2. Oreilly's file uploading library.

Since, Apache commons file upload api is pretty popular and there are a lot of codes available over the internet regarding how to use it...I'll better focus on Oreilly's file uploading library that works magic and is pretty impressive!

All you need to do is -

1. Download the library from http://www.servlets.com/cos/ and include it in your class path the way you import external jar/zip files from you IDE, or using command prompt.

2. Make an HTML file as I suggested in my previous post.

3. Make a servlet (don't use JSP for backend logic...remember I told you...it's a bad practice. use JSP for front end logic only!) that actually uses it to write the file upload logic.

First thing's first, Download the file (cos-26Dec2008.zip) from the link. You'll find the file download link at the bottom of Oreilly's page and iclude it in your project's class path.

Now, lets get started with the servlet....You may like to see the documentation before you get started (and you should before blindly copy-pasting the use of a class and it's methods). The documentation goes here: JAVADOC

I'll be going to use the following constructor :


MultipartRequest(javax.servlet.http.HttpServletRequest request, java.lang.String saveDirectory, int maxPostSize)


There are three parameters of this function, the first one being the HttpServletRequest. The second one defines the path of the directory where the file will get saved in the server hard-disk, after getting uploaded. The third parameter constraints the maximum size of file upload.

So, we can't do much about the first parameter. The second parameter needs to be specified and is the most important. Remember that the path will not be any machine specific path or a client side path. It should be a generalized server path where your project resides.To get the generalized server path use:


String saveFile=this.getServletContext().getRealPath("\\");


For the 3rd parameter, it's upto your will. For eg, if u want to limit max file size to 4MB u should write "4*1024*1024" as the third constructor.

Now if we use these parameters and create an object of the "MultipartRequest" class your file upload code is ready. The only thing left is to retrieve the file name. We'll use the method -


getOriginalFileName(java.lang.String name)


The parameter to this method is the "name" you provide to < input type="file" name="file">.

The entire servlet:


import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import java.io.*;
import javax.servlet.http.HttpServlet;
import com.oreilly.servlet.*;

/**
*
* @author soumya
*/

public class multiserv extends HttpServlet
{

protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try
{

String saveFile=this.getServletContext().getRealPath("\\");
MultipartRequest mr=new MultipartRequest(request,saveFile,4*1024*1024);

System.out.print(saveFile); // see the path in your console for reference

String filename=mr.getOriginalFileName("file");

response.sendRedirect("home.jsp");

}
catch(Exception e)
{
out.print(e.getMessage());
}
}



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



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


So that's it...you got the tutorial for uploading file...and that too without servlet 3.0!...cheers!! :) Hope you liked it....

---

UPLOAD A FILE TO WEB-SERVER

If you are a web developer, I'm definite you have faced this problem at some point or the other. Usually getting any parameter from another jsp/html isn't quite a big deal. A simple "request.getParameter()" handles your request and retrieves the parameter value for the given parameter name. But when sending/uploading a file from client side to the server, request.getParameter() doesn't work, and that's where we get stuck!!..But that's quite obvious, because, a file is not like any other formal parameter. A file needs to be transmitted as a MIME stream (Multipurpose Internet Mail Extensions stream) from the client side to the server side and request.getParameter() doesn't work with MIME streams!!



Now how to solve this....

There are lots of example out there on the internet, but its very hard to choose which one will work, specially if you don't have any clue, how these things work! So first let me warn you, most of the examples that you'll find over the internet used to work in prehistoric dinosaur era.

Now the internet and web-browsers are pretty much secure and to bring about the security, they have changed the way the old-prehistoric-codes used to handle file uploads! Previously, the entire client path used to get parsed on submit to the servlet (for eg.) providing a scope of security breaching! But now, in all modern browsers, the entire class path doesn't get submitted when the form is serialized, but a fake client path followed by the file name is parsed!..So if you find a code that plays with client side path of the file to upload, dump it straight away!!

The second type of examples that successfully upload the files to the web-server are available on the internet by parsing the entire form-data along with the file as MIME stream and retrieves the file name from the boundaries of the stream. But this is pretty ineffective in the sense that, if you have other parameters like input type text/password or anything, you cannot retrieve them using request.getParameter() as I mentioned, the entire thing gets parsed as MIME stream and it doesn't work with MIMEs. So if you want to upload a single file from a single form, it works fine. But my suggestion is, try to avoid those codes!



Servlet 3.0 to the rescue...

So if you have an application server that supports servlet 3.0(usually recent versions like APACHE TOMCAT v7.0,GLASSFISH v3) you're lucky!..Thanx to my friend Soumyajyoti Bhadra for suggesting this to me!Something similar to request.getParameter() works wonder!..It's request.getPart(). Using request.getPart() you can easily retrieve your file from the client end along with other parameters.

So, let's look into the code - You'll need two files-
1. An HTML file
2. A servlet (and not JSP, tired of telling people, JSPs should be used for presentation logic, while servlets as backend logic, it's a better practice).

First, create an HTML file - Do not forget to use method="post" and enctype="multipart/form-data", otherwise your file won't get uploaded!


HTML:

<html>
<head>
<title>File Upload</title>
</head>

<body>
<form name="file_upload" method="post" enctype="multipart/form-data" action="UploadFile">
Select File : <input name="file" type="file"/>
<br>
<input type="submit" value="Upload File"/>

</form>
</body>
</html>


Next, create the servlet - UploadFile.java


SERVLET:

package com.example.servlets;

+ import ........; // package imports



public class UploadFile extends HttpServlet {
protected void processRequest(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException, AddressException {

response.setContentType("text/html;charset=UTF-8");

PrintWriter out = response.getWriter();
try {

Part myfile = request.getPart("file");
Scanner scanner = new Scanner(myfile.getInputStream()); // upload the file
String filename = s.nextLine(); // read the filename
//get the server file path
String path = this.getServletContext().getRealPath(filename);

out.println("File Upload Successful");
}
catch (Exception e){
e.printStackTrace();}

finally {
out.close();
}
}

protected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException
{
try
{
processRequest(request, response);
}catch (AddressException ex) {
Logger.getLogger(UploadFile.class.getName()).log(Level.SEVERE, null, ex);
}


protected void doPost(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException
{
try {
processRequest(request, response);
} catch (AddressException ex) {
Logger.getLogger(addemployee.class.getName()).log(Level.SEVERE, null, ex);
}
}

}



That's it...Your file will get uploaded to the web server. Now use the file name to access the file!..cheers..!! Hope you liked it.

---