Sun JSC2 - How to download files to client

Question

Hi, imagine a document management site.
I want to have a list of files with links that users can click to download them.
Users can upload files (with handy File Upload component), and they get saved as byte streams to a file or database or whatever.
Now, I have a page with a list of files the user can download. The file name, a link to save the file, and a link to download the file.
File1.pdf . . . DOWNLOAD IT! . . . SAVE IT!
The DOWNLOAD IT! link tries to use mime stuff to get the browser to open the file.
The SAVE IT! link tells the browser to not process the file and always bring up the save as dialog. In both cases, I don't want the browser to open a new page.
Starting with a byte[], what's the best way to do this? I searched the web, and these forums, but couldn't come up with anything that gave me a place to start from inside JSC2.
Any ideas on where to start? Thanks in advance!
Mike

Answer 1

Hey Winston, here is what I came up with... Very similar, but a little different.
Java Server Faces File Download Tutorial by Michael Cole
Java Server Faces, abstracts much of the monotonous detail of web programming, letting application developers develop applications, instead of programming servers.
This tutorial explains how to dip just a little under the covers to serve files to a browser. The browser can then interpret this binary data using MIME types. Some common MIME types are �text/plain�, �text/html�, or �application/pdf� or �application/x-unknown�.
How the browser behaves when interacting with these MIME types is based on the client browser's configuration. Because this configuration is different for every browser, let's create two different behaviors:
* First Behavior: When a link is clicked, the browser downloads and �opens� the file, either displaying the file itself, or choosing an appropriate program: zip file program, pdf program, etc.
* Second Behavior: The browser always offers to save the file, no matter what.
At the most basic level, we want to cause this chain of events:
1. Cause browser to send a request to the server.
2. Have the server create a response that sends the file to the client.
For my purposes, the browser should not navigate to a new page for this behavior.
A mockup might look like this:
Files you can download:
Secrets of the Universe.txt
Open it!
Save it!
Perfect love and happiness.pdf
Open it!
Save it!
Make a million dollars now.swf
Open it!
Save it!
To accomplish this, we will execute this code on the server:
// Find the HttpServletResponse object for this request.
// With this object, we can create a response that sends the file.
FacesContext faces = FacesContext.getCurrentInstance();
HttpServletResponse response = (HttpServletResponse) faces.getExternalContext().getResponse();
// We can also get information about what the browser requested.
// This could tell us what data to send
HttpServletRequest request = (HttpServletRequest) faces.getExternalContext().getRequest();
// Your data can be stored in a database, generated at runtime, or whatever you choose.
// We getSomeData() from an arbitrary location. This depends on your application.
byte[] data = getSomeData(request);
// In the response, we will specify a file name to present to the user.
String filename = "myFile.txt";
// Now we have the data to send, and the response object to send it with.
// Next we give the browser some hints on what to do with the file.
// Note that different browsers will behave differently and you have no control over this.
// We'll use different mime types to implement the different "Open" and "Save" behaviors.
// "application/x-unknown" will be the MIME type used for the "Save" behavior.
response.setContentType(mimeType);
// We tell the browser how much data to expect.
response.setContentLength(data.length);
// Cross-browser hack for Firefox 1.0.7 and IE 6 compatibility.
// IE 6 ignores the MIME type and decides based on the "attachment" or "inline"
if (mimeType.equals("application/x-unknown")) {
// Show the "Save As..." dialog
response.setHeader( "Content-disposition", "attachment; filename=\"" + filename + "\"");
} else {
// attempt to "open" the file
response.setHeader( "Content-disposition", "inline; filename=\"" + filename + "\"");
// Now we start sending data with the response object.
// You might consider using a buffer if your data comes from a large file
// or a database.
try {
ServletOutputStream out;
out = response.getOutputStream();
out.write(data);
} catch (IOException e) {
e.printStackTrace();
// Lastly and very importantly, we tell Java Server Faces that
// the request has been handled and not to process it any more.
faces.responseComplete();
Now all we have to do is put this code somewhere.
Step 1: Build the page UI.
* Create a new page in Java Studio Creator. Let's call it �download.jsp�
* Make it the start page (right-click)
* Add a hyperlink component and call it �Open!�
* If you like, add a static text that describes your file.
Step 2: Tell Java Server Faces what to do when the hyperlink is clicked.
* Doubleclick the hyperlink and add this code to it's action:
public String hyperlink1_action() {
// TODO: Replace with your code
DownloadBean d = new DownloadBean();
d.sendFile("text/plain");
return null;
* Compile the download.java and get a �cannot find symbol for class DownloadBean�. Now we have a place to put our code to send the file!
Step 3: Build the DownloadBean that will serve the file.
* Go to your "Source Packages" folder and create a new Java class in the project's package. Call this class �DownloadBean�.
* Copy this code into the class:
public void sendFile(String mimeType) {
FacesContext faces = FacesContext.getCurrentInstance();
HttpServletResponse response = (HttpServletResponse) faces.getExternalContext().getResponse();
HttpServletRequest request = (HttpServletRequest) faces.getExternalContext().getRequest();
byte[] data = getSomeData(request);
String filename = "myFile.txt";
// Note that different browsers will behave differently and you have no control over this.
// We'll use different mime types to implement the different "Open" and "Save" behaviors.
// "application/x-unknown" will be the MIME type used for the "Save" behavior.
response.setContentType(mimeType);
response.setContentLength(data.length);
// Cross-browser hack for Firefox 1.0.7 and IE 6 compatibility.
// IE 6 ignores the MIME type and decides based on the "attachment" or "inline"
if (mimeType.equals("application/x-unknown")) {
// Show the "Save As..." dialog
response.setHeader( "Content-disposition", "attachment; filename=\"" + filename + "\"");
} else {
// attempt to "open" the file
response.setHeader( "Content-disposition", "inline; filename=\"" + filename + "\"");
// Now we start sending data with the response object.
try {
ServletOutputStream out;
out = response.getOutputStream();
out.write(data);
} catch (IOException e) {
e.printStackTrace();
faces.responseComplete();
* Hit Ctrl-Shift-F to make the code pretty.
* Try and compile DownloadBean.java. Build->Compile
* As expected, you will get a variety of �cannot find symbol� errors.
* Hit Ctrl-Alt-F to clean these up, by automatically adding the proper imports.
* Try and compile again and you will get a �cannot find symbol� error for the getSomeData() function. That's ok cause we didn't write it yet.
* Copy this code into the DownloadBean class:
public byte[] getSomeData(Object o) {
// ignore the HttpServletRequest object and return some data.
return "Hello World!".getBytes();
* Compile the file one last time to get a clean compile.
Why didn't we put this code directly in the hyperlink1_action() function? Because we are separating the �model� from the "view" and "controller". DownloadBean can be reused in any page of your application now.
Step 4: Test
1. Run the project and open the page in the Firefox web browser.
2. Click the �Open It!� hyperlink
3. A text file should appear in Firefox that says �Hello World!�
Great! We sent the file, Firefox interpreted the �text/plain� MIME type, and presented the text as a browser page. This covers our �Open It!� functionality.
To serve other kinds of files, pass a different MIME type in the sendFile() function.
For a list of MIME types, check out http://www.webmaster-toolkit.com/mime-types.shtml
Step 5: Save It! Functionality.
What if we always want the file to be saved, no matter what foolishness the browser wants to do with the file?
* Go back to the Design of download.jsp.
* Add another hyperlink to the page, label it �Save It!�
* Double click the hyperlink and JSC2 will take you to its action function.
* Add this code to the function
public String hyperlink2_action() {
// TODO: Replace with your code
DownloadBean d = new DownloadBean();
d.sendFile("application/x-unknown");
return null;
Notice the difference in the MIME type? We changed �text/plain� to �application/x-unknown�. Notice also in the sendFile() function the cross-browser hack to get IE 6.0 to save or open the file.
* Run the project one last time.
* Test with Firefox
* Test with Internet Explorer
Done!