使用socket实现的请求代理

 

    前段时间把TCP/UDP协议复习了一下，了解了一般网络编程的基本步骤，以前在工作中遇到以下两个问题，就可以使用socket代理的方式实现：

 

1.和化为10000号调接口的时候，我们是java web 系统，他们是vc++ 开发的系统，我们对10000号提供webservice服务，联调的时候就比较麻烦，我们走的是http，向一个wsdl地址发送String，然后接受服务器返回的String，相同的入参字符串，给了10000号系统，他们调用就总报错，因为服务器端截获不到报文，我无法定位错误原因，我们的web 系统使用的是 axis 实现的webservice，在地层已经帮助我们封装好了 soap 协议的报文，而10000号系统使用的是socket，如何获得10000号系统的请求报文的底层呢？？就需要我们使用 一下的一个 socket代理

 

                                             c++ ---------------- <- ----------- java

                      10000号系统 ----------------> Scoket代理------------------>目标服务器

 

 

也就是我们使用socket 代理截获底层报文，然后又代理吧报文发给目标服务器，然后socket代理接受目标服务器的报文，返回给10000号系统，这个时候我们就有了 请求和返回的报文，把它以文件的形式存在硬盘上。然后分析报文。

 

2.和ismp联调的时候他们给了wsdl的发布地址，http://133.64.64.13:5011/IsmpCrmEngineService?wsdl，我本地开发就是ping不通，自然也钓不上他们的服务，估计是路由问题，可是我们的服务器 133.64.80.9 可以ping通这个

地址，于是我们也可以使用socket代理，我们在133.64.80.9 部署socket代理 ，我们去请求socket代理，让 代理去请求 目标地址

 

3.socket 代理 还有一个好处就比较牛逼了，我们的系统需要调用tuxedo系统的服务，走的也是socket，比如你现在家，你boss打电话说生产系统 页面上不能查话费了，查话费走的是tuxedo，然你去电信看看，找找原因，你当然不愿意

不愿意飙到电信，可是你如何知道是接口问题还是别的问题呢？？ 你在家里的网络环境如何调用电信DCN网络环境的tuxedo服务呢？嘿嘿，我们生产环境 是一个web系统 在公网上有一个ip地址，你可以把 Scoket代理部署到生产环境上，然后你在家里的 公网上调用 socket代理 ，然代理去调用 DCN网内部的服务，把结果从电信的DCN 网络环境中的

请求结果报文返回给公网上的你。（请勿模仿，后果自负）

 

 

下面我们就根据以上的构想，开发一个socket代理：（知道tcp/udp协议和编程技巧），不明白的可以看我的

 

tcp编程：http://8366.iteye.com/admin/blogs/419331

udp编程：http://8366.iteye.com/admin/blogs/420395

 

代码：

 

 

1.    写缓存文件

 

import java.io.FileOutputStream;
import java.io.IOException;

import org.apache.log4j.Logger;

/**
 * 写缓存文件
 *  *
 */
public class FileWrite
{
	private static Logger log = Logger.getLogger(FileWrite.class);
	
	/** 文件编号 */
	static int file_no = 0;
	
	/**
	 * 写文件
	 * @param buff 内容
	 * @param len 长度
	 * @param type 文件后缀
	 * @throws Exception
	 */
	public static void writeFile(byte[] buff, int len, String type)
	{
		file_no++;
		
		//文件路径
		StringBuilder fileNo = new StringBuilder(SocketProxy.OUT_PATH);
		//文件名编号3位对齐
		for (int i = 0; i < 3 - ("" + file_no).length(); i++)
		{
			fileNo.append("0");
		}
		//文件编号
		fileNo.append(file_no);
		fileNo.append("_");
		//文件后缀
		fileNo.append(type);
		
		FileOutputStream out = null;
		try
		{
			out = new FileOutputStream(fileNo.toString());
			out.write(buff, 0, len);
		}
		catch (IOException e)
		{
			log.error("写文件异常", e);
		}
		finally
		{
			try
			{
				out.close();
			}
			catch (IOException e)
			{
			}
		}
	}
}

 

 2.请求线程

 

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

import org.apache.log4j.Logger;


public class SubRequest extends Thread
{
	private static Logger log = Logger.getLogger(SubRequest.class);

	/** 外部socket */
	Socket outSideSocket;
	/** 外部输入 */
	InputStream in;
	
	/** 内部socket */
	Socket inSideSocket;
	/** 向服务端输出 */
	OutputStream out;
	
	/** 外部输入缓冲区 */
	byte[] buff = new byte[SocketProxy.OUT_INPUT_BUF_LENGTH];
	
	public SubRequest(Socket outSideSocket, Socket inSideSocket)throws Exception
	{
		this.outSideSocket = outSideSocket;
		this.inSideSocket = inSideSocket;
		
		in = outSideSocket.getInputStream();		
		out = inSideSocket.getOutputStream();
	}
	
	public void run()
	{
		while(true)
		{
			try
			{
				int n = in.read(buff);
				log.info("输入字节数：" + n);
				
				//输入字节长度－1表示连接关闭
				if (n == -1)
				{
					break;
				}
				
				//写文件
				FileWrite.writeFile(buff, n, "request");
				//输出
				out.write(buff, 0, n);
			}
			catch (Exception e)
			{
				log.error("输入异常", e);
				break;
			}
		}
		
		//关闭socket
		if (!outSideSocket.isClosed())
		{
			try
			{
				in.close();
				outSideSocket.close();
				log.info("关闭外部socket");
			}
			catch (IOException ex)
			{						
			}
		}
		if (!inSideSocket.isClosed())
		{
			try
			{
				out.close();
				inSideSocket.close();
				log.info("关闭内部socket");
			}
			catch (IOException ex)
			{						
			}
		}

	}
	

}

 

3.接受线程

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

import org.apache.log4j.Logger;


public class SubResponse extends Thread
{
	private static Logger log = Logger.getLogger(SubResponse.class);
	
	/** 外部socket */
	Socket outSideSocket;
	/** 向客户端输出 */
	OutputStream out;
	
	/** 内部socket */
	Socket inSideSocket;
	/** 服务端输入 */
	InputStream in;
	
	/** 内部发送缓冲区 */
	byte[] buff = new byte[SocketProxy.IN_OUTPUT_BUF_LENGTH];

	
	public SubResponse(Socket outSideSocket, Socket inSideSocket)throws Exception
	{
		this.outSideSocket = outSideSocket;
		out = outSideSocket.getOutputStream();
		
		this.inSideSocket = inSideSocket;
		in = inSideSocket.getInputStream();
	}
	
	public void run()
	{
		while (true)
		{
			try
			{
				int n = in.read(buff);
				log.info("输出字节数:" + n);
				
				//输入字节长度－1表示连接关闭
				if (n == -1)
				{
					break;
				}
				
				//写文件
				FileWrite.writeFile(buff, n, "response");
				//输出
				out.write(buff, 0, n);
			}
			catch (Exception e)
			{
				log.error("输出异常", e);
				break;
			}
		}
		
		//关闭socket
		if (!outSideSocket.isClosed())
		{
			try
			{
				out.close();
				outSideSocket.close();
				log.info("关闭外部socket");
			}
			catch (IOException ex)
			{						
			}
		}
		if (!inSideSocket.isClosed())
		{
			try
			{
				in.close();
				inSideSocket.close();
				log.info("关闭内部socket");
			}
			catch (IOException ex)
			{						
			}
		}
	}
}

 

 

4.主线程

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import org.apache.log4j.Logger;


public class SocketProxy
{
	private static Logger log = Logger.getLogger(SocketProxy.class);

	/** 代理对外侦听端口 */
	static int port = 9999;

	/** 内部服务端IP  */
	static String ip = "133.64.41.134";
	/** 内部服务端端口  */
	static int in_port =8299;

	/** 客户端输入缓冲区长度 */
	static final int OUT_INPUT_BUF_LENGTH = 2048 * 10;
	/** 服务端输出缓冲区长度 */
	static final int IN_OUTPUT_BUF_LENGTH = 4096 * 10;

	/** 侦听报文输出目录 */
	static final String OUT_PATH = "c:/";

	/** 代理对外侦听Socket */
	ServerSocket serverSocket;

	public static void main(String[] args)
	{
		SocketProxy socketProxy = new SocketProxy();

		log.info("服务侦听:" + port);

		socketProxy.run();
	}

	public SocketProxy()
	{
		try
		{
			//侦听
			serverSocket = new ServerSocket(port);
		}
		catch (IOException e)
		{
			log.error("Server bind port " + port + " ERR.", e);
			System.exit(-1);
		}
	}

	public void run()
	{
		while(true)
		{
			try
			{
				Socket socket = serverSocket.accept();

				log.debug("接收到1个外部连接请求");

				//连接内部服务
				Socket inSideSocket = new Socket(ip, in_port);

				//启动Request子线程
				new SubRequest(socket, inSideSocket).start();
				//启动Response子线程
				new SubResponse(socket, inSideSocket).start();
			}
			catch (Throwable e)
			{
				log.warn("socket异常，退出", e);
				System.exit(-1);
			}
		}
	}
}

 

 

 

 使用方法：

 

在SocketProxy.java 中配置

 /** 代理对外侦听端口，也就是你的socket代理监听那个端口的消息*/
 static int port = 9999;

 /** 内部服务端IP，也就是收到请求以后，转发给哪个目标ip地址  */
 static String ip = "133.64.64.13";
 /** 内部服务端端口 ，目标地址的端口号 */
 static int in_port =5011;

 /*请求和相应报文在硬盘上的存放位置*/

static final String OUT_PATH = "c:/";

运行SocketProxy.java

 

然后我们请求的使用 只需要讲请求的 目标地址换成代理Socket的 ip 地址和它监听的端口号就可以了

 

 

附件描述：

 

附件中是 一个Socket代理，改了个名字 叫HttpAdapter, 写了个shell，可以部署在linux ，unix上，你只要改改配置文件就可以了