• JAVA基于Netty实现内网穿透功能【设计实践】

    目录

    背景

    实践

    项目结构

    原理分析

    代码实现

    cc-common项目

     cc-server项目

     cc-client项目

    使用

    启动服务端

    启动客户端 

    备注

    背景

    本文实现了一个简单的内网穿透服务，可以满足代理基于TCP协议的项目，如Tomcat、Redis、MySQL、windows远程桌面等。

    实践

    项目结构

    拆分了三个项目：

    1、cc-common项目:存放了消息格式和消息编解码器

    2、cc-server项目:内网穿透服务端项目

    3、cc-client项目:内网穿透客户端项目

    原理分析

    内网穿透的实现过程主要分三步

    1、启动服务端，这时服务端监听了两个端口（16001，16002，可根据启动参数修改），

    一个用来接收客户端请求（16001端口），

    一个用来接收访客代理（16002端口）

    2、启动客户端，客户端访问服务端提供的（16001端口）建立连接（server-client通道）

    3、访客访问代理接口（16002端口），服务端监听到之后创建访客ID，然后通过（server-client通道）向客户端发送指令，客户端接收指令后连接到真实服务端口（8080，可根据启动参数修改），连接真实服务成功后，客户端会重新向服务端建立一条连接（访客-server通道），服务端把访客和该通道进行绑定

    这三步最终形成了（访客-代理-客户端-真实服务）完整的通道。

    代码实现

    cc-common项目

    maven配置

    1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    2. 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    3. 	<modelVersion>4.0.0modelVersion>
    4. 	<groupId>com.luck.ccgroupId>
    5. 	<artifactId>cc-commonartifactId>
    6. 	<version>1.0-SNAPSHOTversion>
    7. 	<name>cc-commonname>
    8. 	<url>http://maven.apache.orgurl>
    9.  
    10. 	<properties>
    11. 		<java.home>${env.JAVA_HOME}java.home>
    12. 		<project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    13. 		<java.version>1.8java.version>
    14. 	properties>
    15.  
    16. 	<dependencies>
    17. 		<dependency>
    18. 			<groupId>io.nettygroupId>
    19. 			<artifactId>netty-allartifactId>
    20. 			<version>4.1.74.Finalversion>
    21. 		dependency>
    22. 	dependencies>
    23. 	<build>
    24. 		<plugins>
    25. 			<plugin>
    26. 				<artifactId>maven-compiler-pluginartifactId>
    27. 				<configuration>
    28. 					<source>1.8source>
    29. 					<target>1.8target>
    30. 				configuration>
    31. 			plugin>
    32. 		plugins>
    33. 	build>
    34. project>

     java代码

     消息类

    1. package com.luck.msg;
    2.  
    3. import java.util.Arrays;
    4.  
    5. public class MyMsg {
    6.  
    7. 	/** 心跳 */
    8. 	public static final byte TYPE_HEARTBEAT = 0X00;
    9.  
    10. 	/** 连接成功 */
    11. 	public static final byte TYPE_CONNECT = 0X01;
    12.  
    13. 	/** 数据传输 */
    14. 	public static final byte TYPE_TRANSFER = 0X02;
    15.  
    16. 	/** 连接断开 */
    17. 	public static final byte TYPE_DISCONNECT = 0X09;
    18.  
    19. 	/** 数据类型 */
    20. 	private byte type;
    21.  
    22. 	/** 消息传输数据 */
    23. 	private byte[] data;
    24.  
    25. 	public byte getType() {
    26. 		return type;
    27. 	}
    28.  
    29. 	public void setType(byte type) {
    30. 		this.type = type;
    31. 	}
    32.  
    33. 	public byte[] getData() {
    34. 		return data;
    35. 	}
    36.  
    37. 	public void setData(byte[] data) {
    38. 		this.data = data;
    39. 	}
    40.  
    41. 	@Override
    42. 	public String toString() {
    43. 		return "MyMsg [type=" + type + ", data=" + Arrays.toString(data) + "]";
    44. 	}
    45.  
    46. }

    消息编码类

    1. package com.luck.msg;
    2.  
    3. import io.netty.buffer.ByteBuf;
    4. import io.netty.channel.ChannelHandlerContext;
    5. import io.netty.handler.codec.MessageToByteEncoder;
    6.  
    7. public class MyMsgEncoder extends MessageToByteEncoder {
    8.  
    9. 	public MyMsgEncoder() {
    10.  
    11. 	}
    12.  
    13. 	@Override
    14. 	protected void encode(ChannelHandlerContext ctx, MyMsg msg, ByteBuf out) throws Exception {
    15. 		int bodyLength = 5;
    16. 		if (msg.getData() != null) {
    17. 			bodyLength += msg.getData().length;
    18. 		}
    19.  
    20. 		out.writeInt(bodyLength);
    21.  
    22. 		out.writeByte(msg.getType());
    23.  
    24. 		if (msg.getData() != null) {
    25. 			out.writeBytes(msg.getData());
    26. 		}
    27. 	}
    28. }

     消息解码类

    1. package com.luck.msg;
    2.  
    3. import io.netty.buffer.ByteBuf;
    4. import io.netty.channel.ChannelHandlerContext;
    5. import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
    6.  
    7. public class MyMsgDecoder extends LengthFieldBasedFrameDecoder {
    8.  
    9. 	public MyMsgDecoder(int maxFrameLength, int lengthFieldOffset, int lengthFieldLength, int lengthAdjustment,
    10. 			int initialBytesToStrip) {
    11. 		super(maxFrameLength, lengthFieldOffset, lengthFieldLength, lengthAdjustment, initialBytesToStrip);
    12. 	}
    13.  
    14. 	public MyMsgDecoder(int maxFrameLength, int lengthFieldOffset, int lengthFieldLength, int lengthAdjustment,
    15. 			int initialBytesToStrip, boolean failFast) {
    16. 		super(maxFrameLength, lengthFieldOffset, lengthFieldLength, lengthAdjustment, initialBytesToStrip, failFast);
    17. 	}
    18.  
    19. 	@Override
    20. 	protected MyMsg decode(ChannelHandlerContext ctx, ByteBuf in2) throws Exception {
    21. 		ByteBuf in = (ByteBuf) super.decode(ctx, in2);
    22. 		if (in == null) {
    23. 			return null;
    24. 		}
    25.  
    26. 		if (in.readableBytes() < 4) {
    27. 			return null;
    28. 		}
    29.  
    30. 		MyMsg myMsg = new MyMsg();
    31. 		int dataLength = in.readInt();
    32. 		byte type = in.readByte();
    33. 		myMsg.setType(type);
    34. 		byte[] data = new byte[dataLength - 5];
    35. 		in.readBytes(data);
    36. 		myMsg.setData(data);
    37. 		in.release();
    38.  
    39. 		return myMsg;
    40. 	}
    41. }

     cc-server项目

    maven配置

    1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    2. 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    3. 	<modelVersion>4.0.0modelVersion>
    4. 	<groupId>com.luck.ccgroupId>
    5. 	<artifactId>cc-serverartifactId>
    6. 	<version>1.0-SNAPSHOTversion>
    7. 	<name>cc-servername>
    8. 	<url>http://maven.apache.orgurl>
    9.  
    10. 	<properties>
    11. 		<java.home>${env.JAVA_HOME}java.home>
    12. 		<project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    13. 		<java.version>1.8java.version>
    14. 	properties>
    15.  
    16. 	<dependencies>
    17. 		<dependency>
    18. 			<groupId>com.luck.ccgroupId>
    19. 			<artifactId>cc-commonartifactId>
    20. 			<version>1.0-SNAPSHOTversion>
    21. 		dependency>
    22. 	dependencies>
    23. 	<build>
    24. 		<plugins>
    25. 			<plugin>
    26. 				<artifactId>maven-compiler-pluginartifactId>
    27. 				<configuration>
    28. 					<source>1.8source>
    29. 					<target>1.8target>
    30. 				configuration>
    31. 			plugin>
    32. 	        <plugin>
    33. 	            <artifactId>maven-assembly-pluginartifactId>
    34. 	            <version>3.0.0version>
    35. 	            <configuration>
    36. 	                <archive>
    37. 	                    <manifest>
    38. 	                        <mainClass>com.luck.server.ServerStartmainClass>
    39. 	                    manifest>
    40. 	                archive>
    41. 	                <descriptorRefs>
    42. 	                    <descriptorRef>jar-with-dependenciesdescriptorRef>
    43. 	                descriptorRefs>
    44. 	            configuration>
    45. 	            <executions>
    46. 	                <execution>
    47. 	                    <id>make-assemblyid>
    48. 	                    <phase>packagephase>
    49. 	                    <goals>
    50. 	                        <goal>singlegoal>
    51. 	                    goals>
    52. 	                execution>
    53. 	            executions>
    54. 	        plugin>
    55. 		plugins>
    56. 	build>
    57. project>

    Java代码 

     常量类

    1. package com.luck.server;
    2.  
    3. import java.util.Map;
    4. import java.util.concurrent.ConcurrentHashMap;
    5.  
    6. import io.netty.channel.Channel;
    7. import io.netty.util.AttributeKey;
    8. import io.netty.util.internal.StringUtil;
    9.  
    10. public class Constant {
    11. 	/** 客户端服务channel */
    12. 	public static Channel clientChannel = null;
    13.  
    14. 	/** 绑定channel_id */
    15. 	public static final AttributeKey VID = AttributeKey.newInstance("vid");
    16.  
    17. 	/** 访客，客户服务channel */
    18. 	public static Map vcc = new ConcurrentHashMap<>();
    19.  
    20. 	/** 访客，访客服务channel */
    21. 	public static Map vvc = new ConcurrentHashMap<>();
    22.  
    23. 	/** 服务代理端口 */
    24. 	public static int visitorPort = 16002;
    25.  
    26. 	/** 服务端口 */
    27. 	public static int serverPort = 16001;
    28.  
    29. 	/**
    30. 	 * 清除连接
    31. 	 * 
    32. 	 * @param vid 访客ID
    33. 	 */
    34. 	public static void clearVccVvc(String vid) {
    35. 		if (StringUtil.isNullOrEmpty(vid)) {
    36. 			return;
    37. 		}
    38. 		Channel clientChannel = vcc.get(vid);
    39. 		if (null != clientChannel) {
    40. 			clientChannel.attr(VID).set(null);
    41. 			vcc.remove(vid);
    42. 		}
    43. 		Channel visitorChannel = vvc.get(vid);
    44. 		if (null != visitorChannel) {
    45. 			visitorChannel.attr(VID).set(null);
    46. 			vvc.remove(vid);
    47. 		}
    48. 	}
    49.  
    50. 	/**
    51. 	 * 清除关闭连接
    52. 	 * 
    53. 	 * @param vid 访客ID
    54. 	 */
    55. 	public static void clearVccVvcAndClose(String vid) {
    56. 		if (StringUtil.isNullOrEmpty(vid)) {
    57. 			return;
    58. 		}
    59. 		Channel clientChannel = vcc.get(vid);
    60. 		if (null != clientChannel) {
    61. 			clientChannel.attr(VID).set(null);
    62. 			vcc.remove(vid);
    63. 			clientChannel.close();
    64. 		}
    65. 		Channel visitorChannel = vvc.get(vid);
    66. 		if (null != visitorChannel) {
    67. 			visitorChannel.attr(VID).set(null);
    68. 			vvc.remove(vid);
    69. 			visitorChannel.close();
    70. 		}
    71. 	}
    72. }

     服务代理handler

    1. package com.luck.server;
    2.  
    3. import com.luck.msg.MyMsg;
    4.  
    5. import io.netty.buffer.ByteBuf;
    6. import io.netty.buffer.Unpooled;
    7. import io.netty.channel.Channel;
    8. import io.netty.channel.ChannelFutureListener;
    9. import io.netty.channel.ChannelHandlerContext;
    10. import io.netty.channel.ChannelOption;
    11. import io.netty.channel.SimpleChannelInboundHandler;
    12. import io.netty.handler.timeout.IdleStateEvent;
    13. import io.netty.util.internal.StringUtil;
    14.  
    15. public class ClientHandler extends SimpleChannelInboundHandler {
    16.  
    17. 	@Override
    18. 	public void channelRead0(ChannelHandlerContext ctx, MyMsg myMsg) {
    19. 		// 代理服务器读到客户端数据了
    20. 		byte type = myMsg.getType();
    21. 		switch (type) {
    22. 		case MyMsg.TYPE_HEARTBEAT:
    23. 			MyMsg hb = new MyMsg();
    24. 			hb.setType(MyMsg.TYPE_HEARTBEAT);
    25. 			ctx.channel().writeAndFlush(hb);
    26. 			break;
    27. 		case MyMsg.TYPE_CONNECT:
    28. 			String vid = new String(myMsg.getData());
    29. 			if (StringUtil.isNullOrEmpty(vid) || "client".equals(vid)) {
    30. 				Constant.clientChannel = ctx.channel();
    31. 			} else {
    32. 				// 绑定访客和客户端的连接
    33. 				Channel visitorChannel = Constant.vvc.get(vid);
    34. 				if (null != visitorChannel) {
    35. 					ctx.channel().attr(Constant.VID).set(vid);
    36. 					Constant.vcc.put(vid, ctx.channel());
    37.  
    38. 					// 通道绑定完成可以读取访客数据
    39. 					visitorChannel.config().setOption(ChannelOption.AUTO_READ, true);
    40. 				}
    41. 			}
    42. 			break;
    43. 		case MyMsg.TYPE_DISCONNECT:
    44. 			String disVid = new String(myMsg.getData());
    45. 			Constant.clearVccVvcAndClose(disVid);
    46. 			break;
    47. 		case MyMsg.TYPE_TRANSFER:
    48. 			// 把数据转到用户服务
    49. 			ByteBuf buf = ctx.alloc().buffer(myMsg.getData().length);
    50. 			buf.writeBytes(myMsg.getData());
    51.  
    52. 			String visitorId = ctx.channel().attr(Constant.VID).get();
    53. 			Channel vchannel = Constant.vvc.get(visitorId);
    54. 			if (null != vchannel) {
    55. 				vchannel.writeAndFlush(buf);
    56. 			}
    57. 			break;
    58. 		default:
    59. 			// 操作有误
    60. 		}
    61. 		// 代理服务器发送数据到用户了
    62. 	}
    63.  
    64. 	@Override
    65. 	public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
    66. 		String vid = ctx.channel().attr(Constant.VID).get();
    67. 		if(StringUtil.isNullOrEmpty(vid)) {
    68. 			super.channelWritabilityChanged(ctx);
    69. 			return;
    70. 		}
    71. 		Channel visitorChannel = Constant.vvc.get(vid);
    72. 		if (visitorChannel != null) {
    73. 			visitorChannel.config().setOption(ChannelOption.AUTO_READ, ctx.channel().isWritable());
    74. 		}
    75.  
    76. 		super.channelWritabilityChanged(ctx);
    77. 	}
    78.  
    79. 	@Override
    80. 	public void channelInactive(ChannelHandlerContext ctx) throws Exception {
    81. 		String vid = ctx.channel().attr(Constant.VID).get();
    82. 		if (StringUtil.isNullOrEmpty(vid)) {
    83. 			super.channelInactive(ctx);
    84. 			return;
    85. 		}
    86. 		Channel visitorChannel = Constant.vvc.get(vid);
    87. 		if (visitorChannel != null && visitorChannel.isActive()) {
    88. 			// 数据发送完成后再关闭连接，解决http1.0数据传输问题
    89. 			visitorChannel.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
    90. 			visitorChannel.close();
    91. 		} else {
    92. 			ctx.channel().close();
    93. 		}
    94. 		Constant.clearVccVvc(vid);
    95. 		super.channelInactive(ctx);
    96. 	}
    97.  
    98. 	@Override
    99. 	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
    100. 		super.exceptionCaught(ctx, cause);
    101. 	}
    102.  
    103. 	@Override
    104. 	public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
    105. 		if (evt instanceof IdleStateEvent) {
    106. 			IdleStateEvent event = (IdleStateEvent) evt;
    107. 			switch (event.state()) {
    108. 			case READER_IDLE:
    109. 				ctx.channel().close();
    110. 				break;
    111. 			case WRITER_IDLE:
    112. 				break;
    113. 			case ALL_IDLE:
    114. 				break;
    115. 			}
    116. 		}
    117. 	}
    118. }

     访客handler

    1. package com.luck.server;
    2.  
    3. import java.util.UUID;
    4.  
    5. import com.luck.msg.MyMsg;
    6.  
    7. import io.netty.buffer.ByteBuf;
    8. import io.netty.channel.Channel;
    9. import io.netty.channel.ChannelHandlerContext;
    10. import io.netty.channel.ChannelOption;
    11. import io.netty.channel.SimpleChannelInboundHandler;
    12. import io.netty.util.internal.StringUtil;
    13.  
    14. public class VisitorHandler extends SimpleChannelInboundHandler {
    15.  
    16. 	@Override
    17. 	public void channelActive(ChannelHandlerContext ctx) throws Exception {
    18. 		// 访客连接上代理服务器了
    19. 		Channel visitorChannel = ctx.channel();
    20. 		// 先不读取访客数据
    21. 		visitorChannel.config().setOption(ChannelOption.AUTO_READ, false);
    22.  
    23. 		// 生成访客ID
    24. 		String vid = UUID.randomUUID().toString();
    25.  
    26. 		// 绑定访客通道
    27. 		visitorChannel.attr(Constant.VID).set(vid);
    28. 		Constant.vvc.put(vid, visitorChannel);
    29.  
    30. 		MyMsg myMsg = new MyMsg();
    31. 		myMsg.setType(MyMsg.TYPE_CONNECT);
    32. 		myMsg.setData(vid.getBytes());
    33. 		Constant.clientChannel.writeAndFlush(myMsg);
    34.  
    35. 		super.channelActive(ctx);
    36. 	}
    37.  
    38. 	@Override
    39. 	public void channelRead0(ChannelHandlerContext ctx, ByteBuf buf) {
    40. 		String vid = ctx.channel().attr(Constant.VID).get();
    41. 		if (StringUtil.isNullOrEmpty(vid)) {
    42. 			return;
    43. 		}
    44. 		byte[] bytes = new byte[buf.readableBytes()];
    45. 		buf.readBytes(bytes);
    46. 		MyMsg myMsg = new MyMsg();
    47. 		myMsg.setType(MyMsg.TYPE_TRANSFER);
    48. 		myMsg.setData(bytes);
    49.  
    50. 		// 代理服务器发送数据到客户端了
    51. 		Channel clientChannel = Constant.vcc.get(vid);
    52. 		clientChannel.writeAndFlush(myMsg);
    53. 	}
    54.  
    55. 	@Override
    56. 	public void channelInactive(ChannelHandlerContext ctx) throws Exception {
    57. 		String vid = ctx.channel().attr(Constant.VID).get();
    58. 		if (StringUtil.isNullOrEmpty(vid)) {
    59. 			super.channelInactive(ctx);
    60. 			return;
    61. 		}
    62. 		Channel clientChannel = Constant.vcc.get(vid);
    63. 		if (clientChannel != null && clientChannel.isActive()) {
    64.  
    65. 			clientChannel.config().setOption(ChannelOption.AUTO_READ, true);
    66.  
    67. 			// 通知客户端，访客连接已经断开
    68. 			MyMsg myMsg = new MyMsg();
    69. 			myMsg.setType(MyMsg.TYPE_DISCONNECT);
    70. 			myMsg.setData(vid.getBytes());
    71. 			clientChannel.writeAndFlush(myMsg);
    72. 		}
    73. 		Constant.clearVccVvc(vid);
    74. 		super.channelInactive(ctx);
    75. 	}
    76.  
    77. 	@Override
    78. 	public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
    79.  
    80. 		Channel visitorChannel = ctx.channel();
    81. 		String vid = visitorChannel.attr(Constant.VID).get();
    82. 		if (StringUtil.isNullOrEmpty(vid)) {
    83. 			super.channelWritabilityChanged(ctx);
    84. 			return;
    85. 		}
    86. 		Channel clientChannel = Constant.vcc.get(vid);
    87. 		if (clientChannel != null) {
    88. 			clientChannel.config().setOption(ChannelOption.AUTO_READ, visitorChannel.isWritable());
    89. 		}
    90.  
    91. 		super.channelWritabilityChanged(ctx);
    92. 	}
    93.  
    94. 	@Override
    95. 	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
    96. 		ctx.close();
    97. 	}
    98. }

     服务代理socket

    1. package com.luck.server;
    2.  
    3. import com.luck.msg.MyMsgDecoder;
    4. import com.luck.msg.MyMsgEncoder;
    5.  
    6. import io.netty.bootstrap.ServerBootstrap;
    7. import io.netty.channel.ChannelFuture;
    8. import io.netty.channel.ChannelFutureListener;
    9. import io.netty.channel.ChannelInitializer;
    10. import io.netty.channel.ChannelPipeline;
    11. import io.netty.channel.EventLoopGroup;
    12. import io.netty.channel.nio.NioEventLoopGroup;
    13. import io.netty.channel.socket.SocketChannel;
    14. import io.netty.channel.socket.nio.NioServerSocketChannel;
    15. import io.netty.handler.timeout.IdleStateHandler;
    16.  
    17. public class ServerSocket {
    18. 	private static EventLoopGroup bossGroup = new NioEventLoopGroup();
    19. 	private static EventLoopGroup workerGroup = new NioEventLoopGroup();
    20. 	private static ChannelFuture channelFuture;
    21.  
    22. 	/**
    23. 	 * 启动服务端
    24. 	 * @throws Exception
    25. 	 */
    26. 	public static void startServer() throws Exception {
    27. 		try {
    28.  
    29. 			ServerBootstrap b = new ServerBootstrap();
    30. 			b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
    31. 					.childHandler(new ChannelInitializer() {
    32. 						@Override
    33. 						public void initChannel(SocketChannel ch) throws Exception {
    34. 							ChannelPipeline pipeline = ch.pipeline();
    35. 							pipeline.addLast(new MyMsgDecoder(Integer.MAX_VALUE, 0, 4, -4, 0));
    36. 							pipeline.addLast(new MyMsgEncoder());
    37. 							pipeline.addLast(new IdleStateHandler(40, 10, 0));
    38. 							pipeline.addLast(new ClientHandler());
    39. 						}
    40.  
    41. 					});
    42. 			channelFuture = b.bind(Constant.serverPort).sync();
    43.  
    44. 			channelFuture.addListener((ChannelFutureListener) channelFuture -> {
    45. 				// 服务器已启动
    46. 			});
    47. 			channelFuture.channel().closeFuture().sync();
    48. 		} finally {
    49. 			shutdown();
    50. 			// 服务器已关闭
    51. 		}
    52. 	}
    53.  
    54. 	public static void shutdown() {
    55. 		if (channelFuture != null) {
    56. 			channelFuture.channel().close().syncUninterruptibly();
    57. 		}
    58. 		if ((bossGroup != null) && (!bossGroup.isShutdown())) {
    59. 			bossGroup.shutdownGracefully();
    60. 		}
    61. 		if ((workerGroup != null) && (!workerGroup.isShutdown())) {
    62. 			workerGroup.shutdownGracefully();
    63. 		}
    64. 	}
    65. }

    访客代理socket

    1. package com.luck.server;
    2.  
    3. import io.netty.bootstrap.ServerBootstrap;
    4. import io.netty.channel.ChannelDuplexHandler;
    5. import io.netty.channel.ChannelInitializer;
    6. import io.netty.channel.ChannelPipeline;
    7. import io.netty.channel.EventLoopGroup;
    8. import io.netty.channel.nio.NioEventLoopGroup;
    9. import io.netty.channel.socket.SocketChannel;
    10. import io.netty.channel.socket.nio.NioServerSocketChannel;
    11.  
    12. public class VisitorSocket {
    13. 	private static EventLoopGroup bossGroup = new NioEventLoopGroup();
    14. 	private static EventLoopGroup workerGroup = new NioEventLoopGroup();
    15.  
    16. 	/**
    17. 	 * 启动服务代理
    18. 	 * 
    19. 	 * @throws Exception
    20. 	 */
    21. 	public static void startServer() throws Exception {
    22.  
    23. 		ServerBootstrap b = new ServerBootstrap();
    24. 		b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
    25. 				.childHandler(new ChannelInitializer() {
    26. 					@Override
    27. 					public void initChannel(SocketChannel ch) throws Exception {
    28. 						ChannelPipeline pipeline = ch.pipeline();
    29. 						pipeline.addLast(new ChannelDuplexHandler());
    30. 						pipeline.addLast(new VisitorHandler());
    31. 					}
    32. 				});
    33. 		b.bind(Constant.visitorPort).get();
    34.  
    35. 	}
    36.  
    37. }

     启动类

    1. package com.luck.server;
    2.  
    3. public class ServerStart {
    4. 	public static void main(String[] args) throws Exception {
    5. 		if (null != args && args.length == 2) {
    6. 			int visitorPort = Integer.parseInt(args[1]);
    7. 			int serverPort = Integer.parseInt(args[0]);
    8. 			Constant.visitorPort = visitorPort;
    9. 			Constant.serverPort = serverPort;
    10. 			// 启动访客服务端，用于接收访客请求
    11. 			VisitorSocket.startServer();
    12. 			// 启动代理服务端，用于接收客户端请求
    13. 			ServerSocket.startServer();
    14. 		}
    15. 	}
    16. }

     cc-client项目

    maven配置

    1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    2. 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    3. 	<modelVersion>4.0.0modelVersion>
    4. 	<groupId>com.luck.ccgroupId>
    5. 	<artifactId>cc-clientartifactId>
    6. 	<version>1.0-SNAPSHOTversion>
    7. 	<name>cc-clientname>
    8. 	<url>http://maven.apache.orgurl>
    9.  
    10. 	<properties>
    11. 		<java.home>${env.JAVA_HOME}java.home>
    12. 		<project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    13. 		<java.version>1.8java.version>
    14. 	properties>
    15.  
    16. 	<dependencies>
    17. 		<dependency>
    18. 			<groupId>com.luck.ccgroupId>
    19. 			<artifactId>cc-commonartifactId>
    20. 			<version>1.0-SNAPSHOTversion>
    21. 		dependency>
    22. 	dependencies>
    23. 	<build>
    24. 		<plugins>
    25. 			<plugin>
    26. 				<artifactId>maven-compiler-pluginartifactId>
    27. 				<configuration>
    28. 					<source>1.8source>
    29. 					<target>1.8target>
    30. 				configuration>
    31. 			plugin>
    32. 	        <plugin>
    33. 	            <artifactId>maven-assembly-pluginartifactId>
    34. 	            <version>3.0.0version>
    35. 	            <configuration>
    36. 	                <archive>
    37. 	                    <manifest>
    38. 	                        <mainClass>com.luck.client.ClientStartmainClass>
    39. 	                    manifest>
    40. 	                archive>
    41. 	                <descriptorRefs>
    42. 	                    <descriptorRef>jar-with-dependenciesdescriptorRef>
    43. 	                descriptorRefs>
    44. 	            configuration>
    45. 	            <executions>
    46. 	                <execution>
    47. 	                    <id>make-assemblyid>
    48. 	                    <phase>packagephase>
    49. 	                    <goals>
    50. 	                        <goal>singlegoal>
    51. 	                    goals>
    52. 	                execution>
    53. 	            executions>
    54. 	        plugin>
    55. 		plugins>
    56. 	build>
    57. project>

    JAVA代码

    常量类

    1. package com.luck.client;
    2.  
    3. import java.util.Map;
    4. import java.util.concurrent.ConcurrentHashMap;
    5.  
    6. import io.netty.channel.Channel;
    7. import io.netty.util.AttributeKey;
    8. import io.netty.util.internal.StringUtil;
    9.  
    10. public class Constant {
    11. 	/** 代理服务channel */
    12. 	public static Channel proxyChannel = null;
    13.  
    14. 	/** 绑定访客id */
    15. 	public static final AttributeKey VID = AttributeKey.newInstance("vid");
    16.  
    17. 	/** 访客，代理服务channel */
    18. 	public static Map vpc = new ConcurrentHashMap<>();
    19.  
    20. 	/** 访客，真实服务channel */
    21. 	public static Map vrc = new ConcurrentHashMap<>();
    22.  
    23. 	/** 真实服务端口 */
    24. 	public static int realPort = 8080;
    25.  
    26. 	/** 服务端口 */
    27. 	public static int serverPort = 16001;
    28.  
    29. 	/** 服务IP */
    30. 	public static String serverIp = "127.0.0.1";
    31.  
    32. 	/**
    33. 	 * 清除连接
    34. 	 * 
    35. 	 * @param vid 访客ID
    36. 	 */
    37. 	public static void clearvpcvrc(String vid) {
    38. 		if (StringUtil.isNullOrEmpty(vid)) {
    39. 			return;
    40. 		}
    41. 		Channel clientChannel = vpc.get(vid);
    42. 		if (null != clientChannel) {
    43. 			clientChannel.attr(VID).set(null);
    44. 			vpc.remove(vid);
    45. 		}
    46. 		Channel visitorChannel = vrc.get(vid);
    47. 		if (null != visitorChannel) {
    48. 			visitorChannel.attr(VID).set(null);
    49. 			vrc.remove(vid);
    50. 		}
    51. 	}
    52.  
    53. 	/**
    54. 	 * 清除关闭连接
    55. 	 * 
    56. 	 * @param vid 访客ID
    57. 	 */
    58. 	public static void clearvpcvrcAndClose(String vid) {
    59. 		if (StringUtil.isNullOrEmpty(vid)) {
    60. 			return;
    61. 		}
    62. 		Channel clientChannel = vpc.get(vid);
    63. 		if (null != clientChannel) {
    64. 			clientChannel.attr(VID).set(null);
    65. 			vpc.remove(vid);
    66. 			clientChannel.close();
    67. 		}
    68. 		Channel visitorChannel = vrc.get(vid);
    69. 		if (null != visitorChannel) {
    70. 			visitorChannel.attr(VID).set(null);
    71. 			vrc.remove(vid);
    72. 			visitorChannel.close();
    73. 		}
    74. 	}
    75. }

      客户端代理handler

    1. package com.luck.client;
    2.  
    3. import com.luck.msg.MyMsg;
    4.  
    5. import io.netty.buffer.ByteBuf;
    6. import io.netty.channel.Channel;
    7. import io.netty.channel.ChannelHandlerContext;
    8. import io.netty.channel.ChannelOption;
    9. import io.netty.channel.SimpleChannelInboundHandler;
    10. import io.netty.handler.timeout.IdleStateEvent;
    11. import io.netty.util.internal.StringUtil;
    12.  
    13. public class ProxyHandler extends SimpleChannelInboundHandler {
    14.  
    15. 	@Override
    16. 	public void channelRead0(ChannelHandlerContext ctx, MyMsg myMsg) {
    17. 		// 客户端读取到代理过来的数据了
    18. 		byte type = myMsg.getType();
    19. 		String vid = new String(myMsg.getData());
    20. 		switch (type) {
    21. 		case MyMsg.TYPE_HEARTBEAT:
    22. 			break;
    23. 		case MyMsg.TYPE_CONNECT:
    24. 			RealSocket.connectRealServer(vid);
    25. 			break;
    26. 		case MyMsg.TYPE_DISCONNECT:
    27. 			Constant.clearvpcvrcAndClose(vid);
    28. 			break;
    29. 		case MyMsg.TYPE_TRANSFER:
    30. 			// 把数据转到真实服务
    31. 			ByteBuf buf = ctx.alloc().buffer(myMsg.getData().length);
    32. 			buf.writeBytes(myMsg.getData());
    33.  
    34. 			String visitorId = ctx.channel().attr(Constant.VID).get();
    35. 			Channel rchannel = Constant.vrc.get(visitorId);
    36. 			if (null != rchannel) {
    37. 				rchannel.writeAndFlush(buf);
    38. 			}
    39. 			break;
    40. 		default:
    41. 			// 操作有误
    42. 		}
    43. 		// 客户端发数据到真实服务了
    44. 	}
    45.  
    46. 	@Override
    47. 	public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
    48. 		String vid = ctx.channel().attr(Constant.VID).get();
    49. 		if (StringUtil.isNullOrEmpty(vid)) {
    50. 			super.channelWritabilityChanged(ctx);
    51. 			return;
    52. 		}
    53. 		Channel realChannel = Constant.vrc.get(vid);
    54. 		if (realChannel != null) {
    55. 			realChannel.config().setOption(ChannelOption.AUTO_READ, ctx.channel().isWritable());
    56. 		}
    57.  
    58. 		super.channelWritabilityChanged(ctx);
    59. 	}
    60.  
    61. 	@Override
    62. 	public void channelInactive(ChannelHandlerContext ctx) throws Exception {
    63. 		String vid = ctx.channel().attr(Constant.VID).get();
    64. 		if (StringUtil.isNullOrEmpty(vid)) {
    65. 			super.channelInactive(ctx);
    66. 			return;
    67. 		}
    68. 		Channel realChannel = Constant.vrc.get(vid);
    69. 		if (realChannel != null && realChannel.isActive()) {
    70. 			realChannel.close();
    71. 		}
    72. 		super.channelInactive(ctx);
    73. 	}
    74.  
    75. 	@Override
    76. 	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
    77. 		super.exceptionCaught(ctx, cause);
    78. 		cause.printStackTrace();
    79. 	}
    80.  
    81. 	@Override
    82. 	public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
    83. 		if (evt instanceof IdleStateEvent) {
    84. 			IdleStateEvent event = (IdleStateEvent) evt;
    85. 			switch (event.state()) {
    86. 			case READER_IDLE:
    87. 				ctx.channel().close();
    88. 				break;
    89. 			case WRITER_IDLE:
    90. 				MyMsg myMsg = new MyMsg();
    91. 				myMsg.setType(MyMsg.TYPE_HEARTBEAT);
    92. 				ctx.channel().writeAndFlush(myMsg);
    93. 				break;
    94. 			case ALL_IDLE:
    95. 				break;
    96. 			}
    97. 		}
    98. 	}
    99. }

     真实服务handler

    1. package com.luck.client;
    2.  
    3. import com.luck.msg.MyMsg;
    4.  
    5. import io.netty.buffer.ByteBuf;
    6. import io.netty.channel.Channel;
    7. import io.netty.channel.ChannelHandlerContext;
    8. import io.netty.channel.ChannelOption;
    9. import io.netty.channel.SimpleChannelInboundHandler;
    10. import io.netty.util.internal.StringUtil;
    11.  
    12. public class RealHandler extends SimpleChannelInboundHandler {
    13.  
    14. 	@Override
    15. 	public void channelRead0(ChannelHandlerContext ctx, ByteBuf buf) {
    16. 		// 客户读取到真实服务数据了
    17. 		byte[] bytes = new byte[buf.readableBytes()];
    18. 		buf.readBytes(bytes);
    19. 		MyMsg myMsg = new MyMsg();
    20. 		myMsg.setType(MyMsg.TYPE_TRANSFER);
    21. 		myMsg.setData(bytes);
    22. 		String vid = ctx.channel().attr(Constant.VID).get();
    23. 		if (StringUtil.isNullOrEmpty(vid)) {
    24. 			return;
    25. 		}
    26. 		Channel proxyChannel = Constant.vpc.get(vid);
    27. 		if (null != proxyChannel) {
    28. 			proxyChannel.writeAndFlush(myMsg);
    29. 		}
    30. 		// 客户端发送真实数据到代理了
    31. 	}
    32.  
    33. 	@Override
    34. 	public void channelActive(ChannelHandlerContext ctx) throws Exception {
    35. 		super.channelActive(ctx);
    36. 	}
    37.  
    38. 	@Override
    39. 	public void channelInactive(ChannelHandlerContext ctx) throws Exception {
    40. 		String vid = ctx.channel().attr(Constant.VID).get();
    41. 		if (StringUtil.isNullOrEmpty(vid)) {
    42. 			super.channelInactive(ctx);
    43. 			return;
    44. 		}
    45. 		Channel proxyChannel = Constant.vpc.get(vid);
    46. 		if (proxyChannel != null) {
    47. 			MyMsg myMsg = new MyMsg();
    48. 			myMsg.setType(MyMsg.TYPE_DISCONNECT);
    49. 			myMsg.setData(vid.getBytes());
    50. 			proxyChannel.writeAndFlush(myMsg);
    51. 		}
    52.  
    53. 		super.channelInactive(ctx);
    54. 	}
    55.  
    56. 	@Override
    57. 	public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
    58. 		String vid = ctx.channel().attr(Constant.VID).get();
    59. 		if (StringUtil.isNullOrEmpty(vid)) {
    60. 			super.channelWritabilityChanged(ctx);
    61. 			return;
    62. 		}
    63. 		Channel proxyChannel = Constant.vpc.get(vid);
    64. 		if (proxyChannel != null) {
    65. 			proxyChannel.config().setOption(ChannelOption.AUTO_READ, ctx.channel().isWritable());
    66. 		}
    67.  
    68. 		super.channelWritabilityChanged(ctx);
    69. 	}
    70.  
    71. 	@Override
    72. 	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
    73. 		super.exceptionCaught(ctx, cause);
    74. 	}
    75. }

     客户端代理socket

    1. package com.luck.client;
    2.  
    3. import java.util.concurrent.Executors;
    4. import java.util.concurrent.ScheduledExecutorService;
    5. import java.util.concurrent.TimeUnit;
    6.  
    7. import com.luck.msg.MyMsg;
    8. import com.luck.msg.MyMsgDecoder;
    9. import com.luck.msg.MyMsgEncoder;
    10.  
    11. import io.netty.bootstrap.Bootstrap;
    12. import io.netty.channel.Channel;
    13. import io.netty.channel.ChannelFuture;
    14. import io.netty.channel.ChannelFutureListener;
    15. import io.netty.channel.ChannelInitializer;
    16. import io.netty.channel.ChannelOption;
    17. import io.netty.channel.ChannelPipeline;
    18. import io.netty.channel.EventLoopGroup;
    19. import io.netty.channel.nio.NioEventLoopGroup;
    20. import io.netty.channel.socket.SocketChannel;
    21. import io.netty.channel.socket.nio.NioSocketChannel;
    22. import io.netty.handler.timeout.IdleStateHandler;
    23. import io.netty.util.internal.StringUtil;
    24.  
    25. public class ProxySocket {
    26. 	private static EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
    27.  
    28. 	/** 重连代理服务 */
    29. 	private static final ScheduledExecutorService reconnectExecutor = Executors.newSingleThreadScheduledExecutor();
    30.  
    31. 	public static Channel connectProxyServer() throws Exception {
    32. 		reconnectExecutor.scheduleAtFixedRate(new Runnable() {
    33. 			public void run() {
    34. 				try {
    35. 					connectProxyServer(null);
    36. 				} catch (Exception e) {
    37. 					e.printStackTrace();
    38. 				}
    39. 			}
    40. 		}, 3, 3, TimeUnit.SECONDS);
    41. 		return connectProxyServer(null);
    42. 	}
    43.  
    44. 	public static Channel connectProxyServer(String vid) throws Exception {
    45. 		if (StringUtil.isNullOrEmpty(vid)) {
    46. 			if (Constant.proxyChannel == null || !Constant.proxyChannel.isActive()) {
    47. 				newConnect(null);
    48. 			}
    49. 			return null;
    50. 		} else {
    51. 			Channel channel = Constant.vpc.get(vid);
    52. 			if (null == channel) {
    53. 				newConnect(vid);
    54. 				channel = Constant.vpc.get(vid);
    55. 			}
    56. 			return channel;
    57. 		}
    58. 	}
    59.  
    60. 	private static void newConnect(String vid) throws InterruptedException {
    61. 		Bootstrap bootstrap = new Bootstrap();
    62. 		bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class)
    63. 				.handler(new ChannelInitializer() {
    64. 					@Override
    65. 					public void initChannel(SocketChannel ch) throws Exception {
    66. 						ChannelPipeline pipeline = ch.pipeline();
    67. 						pipeline.addLast(new MyMsgDecoder(Integer.MAX_VALUE, 0, 4, -4, 0));
    68. 						pipeline.addLast(new MyMsgEncoder());
    69. 						pipeline.addLast(new IdleStateHandler(40, 8, 0));
    70. 						pipeline.addLast(new ProxyHandler());
    71. 					}
    72. 				});
    73.  
    74. 		bootstrap.connect(Constant.serverIp, Constant.serverPort).addListener(new ChannelFutureListener() {
    75. 			@Override
    76. 			public void operationComplete(ChannelFuture future) throws Exception {
    77. 				if (future.isSuccess()) {
    78. 					// 客户端链接代理服务器成功
    79. 					Channel channel = future.channel();
    80. 					if (StringUtil.isNullOrEmpty(vid)) {
    81. 						// 告诉服务端这条连接是client的连接
    82. 						MyMsg myMsg = new MyMsg();
    83. 						myMsg.setType(MyMsg.TYPE_CONNECT);
    84. 						myMsg.setData("client".getBytes());
    85. 						channel.writeAndFlush(myMsg);
    86.  
    87. 						Constant.proxyChannel = channel;
    88. 					} else {
    89.  
    90. 						// 告诉服务端这条连接是vid的连接
    91. 						MyMsg myMsg = new MyMsg();
    92. 						myMsg.setType(MyMsg.TYPE_CONNECT);
    93. 						myMsg.setData(vid.getBytes());
    94. 						channel.writeAndFlush(myMsg);
    95.  
    96. 						// 客户端绑定通道关系
    97. 						Constant.vpc.put(vid, channel);
    98. 						channel.attr(Constant.VID).set(vid);
    99.  
    100. 						Channel realChannel = Constant.vrc.get(vid);
    101. 						if (null != realChannel) {
    102. 							realChannel.config().setOption(ChannelOption.AUTO_READ, true);
    103. 						}
    104. 					}
    105. 				}
    106. 			}
    107. 		});
    108. 	}
    109. }

    真实服务socket 

    1. package com.luck.client;
    2.  
    3. import io.netty.bootstrap.Bootstrap;
    4. import io.netty.channel.Channel;
    5. import io.netty.channel.ChannelFuture;
    6. import io.netty.channel.ChannelFutureListener;
    7. import io.netty.channel.ChannelInitializer;
    8. import io.netty.channel.ChannelOption;
    9. import io.netty.channel.ChannelPipeline;
    10. import io.netty.channel.EventLoopGroup;
    11. import io.netty.channel.nio.NioEventLoopGroup;
    12. import io.netty.channel.socket.SocketChannel;
    13. import io.netty.channel.socket.nio.NioSocketChannel;
    14. import io.netty.util.internal.StringUtil;
    15.  
    16. public class RealSocket {
    17. 	static EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
    18.  
    19. 	/**
    20. 	 * 连接真实服务
    21. 	 * 
    22. 	 * @param vid 访客ID
    23. 	 * @return
    24. 	 */
    25. 	public static Channel connectRealServer(String vid) {
    26. 		if (StringUtil.isNullOrEmpty(vid)) {
    27. 			return null;
    28. 		}
    29. 		Channel channel = Constant.vrc.get(vid);
    30. 		if (null == channel) {
    31. 			newConnect(vid);
    32. 			channel = Constant.vrc.get(vid);
    33. 		}
    34. 		return channel;
    35. 	}
    36.  
    37. 	private static void newConnect(String vid) {
    38. 		try {
    39. 			Bootstrap bootstrap = new Bootstrap();
    40. 			bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class)
    41. 					.handler(new ChannelInitializer() {
    42. 						@Override
    43. 						public void initChannel(SocketChannel ch) throws Exception {
    44. 							ChannelPipeline pipeline = ch.pipeline();
    45. 							pipeline.addLast(new RealHandler());
    46. 						}
    47.  
    48. 					});
    49. 			bootstrap.connect("127.0.0.1", Constant.realPort).addListener(new ChannelFutureListener() {
    50. 				@Override
    51. 				public void operationComplete(ChannelFuture future) throws Exception {
    52. 					if (future.isSuccess()) {
    53. 						// 客户端链接真实服务成功
    54. 						future.channel().config().setOption(ChannelOption.AUTO_READ, false);
    55. 						future.channel().attr(Constant.VID).set(vid);
    56. 						Constant.vrc.put(vid, future.channel());
    57. 						ProxySocket.connectProxyServer(vid);
    58. 					}
    59. 				}
    60. 			});
    61. 		} catch (Exception e) {
    62. 			e.printStackTrace();
    63. 		}
    64. 	}
    65. }

     启动类

    1. package com.luck.client;
    2.  
    3. public class ClientStart {
    4.  
    5. 	public static void main(String[] args) throws Exception {
    6. 		if (null != args && args.length == 3) {
    7. 			int realPort = Integer.parseInt(args[2]);
    8. 			int serverPort = Integer.parseInt(args[1]);
    9. 			String serverIp = args[0];
    10. 			Constant.serverIp = serverIp;
    11. 			Constant.serverPort = serverPort;
    12. 			Constant.realPort = realPort;
    13. 			// 连接代理服务
    14. 			ProxySocket.connectProxyServer();
    15. 		}
    16. 	}
    17. }

    使用

    启动服务端

    java -jar cc-server.jar 16001 16002

    启动客户端 

    java -jar cc-client.jar 127.0.0.1 16001 8080

    备注

    参考：中微子代理: 一款基于netty的内网穿透神器 (gitee.com)

    中微子代理（neutrino-proxy）是一个基于netty的、开源的java内网穿透项目。遵循MIT许可，因此您可以对它进行复制、修改、传播并用于任何个人或商业行为。

    中微子代理项目还在完善中，目前有比较完整的管理功能，支持多租户，代码也比较易读，需要的同学可以去看下。

  • 相关阅读:
    Hybrid Astar 算法剖析和实现（七）
    【ESP32 手机配网教程】
    综合能力 ---- 2. 法律法规
    第六章 图论 7 AcWing 1619. 欧拉路径
    【HCIE考试喜报】2022年11月11日考试通过
    【多态】为什么析构函数的名称统一处理为destructor？
    回归分析：逻辑斯蒂模型，多分类任务
    Pikachu靶场——目录遍历漏洞和敏感信息泄露
    Python爬虫（五）
    docker run和docker start的区别
  • 原文地址：https://blog.csdn.net/anshichuxuezhe/article/details/128193917