基础篇 - Hessian 协议详解

<dependency>
    <groupId>com.caucho</groupId>
    <artifactId>hessian</artifactId>
    <version>4.0.66</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>

public interface GreetingService {
    String sayHello(String name);
}

public class GreetingServiceImpl implements GreetingService {
    @Override
    public String sayHello(String name) {
        return "Hello, " + name + "!";
    }
}

import com.caucho.hessian.server.HessianServlet;
import jakarta.servlet.annotation.WebServlet;

@WebServlet("/greeting")
public class GreetingServiceServlet extends HessianServlet implements GreetingService {
    private final GreetingService greetingService = new GreetingServiceImpl();

    @Override
    public String sayHello(String name) {
        return greetingService.sayHello(name);
    }
}

import com.caucho.hessian.client.HessianProxyFactory;

public class HessianClient {
    public static void main(String[] args) {
        String url = "http://localhost:8080/ServletBase_war/greeting"; // 替换为实际服务地址
        HessianProxyFactory factory = new HessianProxyFactory();
        try {
            GreetingService service = (GreetingService) factory.create(GreetingService.class, url);
            String result = service.sayHello("World");
            System.out.println(result); // 输出: Hello, World!
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

<!-- Servlet API -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>

<!-- Spring Context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

<!-- Spring Web -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

<!-- Spring Web MVC -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

<!-- Hessian -->
<dependency>
    <groupId>com.caucho</groupId>
    <artifactId>hessian</artifactId>
    <version>4.0.66</version>
</dependency>

public interface HelloService {
    String sayHello(String name);
}

import org.springframework.stereotype.Service;

@Service
public class HelloServiceImpl implements HelloService {
    @Override
    public String sayHello(String name) {
        return "Hello, " + name;
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.remoting.caucho.HessianServiceExporter;

@Configuration
@ComponentScan(basePackages = "com.example") // 使用实际包名
public class HessianServerConfig {

    private final HelloService helloService;

    public HessianServerConfig(HelloService helloService) {
        this.helloService = helloService;
    }

    @Bean(name = "/helloService")
    public HessianServiceExporter hessianServiceExporter() {
        HessianServiceExporter exporter = new HessianServiceExporter();
        exporter.setService(helloService);
        exporter.setServiceInterface(HelloService.class);
        return exporter;
    }
}

import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;
import org.springframework.web.WebApplicationInitializer;

public class HessianServerInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        // 初始化 Spring Web 上下文
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(HessianServerConfig.class);

        // 注册 DispatcherServlet
        ServletRegistration.Dynamic dispatcher = servletContext.addServlet("dispatcher", new DispatcherServlet(context));
        dispatcher.setLoadOnStartup(1);
        dispatcher.addMapping("/");
    }
}

public interface HelloService {
    String sayHello(String name);
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.remoting.caucho.HessianProxyFactoryBean;

@Configuration
public class HessianClientConfig {

    @Bean
    public HessianProxyFactoryBean helloService() {
        HessianProxyFactoryBean factory = new HessianProxyFactoryBean();
        factory.setServiceUrl("http://localhost:8080/SpringWebBase_war/helloService"); // 根据实际服务地址调整
        factory.setServiceInterface(HelloService.class);
        return factory;
    }
}

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import pojo.HelloService;

public class HessianClientApplication {

    public static void main(String[] args) {
        // 初始化 Spring 上下文
        ApplicationContext context = new AnnotationConfigApplicationContext(HessianClientConfig.class);

        // 获取并调用远程服务
        HelloService helloService = context.getBean(HelloService.class);
        String response = helloService.sayHello("World");
        System.out.println(response);
    }
}

import com.caucho.hessian.io.HessianInput;
import com.caucho.hessian.io.HessianOutput;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class HessianSerializer {

    /**
     * 将对象序列化为字节数组
     *
     * @param object 要序列化的对象
     * @return 序列化后的字节数组
     * @throws IOException 如果序列化失败
     */
    public static byte[] serialize(Object object) throws IOException {
        try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
            HessianOutput hessianOutput = new HessianOutput(byteArrayOutputStream);
            hessianOutput.writeObject(object);
            return byteArrayOutputStream.toByteArray();
        }
    }

    /**
     * 将字节数组反序列化为对象
     *
     * @param data 字节数组
     * @return 反序列化后的对象
     * @throws IOException 如果反序列化失败
     */
    public static Object deserialize(byte[] data) throws IOException {
        try (ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(data)) {
            HessianInput hessianInput = new HessianInput(byteArrayInputStream);
            return hessianInput.readObject();
        }
    }
}

import java.io.Serializable;

public class User implements Serializable {
    private String name;
    private int age;

    // Constructors, Getters, and Setters

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + '}';
    }
}

import java.io.IOException;
import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        try {
            // 创建一个 User 对象
            User user = new User("Alice", 30);

            // 将 User 对象序列化为字节数组
            byte[] serializedData = HessianSerializer.serialize(user);
            System.out.println("Serialized data: " + serializedData);

            // 以 Arrays.toString() 的方式输出字节数组内容
            System.out.println("Serialized data (byte array): " + Arrays.toString(serializedData));

            // 将字节数组反序列化为 User 对象
            User deserializedUser = (User) HessianSerializer.deserialize(serializedData);
            System.out.println("Deserialized User: " + deserializedUser);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import com.caucho.hessian.io.Hessian2Input;
import com.caucho.hessian.io.Hessian2Output;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class Hessian2Serializer {

    public static byte[] serialize(Object object) throws IOException {
        try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
            Hessian2Output hessian2Output = new Hessian2Output(byteArrayOutputStream);
            hessian2Output.writeObject(object);
            hessian2Output.close();
            return byteArrayOutputStream.toByteArray();
        }
    }

    public static Object deserialize(byte[] data) throws IOException {
        try (ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(data)) {
            Hessian2Input hessian2Input = new Hessian2Input(byteArrayInputStream);
            return hessian2Input.readObject();
        }
    }
}

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

import com.caucho.burlap.io.BurlapInput;
import com.caucho.burlap.io.BurlapOutput;

public class BurlapSerializer {

    public static String serializeToXmlString(Object object) throws IOException {
        try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
            BurlapOutput burlapOutput = new BurlapOutput(byteArrayOutputStream);
            burlapOutput.writeObject(object);
            burlapOutput.flush();

            // 将字节数组转换为字符串
            return byteArrayOutputStream.toString(String.valueOf(StandardCharsets.UTF_8));
        }
    }

    public static Object deserializeFromXmlString(String xmlData) throws IOException {
        try (ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(xmlData.getBytes(StandardCharsets.UTF_8))) {
            BurlapInput burlapInput = new BurlapInput(byteArrayInputStream);
            return burlapInput.readObject();
        }
    }
}

import java.io.IOException;

public class Main {

    public static void main(String[] args) {
        try {
            // 创建一个 User 对象
            User user = new User("Alice", 30);

            // 将 User 对象序列化为 XML 字符串
            String xmlData = BurlapSerializer.serializeToXmlString(user);
            System.out.println("Serialized XML data:\n" + xmlData);

            // 将 XML 字符串反序列化为 User 对象
            User deserializedUser = (User) BurlapSerializer.deserializeFromXmlString(xmlData);
            System.out.println("Deserialized User: " + deserializedUser);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public void init(ServletConfig config)
  throws ServletException
{
  super.init(config);
  
  try {
  	// 初始化 _homeImpl
    if (_homeImpl != null) {
    }
    else if (getInitParameter("home-class") != null) {
      String className = getInitParameter("home-class");

      Class<?> homeClass = loadClass(className);

      _homeImpl = homeClass.newInstance();

      init(_homeImpl);
    }
    else if (getInitParameter("service-class") != null) {
      String className = getInitParameter("service-class");

      Class<?> homeClass = loadClass(className);

      _homeImpl = homeClass.newInstance();

      init(_homeImpl);
    }
    else {
      if (getClass().equals(HessianServlet.class))
        throw new ServletException("server must extend HessianServlet");

      _homeImpl = this;
    }

	// 初始化 _homeAPI
    if (_homeAPI != null) {
    }
    else if (getInitParameter("home-api") != null) {
      String className = getInitParameter("home-api");

      _homeAPI = loadClass(className);
    }
    else if (getInitParameter("api-class") != null) {
      String className = getInitParameter("api-class");

      _homeAPI = loadClass(className);
    }
    else if (_homeImpl != null) {
      _homeAPI = findRemoteAPI(_homeImpl.getClass());

      if (_homeAPI == null)
        _homeAPI = _homeImpl.getClass();
      
      _homeAPI = _homeImpl.getClass();
    }
    
    // 初始化 _objectImpl
    if (_objectImpl != null) {
    }
    else if (getInitParameter("object-class") != null) {
      String className = getInitParameter("object-class");

      Class<?> objectClass = loadClass(className);

      _objectImpl = objectClass.newInstance();

      init(_objectImpl);
    }
	// 初始化 _objectAPI
    if (_objectAPI != null) {
    }
    else if (getInitParameter("object-api") != null) {
      String className = getInitParameter("object-api");

      _objectAPI = loadClass(className);
    }
    else if (_objectImpl != null)
      _objectAPI = _objectImpl.getClass();

	// 初始化 _homeSkeleton
    _homeSkeleton = new HessianSkeleton(_homeImpl, _homeAPI);
    
    if (_objectAPI != null)
      _homeSkeleton.setObjectClass(_objectAPI);

	// 初始化 _objectSkeleton
    if (_objectImpl != null) {
      _objectSkeleton = new HessianSkeleton(_objectImpl, _objectAPI);
      _objectSkeleton.setHomeClass(_homeAPI);
    }
    else
      _objectSkeleton = _homeSkeleton;

    if ("true".equals(getInitParameter("debug"))) {
    }

    if ("false".equals(getInitParameter("send-collection-type")))
      setSendCollectionType(false);
  } catch (ServletException e) {
    throw e;
  } catch (Exception e) {
    throw new ServletException(e);
  }
}

public void invoke(Object service,
                   AbstractHessianInput in,
                   AbstractHessianOutput out)
  throws Exception
{
  ServiceContext context = ServiceContext.getContext();

  // backward compatibility for some frameworks that don't read
  // the call type first
  in.skipOptionalCall();

  // Hessian 1.0 backward compatibility
  // Hessian 1.0 向后兼容性处理，循环读取客户端传递的请求头信息并存储在 ServiceContext 中。
  String header;
  while ((header = in.readHeader()) != null) {
    Object value = in.readObject();

    context.addHeader(header, value);
  }

  // 读取客户端请求的远程方法名 methodName 和参数个数 argLength
  String methodName = in.readMethod();
  int argLength = in.readMethodArgLength();

  Method method;

  // 尝试根据方法名和参数数量组合（如 methodName__argLength）查找对应的方法
  method = getMethod(methodName + "__" + argLength);
  // 如果没有找到，则仅使用方法名进行查找，以便兼容不同参数的重载方法。
  if (method == null)
    method = getMethod(methodName);

  if (method != null) {
  }
  // 如果请求的方法名为 _hessian_getAttribute，则认为这是一个特殊的系统调用，
  // 用于获取服务的特定属性（如 java.api.class、java.home.class 等），返回相应的属性值。
  else if ("_hessian_getAttribute".equals(methodName)) {
    String attrName = in.readString();
    in.completeCall();

    String value = null;

    if ("java.api.class".equals(attrName))
      value = getAPIClassName();
    else if ("java.home.class".equals(attrName))
      value = getHomeClassName();
    else if ("java.object.class".equals(attrName))
      value = getObjectClassName();

    out.writeReply(value);
    out.close();
    return;
  }
  else if (method == null) {
    out.writeFault("NoSuchMethodException",
                   escapeMessage("The service has no method named: " + in.getMethod()),
                   null);
    out.close();
    return;
  }

  Class<?> []args = method.getParameterTypes();

  if (argLength != args.length && argLength >= 0) {
    out.writeFault("NoSuchMethod",
                   escapeMessage("method " + method + " argument length mismatch, received length=" + argLength),
                   null);
    out.close();
    return;
  }

  Object []values = new Object[args.length];

  // 将参数值反序列化保存在 values 数组中。
  for (int i = 0; i < args.length; i++) {
    // XXX: needs Marshal object
    values[i] = in.readObject(args[i]);
  }

  Object result = null;

  try {
    // 方法调用
    result = method.invoke(service, values);
  } catch (Exception e) {
    Throwable e1 = e;
    if (e1 instanceof InvocationTargetException)
      e1 = ((InvocationTargetException) e).getTargetException();

    log.log(Level.FINE, this + " " + e1.toString(), e1);

    out.writeFault("ServiceException", 
                   escapeMessage(e1.getMessage()), 
                   e1);
    out.close();
    return;
  }

  // The complete call needs to be after the invoke to handle a
  // trailing InputStream
  in.completeCall();

  // 结果写入序列化字节流
  out.writeReply(result);

  out.close();
}

@Override
public void writeObject(Object obj, AbstractHessianOutput out) throws IOException {
  // 检查是否已经序列化过该对象
  if (out.addRef(obj)) {  // 如果已序列化过则直接写引用（避免重复序列化相同对象）
    return;
  }

  // 获取对象的类信息
  Class<?> cl = obj.getClass();

  // 写入对象的初始定义并获取引用
  int ref = out.writeObjectBegin(cl.getName());

  // 根据 Hessian 协议版本做不同处理
  if (ref >= 0) {
    // 如果 ref >= 0，表示该对象已经写入过结构定义，仅需要写入实例
    writeInstance(obj, out);
  } else if (ref == -1) {
    // 如果 ref == -1，表示是 Hessian 2.0 的初次定义，需写入对象的结构定义
    writeDefinition20(out);         // 定义对象结构（字段名和类型）
    out.writeObjectBegin(cl.getName());  // 再次标记对象起始
    writeInstance(obj, out);             // 写入实例字段值
  } else {
    // 如果 ref < 0，表示使用 Hessian 1.0 协议格式进行序列化
    writeObject10(obj, out);        // 使用 Hessian 1.0 写入完整对象数据
  }
}

import com.caucho.hessian.client.HessianProxyFactory;

public class HessianClient {
    public static void main(String[] args) {
        String url = "http://localhost:8080/ServletBase_war/greeting"; // 替换为实际服务地址
        HessianProxyFactory factory = new HessianProxyFactory();
        try {
            GreetingService service = (GreetingService) factory.create(GreetingService.class, url);
            String result = service.sayHello("World");
            System.out.println(result); // 输出: Hello, World!
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

-> HessianProxyFactory#create(Class, String)
   HessianProxyFactory#create(Class<?>, String, ClassLoader)
   HessianProxyFactory#create(Class<?>, URL, ClassLoader) # 返回代理对象
-> HessianProxy#invoke(Object, Method, Object[]) # 建立连接，发送请求并接收响应
   HessianProxy#sendRequest(String, Object[])
   -> HessianOutput#call(String, Object[]) # 参数序列化
   -> HessianURLConnection#sendRequest() # 向服务端发送请求

HessianServlet#service(ServletRequest, ServletResponse)
HessianServlet#invoke(InputStream, OutputStream, String, SerializerFactory)
HessianSkeleton#invoke(InputStream, OutputStream, SerializerFactory)
HessianSkeleton#invoke(Object, AbstractHessianInput, AbstractHessianOutput) # 参数反序列化，方法执行，结果返回

HessianServiceExporter#handleRequest(HttpServletRequest, HttpServletResponse)
HessianExporter#invoke(InputStream, OutputStream)
HessianExporter#doInvoke(HessianSkeleton, InputStream, OutputStream)
HessianSkeleton#invoke(AbstractHessianInput, AbstractHessianOutput)
HessianSkeleton#invoke(Object, AbstractHessianInput, AbstractHessianOutput) # 参数反序列化，方法执行，结果返回

Hessian2Output#writeObject(Object)
UnsafeSerializer#writeObject(Object, AbstractHessianOutput)
-> Hessian2Output#writeObjectBegin(String) # 开头写入对象标识符
-> UnsafeSerializer#writeInstance(Object, AbstractHessianOutput) # 序列化字段值

Hessian2Input#readObject()
Hessian2Input#readObject() # 再次调用
Hessian2Input#readObjectInstance(Class<?>, ObjectDefinition)
UnsafeDeserializer#readObject(AbstractHessianInput, Object[])
-> UnsafeDeserializer#instantiate() # 使用 unsafe 创建类实例
-> UnsafeDeserializer#readObject(AbstractHessianInput, Object, FieldDeserializer2[])
   FieldDeserializer2FactoryUnsafe$XxxFieldDeserializer#deserialize(AbstractHessianInput, Object) # 使用 unsafe 写入字段值