HttpInvoker支持不需要证书的HTTPS

最新推荐文章于 2021-07-28 10:52:39 发布
最新推荐文章于 2021-07-28 10:52:39 发布
阅读量1k 收藏
点赞数
分类专栏： J2EE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyt4455/article/details/8863902
版权
【问题】
遇到内部管理非常严格的客户可能存在一套内部系统的部署规范，例如只支持HTTPS协议不支持HTTP，如果系统多出采用HttpInvoker，而此处的配置大多不能直接支持HTTPS。我们可以建议客户同时开放HTTP和HTTPS，对外只开放HTTPS端口，此时物理服务器内部的应用可以使用HTTP协议进行HttpInvoker交互，但如果是分布式部署呢？
 
   【解决办法】
1.  大多的配置如下（很多程序都采用如下配置方式），此时只能支持HTTP协议，不支持HTTPS：
[java] view plain copy print ?
  1. <bean id="remoteService" class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">  
  2.             <!--  远程服务的url-->  
  3.             <property name="serviceUrl" value="${tt.server}/remoteService.remoting" />  
  4.             <!--  远程服务所实现的接口-->  
  5.         <property name="serviceInterface" value="org.kevin.SimpleService" />  
  6.         </bean>  
<bean id="remoteService" class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
           	<!--  远程服务的url-->
    		<property name="serviceUrl" value="${tt.server}/remoteService.remoting" />
    		<!--  远程服务所实现的接口-->
   		<property name="serviceInterface" value="org.kevin.SimpleService" />
	    </bean>

  2.  可以调整为如下，使其同时支持HTTP和HTTPS：           
[java] view plain copy print ?
  1. <SPAN style="WHITE-SPACE: pre">     </SPAN><bean id="remoteService" class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">  
  2.             <!--  远程服务的url-->  
  3.                         <property name="serviceUrl" value="${tt.server}/remoteService.remoting" />  
  4.                         <!--  远程服务所实现的接口-->  
  5.                         <property name="serviceInterface" value="org.kevin.SimpleService" />  
  6.                         <property name="httpInvokerRequestExecutor">  
  7.                             <bean class="org.springframework.remoting.httpinvoker.CommonsHttpInvokerRequestExecutor"></bean>  
  8.                         </property>  
  9.             </bean>  
		<bean id="remoteService" class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
   			<!--  远程服务的url-->
                        <property name="serviceUrl" value="${tt.server}/remoteService.remoting" />
                        <!--  远程服务所实现的接口-->
                        <property name="serviceInterface" value="org.kevin.SimpleService" />
                        <property name="httpInvokerRequestExecutor">
                            <bean class="org.springframework.remoting.httpinvoker.CommonsHttpInvokerRequestExecutor"></bean>
                        </property>
           	</bean>
                  但问题是又来了，这个httpInvokerRequestExecutor使用的是HttpClient，而这个家伙要求你必须配置证书文件（配置方法很复杂，还要考虑证书过期更新问题）。
 
3. 怎么办！？改写一下CommonsHttpInvokerRequestExecutor ，让他即支持HTTPS同时还不校验证书（有点安全隐患，不过用该可以接收），于是采用如下配置：
[java] view plain copy print ?
  1. <bean id="remoteService" class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">  
  2.         <!--  远程服务的url-->  
  3.         <property name="serviceUrl" value="${tt.server}/remoteService.remoting" />  
  4.         <!--  远程服务所实现的接口-->  
  5.         <property name="serviceInterface" value="org.kevin.SimpleService" />  
  6.         <property name="httpInvokerRequestExecutor">  
  7.                 <bean class="org.kevin.KevinCommonsHttpInvokerRequestExecutor"></bean>  
  8.         </property>  
  9.   </bean>  
   <bean id="remoteService" class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
        	<!--  远程服务的url-->
        	<property name="serviceUrl" value="${tt.server}/remoteService.remoting" />
        	<!--  远程服务所实现的接口-->
        	<property name="serviceInterface" value="org.kevin.SimpleService" />
        	<property name="httpInvokerRequestExecutor">
            		<bean class="org.kevin.KevinCommonsHttpInvokerRequestExecutor"></bean>
        	</property>
	    </bean>

【示例代码】
[java] view plain copy print ?
  1. package org.kevin;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.InetAddress;  
  5. import java.net.Socket;  
  6. import java.net.UnknownHostException;  
  7. import java.security.cert.CertificateException;  
  8. import java.security.cert.X509Certificate;  
  9.   
  10. import javax.net.ssl.SSLContext;  
  11. import javax.net.ssl.TrustManager;  
  12. import javax.net.ssl.X509TrustManager;  
  13.   
  14. import org.apache.commons.httpclient.ConnectTimeoutException;  
  15. import org.apache.commons.httpclient.HttpClientError;  
  16. import org.apache.commons.httpclient.params.HttpConnectionParams;  
  17. import org.apache.commons.httpclient.protocol.ControllerThreadSocketFactory;  
  18. import org.apache.commons.httpclient.protocol.Protocol;  
  19. import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;  
  20. import org.apache.commons.httpclient.protocol.SecureProtocolSocketFactory;  
  21. import org.springframework.remoting.httpinvoker.CommonsHttpInvokerRequestExecutor;  
  22.   
  23. /** 
  24.  * <p> 
  25.  * Title: HttpInvoker的自定义httpInvokerRequestExecutor实现 
  26.  * </p> 
  27.  *  
  28.  * <p> 
  29.  * Description: 支持HTTP和HTTPS，同时HTTPS不进行证书的校验 
  30.  * </p> 
  31.  *  
  32.  * <p> 
  33.  * Company: 北京九恒星科技股份有限公司 
  34.  * </p> 
  35.  *  
  36.  * @author li.wenkai 
  37.  *  
  38.  * @since：2011-10-18 下午03:37:03 
  39.  *  
  40.  */  
  41. public class KevinCommonsHttpInvokerRequestExecutor extends CommonsHttpInvokerRequestExecutor {  
  42.   
  43.     static {  
  44.         ProtocolSocketFactory fcty = new MySecureProtocolSocketFactory();  
  45.         Protocol.registerProtocol("https", new Protocol("https", fcty, 443));  
  46.     }  
  47. }  
  48.   
  49. class MyX509TrustManager implements X509TrustManager {  
  50.   
  51.     /* 
  52.      * (non-Javadoc) 
  53.      *  
  54.      * @see 
  55.      * javax.net.ssl.X509TrustManager#checkClientTrusted(java.security.cert. 
  56.      * X509Certificate[], java.lang.String) 
  57.      */  
  58.     public void checkClientTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {  
  59.   
  60.     }  
  61.   
  62.     /* 
  63.      * (non-Javadoc) 
  64.      *  
  65.      * @see 
  66.      * javax.net.ssl.X509TrustManager#checkServerTrusted(java.security.cert. 
  67.      * X509Certificate[], java.lang.String) 
  68.      */  
  69.     public void checkServerTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {  
  70.   
  71.     }  
  72.   
  73.     /* 
  74.      * (non-Javadoc) 
  75.      *  
  76.      * @see javax.net.ssl.X509TrustManager#getAcceptedIssuers() 
  77.      */  
  78.     public X509Certificate[] getAcceptedIssuers() {  
  79.         return null;  
  80.     }  
  81.   
  82.     public boolean isClientTrusted(X509Certificate[] arg0) {  
  83.         return false;  
  84.     }  
  85.   
  86.     public boolean isServerTrusted(X509Certificate[] arg0) {  
  87.         return false;  
  88.     }  
  89.   
  90. }  
  91.   
  92. class MySecureProtocolSocketFactory implements SecureProtocolSocketFactory {  
  93.   
  94.     private SSLContext sslContext = null;  
  95.   
  96.     /** 
  97.      * Constructor for MySecureProtocolSocketFactory. 
  98.      */  
  99.     public MySecureProtocolSocketFactory() {  
  100.     }  
  101.   
  102.     /** 
  103.      *  
  104.      * @return 
  105.      */  
  106.     private static SSLContext createEasySSLContext() {  
  107.         try {  
  108.             SSLContext context = SSLContext.getInstance("SSL");  
  109.             context.init(null, new TrustManager[] { new MyX509TrustManager() }, null);  
  110.             return context;  
  111.         } catch (Exception e) {  
  112.             throw new HttpClientError(e.toString());  
  113.         }  
  114.     }  
  115.   
  116.     /** 
  117.      *  
  118.      * @return 
  119.      */  
  120.     private SSLContext getSSLContext() {  
  121.         if (this.sslContext == null) {  
  122.             this.sslContext = createEasySSLContext();  
  123.         }  
  124.         return this.sslContext;  
  125.     }  
  126.   
  127.     /* 
  128.      * (non-Javadoc) 
  129.      *  
  130.      * @see 
  131.      * org.apache.commons.httpclient.protocol.ProtocolSocketFactory#createSocket 
  132.      * (java.lang.String, int, java.net.InetAddress, int) 
  133.      */  
  134.     public Socket createSocket(String host, int port, InetAddress clientHost, int clientPort) throws IOException,  
  135.             UnknownHostException {  
  136.   
  137.         return getSSLContext().getSocketFactory().createSocket(host, port, clientHost, clientPort);  
  138.     }  
  139.   
  140.     /* 
  141.      * (non-Javadoc) 
  142.      *  
  143.      * @see 
  144.      * org.apache.commons.httpclient.protocol.ProtocolSocketFactory#createSocket 
  145.      * (java.lang.String, int, java.net.InetAddress, int, 
  146.      * org.apache.commons.httpclient.params.HttpConnectionParams) 
  147.      */  
  148.     public Socket createSocket(final String host, final int port, final InetAddress localAddress, final int localPort,  
  149.             final HttpConnectionParams params) throws IOException, UnknownHostException, ConnectTimeoutException {  
  150.         if (params == null) {  
  151.             throw new IllegalArgumentException("Parameters may not be null");  
  152.         }  
  153.         int timeout = params.getConnectionTimeout();  
  154.         if (timeout == 0) {  
  155.             return createSocket(host, port, localAddress, localPort);  
  156.         } else {  
  157.             return ControllerThreadSocketFactory.createSocket(this, host, port, localAddress, localPort, timeout);  
  158.         }  
  159.     }  
  160.   
  161.     /* 
  162.      * (non-Javadoc) 
  163.      *  
  164.      * @see SecureProtocolSocketFactory#createSocket(java.lang.String,int) 
  165.      */  
  166.     public Socket createSocket(String host, int port) throws IOException, UnknownHostException {  
  167.         return getSSLContext().getSocketFactory().createSocket(host, port);  
  168.     }  
  169.   
  170.     /* 
  171.      * (non-Javadoc) 
  172.      *  
  173.      * @see 
  174.      * SecureProtocolSocketFactory#createSocket(java.net.Socket,java.lang.String 
  175.      * ,int,boolean) 
  176.      */  
  177.     public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException,  
  178.             UnknownHostException {  
  179.         return getSSLContext().getSocketFactory().createSocket(socket, host, port, autoClose);  
  180.     }  
  181. }  
package org.kevin;

import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.commons.httpclient.ConnectTimeoutException;
import org.apache.commons.httpclient.HttpClientError;
import org.apache.commons.httpclient.params.HttpConnectionParams;
import org.apache.commons.httpclient.protocol.ControllerThreadSocketFactory;
import org.apache.commons.httpclient.protocol.Protocol;
import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;
import org.apache.commons.httpclient.protocol.SecureProtocolSocketFactory;
import org.springframework.remoting.httpinvoker.CommonsHttpInvokerRequestExecutor;

/**
 * <p>
 * Title: HttpInvoker的自定义httpInvokerRequestExecutor实现
 * </p>
 * 
 * <p>
 * Description: 支持HTTP和HTTPS，同时HTTPS不进行证书的校验
 * </p>
 * 
 * <p>
 * Company: 北京九恒星科技股份有限公司
 * </p>
 * 
 * @author li.wenkai
 * 
 * @since：2011-10-18 下午03:37:03
 * 
 */
public class KevinCommonsHttpInvokerRequestExecutor extends CommonsHttpInvokerRequestExecutor {

	static {
		ProtocolSocketFactory fcty = new MySecureProtocolSocketFactory();
		Protocol.registerProtocol("https", new Protocol("https", fcty, 443));
	}
}

class MyX509TrustManager implements X509TrustManager {

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * javax.net.ssl.X509TrustManager#checkClientTrusted(java.security.cert.
	 * X509Certificate[], java.lang.String)
	 */
	public void checkClientTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * javax.net.ssl.X509TrustManager#checkServerTrusted(java.security.cert.
	 * X509Certificate[], java.lang.String)
	 */
	public void checkServerTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see javax.net.ssl.X509TrustManager#getAcceptedIssuers()
	 */
	public X509Certificate[] getAcceptedIssuers() {
		return null;
	}

	public boolean isClientTrusted(X509Certificate[] arg0) {
		return false;
	}

	public boolean isServerTrusted(X509Certificate[] arg0) {
		return false;
	}

}

class MySecureProtocolSocketFactory implements SecureProtocolSocketFactory {

	private SSLContext sslContext = null;

	/**
	 * Constructor for MySecureProtocolSocketFactory.
	 */
	public MySecureProtocolSocketFactory() {
	}

	/**
	 * 
	 * @return
	 */
	private static SSLContext createEasySSLContext() {
		try {
			SSLContext context = SSLContext.getInstance("SSL");
			context.init(null, new TrustManager[] { new MyX509TrustManager() }, null);
			return context;
		} catch (Exception e) {
			throw new HttpClientError(e.toString());
		}
	}

	/**
	 * 
	 * @return
	 */
	private SSLContext getSSLContext() {
		if (this.sslContext == null) {
			this.sslContext = createEasySSLContext();
		}
		return this.sslContext;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.apache.commons.httpclient.protocol.ProtocolSocketFactory#createSocket
	 * (java.lang.String, int, java.net.InetAddress, int)
	 */
	public Socket createSocket(String host, int port, InetAddress clientHost, int clientPort) throws IOException,
			UnknownHostException {

		return getSSLContext().getSocketFactory().createSocket(host, port, clientHost, clientPort);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.apache.commons.httpclient.protocol.ProtocolSocketFactory#createSocket
	 * (java.lang.String, int, java.net.InetAddress, int,
	 * org.apache.commons.httpclient.params.HttpConnectionParams)
	 */
	public Socket createSocket(final String host, final int port, final InetAddress localAddress, final int localPort,
			final HttpConnectionParams params) throws IOException, UnknownHostException, ConnectTimeoutException {
		if (params == null) {
			throw new IllegalArgumentException("Parameters may not be null");
		}
		int timeout = params.getConnectionTimeout();
		if (timeout == 0) {
			return createSocket(host, port, localAddress, localPort);
		} else {
			return ControllerThreadSocketFactory.createSocket(this, host, port, localAddress, localPort, timeout);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see SecureProtocolSocketFactory#createSocket(java.lang.String,int)
	 */
	public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
		return getSSLContext().getSocketFactory().createSocket(host, port);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * SecureProtocolSocketFactory#createSocket(java.net.Socket,java.lang.String
	 * ,int,boolean)
	 */
	public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException,
			UnknownHostException {
		return getSSLContext().getSocketFactory().createSocket(socket, host, port, autoClose);
	}
}

 
juce
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring HttpInvoke实现，以及效率提升！
03-19
NULL 博文链接：https://snowolf.iteye.com/blog/703732
使用httpclient无需证书调用https的示例(java调用https)
jnsz7481is的专栏
05-26 3936
package com.paic.hmreport.metaQ; 　　import java.io.BufferedInputStream; 　　import java.io.BufferedReader; 　　import java.io.ByteArrayInputStream; 　　import java.io.FileOutputStream; 　　import java.io.
调用不需要证书认证的HTTPS接口，兼容http接口
qq_34769161的博客
10-26 1762
不使用证书调用HTTPs接口，支持HTTP package com.xysd.oauthSSO.service; import java.io.IOException; import java.security.cert.CertificateException; import java.security.cert.X509Certificate; import java.util.ArrayL...
spring httpinvoker https
asdfljw的博客
12-11 303
Spring HttpInvoke，一种较为常用的、基于Spring架构的服务器之间的远程调用实现，可以说是轻量级的RMI   1.在web.xml配置spring 并添加对应的spring配置文件   &lt;listener&gt; &lt;listener-class&gt;org.springframework.web.context.ContextLoaderListene...
httpclient4.5 jar包
03-27
HttpClient支持多种安全协议，如SSL/TLS，可以配置证书和密钥管理器，实现HTTPS通信。同时，通过`CredentialsProvider`和`Authenticator`，可以处理HTTP基本认证和其他复杂认证需求。 6. **与其他技术的集成** ...
JAVA上百实例源码以及开源项目源代码
12-11
简介 笔者当初为了学习JAVA，收集了很多经典源码，源码难易程度分为初级、中级、高级等，详情看源码列表，需要的可以直接下载！ 这些源码反映了那时那景笔者对未来的盲目，对代码的热情、执着，对IT的憧憬、向往！...
spring security 中文指南
03-02
- RMI 和 HttpInvoker 的透明认证传播 - 自动“记住我”认证 - 匿名认证 - Run-as 认证 - Java Authentication and Authorization Service (JAAS) - JEE 容器认证 - Kerberos - JOSSO、OpenNMS、AppFuse 等...
Http Invoker (http访问测试工具)
04-19
该工具是作者为测试自己开发的基于 HTTP 协议的移动应用 API 而编写的。它的主要功能是使用用户输入网址，要提交的参数，要上传的文件等信息，向 HTTP 服务发出请求，并展示服务的返回结果。之所以没有使用 Fiddler 的 Composer 功能，是因为在我的需求中测试工具需要管理 Cookie， 而在 Fiddler 手工管理比较麻烦。
HttpInvoker SSL双向认证远程接口调用
hongfu951的专栏
02-13 1650
在工作中，遇到需要开放一个web接口给对方调用，所以用到了HttpInvoker ，但是又遇到了一个问题，就是采用的是双向认证，只开放443端口，也就是说配置接口必须采用https，而且调用接口时，还需要通过双向认证。下面是我做的事例，贴出来供大家参考。 一、创建接口和接口实现类 public interface SyncRemoteService {     /**      * 挂网成
HttpInvoker运作原理
热门推荐
zstu_cc的专栏
01-26 1万+
Spring源码解析系列均基于Spring Framework 4.2.7 把第三方系统的方法搬到本地HttpInvoker是常用的Java同构系统之间方法调用实现方案，是众多Spring项目中的一个子项目。顾名思义，它通过HTTP通信即可实现两个Java系统之间的远程方法调用，使得系统之间的通信如同调用本地方法一般。HttpInvoker和RMI同样使用JDK自带的序列化方式，但是HttpInvo
Spring HttpInvokerProxyFactoryBean 远程调用示例
solomon
09-21 1264
Spring    HTTP  远程调用   A. 提供服务的应用   web.xml  文件中：  &lt;servlet&gt;  &lt;servlet-name&gt;remote&lt;/servlet-name&gt;  &lt;servlet-class&gt;org.springframework.web.servlet.DispatcherServlet&lt;/se...
通过HttpInvokerProxyFactory调用第三方接口
zhangjing_666的博客
04-26 413
一、服务端配置（Spring） 1.web.xml配置servlet 2.注入HttpInvokerProxyFactorybean 二、客户端配置（Springboot） 1.注入HttpInvokerProxyFactorybean 2.调用第三方接口
HttpInvoker简单介绍以及使用
zhang14533的博客
07-28 2792
此文章来源：https://www.cnblogs.com/lpc-xx/p/8556827.html 一、Spring HTTP Invoker简介 Spring HTTP invoker是spring框架中的一个远程调用模型，执行基于HTTP的远程调用（意味着可以通过防火墙），并使用java的序列化机制在网络间传递对象。这需要在远端和本地都使用Spring才行。客户端可以很轻松的像调用本地对象一样调用远程服务器上的对象，这有点类似于webservice，但又不同于webs...
Spring中HttpInvoker远程方法调用总结
枕簟、冷秋
07-07 2389
Spring为各种远程访问技术的集成提供了工具类。Spring远程支持是由普通（Spring）POJO实现的，这使得开发具有远程访问功能的服务变得相当容易。目前，Spring支持四种远程技术： 远程方法调用（RMI）。通过使用 RmiProxyFactoryBean 和 RmiServiceExporter，Spring同时支持传统的RMI（使用java.rmi.Remote接口和java.
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter.handleRequest方法
最新发布
07-22
使用该方法需要正确配置Spring的HTTP Invoker相关组件，并在Spring配置文件中声明HttpInvokerServiceExporter bean。这样，当有HTTP Invoker请求到达服务器时，Spring会自动将请求交给HttpInvokerServiceExporter来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值