|
|
|
Using WebLogic File Services
WebLogic File is a service added to WebLogic in release 2.5. WebLogic File provides high-speed client-side access to native operating system files on the server. The client API extends the lowest-common-denominator capabilities of Java (java.io.InputStream and java.io.OutputStream), which allows it to be used seamlessly in existing code, with additional services that are specific to manipulating remote files.
As a service, WebLogic File also has access to all of the other WebLogic
facilities, like logging, instrumentation, and workspaces With WebLogic File, as with other WebLogic services, the client uses factory methods to generate T3FileInputStream and T3FileOutputStream objects. These classes extend the standard Java InputStream and OutputStream classes, allowing them to be plugged into existing client code. They also provide additional methods that are specific to remote file streams. WebLogic File enhances read and write performance over a network by transmitting data in buffers whose size is independent of the size of the requests, and by using readAhead and writeBehind buffering. The implementation increases the rate of data transfer in several ways.
An application may specify the transfer buffer size, the number of buffers of read ahead, and the number of buffers of write behind, or it may rely on default values. The default buffer size is 100K, and the default number of buffers for both read ahead and write behind is 1. The defaults set by WebLogic File are usually the best choice for maximum speed. If you decide not to use the defaults, here are some hints for choosing other values.
This document covers information specific to using the WebLogic File API. You should also read the Developers Guide that covers all the services and facilities within WebLogic, Writing a T3Client application. If this is your first experience working with InputStream and OutputStream in Java, you may also want to read the general information available in the JavaSoft tutorial. There is also more specific information about Using Streams to Read and Write Files at the JavaSoft website.
Class java.lang.Object
Interface weblogic.io.common.IOServicesDef
Class java.io.InputStream
Class weblogic.io.common.T3FileInputStream
Class java.io.OutputStream
Class weblogic.io.common.T3FileOutputStream
Interface weblogic.io.common.T3File
Interface weblogic.io.common.T3FileSystem
Class java.lang.Throwable
(implements java.io.Serializable)
Class java.lang.Exception
Class weblogic.common.T3Exception
The interfaces T3File and T3FileSystem define T3Files and T3FileSystems. T3Files, which may represent local (usually client-side) or remote (usually server-side) files, are produced by T3FileSystems, which may also represent local or remote files. T3Files and T3FileSystems make it easy to write code that treats local and remote files uniformly. Objects from these interfaces, like all service-related objects in the WebLogic framework, are allocated by requests to an object factory. This gives the developer a fine level of control over resources.
Two classes from the weblogic.io.common package -- T3FileInputStream and T3FileOutputStream -- provide server-side read and write access to files.
With its class variable "services," a T3Client accesses WebLogic services through methods in the weblogic.common.T3ServicesDef. WebLogic Files and WebLogic File Systems are accessed through the method, T3ServicesDef.io(), which returns a weblogic.io.common.IOServicesDef object. The IOServicesDef interface has methods for requesting a T3FileSystem from the IOServices object factory. You supply the name of the fileSystem as an argument to IOServicesDef.getFileSystem() and are returned a T3FileSystem object. The T3FileSystem interface has methods for requesting a T3File from the IOServicesDef object factory, and the T3File interface has methods for requesting a T3FileInput/OutputStream for reading or writing to the file. Here is a short example of how you might get a T3FileSystem, and from it a T3File, and from that an OutputStream for writing to the file: T3Client t3 = new T3Client("t3://localhost:7001");
T3FileSystem myFS = t3.services.io().getFileSystem("usr");
T3File myFile = myFS.getFile("myDirectory/myFilename");
T3FileOutputStream t3os = myFile.getFileOutputStream();
t3os.write(b);
This interface also has a set of "convenience" methods called getFileInputStream() and getFileOutputStream(). These methods invoke the getFileInput/OutputStream() method of a T3File and return a new T3FileInput/OutputStream object for reading from the file. The recommended method of getting a T3FileInput/OutputStream for a T3File is to invoke T3File.getFileInput/OutputStream() directly on a T3File object. T3FileInputStream and T3FileOutputStream objects both extend standard java.io.* classes. Setting up the WebLogic Server to read and write filesBefore you can use WebLogic File services, you must first establish one or more path prefixes -- a fileSystem -- for use by clients by setting a property in the weblogic.properties file. For example, to map the file system name "users" to the path on the server host "/usr/local/tmp" add the following line to your weblogic.properties file: weblogic.io.fileSystem.users=/usr/local/tmp When you request a T3FileSystem from the IOServicesDef factory -- eventually to be used to creating a T3File and reading/writing to it with an input or output stream -- you use the registered fileSystem name as an argument for the getFileSystem() method. The T3FileSystem object that is returned is mapped to the fileSystem registered in the properties file. For security reasons, a T3Client cannot access files higher in the directory than the lowest directory registered as part of a file system name. Filenames cannot contain ".." or an Exception will be thrown. For example, an attempt to read or write "/users/../filename" will throw an Exception. Note: When you are setting properties in the properties file on a Windows NT system, you cannot use single backslashes (\) because they will be interpreted as escape characters. Using single backslashes when setting a property result in an error message similar to this: java.io.FileNotFoundException: Remote file name <filename> malformedYou can either use double backslashes, as in this example: weblogic.io.volume.vol=c:\\remote\\tempor use forward slashes instead, which will be properly mapped to a Window-style syntax by the parser: weblogic.io.volume.vol=c:/remote/temp Manufacturing T3File-related objectsIn these examples, we show how to request a T3FileSystem object, and from it, to get a T3File and the input and output streams necessary to read and write to it. In the following examples, "users" is the name of a fileSystem that has been registered in the weblogic.properties file, and maps to the absolute path "/usr/local/users" on the WebLogic Server host. T3Client t3 = new T3Client("t3://localhost:7001");
t3.connect();
// Get a T3FileSystem object from the IOServicesDef factory
// Use a registered fileSystem as an arg
T3FileSystem myFS = t3.services.io().getFileSystem("users");
// Get a T3File from the T3FileSystem
T3File myFile = myFS.getFile("ben/notes");
// Get an OutputStream to write to the file
T3FileOutputStream t3os = myFile.getFileOutputStream();
// Write a byte "b" to the OutputStream
t3os.write(b);
You have created and written a byte to a file that maps to the Server
host path "/usr/local/users/ben/notes".
This brief example illustrates the most common usage. There are other way to request particular T3File-related objects from the IOServicesDef factory, through a set of "convenience" methods that allow you to directly request a T3FileInputStream or T3FileOutputStream without first creating a T3FileSystem or T3File object. Here are examples of using the "convenience" methods provided by the IOServicesDef factory. You can request a T3FileInputStream or T3FileOutputStream object directly from the IOServicesDef factory by calling the getFileInput/OutputStream() method, with a pathname argument that follows this pattern: "/registeredFileSystem/fileName"where the registeredFileSystem is a mount-point registered in the weblogic.properties file as the property "weblogic.io.filesystem.registeredFileSystem=actualPath; and the fileName is the name of the destination file. When you request a T3FileInputStream or T3FileOutputStream object directly, without getting one from methods called on a T3FileSystem, you must include the leading slash in the fileSystem name or the server will generate this type of error: java.io.FileNotFoundException: Remote file name <filename> is relative Here is an example. This T3FileInputStream object uses the defaults for buffer size and readAhead. If you choose not to use the default settings for buffer size and readAhead/writeBehind, you can set these values by using different factory methods that allow you to specify these values. In this example, an InputStream object is created with a buffer size of 1024 bytes and 3 readAhead buffers: int bufferSize = 1024;
int readAhead = 3;
T3Client t3 = new T3Client("t3://localhost:7001");
t3.connect();
InputStream is =
t3.services.io().getFileInputStream("/users/myfile",
bufferSize,
readAhead);
In this example, the OutputStream object is created with a buffer of 1024 bytes and 2 writeBehind buffers. int bufferSize = 1024;
int writeBehind = 2;
T3Client t3 = new T3Client("t3://localhost:7001");
t3.connect();
Outputstream os =
t3.services.io().getFileOutputStream("/users/myfile",
bufferSize,
writeBehind);
Error handling. When an error occurs, the factory methods throw the exception weblogic.common.T3Exception, which contains the cause of the problem as a nested exception. T3FileSystems and T3Files
You request a T3FileSystem from the IOServicesDef factory with the getFileSystem() method. The T3FileSystem interface also has other methods that return the file-system-dependent file separator string, and the file-system-dependent path separator string. This interface also contains more "convenience" methods that allow direct access to file Input/OutputStreams without creating an intermediary T3File object.
You request a T3File by calling one of the T3FileSystem.getFile() methods. Like a T3FileSystem, a T3File can represent either local or remote files. In addition to methods for getting Input/OutputStreams to read and write to the file, this interface also has accessory methods to get the file name and path associated with the T3File object, to get its parent directory, to check if the file exists and is a "normal" T3file, to test if you can read and write to the file, to get its length and last modified date, to rename it, to make a directory, and other file-related tasks. The T3FileInputStream class
You customarily create a T3FileInputStream by calling the T3File.getFileInputStream() method, which returns an object of the class T3FileInputStream. This class extends the standard java.io.InputStream class and provides two additional methods: public int bufferSize(); which returns the current buffer size and public int readAhead(); which returns the current number of buffers of read ahead. The implementation of two other methods in T3FileInputStream that override methods in java.io.InputStream are of interest:
Currently, T3FileInputStream does not support the methods java.io.InputStream.mark() and java.io.InputStream.reset(). The T3FileOutputStream class
You customarily create a T3FileOutputStream by calling the T3File.getFileOutputStream() method, which returns an object of class T3FileOutputStream. This class extends the standard java.io.OutputStream class and provides two additional methods:
public int bufferSize(); which returns the current buffer size and public int writeBehind();which returns the current number of buffers of write behind. The implementation of two other methods in T3FileOutputStream that override methods in java.io.OutputStream are of interest:
If an error occurs on the server while a file is being written, the client is asynchronously notified and all subsequent operations -- write(), flush(), or close() -- will generate a java.io.IOException. 
Here are step-by-step instructions on how to request and use T3File-related objects in your application.
In addition to other packages you import for your program, WebLogic File applications import the following: import java.io.*; import weblogic.common.*; import weblogic.io.common.*;
In most cases, you will be using WebLogic File services in a T3Client application, which requires creating a T3Client and connecting to the WebLogic Server as shown here: try {
T3Client t3 = new T3Client("t3://localhost:7001");
t3.connect();
}
For more information about constructing a T3Client, see Writing a T3Client application.
Use the T3Client's "services" stub to gain access to WebLogic's services, like IO services, and call the IOServicesDef factory method to get a T3FileSystem object. You will need to supply the name of a file system that has been registered in the WebLogic Server's weblogic.properties file with the property weblogic.io.fileSystem.name=path. We'll assume in this example that we have got this line in our properties file: weblogic.io.fileSystem.myFS=/usr/local T3Files created in the T3FileSystem mapped to "myFS" will be physically located in the directory "/usr/local" on the WebLogic Server's host. Here is the code to get the T3FileSystem and a T3File named "test": T3FileSystem t3fs =
t3.services.io().getFileSystem("myFS");
T3File myFile = t3fs.getFile("test");
We can also check to see if the file exists before we read from
or write to it, as shown here:
if (myFile.exists()) {
System.out.println("The file already exists");
}
else {
// Create a file with an array of bytes. We'll write it
// to an output stream in the next step
byte b[] = new byte[11];
b[0]='H'; b[1]='e'; b[2]='l'; b[3]='l'; b[4]='o'; b[5]=' ';
b[6]='W'; b[7]='o'; b[8]='r'; b[9]='l'; b[10]='d';
We have assembled an array of bytes that we'd like to write to a T3File on the WebLogic Server. You customarily create a T3File, and then request an OutputStream to write to it, using the T3File.getOutputStream() method. Using the T3File "myFile" that we created in the previous step, this example illustrates this process: Outputstream os =
myFile.getFileOutputStream();
os.write(b);
os.close();
Always close the OutputStream object when work with it is completed.
Step 5. Create and use an InputStream objectNow we have got a T3File that we'd like to read from and confirm its contents. You request and use an InputStream object with the same patterns you use for an OutputStream object. Here we request an InputStream object with which we can read from the T3File "myFile." This opens an InputStream to the T3File. In this example, we're reading bytes; first, we allocate an array of bytes to read into (from which we will later create a String that we can display); then we use the standard methods of the java.io.InputStream class to read from the T3File, as shown here: byte b[] = new byte[11]; InputStream is = myFile.getFileInputStream(); is.read(b); is.close(); Now let's create a String for display to confirm the results: String result = new String(b);
System.out.println("Read from file " + T3File.getName()
" on the WebLogic Server:");
System.out.println(result);
is.close();
Always close the InputStream object when work with it is completed.
Step 6. CleanupAlways disconnect the T3Client when you have finished working with it, to ensure that the client's resources on the WebLogic Server are properly cleaned up. In this example, we wrap the call to disconnect() in a try block so that if there is a problem, we can catch the Exception. try (t3.disconnect();
catch (Exception e) {
e.printStackTrace();
}
public class HelloWorld {
public static void main(String[] argv) {
// Strings for the WebLogic Server URL, the T3FileSystem
// name, and the T3File name
String url;
String fileSystemName;
String fileName;
// Check the user's input, and then use it if correct
if (argv.length == 2) {
url = argv[0];
// Use the local file system on the client
fileSystemName = "";
fileName = argv[1];
}
else if (argv.length == 3) {
url = argv[0];
fileSystemName = argv[1];
fileName = argv[2];
}
else {
System.out.println("Usage: java tutorial.io.HelloWorld " +
"WebLogicURL fileSystemName fileName");
System.out.println("Example: java tutorial.io.HelloWorld " +
"t3://localhost:7001 users test");
return;
}
// Create a T3Client and connect to WebLogic
T3Client t3 = null;
try {
t3 = new T3Client(url);
t3.connect();
// Get the file system and the file
System.out.println("Getting the file system " + fileSystemName);
T3FileSystem fileSystem =
t3.services.io().getFileSystem(fileSystemName);
System.out.println("Getting the file " + fileName);
T3File file = fileSystem.getFile(fileName);
if (file.exists()) {
// The file exists. Don't do anything
System.out.println("The file already exists");
}
else {
// The file does not exist. Create it.
byte b[] = new byte[11];
b[0]='H'; b[1]='e'; b[2]='l'; b[3]='l'; b[4]='o'; b[5]=' ';
b[6]='W'; b[7]='o'; b[8]='r'; b[9]='l'; b[10]='d';
// Get an OutputStream and write to the file
System.out.println("Writing to the file");
OutputStream os = file.getFileOutputStream();
os.write(b);
os.close();
}
// Get an InputStream and read from the file
byte b[] = new byte[11];
System.out.println("Reading from the file");
InputStream is = file.getFileInputStream();
is.read(b);
is.close();
// Report the result
String result = new String(b);
System.out.println("File contents is: " + result);
}
catch (Exception e) {
System.out.println("The following exception occurred " +
"while running the HelloWorld tutorial.");
e.printStackTrace();
if (!fileSystemName.equals("")) {
System.out.println("Make sure the WebLogic server at " +
url + " was started with " +
"the property weblogic.io.fileSystem." +
fileSystemName + " set.");
}
}
finally {
// Always disconnect from the WebLogic Server
try {
if (t3 != null) {t3.disconnect();}
}
catch (Exception e) {}
}
}
}
|
|
|
|
Copyright © 2000 BEA Systems, Inc. All rights reserved.
|
