In -depth research hessian framework and its principles
In -depth research hessian framework and its principles
introduce:
HESSIAN is a remote call framework based on binary protocols, which aims to simplify service communication between different platforms.It calls protocols through serialized objects and remote methods to realize data transmission and interaction between server and clients.This article will study the principle of the HESSIAN framework in depth and provide some Java code examples.
Hessian basic concept:
1. Serialization: Hessian uses a binary protocol to serialize the object and converts the object to byte array.The serialization process includes converting the field value of the object to byte array, and the byte array is sent to the receiver for a back serving.
2. Reverse serialization: The process of re -convert the received byte array to the object.Hessian reads the contents of the bytes and re -constructs the object based on the type information of the object.
Hessian's working principle:
1. Client calling: The client initiates remote method call requests through the proxy object. The proxy object encapsulates the request data as the hessian request message and sends it to the server via HTTP or other protocols.
2. Services processing: After receiving the request message, the server is serialized by the Hessian parseper to call the information as the method, and then the specific server method is called through the reflection mechanism.
3. Server response: After the server is executed, the result is returned. The server again uses the hessian parser to sequence the result to hessian response message and send it to the client.
4. Client processing: After the client receives the response message, the response data is serialized into a method to call the result through the Hessian parser, and the result is returned to the remote proxy object to complete the entire remote call process.
Hessian use example:
The following uses a simple example to illustrate the use of hessian.
1. Define the service interface:
public interface HelloWorldService {
String sayHello(String name);
}
2. Implement service interface:
public class HelloWorldServiceImpl implements HelloWorldService {
public String sayHello(String name) {
return "Hello, " + name + "!";
}
}
3. Server code:
public class Server {
public static void main(String[] args) throws IOException {
HelloWorldService service = new HelloWorldServiceImpl();
SerializerFactory factory = new SerializerFactory();
HessianSkeleton skeleton = new HessianSkeleton(service, HelloWorldService.class, factory);
HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);
HttpContext context = server.createContext("/");
context.setHandler(exchange -> {
if ("POST".equals(exchange.getRequestMethod())) {
InputStream input = exchange.getRequestBody();
OutputStream output = exchange.getResponseBody();
skeleton.handle(input, output);
output.close();
}
});
server.start();
System.out.println("Server started on port 8080.");
}
}
4. Client code:
public class Client {
public static void main(String[] args) throws IOException {
String url = "http://localhost:8080/";
HessianProxyFactory factory = new HessianProxyFactory();
HelloWorldService service = (HelloWorldService) factory.create(HelloWorldService.class, url);
String result = service.sayHello("Hessian");
System.out.println(result);
}
}
in conclusion:
Through the in -depth study of this article, we learned about the principles and workflows of the HESSIAN framework, and demonstrated the use of the HESSIAN framework through the example code.Hessian provides a simple and efficient way to achieve cross -platform service communication, making the remote method call more convenient and flexible.
