Hessian与HTTP Header

企业开发 2018-05-09 17:17:49 阅读次数: 1

    最近在开发一个RPC服务，在多种RPC框架之间选来选取，最终还是选择了hessian，整体上来说，hessian不仅简单而且优秀，还符合“微服务”的轻量级服务治理的理念；这个RPC框架优秀到简直没有升级和扩展的必要... 不过在实际开发中，遇到了一个小小的问题，就是如何通过hessian协议（框架）来发送一些“附属信息”，比如token等；这些附属信息，内容较小，但是可能条目个数较多，如果都封装成JAVA对象通过API传送，确实引入一些扩展性的问题。既然hessian底层基于HTTP协议，这些附属信息能否通过Header传递呢？ 经过思考和验证，不仅可以，而且这也是最佳的策略；此后Client端如果需要额外传递更多的附属信息，则不需要升级API Client，透明易用。同时通过HEADER传送一些信息，这对WEB Proxy层也是良好的。

     设计要求：

     1、对于一个附属信息，比如TOKEN、备注等附属信息，不能通过hessian API传送。

     2、附属信息可能很多，不过需要支持动态增加，增加时不应该修改hessian API，以便给Client带来兼容性问题。

     3、性能问题需要兼顾。

     4、附属信息通过HTTP Headers发送。

     经过研究Hessian源码，发现Hessian请求默认会在header中添加一些标识信息，不过addHeader的操作是“关闭的”，不能通过简单的Spring配置或者Hessian API额外的增加其他的header；为了支持此特性，我们需要扩展Hessian API，本实例基于Spring容器。

     1、我们希望Headers可以通过Spring配置方式制定。

     2、我们希望可以在runtime期间，Hessian请求发送时开发者可以自定headers并通过Hessian协议发送。

     3、Hessian Remote Service应该可以解析出header，并能够在Service内部获得header的内容，以便使用。

     4、请求响应结束后，这些headers应该被Clear，即无状态。

     设计思路：

     1）那些可以通过Spring配置指定的headers，我们可以通过扩展Hessian FactoryBean来实现，将配置中指定的header（通常为全局headers）保存在Spring Bean属性中。

     2）那些需要在runtime期间动态添加的headers，为了避免耦合，我们可以使用ThreadLocal方式，将它们保存在Context中，并在Hessian请求实际发送之间，扩展其addHeader方法，并将它们添加在HTTP 请求中。

     3）Hessian Remote Service，通常为HTTP Servlet实例，那么我们可以基于Fitler的方式解析这些headers，这也要求Hessian Headers需要遵循一定的规则，比如header均已“x-rpc-hessian”开头等。

     5）对于Spring容器中的remote service，我们也可以扩展相应的FactoryBean，来解析这些header，并放置在ThreadLocal中，此后Service执行过程中，就可以获取这些headers内容。



 

一、HContext.java

    一个基于ThreadLocal实现的Context类，用于保存runtime期间开发者动态添加的headers。

import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
 * Created by liuguanqing on 17/4/12.
 *  如果header中，有中文，需要进行URLEncoder后才能发送
 */
public class HContext {

    public static final String KEY_PREFIX = "x-rpc-";
    public static final String UTF8 = "utf-8";
    public static final String SOURCE_HOST = "source_host";
    public static final String REQUEST_TYPE = "request_type";
    private static final ThreadLocal<Map<String,String>> context = new InheritableThreadLocal<>();

    public static void init() {
        Map<String, String> model = context.get();
        if(model == null) {
            context.set(new HashMap<>());
        }
    }

    public static void put(String key,String value) {
        if(value == null) {
            return;
        }
        Map<String,String> model = context.get();
        if(model == null) {
            init();
        }
        if(!key.startsWith(KEY_PREFIX)) {
            key = KEY_PREFIX + key;
        }
        context.get().put(key,value);
    }

    public static void putAll(Map<String,String> kvs) {
        if(kvs == null || kvs.isEmpty()) {
            return;
        }
        for(Map.Entry<String,String> entry : kvs.entrySet()) {
            String value = entry.getValue();
            if(value == null) {
                continue;
            }
            put(entry.getKey(),value);
        }
    }

    public static String get(String key) {
        key = KEY_PREFIX + key;
        Map<String,String> model = context.get();
        if(model == null) {
            return null;
        }
        return model.get(key);
    }

    public static Map<String,String> getAll() {
        Map<String,String> model = context.get();
        if(model == null) {
            return Collections.EMPTY_MAP;
        }
        return model;
    }

    public static void clear() {
        context.remove();
    }
}

    需要注意，如果headers中包含中文，需要进行UrlEncoder之后才能发送，对应在Service端则需要UrlDecoder。

二、HessianProxy扩展类

    大家都知道，Hessian客户端必须创建一个HessianProxy代理类，才能进行RPC调用。HessianProxy是通过JAVA动态代理方式创建，其代理了Serivce API的接口。HessianProxy负责进行实际的RPC请求和响应处理，它在发送请求时总会调用内部的addHeader方法，那么我们即可围绕addHeader方法开展。

import com.caucho.hessian.client.HessianConnection;
import com.caucho.hessian.client.HessianProxy;
import com.caucho.hessian.client.HessianProxyFactory;

import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;

/**
 * Created by liuguanqing on 17/4/12.
 *
 */
public class HessianWithContextProxy extends HessianProxy {

    protected Map<String,String> globalHeaders = new HashMap<>();

    public HessianWithContextProxy(URL url, HessianProxyFactory factory) {
        super(url, factory);
        HContext.init();
    }

    public HessianWithContextProxy(URL url, HessianProxyFactory factory, Class type) {
        super(url, factory, type);
        HContext.init();
    }

    public HessianWithContextProxy(URL url, HessianProxyFactory factory, Class type,Map<String,String> headers) {
        super(url, factory, type);
        HContext.init();
        globalHeaders = headers;
    }

    protected void addRequestHeaders(HessianConnection conn) {
        super.addRequestHeaders(conn);
        try {
            HContext.putAll(globalHeaders);//global headers cant be replaced!
            Map<String, String> context = HContext.getAll();
            for (Map.Entry<String, String> entry : context.entrySet()) {
                try {
                    String value = entry.getValue();
                    if (value == null) {
                        continue;
                    }
                    conn.addHeader(entry.getKey(), URLEncoder.encode(value, HContext.UTF8));
                } catch (Exception e) {
                    //
                }
            }
        } finally {
            HContext.clear();
            //after send,we clear at once.
            //must clear context here.
        }
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return super.invoke(proxy,method,args);
    }
}

    对于那些global级别的headers，即通过Spring配置文件声明的、所有请求都公用的headers，我们应该在保存在HessianProxy实例的内部；对于那些runtime期间动态增加的headers，我们需要从HContext中获取，并将它们均通过addHeaders方法添加到connection中。考虑到ThreadLocal的容器的生命周期管理，我们必须在addHeaders方法调用结束后，进行clear。

    在考虑HContext.clear的时机时，本人曾经引入过一些问题。起初，本人在invoke方法返回之前调用clear，事实上经过测试发现，这是错误的。需要注意，invoke方法的执行时机时“调用API的任何方法都会执行”（包括toString、getClass等等），所以Client请求在发送之前，可能多次执行invoke，那些不是API方法的执行，会导致HContext数据被清除。所以，我们应该在临近请求发送的地方进行HContext操作。

三、HessianProxyFactoryBean扩展

    HessianProxy是有HessianProxyFactory创建的，我们通常可以在此FactoryBean中指定serviceUrl等等一些Hessian Client的配置信息，当然我们可以扩展它，并支持配置一些global级别的headers，这些headers，通常是一些常量，此Service Client的所有请求都可以通用；比如Token等。

import com.caucho.hessian.client.HessianProxyFactory;
import com.caucho.hessian.io.HessianRemoteObject;

import java.lang.reflect.Proxy;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;

/**
 * Created by liuguanqing on 17/4/12.
 */
public class HessianWithContextProxyFactory extends HessianProxyFactory {

    private Map<String,String> globalHeaders = new HashMap<>();

    public HessianWithContextProxyFactory() {
        super();
    }

    public void setGlobalHeaders(Map<String, String> globalHeaders) {
        this.globalHeaders = globalHeaders;
    }

    public Map<String, String> getGlobalHeaders() {
        return globalHeaders;
    }

    @Override
    public Object create(Class api, URL url, ClassLoader loader) {
        if (api == null)
            throw new NullPointerException("api must not be null for HessianProxyFactory.create()");
        HessianWithContextProxy handler = new HessianWithContextProxy(url, this, api,globalHeaders);
        return Proxy.newProxyInstance(loader, new Class[]{api, HessianRemoteObject.class}, handler);
    }
}

    这个扩展类比较简单，只需要注意，在创建HessianProxy实例时，将配置的global headers作为参数传递过去。因为面向开发者或者Spring框架时，只有HessianProxyFactory是可见的，所以这些参数只能通过FactoryBean配置然后传递给HessianProxy。

四、基于Spring框架的ProxyFactoryBean扩展

    Spring支持Hessian框架，它基于HessianProxyFactoryBean实现，这个类名与Hessian原始的“HessianProxyFactory”比较类似，不过它是Spring容器的工厂bean，用于创建单例模式的HessianProxyFactory实例。注意此类是面向Hessian Client端！

import java.net.InetAddress;
import java.net.NetworkInterface;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

/**
 * Created by liuguanqing on 17/4/12.
 */
public class HessianWithContextProxyFactoryBean extends HessianProxyFactoryBean {

    protected HessianWithContextProxyFactory proxyFactory = new HessianWithContextProxyFactory();

    protected Map<String,String> headers = new HashMap<>();

    public void setHeaders(Map<String, String> headers) {
        this.headers = headers;
    }

    private String localIp;


    public HessianWithContextProxyFactoryBean() {
        super();
        super.setProxyFactory(proxyFactory);//强制修改
    }

    @Override
    public void afterPropertiesSet() {
        super.afterPropertiesSet();
        localIp = getLocalIp();//本地IP地址
        headers.put(HContext.SOURCE_HOST,localIp);
        proxyFactory.getGlobalHeaders().putAll(headers);//append
    }

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        //all the methods of hessian instances will be invoked here,
        //so we cant use threadLocal there.
        return super.invoke(invocation);
    }

    public String getLocalIp() {
        try {
            //一个主机有多个网络接口
            Enumeration<NetworkInterface> netInterfaces = NetworkInterface.getNetworkInterfaces();
            while (netInterfaces.hasMoreElements()) {
                NetworkInterface netInterface = netInterfaces.nextElement();
                Enumeration<InetAddress> addresses = netInterface.getInetAddresses();
                while (addresses.hasMoreElements()) {
                    InetAddress address = addresses.nextElement();
                    if (address.isSiteLocalAddress() && !address.isLoopbackAddress()) {
                         return address.getHostAddress();

                    }
                }
            }
        }catch (Exception e) {
            //
        }
        return null;
    }
}

    没有特别之处，只是我们默认添加了一个全局header，表示Client端的本机IP地址，主要用于Remote Service跟踪请求的来源。

五、Remote Service端

    

import org.springframework.remoting.caucho.HessianServiceExporter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URLDecoder;
import java.util.Enumeration;

/**
 * Created by liuguanqing on 17/4/12.
 *
 */
public class HessianWithContextServiceExporter extends HessianServiceExporter {

    @Override
    public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //处理请求
        try {
            Enumeration<String> headers = request.getHeaderNames();
            while (headers.hasMoreElements()) {
                String key = headers.nextElement();
                if(key.startsWith(HContext.KEY_PREFIX)) {
                    try {
                        String value = request.getHeader(key);
                        if(value != null) {
                            HContext.put(key, URLDecoder.decode(value,HContext.UTF8));
                        }
                    } catch (Exception e) {
                        //
                    }
                }
            }
            HContext.put(HContext.REQUEST_TYPE,"SDK");
            super.handleRequest(request,response);
        } finally {
            HContext.clear();
        }
    }


}

    HessianServiceExporter是Spring提供的机制，即可以将Spring Bean暴露并与Servlet容器结合（Spring-web），它只有一个主要的方法，用于处理Client发送的请求，那么我们可以在此方法中解析Client发送的headers，并保存在HContext中。

六、使用方式

    1、Client端配置

    <bean id="remotePortalService" class="com.demo.hessian.spring.HessianWithContextProxyFactoryBean">
        <property name="serviceUrl" value="${portal.service.url}" />
        <property name="serviceInterface" value="com.demo.service.PortalService" />
        <property name="overloadEnabled" value="true"/>
        <property name="connectTimeout" value="3000"/>
        <property name="hessian2" value="true"/>
        <property name="readTimeout" value="3000"/>
        <property name="headers">
            <map>
                <entry key="project" value="${portal.service.project}"/>
                <entry key="token" value="${.portal.service.token}" />
            </map>
        </property>
    </bean>

    2、Client端JAVA代码样例

HContext.put("comment","这是Hessian服务");
HContext.put("operator","zhangsan");
remotePortalService.send(target);
//不需要对HContext进行clear，HessianProxy会自动执行。

    3、Remote Service端配置（web.xml）

    <servlet>
        <servlet-name>hessianService</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-hessian.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>hessianService</servlet-name>
        <url-pattern>/rpc/*</url-pattern>
    </servlet-mapping>

    spring-hessian.xml配置

    <bean name="/portal" class="com.vipkid.utils.hessian.spring.HessianWithContextServiceExporter">
        <property name="service" ref="portalService"/>
        <property name="serviceInterface" value="com.demo.service.PortalService"/>
    </bean>

    你可能还需要在其他配置文件中声明“portalService”，这是一个Spring Bean。此外，你的Spring Controller的URI路径也需要以“/rpc”开头，即与web.xml配置保持一致。

    4、Remote Service端JAVA示例

public Object send(Object target) {
    String clientId = HContext.get("source_host");
    //HContext已经在Exportor中进行了数据准备，所以可以直接使用，也不需要clear。
}

猜你喜欢

转载自shift-alt-ctrl.iteye.com/blog/2373965
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022