| Hessian |
| Protocols |
| Hessian Messaging |
Hessian is a simple binary protocol for connecting web services. The com.caucho.hessian.client and com.caucho.hessian.server packages do not require any other Resin classes, so can be used in smaller clients, like applets.
Because Hessian is a small protocol, J2ME devices like cell-phones can use it to connect to Resin servers. Because it's powerful, it can be used for EJB services.
The Hessian specification itself is a short and interesting description.
| Hessian Client |
Each service will have a normal Java interface describing the service. The trivial hello, world example just returns a string. Because the Hessian services support Java serialization, any Java type can be used.
package example;
public interface Basic {
public String hello();
}
|
The following is an example of a standalone Hessian client. The client creates a HessianProxyFactory. The client uses the factory to create client stubs with the given target URL and a Java interface for the API. The returned object is a stub implementing the API.
package example;
import com.caucho.hessian.client.HessianProxyFactory;
public class BasicClient {
public static void main(String []args)
throws Exception
{
String url = "http://www.caucho.com/hessian/test/basic";
HessianProxyFactory factory = new HessianProxyFactory();
Basic basic = (Basic) factory.create(Basic.class, url);
System.out.println("Hello: " + basic.hello());
}
}
|
| Hessian Service |
Any public method is treated as a service method. So adding new methods is as easy as writing a normal Java class.
Because the service is implemented as a Servlet, it can use all the familiar servlet data in the ServletContext, just like a normal servlet.
package example;
public class BasicService implements Basic {
private String _greeting = "Hello, world";
public void setGreeting(String greeting)
{
_greeting = greeting;
}
public String hello()
{
return _greeting;
}
}
|
Configuration with Dependency Injection in Resin 3.0
<web-app xmlns="http://caucho.com/ns/resin">
<servlet servlet-name="hello"
servlet-class="com.caucho.hessian.server.HessianServlet">
<init>
<home resin:type="example.BasicService">
<greeting>Hello, world</greeting>
</home>
<home-api>example.Basic</home-api>
</init>
</servlet>
<servlet-mapping url-pattern="/hello"
servlet-name="hello"/>
</web-app>
|
Configuration for standard web.xml
Since the HessianServlet is a standard servlet, it can also be configured in the standard servlet configuration.
<web-app>
<servlet>
<servlet-name>hello</servlet-name>
<servlet-class>com.caucho.hessian.server.HessianServlet</servlet-class>
<init-param>
<param-name>home-class</param-name>
<param-value>example.BasicService</param-value>
</init-param>
<init-param>
<param-name>home-api</param-name>
<param-value>example.Basic</param-value>
</init-param>
</servlet>
<servlet-mapping>
<url-pattern>/hello</url-pattern>
<servlet-name>hello</servlet-name>
</servlet-mapping>
</web-app>
|
| Hessian Serialization |
The Hessian classes can be used for serialization and deserialization. Hessian's serialization forms the basis for the protocol and taking control of the serialization lets application use Hessian more efficiently than the proxy interface for specialized application protocols.
Object obj = ...;
OutputStream os = new FileOutputStream("test.xml");
HessianOutput out = new HessianOutput(os);
out.writeObject(obj);
os.close();
|
InputStream is = new FileInputStream("test.xml");
HessianInput in = new HessianInput(is);
Object obj = in.readObject(null);
is.close();
|
| Hessian with large binary data |
When a distributed application needs to send large amounts of binary data, it can be more efficient to use InputStream and OutputStream to avoid allocating large byte arrays. For example, a file downloading service could be implemented efficiently using Hessian.
In this example, the client needs to take control of the Hessian protocol directly, because the proxy interface would require buffering the entire file before the call returns.
OutputStream os = conn.getOutputStream();
HessianOutput out = new HessianOutput(os);
out.startCall("download");
out.writeString("my-file.txt");
out.completeCall();
InputStream is = conn.getInputStream();
HessianInput in = new HessianInput(is);
in.startReply();
InputStream is = in.readInputStream();
... // save the input stream data somewhere
in.completeReply();
|
An upload servlet would also take control of the Hessian protocol to avoid buffering the data argument. Like the client, the implementation is straightforward, although more complicated than the basic service.
| Hessian Client for a cell-phone |
- MicroHessianInput
- MicroHessianOutput
- HessianRemote
- HessianServiceException
- HessianProtocolException
import javax.microedition.io.Connector;
import javax.microedition.io.HttpConnection;
...
MicroHessianInput in = new MicroHessianInput();
String url = "http://www.caucho.com/hessian/test/basic";
HttpConnection c = (HttpConnection) Connector.open(url);
c.setRequestMethod(HttpConnection.POST);
OutputStream os = c.openOutputStream();
MicroHessianOutput out = new MicroHessianOutput(os);
out.call("hello", null);
os.flush();
is = c.openInputStream();
MicroHessianInput in = new MicroHessianInput(is);
Object value = in.readReply(null);
|
| Protocols |
| Hessian Messaging |
| Copyright © 1998-2005 Caucho Technology, Inc. All rights reserved. Resin® is a registered trademark, and HardCoretm and Quercustm are trademarks of Caucho Technology, Inc. |  |