几行代码使用Go语言对接第三方工具之集成gin、kite框架、通过原生不借助其他软件实现内网穿透工具

于 2024-05-27 09:22:43 发布
阅读量194 收藏
点赞数 5
分类专栏： GO相关 文章标签： golang gin kite 内网穿透 nps npc 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014374009/article/details/139226237
版权

几行代码使用Go语言对接第三方工具之集成gin、kite框架、通过原生不借助其他软件实现内网穿透工具。

在这里插入图片描述

内网穿透工具
多协程与通道配合达到快速响应
3秒发送一次心跳包维护连接
client断开自动重连

说明
server端： 具有公网地址的服务器
client端： 需要内网穿透的主机
使用
server端, 默认本地为5200端口

./server -l 5200 -r 3333

client端

./client -l 8080 -r 3333 -h 公网IP地址

用户访问 公网IP地址:5200 即可访问到 内网中的 8080端口程序

几行代码使用Go语言对接第三方工具之集成gin框架。

package main

import (
	"fmt"
	"github.com/gin-contrib/pprof"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"gopkg.in/go-playground/validator.v8"
	"log"
	"net/http"
	"reflect"
)

func main() {
	r := gin.Default()

	// 设置gin mode
	gin.SetMode(gin.DebugMode)

	// 修改默认路由打印格式
	gin.DebugPrintRouteFunc = func(httpMethod, absolutePath, handlerName string, nuHandlers int) {
		log.Printf("【%v】====> %v\n", httpMethod, absolutePath)
	}

	// 全局中间件，阻止panic
	r.Use(gin.Recovery())

	// 为某个group下的路由注册中间件
	r.Group("/admin").Use(func(context *gin.Context) {
		if id := context.GetHeader("adminUserId"); id == "" {
			context.JSON(http.StatusForbidden, "请登录管理员")
		}
	})

	// 开启pprof
	pprof.Register(r)

	// 自定义校验
	// 将我们自定义的校验方法注册到 validator中
	if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
		if err := v.RegisterValidation("NotNullAndAdmin", nameNotNullAndAdmin); err != nil {
			fmt.Println("RegisterValidation NotNullAndAdmin", err.Error())
		}
	}

	if err := r.Run(":8080"); err != nil {
		panic(err)
	}
}

func nameNotNullAndAdmin(v *validator.Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
	if value, ok := field.Interface().(string); ok {
		// 字段不能为空，并且不等于  admin
		return value != "" && "admin" != value
	}
	return true
}

type Req struct {
	Name string `validate:"NotNullAndAdmin"`
}

几行代码使用Go语言对接第三方工具之集成kite框架。

package main

import "github.com/koding/kite"

func main() {
	// Create a kite
	k := kite.New("math", "1.0.0")

	// Add our handler method with the name "square"
	k.HandleFunc("square", func(r *kite.Request) (interface{}, error) {
		a := r.Args.One().MustFloat64()
		result := a * a    // calculate the square
		return result, nil // send back the result
	}).DisableAuthentication()

	// Attach to a server with port 3636 and run it
	k.Config.Port = 3636
	k.Run()
}

通过原生不借助其他软件实现内网穿透工具：

client/client.go

package main

import (
	"context"
	"flag"
	"fmt"
	"io"
	"net"
	"strings"
	"time"
)

var (
	host       string
	localPort  int
	remotePort int
)

func init() {
	flag.StringVar(&host, "h", "127.0.0.1", "remote server ip")
	flag.IntVar(&localPort, "l", 8080, "the local port")
	flag.IntVar(&remotePort, "r", 3333, "remote server port")
}

type server struct {
	conn net.Conn
	// 数据传输通道
	read  chan []byte
	write chan []byte
	// 异常退出通道
	exit chan error
	// 重连通道
	reConn chan bool
}

// 从Server端读取数据
func (s *server) Read(ctx context.Context) {
	// 如果10秒钟内没有消息传输，则Read函数会返回一个timeout的错误
	_ = s.conn.SetReadDeadline(time.Now().Add(time.Second * 10))
	for {
		select {
		case <-ctx.Done():
			return
		default:
			data := make([]byte, 10240)
			n, err := s.conn.Read(data)
			if err != nil && err != io.EOF {
				// 读取超时，发送一个心跳包过去
				if strings.Contains(err.Error(), "timeout") {
					// 3秒发一次心跳
					_ = s.conn.SetReadDeadline(time.Now().Add(time.Second * 3))
					s.conn.Write([]byte("pi"))
					continue
				}
				fmt.Println("从server读取数据失败, ", err.Error())
				s.exit <- err
				return
			}

			// 如果收到心跳包, 则跳过
			if data[0] == 'p' && data[1] == 'i' {
				fmt.Println("client收到心跳包")
				continue
			}
			s.read <- data[:n]
		}
	}
}

// 将数据写入到Server端
func (s *server) Write(ctx context.Context) {
	for {
		select {
		case <-ctx.Done():
			return
		case data := <-s.write:
			_, err := s.conn.Write(data)
			if err != nil && err != io.EOF {
				s.exit <- err
				return
			}
		}
	}
}

type local struct {
	conn net.Conn
	// 数据传输通道
	read  chan []byte
	write chan []byte
	// 有异常退出通道
	exit chan error
}

func (l *local) Read(ctx context.Context) {

	for {
		select {
		case <-ctx.Done():
			return
		default:
			data := make([]byte, 10240)
			n, err := l.conn.Read(data)
			if err != nil {
				l.exit <- err
				return
			}
			l.read <- data[:n]
		}
	}
}

func (l *local) Write(ctx context.Context) {
	for {
		select {
		case <-ctx.Done():
			return
		case data := <-l.write:
			_, err := l.conn.Write(data)
			if err != nil {
				l.exit <- err
				return
			}
		}
	}
}

func main() {
	flag.Parse()

	target := net.JoinHostPort(host, fmt.Sprintf("%d", remotePort))
	for {
		serverConn, err := net.Dial("tcp", target)
		if err != nil {
			panic(err)
		}

		fmt.Printf("已连接server: %s \n", serverConn.RemoteAddr())
		server := &server{
			conn:   serverConn,
			read:   make(chan []byte),
			write:  make(chan []byte),
			exit:   make(chan error),
			reConn: make(chan bool),
		}

		go handle(server)
		<-server.reConn
		//_ = server.conn.Close()
	}

}

func handle(server *server) {
	// 等待server端发来的信息，也就是说user来请求server了
	ctx, cancel := context.WithCancel(context.Background())

	go server.Read(ctx)
	go server.Write(ctx)

	localConn, err := net.Dial("tcp", fmt.Sprintf("127.0.0.1:%d", localPort))
	if err != nil {
		panic(err)
	}

	local := &local{
		conn:  localConn,
		read:  make(chan []byte),
		write: make(chan []byte),
		exit:  make(chan error),
	}

	go local.Read(ctx)
	go local.Write(ctx)

	defer func() {
		_ = server.conn.Close()
		_ = local.conn.Close()
		server.reConn <- true
	}()

	for {
		select {
		case data := <-server.read:
			local.write <- data

		case data := <-local.read:
			server.write <- data

		case err := <-server.exit:
			fmt.Printf("server have err: %s", err.Error())
			cancel()
			return
		case err := <-local.exit:
			fmt.Printf("local have err: %s", err.Error())
			cancel()
			return
		}
	}
}

server/server.go

package main

import (
	"context"
	"flag"
	"fmt"
	"io"
	"net"
	"strings"
	"time"
)

var (
	localPort  int
	remotePort int
)

func init() {
	flag.IntVar(&localPort, "l", 5200, "the user link port")
	flag.IntVar(&remotePort, "r", 3333, "client listen port")
}

type client struct {
	conn net.Conn
	// 数据传输通道
	read  chan []byte
	write chan []byte
	// 异常退出通道
	exit chan error
	// 重连通道
	reConn chan bool
}

// 从Client端读取数据
func (c *client) Read(ctx context.Context) {
	// 如果10秒钟内没有消息传输，则Read函数会返回一个timeout的错误
	_ = c.conn.SetReadDeadline(time.Now().Add(time.Second * 10))
	for {
		select {
		case <-ctx.Done():
			return
		default:
			data := make([]byte, 10240)
			n, err := c.conn.Read(data)
			if err != nil && err != io.EOF {
				if strings.Contains(err.Error(), "timeout") {
					// 设置读取时间为3秒，3秒后若读取不到, 则err会抛出timeout,然后发送心跳
					_ = c.conn.SetReadDeadline(time.Now().Add(time.Second * 3))
					c.conn.Write([]byte("pi"))
					continue
				}
				fmt.Println("读取出现错误...")
				c.exit <- err
				return
			}

			// 收到心跳包,则跳过
			if data[0] == 'p' && data[1] == 'i' {
				fmt.Println("server收到心跳包")
				continue
			}
			c.read <- data[:n]
		}
	}
}

// 将数据写入到Client端
func (c *client) Write(ctx context.Context) {
	for {
		select {
		case <-ctx.Done():
			return
		case data := <-c.write:
			_, err := c.conn.Write(data)
			if err != nil && err != io.EOF {
				c.exit <- err
				return
			}
		}
	}
}

type user struct {
	conn net.Conn
	// 数据传输通道
	read  chan []byte
	write chan []byte
	// 异常退出通道
	exit chan error
}

// 从User端读取数据
func (u *user) Read(ctx context.Context) {
	_ = u.conn.SetReadDeadline(time.Now().Add(time.Second * 200))
	for {
		select {
		case <-ctx.Done():
			return
		default:
			data := make([]byte, 10240)
			n, err := u.conn.Read(data)
			if err != nil && err != io.EOF {
				u.exit <- err
				return
			}
			u.read <- data[:n]
		}
	}
}

// 将数据写给User端
func (u *user) Write(ctx context.Context) {
	for {
		select {
		case <-ctx.Done():
			return
		case data := <-u.write:
			_, err := u.conn.Write(data)
			if err != nil && err != io.EOF {
				u.exit <- err
				return
			}
		}
	}
}

func main() {
	flag.Parse()

	defer func() {
		err := recover()
		if err != nil {
			fmt.Println(err)
		}
	}()

	clientListener, err := net.Listen("tcp", fmt.Sprintf(":%d", remotePort))
	if err != nil {
		panic(err)
	}
	fmt.Printf("监听:%d端口, 等待client连接... \n", remotePort)
	// 监听User来连接
	userListener, err := net.Listen("tcp", fmt.Sprintf(":%d", localPort))
	if err != nil {
		panic(err)
	}
	fmt.Printf("监听:%d端口, 等待user连接.... \n", localPort)

	for {
		// 有Client来连接了
		clientConn, err := clientListener.Accept()
		if err != nil {
			panic(err)
		}

		fmt.Printf("有Client连接: %s \n", clientConn.RemoteAddr())

		client := &client{
			conn:   clientConn,
			read:   make(chan []byte),
			write:  make(chan []byte),
			exit:   make(chan error),
			reConn: make(chan bool),
		}

		userConnChan := make(chan net.Conn)
		go AcceptUserConn(userListener, userConnChan)

		go HandleClient(client, userConnChan)

		<-client.reConn
		fmt.Println("重新等待新的client连接..")
	}
}

func HandleClient(client *client, userConnChan chan net.Conn) {
	ctx, cancel := context.WithCancel(context.Background())

	go client.Read(ctx)
	go client.Write(ctx)

	user := &user{
		read:  make(chan []byte),
		write: make(chan []byte),
		exit:  make(chan error),
	}

	defer func() {
		_ = client.conn.Close()
		_ = user.conn.Close()
		client.reConn <- true
	}()

	for {
		select {
		case userConn := <-userConnChan:
			user.conn = userConn
			go handle(ctx, client, user)
		case err := <-client.exit:
			fmt.Println("client出现错误, 关闭连接", err.Error())
			cancel()
			return
		case err := <-user.exit:
			fmt.Println("user出现错误，关闭连接", err.Error())
			cancel()
			return
		}
	}
}

// 将两个Socket通道链接
// 1. 将从user收到的信息发给client
// 2. 将从client收到信息发给user
func handle(ctx context.Context, client *client, user *user) {
	go user.Read(ctx)
	go user.Write(ctx)

	for {
		select {
		case userRecv := <-user.read:
			// 收到从user发来的信息
			client.write <- userRecv
		case clientRecv := <-client.read:
			// 收到从client发来的信息
			user.write <- clientRecv

		case <-ctx.Done():
			return
		}
	}
}

// 等待user连接
func AcceptUserConn(userListener net.Listener, connChan chan net.Conn) {
	userConn, err := userListener.Accept()
	if err != nil {
		panic(err)
	}
	fmt.Printf("user connect: %s \n", userConn.RemoteAddr())
	connChan <- userConn
}
代码讲故事
关注
专栏目录
Go语言网络编程：Go实现简单的内网穿透
Pistachiout的学习博客
06-27 2913
内网穿透是一种通过互联网建立远程连接到私有网络（内网）中设备的技术。通常情况下，内网设备由于位于一个受限制的网络环境中，无法直接从外部访问。内网穿透通过将内网设备的流量转发到公共网络上的服务器，然后再将该流量转发到客户端，从而实现与内网设备的通信。
用go语言写一个内网穿透
weixin_35753431的博客
01-07 321
内网穿透是指通过在内网机器上运行的程序来连接到内网中的其他机器的过程。 要在 Go 语言中写一个内网穿透程序，你可以使用 net 包中的一些函数来实现网络通信。 下面是一个简单的例子，展示了如何使用 Go 语言的 net 包来实现内网穿透： package main import ( "fmt" "net" ) func main() { // 连接到内网中的机器 ...
这些内网穿透工具 你都知道吗？
wuli1024的博客
01-17 1746
在日常工作中我们需要将本地的某些端口如22803306等端口分享。让别人或者不在同一局域网内的设备访问。
go 使用gin封装post get 接口对第三方接口进行请求，传入值为json，form
唐夫人
09-13 1939
下面是go，main文件的核心 （struct 里面注释的内容是为了在页面如果没有传值，也没有关系，只有特殊的请求这些值才会有变化）使用postman 对go的接口进行请求，需要传入要请求的地址，还有请求类型，如果是POST请求还要有请求的数据等等。我的接口是api/v1/login 路由不要错了，其他应该是没有问题了，有问题可以私聊我哦。请求如果不成功，要检查route这个文件。上面是postman上面请求传的参数。
Go 高级日志记录库&集成Gin框架
qq_39335595的博客
05-23 1859
将错误日志同时输出到文件首先，你需要定义一个实现了接口的结构体。Levels(), 和可选的。import ("os"// FileHook 将错误日志写入文件// NewFileHook 创建一个新的 FileHook 实例if err!= nil {// Levels 钩子关心的日志级别// Fire 当日志事件触发时被调用if err!= nil {return errreturn nil// 初始化日志// 创建并添加 FileHook} else {
Go语言中的gin框架之GET/POST请求参数接收传值（五）
06-15
在Go语言中，Gin框架是一个非常流行的HTTP微服务框架，它提供了简洁的API来处理HTTP请求，使得开发Web应用变得更加高效。本教程将详细讲解如何在...这使得Gin成为构建Web服务的强大工具，特别是在Go语言的生态系统中。
Go语言实例教程从入门到进阶，包括基础库使用、设计模式、面试易错点、工具类、对接第三方等.zip
02-04
本教程旨在帮助学习者从零开始掌握Go语言，逐步进阶到高级应用，其中包括了基础库的使用、设计模式的实践、面试常见问题解析、实用工具类的编写以及如何与第三方库或服务进行接口对接。 **1. Go语言基础** Go语言的...
基于Gin框架开发的脚手架工具，便于使用Go快速开发接口，集成数据库、日志、配置等开源库，开箱即用.zip
01-03
Gin框架是Go语言中广泛使用的Web开发框架，它以其高效、简洁的API设计深受开发者喜爱。Gin框架基于Martini框架进行优化，提供了更强大的路由功能和中间件管理，使得Go语言在构建RESTful API时更加得心应手。 在标题...
编写OpenAPI_Gin框架工具：使用Go语言编写一个基于Gin框架的OpenAPI工具，用于接收_aigc.zip
最新发布
09-23
编写OpenAPI_Gin框架工具：使用Go语言编写一个基于Gin框架的OpenAPI工具，用于接收_aigc
微信支付（一）：小程序支付（Go+Gin+内网穿透+支付回调处理）
新鲜雾霾的博客
07-06 2218
微信小程序支付
github gitee go开发 热门中后台开源项目
zhaoyang10的专栏
06-22 3891
go 开源中后台管理系统
09｜自研or借力（下）：集成Gin替换已有核心
Zerore的博客
03-03 296
框架中引入gin
go-gin框架
roning的博客
03-27 8894
Gin是一个golang的微框架，封装比较优雅，API友好，源码注释比较明确，已经发布了1.0版本。具有快速灵活，容错方便等特点
go集成gin处理error
卿着飞翔
05-16 1802
go集成gin集中处理error 1 gin的使用 gin在go开发web的占比是挺大的。很好用的web框架，简单快速高效。但是呢，在使用gin的过程中，如何去统一去处理error和数据返回给客户端呢？原始的做法如下： func main() { r := gin.Default()//路由引擎 r.GET("/get",getMsg) //get方法 r.Run(":9090") //如果不指定IP地址、端口号，默认为本机IP地址、8080端口 } func getMsg(c *gin.Con
go集成gin+swagger
不积跬步，无以至千里；不积小流，无以成江海。
01-22 1269
1.安装 swag go get github.com/swaggo/swag/cmd/swag swag 用于生成 docs 文件夹(swagger文档程序使用) 安装完成后会在 ${GOPATH}/bin生成一个执行文件 2.编写代码 /** * Created by liuyusnhengsir on 23/01/2022 */ package main import ( _ "lys_gin_swag/docs" "github.com/gin-gonic/gin" ginSw
推荐几个可以写到简历上的Go方向优质开源项目（需花点心思研究）
qq_39397165的博客
12-06 2780
前言哈喽，大家好，我是asong。最近总有读者问我有没有Go语言方向优质的开源项目，可以写在简历上那种，一时还真想不起来，花了两天时间调研了一下，针对有无工作经验的分别推荐几个开源项目，下...
对接第三方支付宝支付服务
pmc0_0的博客
05-17 1904
文章目录导入相关SDK配置文件改造第三方接口接入自己的应用 导入相关SDK 配置文件 # 支付宝网关名、partnerId和appId open_api_domain = https://openapi.alipaydev.com/gateway.do mcloud_api_domain = http://mcloudmonitor.com/gateway.do pid = 2088621955632751 appid = 2021000117643966 # RSA私钥、公钥和支付宝公钥 priv
go 实现内网穿透
daliucheng的博客
11-11 1549
go实现内网穿透 1. 实现思路 主要分为服务端和客户端 服务端 主要有两个线程 socket线程，负责和客户端的通信，将http线程的数据通过socket线程传递给客户端， http线程，负责接受http请求，将调用的数据传递给socket线程，等待socket线程的返回go结果。并将结果返回 客户端 socket线程 和服务端建立连接，接受服务端的消息，看是什么方法，是get？还是post？客户端调用本地的映射地址。将调用的结果返回给服务端。 1.1 思维导图 https:/
frp ---- golang编写的内网穿透工具简介
weixin_44235759的博客
11-16 4178
官网： https://gofrp.org/ frp 是一个专注于内网穿透的高性能的反向代理应用，支持 TCP、UDP、HTTP、HTTPS 等多种协议。可以将内网服务以安全、便捷的方式通过具有公网 IP 节点的中转暴露到公网。 frp 采用 Golang 编写，支持跨平台，仅需下载对应平台的二进制文件即可执行，没有额外依赖。 由于采用 Golang 编写，所以系统需求和最新的 Golang 对系统和平台的要求一致 下载 https://github.com/fatedier/frp/releases
Gin框架开发的Go语言接口脚手架工具
资源摘要信息:"基于Gin框架的脚手架工具，利用Go语言的高效性能和简洁语法，为快速开发RESTful API接口提供了一个强大的平台。该工具内置了数据库操作、日志记录和配置管理等常用功能，通过集成众多开源库，实现了开...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

代码讲故事

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值