js.io

Class StreamHandler<T extends OutputStream>

java.lang.Object

js.io.StreamHandler<T>

Type Parameters:

T - wrapped output stream.

public abstract class StreamHandler<T extends OutputStream>
extends Object

Abstract stream handler for remote output streams for both server and client logic. When used on server, output stream is download - that is, output from server and input on client; when used on client side, output stream is used for upload - output from client and input on server. Please note that remote class client interface takes care to reverse input and output streams. For a discussion about service provider interface see package description.

On server side upload just declare the method using desired input stream as parameters; additional parameters are allowed. For download need to wrap returned stream into this stream handler - see downloadStream() from code sample.

 @Remote
 interface Controller
 {
   void uploadStream(InputStream inputStream) throws IOException;
 
   StreamHandler<OutputStream> downloadStream();
 }
 

 class ControllerImpl implements Controller
 {
   public void uploadStream(InputStream inputStream) throws IOException
   {
     StringWriter writer = new StringWriter();
     Files.copy(new InputStreamReader(inputStream, "UTF-8"), writer);
   }
 
   public StreamHandler<OutputStream> downloadStream()
   {
     return new StreamHandler<OutputStream>(OutputStream.class)
     {
       @Override
       public void handle(OutputStream outputStream) throws IOException
       {
         outputStream.write("output stream".getBytes("UTF-8"));
       }
     };
   }
 }
 

Client side logic uses service provider interface, see Controller interface from below code snippet. Client interfaces should reverse streams declared by server interface used for implementation. In our example, server uploadStream method has input stream whereas client interface has output stream, wrapped in stream handler instance. For downloadStream, client replaces server output stream with input and because is an input stream there is no need to use stream handler.

 // service provider interface reverse streams direction
 interface Controller
 {
   void uploadStream(StreamHandler<FileOutputStream> outputStream) throws IOException;
 
   InputStream downloadStream();
 }
 

 Controller controller = Factory.getInstance(controllerURL, Controller.class);
 
 // wrap output stream into StreamHandler instance
 controller.uploadStream(new StreamHandler<FileOutputStream>(FileOutputStream.class)
 {
   @Override
   protected void handle(FileOutputStream outputStream) throws IOException
   {
     outputStream.write("output stream".getBytes("UTF-8"));
   }
 });
 
 InputStream inputStream = controller.downloadStream();
 Files.read(inputStream, outputStream); // just uses input stream the usual way
 

Version:

final

Author:

Iulian Rotaru

Field Summary

Fields

Modifier and Type	Field and Description
private Class<T>	streamClass Wrapped output stream class.

Constructor Summary

Constructors

Constructor and Description
StreamHandler(Class<T> streamClass) Construct concrete stream handler instance wrapping given output stream.

Method Summary

Modifier and Type	Method and Description
Class<T>	getStreamClass() Get wrapped output stream class.
protected abstract void	handle(T outputStream) Concrete stream handler should implement this method, usually to writing to given output stream.
void	invokeHandler(OutputStream outputStream) Helper method used to invoke concrete output stream handler method.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

streamClass

private Class<T extends OutputStream> streamClass

Wrapped output stream class.

Constructor Detail

StreamHandler

public StreamHandler(Class<T> streamClass)

Construct concrete stream handler instance wrapping given output stream.

Parameters:

streamClass - the class of wrapped output stream.

Method Detail

handle

protected abstract void handle(T outputStream)
                        throws IOException

Concrete stream handler should implement this method, usually to writing to given output stream.

Parameters:

outputStream - output stream instance.

Throws:

IOException - if output stream writing fails.

getStreamClass

public Class<T> getStreamClass()

Get wrapped output stream class.

Returns:

output stream class.

invokeHandler

public void invokeHandler(OutputStream outputStream)
                   throws IOException

Helper method used to invoke concrete output stream handler method. Please note that given output stream is closed after handler invocation, just before this method return.

Parameters:

outputStream - wrapped output stream instance.

Throws:

IOException - any output stream exception is bubbled up.