Welcome to Day 15! Today you'll see one of the most important topics in JSP programming—storing data on the server. One of the main reasons that programmers switch from client-based applications (such as those written in JavaScript that execute in the browser) to JSP is to be able to store and work with data in files (which you can't do in JavaScript). For example, you may want to create a guest book that stores user comments on the server, or even create and work with your own database. You might even want to log errors or user accesses—any data that you want to persist between sessions, you can store in files on the server. There are literally thousands of uses for working with files on the server.
Here are the topics you'll see today:
Understanding Java file I/O
Understanding I/O streams
Using Java readers and writers
Working with text files
Working with binary files
Creating a guest book
Logging data on the server
Getting a list of the files in a directory
Today's work will start with a topic you were first introduced to yesterday—using Tomcat log files.
Note
As you'll see today, working with files in Java is a large and complex subject. There is far more material than can be covered here, so if you need more information, take a look at the Java documentation, or pick up a book on Java.
You learned how to write to a Tomcat log file using a filter yesterday; here's an example showing how to do that from JSP. First, you set up a log file for the examples in the ch15 directory on the server in Tomcat's server.xml file. This is accomplished with a new <Context> element (it's inside the <Host> element in server.xml). You place this <Context> element after the other <Context> elements in server.xml:
<Context path="/ch15" docBase="ch15" debug="0" reloadable="true">
<Logger className="org.apache.catalina.logger.FileLogger"
directory="logs" prefix="ch15." suffix=".txt"
timestamp="true"/>
</Context>
That sets up the log file, which will be stored in the jakarta-tomcat-4.0.3logs directory and have the prefix ch15. Now you can use the servlet context's log method to write to the log file (you can get access to the servlet context with the session object's getServletContext method). For example, to log the IP address of the user accessing this JSP page, and the URL to which she has navigated, you can use the code you see in Listing 15.1.
Example 15.1. Writing to a Log File (ch15_01.jsp)
<HTML> <HEAD> <TITLE>Using Log Files</TITLE> </HEAD> <BODY> <H1>Using Log Files</H1> This page writes to a log file. <% String address = request.getRemoteAddr(); String file = ((HttpServletRequest) request).getRequestURI(); session.getServletContext().log( "User access! " + " User IP: " + address + " Resource: " + file ); %> </BODY> </HTML>
You can see this page in Figure 15.1, where you see a message indicating that this JSP page writes to a log file.
You can see the results in the log file, such as jakarta-tomcat-4.0.3logsch15.2002-05-29.txt (where you'd use the current date in this log file's name). If you look in that file, you can find the entry in this log file caused by the user access:
2002-05-30 10:31:50 WebappLoader[/ch15]: Deploying class repositories to work directory D:omcatjakarta-tomcat-4.0.3worklocalhostch15 2002-05-30 10:31:50 WebappLoader[/ch15]: Reloading checks are enabled for this Context 2002-05-30 10:31:50 StandardManager[/ch15]: Seeding random number generator class java
This gives you access to the log files maintained by Tomcat itself. In this case, the JSP page only stored a little information about the user, but there are many uses for such logs. For example, if an exception occurs when your JSP executes, you might record it in the log file, including what data caused the problem:
try{
.
.
.
}
catch (Exception e){
session.getServletContext().log("An exception occurred: " + e.getMessage());
session.getServletContext().log("Current parameters: " + param1 + ", " + param2);
}
Java comes with dozens of classes built in to work with files. Most of those classes work by writing data to files or reading it back, but there's one class—the File class—that enables you to work with files without even opening them.
You can use the File class to handle files in Java without needing to open a file to access its contents. For example, using the File class, you can get a list of the files in a particular directory, delete a file, or get a file's length. This class is a big one—you can see the fields of the File class in Table 15.1, and its methods in Table 15.2.
Table 15.1. Fields of the File Class
Field | Means This |
|---|---|
| The (system-dependent) path-separator character ( |
| The (system-dependent) path-separator character. |
| The (system-dependent) default name-separator character, as a string. |
| The (system-dependent) default name-separator character. |
Table 15.2. Methods of the File Class
Here's an example showing how to work with the File class. Say that you wanted to present the user with a list of files he can download. You can get such a list using the File class, and you can make each filename into a hyperlink to the file itself as you display it.
Here's one thing to remember when you work with files—from the server's point of view, the directory it treats as the root directory for your Web application is the directory where your Web application is located. However, from Java's point of view, the root directory is the actual root directory of the disk itself. To get the actual path to your application's directory in terms that Java can understand, you can use the application object's getRealPath method:
String file = application.getRealPath("/");
Now you can use this real path to create a new File object, and get an array of the filenames in that directory, and an array of File objects corresponding to those files:
String file = application.getRealPath("/");
File file1 = new File(file);
String [] fileNames = file1.list();
File [] fileObjects= file1.listFiles();
.
.
.
To display a hyperlink to each file, as well as each file's length, you can loop over each file like this, making sure it's a real file and not a directory (check with the File class's isDirectory method):
String file = application.getRealPath("/");
File file1 = new File(file);
String [] fileNames = file1.list();
File [] fileObjects= file1.listFiles();
for (int loopIndex = 0; loopIndex < fileObjects.length; loopIndex++) {
if(!fileObjects[loopIndex].isDirectory()){
.
.
.
}
}
Now it's easy to create a hyperlink to each file in the current directory, as well as to indicate its length in bytes (which you can get with the File class's length method), as you see in Listing 15.2.
Example 15.2. Displaying a List of Downloadable Files (ch15_02.jsp)
<%@ page import="java.io.*" %> <HTML> <HEAD> <TITLE>Index of Files</TITLE> </HEAD> <BODY> <H1>Index of Files</H1> Click a file to open/download it... <% String file = application.getRealPath("/"); File file1 = new File(file); String [] fileNames = file1.list(); File [] fileObjects= file1.listFiles(); %> <UL> <% for (int loopIndex = 0; loopIndex < fileObjects.length; loopIndex++) { if(!fileObjects[loopIndex].isDirectory()){ %> <LI> <A HREF="<%= fileNames[loopIndex] %>"><%= fileNames[loopIndex] %></A> (<%= Long.toString(fileObjects[loopIndex].length()) %> bytes long) <% } } %> </UL> </BODY> </HTML>
You can see the results in Figure 15.2, where you see a list of hyperlinks giving the names of the files in the current directory (the same directory that ch15_02.jsp is in), as well as the length of each file. All the user has to do to open or download a file is click its name, making this a handy utility application, indeed.
As you can see, the File class is a use ful one. However, to work with the actual contents of a file, you need to use some of the dozens of Java classes targeted to that task, and that's coming up next.
In Java, stream I/O is based on the InputStream, OutputStream, Reader, and Writer classes. InputStream and OutputStream are for byte-oriented streams (when you work with binary files), and the Reader and Writer classes are for character-oriented streams (when you work with text files). You don't use these classes directly; instead, you derive classes from them, and in fact, Java has already done a lot of that for you—so much that there are many classes to work with. Here are some of them:
Writersubclasses—.BufferedWriter,CharArrayWriter,FilterWriter,OutputStreamWriter,PipedWriter,PrintWriter,StringWriter,FileWriterReadersubclasses—.BufferedReader,CharArrayReader,FilterReader,InputStreamReader,PipedReader,StringReader,FileReaderInputStreamsubclasses—.AudioInputStream,ByteArrayInputStream,FileInputStream,FilterInputStream,InputStream,ObjectInputStream,PipedInputStream,SequenceInputStream,StringBufferInputStreamOutputStreamsubclasses—.ByteArrayOutputStream,FileOutputStream,FilterOutputStream,ObjectOutputStream,OutputStream, andPipedOutputStream
You use a stream class's constructor to create a stream and open a file. The stream classes are usually divided into input and output streams, so you select the one that's appropriate—input to read, output to write. After you have a stream object, you can use its methods, typically read and write, to transfer data. When you're done with the stream object, you typically use its close method to close it and end your work with the data source or store.
When you work with files today, you'll use the file-oriented streams. In particular, the text files you'll be working with today are FileWriter and FileReader. The binary files you'll be working with today are FileInputStream and FileOutputStream. First on the agenda is learning how to work with text files, so you can see how to support a guest book into which the user can enter text.
The work you'll see here on text files uses the FileWriter and FileReader classes. These stream classes inherit methods from other classes in turn. For example, here's how the java.io.FileWriter class you'll be using is derived:
java.lang.Object
|
|__java.io.Writer
|
|__java.io.OutputStreamWriter
|
|__java.io.FileWriter
You can see the methods of the java.io.Writer class in Table 15.3, the methods of java.io.OutputStreamWriter in Table 15.4, and the methods of the java.io.FileWriter class in Table 15.5.
Table 15.3. Methods of the java.io.Writer Class
Method | Does This |
|---|---|
| Creates a new character-stream writer object. |
| Creates a new character-stream writer object that you can synchronize with other programs using the specified object. |
| Closes the stream. |
| Flush the stream, writing all remaining data out. |
| Writes an array of characters. |
| |
| Writes a single character. |
| Writes a string. |
|
Table 15.4. Methods of the OutputStreamWriter Class
Method | Does This |
|---|---|
| |
| Creates an |
| Closes the stream. |
| Flushes the stream. |
| Returns the name of the character encoding being used. |
| Writes a part of an array of characters. |
| Writes a single character. |
|
Table 15.5. Methods of the FileWriter Class
Similarly, you'll be using the FileReader class to read from text files today. Here's the hierarchy of this class:
java.lang.Object
|
|__java.io.Reader
|
|__java.io.InputStreamReader
|
|__java.io.FileReader
You can find the methods of the Reader class in Table 15.6, the methods of the InputStreamReader class in Table 15.7, and the methods of the FileReader in Table 15.8.
Table 15.6. Methods of the Reader Class
Method | Does This |
|---|---|
| |
| Creates a new character-stream reader synchronized with other processes using the specified object. |
| Closes the stream. |
| Marks the current position in the stream. |
| True if this stream supports the mark method. |
| Reads a single character. |
| Reads characters into an array. |
| Reads characters into a part of an array. |
| Tells whether this stream is ready to be read. |
| |
| Skips n characters. |
Table 15.7. Methods of the InputStreamReader Class
As with everything else in this book, this is all made clearer with an example, and it's time to look at one now.
This text file example will let users write to a guest book that's stored on the server. For example, the Web page you see in Listing 15.3 accepts the user's name and a message for the guest book application, which is ch15_04.jsp.
Example 15.3. HTML Page for the Guest Book (ch15_03.html)
<HTML>
<HEAD>
<TITLE>Please Sign My Guest Book!</TITLE>
</HEAD>
<BODY>
<CENTER>
<H1>Please Sign My Guest Book!</H1>
<FORM ACTION="ch15_04.jsp" METHOD="POST">
Your name:
<INPUT TYPE="TEXT" NAME="TEXT1">
<BR>
<BR>
<BR>
Your comments:
<BR>
<TEXTAREA NAME="TEXTAREA1" ROWS="5" COLS="50"></TEXTAREA>
<BR>
<INPUT TYPE="SUBMIT" VALUE="Submit"><INPUT TYPE="RESET" VALUE="Reset">
</FORM>
</CENTER>
</BODY>
</HTML>
You can see this Web page at work in Figure 15.3.
In the JSP page that will handle the guest book (ch15_04.jsp), the code starts by getting the user's name and comments, as well as the real path of the file in which it will store the information (ch15_04.txt):
<%
String name = request.getParameter("TEXT1");
String text = request.getParameter("TEXTAREA1");
String file = application.getRealPath("/") + "ch15_04.txt";
.
.
.
%>
Next, open the file ch15_04.txt using the FileWriter constructor:
<%
String name = request.getParameter("TEXT1");
String text = request.getParameter("TEXTAREA1");
String file = application.getRealPath("/") + "ch15_04.txt";
FileWriter filewriter = new FileWriter(file, true);
.
.
.
%>
The second argument to the FileWriter constructor, true, indicates to FileWriter that you want to append text to the end of ch15_04.txt. (The default is to simply open the file you want to write to and delete its current contents before you start writing.)
Now you can write the data the user sent along with a little HTML in the guest book file, ch15_04.txt, using the write method. When you're done writing, you use the close method to close the stream, which closes the file and makes it available to other applications:
<%
String name = request.getParameter("TEXT1");
String text = request.getParameter("TEXTAREA1");
String file = application.getRealPath("/") + "ch15_04.txt";
FileWriter filewriter = new FileWriter(file, true);
filewriter.write("<B>Name: </B>" + name + "<BR>");
filewriter.write("<B>Comments: </B><BR>");
filewriter.write(text + "<BR><BR>");
filewriter.close();
%>
You can also display the current contents of the guest book simply by including the guest book file, ch15_04.txt, in the output using <jsp:include>, as you see in the whole guest book application, ch15_04.jsp, which appears in Listing 15.4.
Example 15.4. A Guest Book JSP Application (ch15_04.jsp)
<%@ page import="java.io.*" %> <HTML> <HEAD> <TITLE>Thanks for Adding to the Guest Book!</TITLE> </HEAD> <BODY> <H1>Thanks for Adding to the Guest Book!</H1> Here's what you and others have said: <BR> <BR> <% String name = request.getParameter("TEXT1"); String text = request.getParameter("TEXTAREA1"); String file = application.getRealPath("/") + "ch15_04.txt"; FileWriter filewriter = new FileWriter(file, true); filewriter.write("<B>Name: </B>" + name + "<BR>"); filewriter.write("<B>Comments: </B><BR>"); filewriter.write(text + "<BR><BR>"); filewriter.close(); %> <jsp:include page="ch15_04.txt" flush="true"/> </BODY> </HTML>
After the user sends her name and comments to the guest book, you can see the result in Figure 15.4, where the JSP application has stored the user's input in the guest book, and displays the current contents of the guest book.
You can also explicitly open the guest book file and read it without using <jsp:include> at all—that's coming up next.
To explicitly open the guest book and read it, you can use a FileReader object, which supports a read method. The read method enables you to read text from a text file and store that text in a character array. You can supply the read method with an offset into the file to start reading, and the number of bytes to read. To set how many bytes to read, you can use a File object to get the length of the guest book file.
First, get the real path to the guest book file, ch15_04.txt, and create a new File object using that file:
<%
String file = application.getRealPath("/") + "ch15_04.txt";
File fileObject = new File(file);
.
.
.
%>
Now you can create a character array named data of the same length as the guest book file to hold the guest book data, and create a FileReader object to read the data from that file. The FileReader object's read method will return the number of characters actually read. (You can ask it to read more bytes than there are in the file, and the read method will let you know how many bytes were actually read.) Here's how the code reads the guest book into the array named data:
<%
String file = application.getRealPath("/") + "ch15_04.txt";
File fileObject = new File(file);
char data[] = new char[(int) fileObject.length()];
FileReader filereader = new FileReader(file);
int charsread = filereader.read(data);
.
.
.
%>
All that's left is to display the guest book, and to close the FileReader object, as you see in Listing 15.5.
Example 15.5. Displaying the Guest Book (ch15_05.jsp)
<%@ page import="java.io.*" %> <HTML> <HEAD> <TITLE>The Guest Book</TITLE> </HEAD> <BODY> <H1>The Guest Book</H1> Here are the current entries in the guest book: <BR> <BR> <% String file = application.getRealPath("/") + "ch15_04.txt"; File fileObject = new File(file); char data[] = new char[(int) fileObject.length()]; FileReader filereader = new FileReader(file); int charsread = filereader.read(data); out.println(new String(data, 0 , charsread)); filereader.close(); %> </BODY> </HTML>
You can see the results in Figure 15.5, which shows the guest book's contents, success fully read and displayed.
The FileReader class's read method reads in as much data as you want, but there's another method that's even easier to work with when it comes to text files. The BufferedReader class provides a buffered character reader class that reads data into a temporary buffer before passing it on to you. One of the advantages of this is that BufferedReader provides a readLine method, which is good for reading text files line by line. For example, here's how you read in a file line by line using BufferedReader and a while loop—note that you pass a FileReader object to the BufferedReader class's constructor:
Besides text files, you can also work with binary files in Java. A binary file contains binary data, such as an image file or an executable program. Like text files, you can open, read, write, and close binary files in Java. This is done with binary I/O streams.
When you work with binary files, you can use the FileInputStream class to read from binary files and the FileOutputStream class to write to binary files.
Here's the inheritance diagram of the FileInputStream class:
java.lang.Object
|
|__java.io.InputStream
|
|__java.io.FileInputStream
You can see the methods of the InputStream class in Table 15.9, and the methods of the FileInputStream class in Table 15.10.
Table 15.9. Methods of the InputStream Class
Table 15.10. Methods of the FileInputStream Class
Here's the inheritance diagram for the FileOutputStream class:
java.lang.Object
|
|__java.io.OutputStream
|
|__java.io.FileOutputStream
You can see the methods of the OutputStream class in Table 15.11, and the methods of the FileOutputStream class in Table 15.12.
Table 15.11. Methods of the OutputStream Class
Method | Does This |
|---|---|
| |
| Closes this output stream. |
| Flushes this output stream, forcing any buffered output bytes to be written out. |
| Writes |
| Writes |
| Writes the specified byte to this output stream. |
Table 15.12. Methods of the FileOutputStream Class
These classes are best understood by putting them to work—and an example using these classes is coming up next.
Your JSP code might work with binary data, such as an image file—in fact, you'll see how to create image files on the fly in Day 20, “Creating Images On the Fly and Handling Internet Programming.” The data in an image file is binary data, and you typically store such data in byte arrays.
Here's an example showing how to use FileOutputStream to write out a byte array that contains just the values 1, 2, 3, and 4. First, you create a byte array and then a FileOutputStream object connected to a data file:
byte data[] = {1, 2, 3, 4};
String file = application.getRealPath("/") + "ch15_06.dat";
FileOutputStream fileoutputstream = new FileOutputStream(file);
.
.
.
Then you can use the write method to write your data byte by byte to the output file:
byte data[] = {1, 2, 3, 4};
String file = application.getRealPath("/") + "ch15_06.dat";
FileOutputStream fileoutputstream = new FileOutputStream(file);
for (int loopIndex = 0; loopIndex < data.length; loopIndex++) {
fileoutputstream.write(data[loopIndex]);
}
You can see this code in a JSP page in Listing 15.6.
Example 15.6. Writing Byte Data (ch15_06.jsp)
<%@ page import="java.io.*" %> <HTML> <HEAD> <TITLE>Writing Binary Data</TITLE> </HEAD> <BODY> <H1>Writing Binary Data</H1> This page writes binary data to a file. <BR> <% byte data[] = {1, 2, 3, 4}; String file = application.getRealPath("/") + "ch15_06.dat"; FileOutputStream fileoutputstream = new FileOutputStream(file); for (int loopIndex = 0; loopIndex < data.length; loopIndex++) { fileoutputstream.write(data[loopIndex]); } fileoutputstream.close(); %> Four byte values were written to a file byte by byte. </BODY> </HTML>
You can see this JSP page at work in Figure 15.6.
To read the byte data you just wrote to file, you can use FileInputStream. First, connect a FileInputStream object to the data file:
String file = application.getRealPath("/") + "ch15_06.dat";
FileInputStream fileinputstream = new FileInputStream(file);
.
.
.
Then you can determine how many bytes there are to read with the available method, and read that data into a byte array with the read method:
String file = application.getRealPath("/") + "ch15_06.dat";
FileInputStream fileinputstream = new FileInputStream(file);
int numberBytes = fileinputstream.available();
byte bytearray[] = new byte[numberBytes];
fileinputstream.read(bytearray);
.
.
.
Finally, loop over the resulting byte array and display its data, as in Listing 15.7.
Example 15.7. Reading a Binary File (ch15_07.jsp)
<%@ page import="java.io.*" %> <HTML> <HEAD> <TITLE>Reading Binary Data</TITLE> </HEAD> <BODY> <H1>Reading Binary Data</H1> This page reads binary data from a file. <BR> Read this data: <BR> <BR> <% String file = application.getRealPath("/") + "ch15_06.dat"; FileInputStream fileinputstream = new FileInputStream(file); int numberBytes = fileinputstream.available(); byte bytearray[] = new byte[numberBytes]; fileinputstream.read(bytearray); for(int loopIndex = 0; loopIndex < numberBytes; loopIndex++){ out.println(bytearray[loopIndex]); } fileinputstream.close(); %> </BODY> </HTML>
You can see the results in Figure 15.7—the byte data was successfully read back in.
That's fine if you want to work with binary data byte by byte—but what if you want to work with objects or primitive data types, such as double values?
There's a special class you can use to write objects and primitive data types in binary to files—the ObjectOutputStream class. You can see the methods of this class, which include methods such as writeInt and writeDouble to write primitive data types to files, in Table 15.13.
Table 15.13. Methods of the ObjectOutputStream Class
For example, take a look at Listing 15.8, which writes four double values, 1.234, 2.345, 3.456, 4.567, to a data file using the ObjectOutputStream method writeDouble.
Example 15.8. Writing Doubles to a File (ch15_08.jsp)
<%@ page import="java.io.*" %> <HTML> <HEAD> <TITLE>Writing Binary Data</TITLE> </HEAD> <BODY> <H1>Writing Binary Data</H1> This page writes binary data to a file. <BR> <% double data[] = {1.234, 2.345, 3.456, 4.567}; String file = application.getRealPath("/") + "ch15_08.dat"; FileOutputStream fileoutputstream = new FileOutputStream(file); ObjectOutputStream objectStream = new ObjectOutputStream(fileoutputstream); for (int loopIndex = 0; loopIndex < data.length; loopIndex++) { objectStream.writeDouble(data[loopIndex]); } objectStream.close(); %> Four double values were written to a file byte by byte. </BODY> </HTML>
You can see this page at work in Figure 15.8.
Now that you've written them out, the next step is to read those four double values back in.
To read the double values back in, you can use the ObjectInputStream class, which includes methods such as readDouble, to read primitive data types back in. You can see the methods of this class in Table 15.14.
Table 15.14. Methods of the ObjectInputStream Class
For example, you can see a JSP page that reads the double values you wrote to disk in Listing 15.9, using the ObjectInputStream method readDouble.
Example 15.9. Reading Doubles From a File (ch15_09.jsp)
<%@ page import="java.io.*" %> <HTML> <HEAD> <TITLE>Reading Binary Data</TITLE> </HEAD> <BODY> <H1>Reading Binary Data</H1> This page reads binary data from a file. <BR> Read this data: <BR> <BR> <% String file = application.getRealPath("/") + "ch15_08.dat"; FileInputStream fileinputstream = new FileInputStream(file); ObjectInputStream objectStream = new ObjectInputStream(fileinputstream); for(int loopIndex = 0; loopIndex < 4; loopIndex++){ double d = objectStream.readDouble(); out.println(d); } objectStream.close(); %> </BODY> </HTML>
You can see the results of this code in Figure 15.9, which shows that all the double values were read back in successfully.
That completes our work with files on the server for today. You've gotten a good introduction to the topic, but bear in mind that file handling in Java is a large and complex topic—for more details, see the Java documentation, or look up books on Java.
Today you were introduced to the topic of creating files on the server, starting with Tomcat's own built-in capability to create log files that you can access. In particular, you learned how to name and write to such log files.
You also learned about the File class, which enables you to work with files on the server. You learned how to get a list of filenames and File objects for the files in a directory, as well as methods that let you delete and rename files.
You also got an introduction to working with the contents of files on the server using Java streams. You can use streams to read and write data to files on the server using Java, and there are many stream classes to choose from.
Finally, you learned how to use the main streams that deal with files in Java: the FileReader and FileWriter classes for text files, and the FileInputStream and FileOutputStream to work with binary files.
Tomorrow you'll see more on working with a particular type of file—database files. One of the most important uses of JSP on Web servers is to interact with databases, and you're going to see how that works over the next two days.
This workshop tests whether you understand all the concepts you learned today. It's a good idea to master today's concepts by honing your knowledge here before starting tomorrow's material. You can find the answers to the quiz questions in Appendix A.