Hessian学习（二）源码分析HessianServlet

我会带着你远行 2022-05-27 00:37 402阅读 0赞

# 说明 #

在上篇博文[Hessian学习（一）][Hessian]中，初步了解了Hessian，并使用Hessian搭建了一个简单的项目，了解了Hessian如何使用，本文主要学习记录Hessian的实现原理

# 正文 #

在使用Hessian时，最重要的就是服务端web.xml中的配置

<servlet>
        <servlet-name>HessianServlet</servlet-name>
        <servlet-class>com.caucho.hessian.server.HessianServlet</servlet-class>
        <init-param>
            <param-name>service-class</param-name>
            <param-value>com.basic.server.impl.HelloImpl</param-value>
        </init-param>
      </servlet>
    
      <servlet-mapping>
        <servlet-name>HessianServlet</servlet-name>
        <url-pattern>/hessian</url-pattern>
      </servlet-mapping>
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13

在web.xml中配置了一个Servlet，通过这个Servlet来处理请求，可见Hessian的使用都是围绕着com.caucho.hessian.server.HessianServlet这类来展开

当服务器初始化Servlet时调用Servlet的init()方法，调用service()方法实现服务  
通过阅读源码了解Hessian的运行原理

## HessianServlet ##

HessianServlet继承了HttpServlet，在这可以看出Hessian是基于HTTP协议的

public class HessianServlet extends HttpServlet { 
     
      
       1

### 重要参数 ###

private Class<?> _homeAPI;   // 服务类的接口
      private Object _homeImpl;  // 服务类的实例
    
      private Class<?> _objectAPI;  // 不清楚 此参数的意义
      private Object _objectImpl;
    
      private HessianSkeleton _homeSkeleton; // hsesian服务的代理类，服务端功能的核心
      private HessianSkeleton _objectSkeleton;
    
      private SerializerFactory _serializerFactory;
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10

### init(config)方法 ###

初始化时，读取配置文件信息，初始化servlet

在init方法中通过service-class或home-class来获取服务类的实例,通过home-api或api-class来获取服务接口的class对象  
当把参数名称换为object-class、object-api时程序无法运行  
当把web.xml文件中的service-class替换成object-class时，客户端测试会报错

com.caucho.hessian.client.HessianConnectionException: 500: java.io.IOException: Server returned HTTP response code: 500 for URL:
     
      
       1

public void init(ServletConfig config)
        throws ServletException
      {
        super.init(config);
    
        try {
          if (_homeImpl != null) {
          }
          else if (getInitParameter("home-class") != null) {
            String className = getInitParameter("home-class"); // 获取配置文件中名为home-class参数的值
    
            Class<?> homeClass = loadClass(className); //获得class对象
    
            _homeImpl = homeClass.newInstance(); //创建实例对象
    
            init(_homeImpl);
          }
          else if (getInitParameter("service-class") != null) { //获取配置文件中名为service-class参数的值
    
            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;
          }
    
          if (_homeAPI != null) {
          }
          else if (getInitParameter("home-api") != null) {
            String className = getInitParameter("home-api"); //得到配置文件中名为home-api的参数值
    
            _homeAPI = loadClass(className); // 获取class对象
          }
          else if (getInitParameter("api-class") != null) {
            String className = getInitParameter("api-class"); //得到配置文件中名为api-class的参数值
    
            _homeAPI = loadClass(className);
          }
          else if (_homeImpl != null) {
       //当没有配置那两个参数时，会使用服务类实例对象获取class对象
            _homeAPI = findRemoteAPI(_homeImpl.getClass()); // 该方法在源码中已经被注释
    
            if (_homeAPI == null)
              _homeAPI = _homeImpl.getClass();
    
            _homeAPI = _homeImpl.getClass();
          }
    
          if (_objectImpl != null) {
          }
          else if (getInitParameter("object-class") != null) {
            String className = getInitParameter("object-class");
    
            Class<?> objectClass = loadClass(className);
    
            _objectImpl = objectClass.newInstance();
    
            init(_objectImpl);
          }
    
          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 = new HessianSkeleton(_homeImpl, _homeAPI);
    
          if (_objectAPI != null)
            _homeSkeleton.setObjectClass(_objectAPI);
    
          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);
        }
      }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59
       60
       61
       62
       63
       64
       65
       66
       67
       68
       69
       70
       71
       72
       73
       74
       75
       76
       77
       78
       79
       80
       81
       82
       83
       84
       85
       86
       87
       88
       89
       90
       91
       92
       93
       94
       95
       96
       97
       98
       99
       100

### service（request，response）方法 ###

当客户端请求时，使用service方法来处理请求，在此方法中主要是调用invoke()来处理请求

public void service(ServletRequest request, ServletResponse response)
        throws IOException, ServletException
      {
        HttpServletRequest req = (HttpServletRequest) request; // 强转为HttpServelt 的request和response
        HttpServletResponse res = (HttpServletResponse) response;
    
        if (! req.getMethod().equals("POST")) {  // 当请求的方法不是POST时，直接返回结束方法
          res.setStatus(500); // , "Hessian Requires POST");
          PrintWriter out = res.getWriter();
    
          res.setContentType("text/html");
          out.println("<h1>Hessian Requires POST</h1>");
    
          return;
        }
    
        String serviceId = req.getPathInfo(); // 从http的请求url中获取服务id 
        String objectId = req.getParameter("id"); // 获取参数id
        if (objectId == null)
          objectId = req.getParameter("ejbid");
    
        ServiceContext.begin(req, res, serviceId, objectId); // 初始化service的上下文
    
        try {
          InputStream is = request.getInputStream();
          OutputStream os = response.getOutputStream();
    
          response.setContentType("x-application/hessian");
    
          SerializerFactory serializerFactory = getSerializerFactory();// 得到序列化的factory
    
          invoke(is, os, objectId, serializerFactory);// 调用invoke方法处理请求
        } catch (RuntimeException e) {
          throw e;
        } catch (ServletException e) {
          throw e;
        } catch (Throwable e) {
          throw new ServletException(e);
        } finally {
          ServiceContext.end();
        }
      }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42

### invoke(is, os, objectId, serializerFactory)方法 ###

这里根据objectId是否为null，调用不同对象的invoke方法 ，都是调用的HessianSkeleton的invoke方法 invoke方法中涉及到了hessian的序列化

protected void invoke(InputStream is, OutputStream os,
                            String objectId,
                            SerializerFactory serializerFactory)
        throws Exception
      {
        if (objectId != null)
          _objectSkeleton.invoke(is, os, serializerFactory);
        else
          _homeSkeleton.invoke(is, os, serializerFactory);
      }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10

在HessianSkeleton的invoke方法中，最终的执行还是调用method的invoke方法

try {
          result = method.invoke(service, values); // 调用method的invoke方法
        } 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对象的方法将结果返回给客户端
    
        out.close();
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23

参考博文：[https://blog.csdn.net/qq924862077/article/details/52799330][https_blog.csdn.net_qq924862077_article_details_52799330]

[Hessian]: https://blog.csdn.net/sinat_36553913/article/details/79771533
[https_blog.csdn.net_qq924862077_article_details_52799330]: https://blog.csdn.net/qq924862077/article/details/52799330