使用Java实现简单搭建内网穿透
作者：cloudy491
内网穿透是一种网络技术,适用于需要远程访问本地部署服务的场景,本文主要为大家介绍了如何使用Java实现简单搭建内网穿透,感兴趣的可以了解下
思路
内网穿透是一种网络技术，适用于需要远程访问本地部署服务的场景，比如你在家里搭建了一个网站或者想远程访问家里的电脑。由于本地部署的设备使用私有IP地址，无法直接被外部访问，因此需要通过公网IP实现访问。通常可以通过购买云服务器获取一个公网IP来实现这一目的。
实际上，内网穿透的原理是将位于公司或其他工作地点的私有IP数据发送到云服务器（公网IP），再从云服务器发送到家里的设备（私有IP）。从私有IP到公网IP的连接是相对简单的，但是从公网IP到私有IP就比较麻烦，因为公网IP无法直接找到私有IP。
为了解决这个问题，我们可以让私有IP主动连接公网IP。这样，一旦私有IP连接到了公网IP，公网IP就知道了私有IP的存在，它们之间建立了连接关系。当公网IP收到访问请求时，就会通知私有IP有访问请求，并要求私有IP连接到公网IP。这样一来，公网IP就建立了两个连接，一个是用于访问的连接，另一个是与私有IP之间的连接。最后，通过这两个连接之间的数据交换，实现了远程访问本地部署服务的目的。
代码操作
打开IDEA创建一个mave项目，删除掉src,创建两个模块client和service,一个是在本地的运行，一个是在云服务器上运行的，这边socket(tcp)连接，我使用的是AIO,AIO的函数回调看起来好复杂。
先编写service服务端，创建两个ServerSocket服务，一个是监听16000的，用来外来连接的，另一是监听16088是用来client访问的，也就是给service和client之间交互用的。先讲一个extListener他是监听16000，当有外部请求来时，也就是在公司访问时，先判断registerChannel是不是有client和service，没有就关闭连接。有的话就下发指令告诉client有访问了赶快给我连接，连接会存在channelQueue队列里，拿到连接后，两个连接交换数据就行。
private static final int extPort = 16000;
private static final int clintPort = 16088;
private static AsynchronousSocketChannel registerChannel;
static BlockingQueue<AsynchronousSocketChannel> channelQueue = new LinkedBlockingQueue<>();
public static void main(String[] args) throws IOException {
final AsynchronousServerSocketChannel listener =
AsynchronousServerSocketChannel.open().bind(new InetSocketAddress("192.168.1.10", clintPort));
listener.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
public void completed(AsynchronousSocketChannel ch, Void att) {
// 接受连接，准备接收下一个连接
listener.accept(null, this);
// 处理连接
clintHandle(ch);
}
public void failed(Throwable exc, Void att) {
exc.printStackTrace();
}
});
final AsynchronousServerSocketChannel extListener =
AsynchronousServerSocketChannel.open().bind(new InetSocketAddress("localhost", extPort));
extListener.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
private Future<Integer> writeFuture;
public void completed(AsynchronousSocketChannel ch, Void att) {
// 接受连接，准备接收下一个连接
extListener.accept(null, this);
try {
//判断是否有注册连接
if(registerChannel==null || !registerChannel.isOpen()){
try {
ch.close();
} catch (IOException e) {
e.printStackTrace();
}
return;
}
//下发指令告诉需要连接
ByteBuffer bf = ByteBuffer.wrap(new byte[]{1});
if(writeFuture != null){
writeFuture.get();
}
writeFuture = registerChannel.write(bf);
AsynchronousSocketChannel take = channelQueue.take();
//clint连接失败的
if(take == null){
ch.close();
return;
}
//交换数据
exchangeDataHandle(ch,take);
} catch (Exception e) {
e.printStackTrace();
}
}
public void failed(Throwable exc, Void att) {
exc.printStackTrace();
}
});
Scanner in = new Scanner(System.in);
in.nextLine();
}
看看clintHandle方法是怎么存进channelQueue里的，很简单client发送0，就认为他是注册的连接，也就交互的连接直接覆盖registerChannel，发送1的话就是用来交换数据的，扔到channelQueue，发送2就异常的连接。
private static void clintHandle(AsynchronousSocketChannel ch) {
final ByteBuffer buffer = ByteBuffer.allocate(1);
ch.read(buffer, null, new CompletionHandler<Integer, Void>() {
public void completed(Integer result, Void attachment) {
buffer.flip();
byte b = buffer.get();
if (b == 0) {
registerChannel = ch;
} else if(b == 1){
channelQueue.offer(ch);
}else{
//clint连接不到
channelQueue.add(null);
}
}
public void failed(Throwable exc, Void attachment) {
exc.printStackTrace();
}
});
}
再编写client客户端，dstHost和dstPort是用来连接service的ip和端口，看起来好长，实际上就是client连接service，第一个连接成功后向service发送了个0告诉他是注册的连接，用来交换数据。当这个连接收到service发送的1时，就会创建新的连接去连接service。
private static final String dstHost = "192.168.1.10";
private static final int dstPort = 16088;
private static final String srcHost = "localhost";
private static final int srcPort = 3389;
public static void main(String[] args) throws IOException {
System.out.println("dst:"+dstHost+":"+dstPort);
System.out.println("src:"+srcHost+":"+srcPort);
//使用aio
final AsynchronousSocketChannel client = AsynchronousSocketChannel.open();
client.connect(new InetSocketAddress(dstHost, dstPort), null, new CompletionHandler<Void, Void>() {
public void completed(Void result, Void attachment) {
//连接成功
byte[] bt = new byte[]{0};
final ByteBuffer buffer = ByteBuffer.wrap(bt);
client.write(buffer, null, new CompletionHandler<Integer, Void>() {
public void completed(Integer result, Void attachment) {
//读取数据
final ByteBuffer buffer = ByteBuffer.allocate(1);
client.read(buffer, null, new CompletionHandler<Integer, Void>() {
public void completed(Integer result, Void attachment) {
buffer.flip();
if (buffer.get() == 1) {
//发起新的连
try {
createNewClient();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
buffer.clear();
// 这里再次调用读取操作，实现循环读取
client.read(buffer, null, this);
}
public void failed(Throwable exc, Void attachment) {
exc.printStackTrace();
}
});
}
public void failed(Throwable exc, Void attachment) {
exc.printStackTrace();
}
});
}
public void failed(Throwable exc, Void attachment) {
exc.printStackTrace();
}
});
Scanner in = new Scanner(System.in);
in.nextLine();
}
createNewClient方法，尝试连接本地服务，如果失败就发送2，成功就发送1，这个会走 service的clintHandle方法，成功的话就会让两个连接交换数据。
private static void createNewClient() throws IOException {
final AsynchronousSocketChannel dstClient = AsynchronousSocketChannel.open();
dstClient.connect(new InetSocketAddress(dstHost, dstPort), null, new CompletionHandler<Void, Void>() {
public void completed(Void result, Void attachment) {
//尝试连接本地服务
final AsynchronousSocketChannel srcClient;
try {
srcClient = AsynchronousSocketChannel.open();
srcClient.connect(new InetSocketAddress(srcHost, srcPort), null, new CompletionHandler<Void, Void>() {
public void completed(Void result, Void attachment) {
byte[] bt = new byte[]{1};
final ByteBuffer buffer = ByteBuffer.wrap(bt);
Future<Integer> write = dstClient.write(buffer);
try {
write.get();
//交换数据
exchangeData(srcClient, dstClient);
exchangeData(dstClient, srcClient);
} catch (Exception e) {
closeChannels(srcClient, dstClient);
}
}
public void failed(Throwable exc, Void attachment) {
exc.printStackTrace();
//失败
byte[] bt = new byte[]{2};
final ByteBuffer buffer = ByteBuffer.wrap(bt);
dstClient.write(buffer);
}
});
} catch (IOException e) {
e.printStackTrace();
//失败
byte[] bt = new byte[]{2};
final ByteBuffer buffer = ByteBuffer.wrap(bt);
dstClient.write(buffer);
}
}
public void failed(Throwable exc, Void attachment) {
exc.printStackTrace();
}
});
}
下面是exchangeData交换数据方法,看起好麻烦,效果就类似IOUtils.copy(InputStream,OutputStream),一个流写入另一个流。
private static void exchangeData(AsynchronousSocketChannel ch1, AsynchronousSocketChannel ch2) {
try {
final ByteBuffer buffer = ByteBuffer.allocate(1024);
ch1.read(buffer, null, new CompletionHandler<Integer, CompletableFuture<Integer>>() {
public void completed(Integer result, CompletableFuture<Integer> readAtt) {
CompletableFuture<Integer> future = new CompletableFuture<>();
if (result == -1 || buffer.position() == 0) {
// 处理连接关闭的情况或者没有数据可读的情况
try {
readAtt.get(3,TimeUnit.SECONDS);
} catch (Exception e) {
e.printStackTrace();
}
closeChannels(ch1, ch2);
return;
}
buffer.flip();
CompletionHandler readHandler = this;
ch2.write(buffer, future, new CompletionHandler<Integer, CompletableFuture<Integer>>() {
@Override
public void completed(Integer result, CompletableFuture<Integer> writeAtt) {
if (buffer.hasRemaining()) {
// 如果未完全写入，则继续写入
ch2.write(buffer, writeAtt, this);
} else {
writeAtt.complete(1);
// 清空buffer并继续读取
buffer.clear();
if(ch1.isOpen()){
ch1.read(buffer, writeAtt, readHandler);
}
}
}
@Override
public void failed(Throwable exc, CompletableFuture<Integer> attachment) {
if(!(exc instanceof AsynchronousCloseException)){
exc.printStackTrace();
}
closeChannels(ch1, ch2);
}
});
}
public void failed(Throwable exc, CompletableFuture<Integer> attachment) {
if(!(exc instanceof AsynchronousCloseException)){
exc.printStackTrace();
}
closeChannels(ch1, ch2);
}
});
} catch (Exception ex) {
ex.printStackTrace();
closeChannels(ch1, ch2);
}
}
private static void closeChannels(AsynchronousSocketChannel ch1, AsynchronousSocketChannel ch2) {
if (ch1 != null && ch1.isOpen()) {
try {
ch1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (ch2 != null && ch2.isOpen()) {
try {
ch2.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
测试
我这边就用虚拟机来测试，用云服务器就比较麻烦，得登录账号，增加开放端口规则，上传代码。我这边用Hyper-V快速创建了虚拟机，创建一个windows 10 MSIX系统,安装JDK8，下载地址 。怎样把本地编译好的class放到虚拟机呢，虚拟机是可以访问主机ip的，我们可以弄一个web的文件目录下载给虚拟机访问，人生苦短我用pyhton，下面python简单代码
if __name__ == '__main__':
# 定义服务器的端口
PORT = 8000
# 创建请求处理程序
Handler = http.server.SimpleHTTPRequestHandler
# 设置工作目录
os.chdir("C:\netTunnlDemo\client\target")
# 创建服务器
with socketserver.TCPServer(("", PORT), Handler) as httpd:
print(f"服务启动在端口 {PORT}")
httpd.serve_forever()
到class的目录下运行cmd，执行java -cp . org.example.Main，windows 默认远程端口3389。
最后效果
以上就是使用Java实现简单搭建内网穿透的详细内容，更多关于Java内网穿透的资料请关注脚本之家其它相关文章！