HproseUtils HPROSE java 调用别人接口的工具类 解决调用https接口问题

package com.eluotuo.common.util;

import hprose.client.HproseHttpClient;

import java.io.IOException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.Map;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLSession;

import com.eluotuo.common.constant.Constant;
public class HproseUtils
{
    private static final Logger LOGGER = Logger.getLogger(HproseUtils.class);
    
    /**
     * hprose返回成功的code:200
     */
    public static final String SUCCESS_CODE = "200";
    
    /**
     * hprose返回错误的code:300
     */
    public static final String ERROR_CODE = "300";
    
    /**
     * 执行一个hprose
     * 
     * @param param 各种参数
     * @param functionName 调用的方法名
     * @param openUrl 调用的url
     * @return 成功{code=200,returnData=返回的参数}{code=300,returnData=error信息}
     */
    public static Map<String, Object> exeHproseFun(Object param, String functionName, String openUrl)
    {
        if(openUrl !=null && openUrl.startsWith("https"))
        {
            initSSLConnection();
        }
        HproseHttpClient client = new HproseHttpClient();
        client.useService(openUrl);
        Map<String, Object> interfaceResult;
        HproseResult hproseResult = null;
        try
        {
            interfaceResult = (Map<String, Object>)client.invoke(functionName, new Object[] {param});
            LOGGER.error("hprose exe success result is: " + interfaceResult );
            if (ConverterUtils.toInt(interfaceResult.get("code")) == Constant.HPROSE_SUCCESS_CODE)
            {
                hproseResult =
                    new HproseResult(Constant.HPROSE_SUCCESS_CODE, interfaceResult.get("data") == null ? Constant.EMPTY
                        : interfaceResult.get("data"));
                return hproseResult.getHproseResult();
            }
            else
            {
                LOGGER.error("hprose function execute error,function name :" + functionName + " and the param :"
                    + param + " the server return message : " + interfaceResult.get("error"));
            }
        }
        catch (IOException e)
        {
            LOGGER.error(e);
            e.printStackTrace();
            
        }
        Map<String, Object> errorMap = new HashMap<String, Object>();
        errorMap.put("code", 300);
        return errorMap;
    }
    
    /** 
     * 让hprose可以使用https的接口
     * @return 是否初始化成功 true成功 false失败
     */
    public static boolean initSSLConnection()
    {
        javax.net.ssl.TrustManager[] trustAllCerts = new javax.net.ssl.TrustManager[1];
        javax.net.ssl.TrustManager tm = new miTM();
        trustAllCerts[0] = tm;
        javax.net.ssl.SSLContext sc;
        try
        {
            sc = javax.net.ssl.SSLContext.getInstance("SSL");
            sc.init(null, trustAllCerts, null);
            javax.net.ssl.HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
            HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {  
                public boolean verify(String urlHostName, SSLSession session) {  
                    return true;  
                }  
            });  
        }
        catch (NoSuchAlgorithmException e1)
        {
            LOGGER.error(e1);
            return false;
        }
        catch (KeyManagementException e)
        {
            LOGGER.error(e);
            return false;
        }
        return true;
    }
    
    public static Map<String, Object> getSuccessMap(Object resultObject)
    {
        Map<String, Object> resultInfo = new HashMap<String, Object>();
        resultInfo.put("data", resultObject);
        resultInfo.put("code", SUCCESS_CODE);
        return resultInfo;
    }
    
    public static Map<String, Object> getErrorMap(Object errorInfo)
    {
        Map<String, Object> resultInfo = new HashMap<String, Object>();
        resultInfo.put("code", ERROR_CODE);
        resultInfo.put("error", errorInfo);
        return resultInfo;
    }
    
    public static void main(String[] args)
    {
        
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("client_id", 14);
        map.put("token", "xxx");
        map.put("sso_sid", "xx");
        try
        {
            
            Map<String, Object> result = HproseUtils.exeHproseFun(map, "is_login", "https://center.xx.cn/Open");
            System.out.println(result);
        }
        catch (Exception e)
        {
            LOGGER.error(e, e);
        }
    }
    
    /**
     * 处理https hprose接口调用的类 -- 网桑抄的
     * @author  wanglei
     * @version  [版本号, 2016年9月1日]
     * @see  [相关类/方法]
     * @since  [产品/模块版本]
     */
    static class miTM implements javax.net.ssl.TrustManager, javax.net.ssl.X509TrustManager
    {
        public java.security.cert.X509Certificate[] getAcceptedIssuers()
        {
            return null;
        }
        
        public boolean isServerTrusted(java.security.cert.X509Certificate[] certs)
        {
            return true;
        }
        
        public boolean isClientTrusted(java.security.cert.X509Certificate[] certs)
        {
            return true;
        }
        
        public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType)
            throws java.security.cert.CertificateException
        {
            return;
        }
        
        public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType)
            throws java.security.cert.CertificateException
        {
            return;
        }
    }
}

/**
 * hprose 返回
 * 
 * @author wangpengfei
 * @version [版本号, 2015年11月4日]
 * @see [相关类/方法]
 * @since [产品/模块版本]
 */
class HproseResult
{
    private int code;
    
    private Object returnData;
    
    Map<String, Object> paramMap = new HashMap<String, Object>();
    
    HproseResult(int code, Object returnData)
    {
        this.code = code;
        this.returnData = returnData;
    }
    
    Map<String, Object> getHproseResult()
    {
        paramMap.put("code", code);
        paramMap.put("returnData", returnData);
        return paramMap;
    }
}

我们在服务端要求返回的时候必须返回一个code 和 一个 data  字段。

code 200代表成功 300 代表失败。

另外适配了https接口调用问题。

initSSLConnection

如果觉得这篇文章帮助到你，给作者打赏点咖啡钱吧。