java实现一个socks5代理 <一>了解nio Selector的基本用法

最新推荐文章于 2025-07-19 16:36:09 发布

woaiqianzhige

最新推荐文章于 2025-07-19 16:36:09 发布

阅读量2.1k

点赞数

CC 4.0 BY-SA版权

分类专栏：学习中遇到的问题文章标签： java nio java socket写一个socks代 socket5

本文链接：https://blog.youkuaiyun.com/woaiqianzhige/article/details/78733686

学习中遇到的问题专栏收录该内容

16 篇文章

订阅专栏

本文介绍了如何使用Java NIO和Selector来实现一个SOCKS5代理，详细阐述了从创建ServiceSocketChannel监听端口，处理客户端连接，到数据传输的全过程，适合对NIO有一定了解的读者深入学习。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

上面浏览器可以放心的将数据交给代理了，接下来做的是怎样处理这些数据，以及面对浏览器突然过来的很多连接如何处理他们，这就要用到javax.nio包下的东西了，下面做简单介绍，不会nio可以先去学习下nio selector的基本用法，再回来接着看，下面先讲思路再上代码

1.创建ServiceSocketChannel,监听在5661端口。

2.像selector注册accept事件

3.堵塞式的从selector选择，选择后就开始执行

4.允许所有的连接，对获取到的连接都发送 5 0 表示接受无密码的连接

5.接受到ip port 的信息后，ip port 解析出来，异步连接到此ip port 并注册 connection事件

6。当连接事件触发后，完成连接，像浏览器返回连接成功的标识。

7.像selector注册两个监听，分别监听client 和外网的socketchannel连接 read事件

8.当监听到其中一方的数据就读取并将数据写入另一方的channel中。

9.当读到流的末尾，管理连接，注销掉channel 等。

10.socks4的握手方式和socks5不同其他都相同，所以可以共用大部分代码

package com.proxydemo;
import java.io.IOException;
public class Main {
	//程序启动入口
	public static void main(String[] args) throws IOException {
		Reactor reactor=new Reactor();
		reactor.run();
	}
}

package com.proxydemo;
/*

容器类，selector的创建 以及做选择 并且执行的类

*/
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.util.Iterator;
import java.util.Set;

//容器类
public class Reactor implements Runnable {
	private Selector selector;	//容器
	private ServerSocketChannel ssc;	//服务端socketchannel
	
	public Reactor() throws IOException{
	//初始化容器和服务器
		selector=Selector.open();
		ssc=ServerSocketChannel.open();
	//绑定事件 和 端口 设置异步
		ssc.bind(new InetSocketAddress(5661));
		ssc.configureBlocking(false);
		SelectionKey key = ssc.register(selector, SelectionKey.OP_ACCEPT);
		//创建accept事件,以及创建处理的线程
		key.attach(new AcceptAcceptor(selector,ssc));

	}
	
	public void run() {
		while(true){
			try {
				int size = selector.select();
				if(size==0){
					continue;
				}
			} catch (IOException e) {
				e.printStackTrace();
			}

			Set<SelectionKey> keys = selector.selectedKeys();
			Iterator<SelectionKey> iterator = keys.iterator();
			while(iterator.hasNext()){
				SelectionKey next = iterator.next();
				consume(next);
				iterator.remove();
			}
		}
		
	}
	
	private void consume(SelectionKey key){
		Runnable r = (Runnable) key.attachment();
		r.run();
	}
	

}

package com.proxydemo;

import java.io.IOException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;


//负责接受连接的类，接受完立即注册   读操作 读操作出发 Handler551
public class AcceptAcceptor implements Runnable {
	private Selector selector;
	private ServerSocketChannel ssc;
	
	public AcceptAcceptor(Selector selector,ServerSocketChannel ssc){
		this.selector=selector;
		this.ssc=ssc;
	}
	
	
	public void run() {
		try {
			SocketChannel socket = ssc.accept();
			socket.configureBlocking(false);
			SelectionKey keyclient = socket.register(selector, SelectionKey.OP_READ);
			keyclient.attach(new Handler551(keyclient));		
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		
		
		
	}

}

package com.proxydemo;

import java.io.IOException;
import java.net.InetAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Arrays;


/*出发了读操作触发此事件 目的读取 5 1 0 /或者4 1 0 
 * 出发写操作的事件，目的写入 5 0
 * 根据事件的不同做出不同行为

根据是socks4 /socks5做不同处理
 * */
public class Handler551 implements Runnable {
	
	private Selector selector;
	private SocketChannel sc;
	private SelectionKey keyclient;
	private ByteBuffer bytebuffer=ByteBuffer.allocate(10);
	static byte bb510[]={5,0};
	static byte bb410[]={0,90,0,0,0,0,0,0};
	 //返回愿意连接
	public Handler551(SelectionKey keyclient){
			this.selector=keyclient.selector();
			this.keyclient=keyclient;
			sc=(SocketChannel) keyclient.channel();
	}
	
	
	public void run() {
		bytebuffer.clear();
			try {
				int read = sc.read(bytebuffer);
				if(read==-1){
					keyclient.cancel();
					return;
				}
				System.out.println("得到的结果"+Arrays.toString(bytebuffer.array()));
				int b = bytebuffer.get(0);
				if(b==5){ //协议5
					sc.write(ByteBuffer.wrap(bb510));
					keyclient.attach(new Handler501002( keyclient));
				}else if(b==4){	//协议4
					int portflag=bytebuffer.get(2);
					int port=bytebuffer.get(3);
					if(port>0){
						port=256*portflag+port;
					}else{
						port=256*portflag+(256+port);
					}
					StringBuilder sb=new StringBuilder();
					int A=bytebuffer.get(4);
					int B=bytebuffer.get(5);
					int C=bytebuffer.get(6);
					int D=bytebuffer.get(7);
					System.out.println("原来的"+A+"."+B+"."+C+"."+D);
					if(A<0) A=256+A;
					if(B<0) B=256+B;
					if(C<0) C=256+C;
					if(D<0) D=256+D;
					sb.append(A);sb.append(".");sb.append(B);sb.append(".");
					sb.append(C);sb.append(".");sb.append(D);
					
					String host=sb.toString();
					sc.write(ByteBuffer.wrap(bb410));
					keyclient.attach(new Sockts4Handler( keyclient,host,port));
					
				}

			} catch (IOException e) {
				keyclient.cancel();
				selector.wakeup();
				e.printStackTrace();
			}
		
	}
}

package com.proxydemo;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;

/*
 * 第一步初步握手完成后 第二步 进行验证握手
 如果是socks5 则执行这一步 进行接受ip和端口信息 * */

public class Handler501002 implements Runnable {
	private Selector selector;
	private SocketChannel sc;
	private SelectionKey keyclient;
	static byte bb501002[]={5,0,0,1,0,0,0,0,1,1};
	ByteBuffer bytebuffer=ByteBuffer.allocate(100);
	public Handler501002(SelectionKey keyclient){
			this.selector=keyclient.selector();
			this.keyclient=keyclient;
			this.sc=(SocketChannel) keyclient.channel();
	}
	
	/*	1.读取数据
	 * 	2.解析数据，建立连接，绑定下一个handler
	 * 
	 * */
	public void run() {
				int read=-1;
				try {
					read = sc.read(bytebuffer);
				} catch (IOException e) {
					e.printStackTrace();
				}
				if(read==-1){
					keyclient.cancel();
					return;
				}
				
				//sc.write(ok50001);
				//2.解析数据
				String host=getHost(bytebuffer.asReadOnlyBuffer(), read);
				int port=getPort(bytebuffer.asReadOnlyBuffer(), read);
				try{
				//4.不处理host为空的数据
				if(host==null||"".equals(host)){
					for(int i=0;i<read;i++){						//***********************
						System.out.print(bytebuffer.get(i));
						System.out.println("host null");
					}
					sc.close();
					keyclient.cancel();
					selector.wakeup();
					return;
				}
				//3.创建channel
				SocketChannel scClient=SocketChannel.open();
				//5 不处理查找不到ip地址的域名
				InetSocketAddress isa=new InetSocketAddress(host, port);
				if(isa.isUnresolved() || isa.getAddress().equals("") ||isa.getAddress().equals("127.0.0.1")){
					sc.close();
					keyclient.cancel();
					return;
				}
				//5.设置异步
				scClient.configureBlocking(false);
				//6.异步连接
				scClient.connect(isa);
				//7.注册
				SelectionKey register = scClient.register(selector, SelectionKey.OP_CONNECT);
				//7 还没有连接上时 暂时不监测client、的是否有东西可读
				keyclient.interestOps(keyclient.interestOps() &~SelectionKey.OP_READ );
				//8添加连接事件
				/* 分别是与优酷之间的连接 || 与client之间的连接  */
				register.attach(new LinkFinish( register,keyclient)); //传进去代理和优酷之间的连接
			
				System.out.println(host+":"+port);
				}catch(IOException e){
					e.printStackTrace();
				}
	}
	
	
	//解析地址
			public String getHost(ByteBuffer a,int len){
				if(len<8){
					return null;
				}
				StringBuffer sb=new StringBuffer();
				if(a.get(3)==3){
					//说明是网址地址
					int size=a.get(4); //网址长度
					for(int i=5;i<(5+size);i++){
						sb.append((char)a.get(i));
					}
					
				}else if(a.get(3)==1){
					//说明是ip地址
					for(int i=4;i<=7;i++){
						int A=a.get(i);
						if(A<0) A=256+A;
						sb.append(A);
						sb.append(".");
					}
					sb.deleteCharAt(sb.length()-1);
				}
				return sb.toString();
			}
			
			//解析端口
			public int getPort(ByteBuffer a,int len){
				if(len<4){
					return 0;
				}
				int port = a.get(len-1);
				int thod=a.get(len-2);
				if(port>0){
					return 256*thod+port;
				}else{
					return 256*thod +(256+port);
				}
			}
}

package com.proxydemo;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.concurrent.TimeoutException;

/*
 * 异步连接如果触发，则完成连接，注册读取事件
 上一步获取了真正的ip和port并进行异步连接，这一步完成真正的连接* */


public class LinkFinish implements Runnable {
	static byte bb501002[]={5,0,0,1,0,0,0,0,1,1};
		private Selector selector;
		private SocketChannel sc; //代理和实际网站的连接
		private SocketChannel cd; //client和代理之间
		private SelectionKey key551,keyWeb;
		
		public LinkFinish(SelectionKey keyWeb,SelectionKey key551){
				this.selector=key551.selector();
				this.key551=key551;
				this.keyWeb=keyWeb;
				sc=(SocketChannel) keyWeb.channel();
				cd=(SocketChannel) key551.channel();
				
		}
	public void run() {
		//1.完成连接
			boolean finishConnect =false;
			try {
				finishConnect = sc.finishConnect();
				//1  向客户端通知他连接成功了，可以发送数据了
				ByteBuffer ok50001 = ByteBuffer.wrap(bb501002);//返回愿意连接
					cd.write(ok50001);
					
			if(finishConnect){
			//2.转换成read
				//keyFor.interestOps(SelectionKey.OP_READ &~SelectionKey.OP_CONNECT);
				keyWeb.interestOps(keyWeb.interestOps() & 0 |SelectionKey.OP_READ);
				key551.interestOps(SelectionKey.OP_READ );
			//3.切换handler
				keyWeb.attach(new ReadHandler(keyWeb,key551));	//设置Handler   代理to优酷      电脑to代理
				key551.attach(new ReadHandler2( keyWeb,key551));		//代理to优酷      电脑to代理
				System.out.println("实际连接");
		//	selector.wakeup();
			}
	
			
			} catch (IOException e1) {
				try {
					sc.close();
					cd.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
				keyWeb.cancel();
				key551.cancel();
				System.out.println("超时一个"+sc.socket().getInetAddress());
			//selector.wakeup();
				return;
			}
		
		
		
	}

}

package com.proxydemo;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Arrays;

/*
 * 代理将数据打向浏览器
 * */
public class ReadHandler implements Runnable {

	private Selector selector;
	private SocketChannel sc; //代理和优酷网站之间的通道
	private SocketChannel cd;//浏览器和代理之间的通道
	private SelectionKey key551,keyWeb;
	
	
	ByteBuffer buffer=ByteBuffer.allocate(6144);
	public ReadHandler(SelectionKey keyWeb,SelectionKey key551){
			this.selector=key551.selector();
			this.keyWeb=keyWeb;
			this.key551=key551;
			sc=(SocketChannel) keyWeb.channel();
			cd=(SocketChannel) key551.channel();
	}
	/*负责交换数据，都的话放进缓冲区，写的话，从缓冲区中国写
	 * */
	
	public void run() {
	//	ByteBuffer buffer=ByteBuffer.allocate(4096);
	 //浏览器打向代理
			//1.清空缓冲区
			buffer.clear();
			//2.读取数据
		
				int read=-1;
				try {
					read = sc.read(buffer);
				} catch (IOException e1) {
					/*异常则证明连接已经断开了，直接断开就可以*/
					e1.printStackTrace();
				}
				//检查是否是-1 是的话说明没有数据读 或者已经关闭了
				if(read==-1){
					//没关闭就将他关闭
					if(sc.isOpen()){
						try {
							sc.close();
						} catch (IOException e) {
							e.printStackTrace();
						}
					}
					keyWeb.cancel();
					return;
					//selector.wakeup();
				}
				
				int write=-1;
					if(read>0){
					buffer.flip();
					if(cd.isOpen()){
					try {
						 write = cd.write(buffer);
					} catch (IOException e) {
						e.printStackTrace();
						}
					}
					
					}
				if(write==-1){
					if(cd.isOpen()){
						try {
							cd.close();
						} catch (IOException e) {
							e.printStackTrace();
						}
						key551.cancel();
						
					}
					
				}
				
					buffer.clear();
				
					if(read==0){
						//	keyFor2.interestOps(SelectionKey.OP_WRITE);
						//selector.wakeup();
					}
					
				System.out.println(read+"接收");	
			
		
		
		
		
	}

}

package com.proxydemo;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;

//浏览器将数据打向代理
//
public class ReadHandler2 implements Runnable {

	private Selector selector;
	private SocketChannel sc; //代理和优酷网站之间的通道
	private SocketChannel cd;//浏览器和代理之间的通道
	private SelectionKey key551,keyWeb;
	ByteBuffer buffer=ByteBuffer.allocate(6144);
	public ReadHandler2(SelectionKey keyWeb,SelectionKey key551){
			this.selector=key551.selector();
			this.keyWeb=keyWeb;
			this.key551=key551;
			this.sc=(SocketChannel) keyWeb.channel();
			this.cd=(SocketChannel) key551.channel();
	}
	/*负责交换数据，都的话放进缓冲区，写的话，从缓冲区中国写
	 * */
	public void run() {
	//	ByteBuffer buffer=ByteBuffer.allocate(10240);
			//1.清空缓冲区
			buffer.clear();
			//2.读取数据
				int read=-1;
				if(cd.isOpen()){
				try {
					read = cd.read(buffer);
				} catch (IOException e) {
					e.printStackTrace();
				}
				}
				
				if(read==-1){
					if(cd.isOpen()){
					try {
						cd.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
					}
					key551.cancel();
					return;
				}
				
				int write=-1;
					if(read>0){
						buffer.flip();
						if(cd.isOpen()){
						try {
							write = sc.write(buffer);
						} catch (IOException e) {
							e.printStackTrace();
						}
						}
					}
					
					if(write==-1){
						if(cd.isOpen()){
							try {
								cd.close();
							} catch (IOException e) {
								e.printStackTrace();
							}
						}
						keyWeb.cancel();
					}
					
					buffer.clear();
				
					
					if(read==0){
						//keyFor.interestOps(SelectionKey.OP_WRITE);
						//selector.wakeup();
					}
					System.out.println("发送"+read);
			
		
		
	}

}

package com.proxydemo;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
//如果是sockets4 则执行这个
public class Sockts4Handler implements Runnable {

	private Selector selector;
	private SocketChannel sc;
	private SelectionKey keyclient;
	String host;
	int port;
	public Sockts4Handler(SelectionKey keyclient,String host,int port){
			this.selector=keyclient.selector();
			this.keyclient=keyclient;
			this.sc=(SocketChannel) keyclient.channel();
			this.host=host;
			this.port=port;
	}
	
	/*	1.读取数据
	 * 	2.解析数据，建立连接，绑定下一个handler
	 * 
	 * */
	public void run() {	
				try{
				//4.不处理host为空的数据
				if(host==null||"".equals(host)){
					sc.close();
					keyclient.cancel();
					selector.wakeup();
					return;
				}
				//3.创建channel
				SocketChannel scClient=SocketChannel.open();
				//5 不处理查找不到ip地址的域名
				InetSocketAddress isa=new InetSocketAddress(host, port);
				if(isa.isUnresolved() || isa.getAddress().equals("") ||isa.getAddress().equals("127.0.0.1")){
					sc.close();
					keyclient.cancel();
					return;
				}
				//5.设置异步
				scClient.configureBlocking(false);
				//6.异步连接
				scClient.connect(isa);
				//7.注册
				SelectionKey register = scClient.register(selector, SelectionKey.OP_CONNECT);
				//7 还没有连接上时 暂时不监测client、的是否有东西可读
				keyclient.interestOps(keyclient.interestOps() &~SelectionKey.OP_READ );
				//8添加连接事件
				/* 分别是与优酷之间的连接 || 与client之间的连接  */
				register.attach(new Sockets4LinkFinish( register,keyclient)); //传进去代理和优酷之间的连接
				System.out.println(host+":"+port);
				}catch(IOException e){
					e.printStackTrace();
				}
	}
	
	

	
}

package com.proxydemo;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.concurrent.TimeoutException;

/*
 * 异步连接如果触发，则完成连接，注册读取事件
 sockets4 执行这个* */


public class Sockets4LinkFinish implements Runnable {
	static byte bb501002[]={5,0,0,1,0,0,0,0,1,1};
	static byte bb401002[]={0,90,0,0,0,0,0,0};
		private Selector selector;
		private SocketChannel sc; //代理和实际网站的连接
		private SocketChannel cd; //client和代理之间
		private SelectionKey key551,keyWeb;
		
		public Sockets4LinkFinish(SelectionKey keyWeb,SelectionKey key551){
				this.selector=key551.selector();
				this.key551=key551;
				this.keyWeb=keyWeb;
				sc=(SocketChannel) keyWeb.channel();
				cd=(SocketChannel) key551.channel();
				
		}
	public void run() {
		//1.完成连接
			boolean finishConnect =false;
			try {
				finishConnect = sc.finishConnect();
				//1  向客户端通知他连接成功了，可以发送数据了
				ByteBuffer ok50001 = ByteBuffer.wrap(bb401002);//返回愿意连接
					//cd.write(ok50001);
					
			if(finishConnect){
			//2.转换成read
				//keyFor.interestOps(SelectionKey.OP_READ &~SelectionKey.OP_CONNECT);
				keyWeb.interestOps(keyWeb.interestOps() & 0 |SelectionKey.OP_READ);
				key551.interestOps(SelectionKey.OP_READ );
			//3.切换handler
				keyWeb.attach(new ReadHandler(keyWeb,key551));	//设置Handler   代理to优酷      电脑to代理
				key551.attach(new ReadHandler2( keyWeb,key551));		//代理to优酷      电脑to代理
				System.out.println("实际连接");
		//	selector.wakeup();
			}
	
			
			} catch (IOException e1) {
				try {
					sc.close();
					cd.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
				keyWeb.cancel();
				key551.cancel();
				System.out.println("超时一个"+sc.socket().getInetAddress());
			//selector.wakeup();
				return;
			}
		
		
		
	}

}

这个demo主要是练习下nio的使用，兼容socks4 后，可以将internate选项中设置套接字，那个直接就是socks4的代理，这样能看到很多数据包在代理中流动，本地使用对浏览器打开网页的速度影响非常小，几乎看不出来

这里的源码下载可以导入eclipse 直接执行看结果了源码地址