1. Toy模板网首页
  2. > Toy博客

【Java转Go】快速上手学习笔记（六）之网络编程篇一

9月前 作者：符华- 分类：Toy博客 阅读(43) 违法举报

这篇具有很好参考价值的文章主要介绍了【Java转Go】快速上手学习笔记（六）之网络编程篇一。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

go往期文章笔记：

【Java转Go】快速上手学习笔记（一）之环境安装篇

【Java转Go】快速上手学习笔记（二）之基础篇一

【Java转Go】快速上手学习笔记（三）之基础篇二

【Java转Go】快速上手学习笔记（四）之基础篇三

【Java转Go】快速上手学习笔记（五）之Gorm篇


这篇记的是网络编程相关的笔记。

TCP

开启服务端，监听连接的请求。示意图：
【Java转Go】快速上手学习笔记（六）之网络编程篇一,Go,golang,go

服务端：启动后，监听连接过来的客户端，每连接过来一个客户端，开启一个协程去和客户端进行交互（一个协程代表一个客户端）

客户端：根据服务端的IP和端口号去访问服务端，连接成功后可以向服务端发送消息。

连接的时候通过IP和端口号去连接，但是和客户端进行交流的是协程。

一个简单案例

创建两个文件夹，一个是server、一个是client，然后两个文件夹里面分别创建 server.go、client.go 文件，如下图：

【Java转Go】快速上手学习笔记（六）之网络编程篇一,Go,golang,go

server.go 服务端

package main

import (
	"fmt"
	"io"
	"net"
)

// tcp处理客户端发送过来的信息
func tcpHandler(conn net.Conn) {
	defer conn.Close()
	for {
		var buf []byte = make([]byte, 1024)
		// 等待客户端通过conn发送信息，如果客户端没有wrtie[发送]，那么协程就阻塞在这里
		n, err := conn.Read(buf)
		if err == io.EOF {
			fmt.Println(conn.RemoteAddr().String() + " 退出连接")
			break
		}
		// 客户端发送的内容显示到服务器的终端
		fmt.Print(string(buf[:n]))
	}
}

func main() {
	TCP服务端()
}

func TCP服务端() {
	fmt.Println("服务器开始监听")
	listen, err := net.Listen("tcp", "0.0.0.0:8888")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer listen.Close()
	for { // 循环等待客户端来连接
		conn, err := listen.Accept()
		if err != nil {
			fmt.Println(err)
		} else {
			fmt.Printf("客户端 %v 连接成功\n", conn.RemoteAddr().String())
		}
		// 这里开启协程
		go tcpHandler(conn)
	}
}

client.go 客户端

package main

import (
	"fmt"
	"net"
)

func main() {
	TCP客户端()
}

func TCP客户端() {
	conn, err := net.Dial("tcp", "127.0.0.1:8888")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer conn.Close()
	fmt.Println(conn.RemoteAddr().String(), "连接成功")
	var s string
	for { // 循环输入，给服务端发送消息
		// 从终端读取用户输入，并发送给服务器
		fmt.Scanln(&s)
		if s == "exit" {
			fmt.Println(conn.RemoteAddr().String(), "退出连接")
			break
		}
		conn.Write([]byte(s + "\r\n")) // 发送给服务端
	}
}

写好之后，我们先启动服务端，然后再启动客户端。在客户端里面输入消息发送给服务端，服务端接收后要将消息显示出来。

【Java转Go】快速上手学习笔记（六）之网络编程篇一,Go,golang,go
【Java转Go】快速上手学习笔记（六）之网络编程篇一,Go,golang,go

客户端输入 exit 时，退出程序，关闭了连接，服务端也显示这个客户端已经退出了连接。
【Java转Go】快速上手学习笔记（六）之网络编程篇一,Go,golang,go
【Java转Go】快速上手学习笔记（六）之网络编程篇一,Go,golang,go

HTTP

server.go 服务端

// http处理请求
func httpHandler(res http.ResponseWriter, req *http.Request) {
	switch req.Method {
	case "GET":
		fmt.Println("这里是get请求")
		res.Write([]byte("这里是get请求"))
	case "POST":
		defer req.Body.Close()
		// 1、 请求类型是aplication/x-www-form-urlencode时解析form数据
		//req.ParseForm()
		//fmt.Println(req.PostForm) //打印form数数据
		//fmt.Println(req.PostForm.Get("username"), req.PostForm.Get("password"))

		// 2、请求类型是application/json时从req.Body读取数据
		b, err := io.ReadAll(req.Body)
		if err != nil {
			fmt.Println("获取请求数据错误", err)
			return
		}
		fmt.Println(string(b))
		result := `{"code":0,"message":"ok","data":{}}` // 请求成功，返回数据
		res.Write([]byte(result))
	}
}

func main() {
	HTTP服务端()
}

func HTTP服务端() {
	http.HandleFunc("/index", httpHandler) // 回调函数
	fmt.Println("http://localhost:8080")
	http.ListenAndServe(":8080", nil) // 绑定服务
}

client.go 客户端

func main() {
	HTTP客户端()
}

func HTTP客户端() {
	data := `{"username":"符华","password":"123456"}`
	//resp, err := http.Get("http://localhost:8080/index")
	resp, err := http.Post("http://localhost:8080/index", "application/json", strings.NewReader(data))
	//resp, err := http.PostForm("http://localhost:8080/index", url.Values{"username": {"符华"}, "password": {"123456"}})
	if err != nil {
		fmt.Println("请求错误", err)
		return
	}
	defer resp.Body.Close()

	b, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("获取返回数据错误", err)
		return
	}
	fmt.Println(string(b))
}

RPC

一个很简单的示例

server.go 服务端

import (
	"net"
	"net/http"
	"net/rpc"
)

type Server struct{}
type Req struct {
	Num1 int
	Num2 int
}
type Res struct {
	Num int
}

func (s Server) Add(req Req, res *Res) error {
	res.Num = req.Num1 + req.Num2
	return nil
}

func RPC服务端() {
	// 注册rpc服务
	rpc.Register(new(Server))
	rpc.HandleHTTP()
	listen, err := net.Listen("tcp", ":8080")
	if err != nil {
		fmt.Println(err)
		return
	}
	http.Serve(listen, nil)
}

func main() {
	RPC服务端()
}

client.go 客户端

import (
	"fmt"
	"net"
	"net/rpc"
)

type Req struct {
	Num1 int
	Num2 int
}
type Res struct {
	Num int
}

func RPC客户端() {
	req := Req{1, 2}
	client, err := rpc.DialHTTP("tcp", ":8080")
	if err != nil {
		fmt.Println(err)
		return
	}
	var res Res
	client.Call("Server.Add", req, &res)
	fmt.Println(res)
}

func main() {
	RPC客户端()
}

WebSocket

websocket是socket连接和http协议的结合体，可以实现网页和服务端的长连接。

要使用websocket我们要先去下载依赖

go get github.com/gorilla/websocket

server.go 服务端

// websocke 连接的升级器。升级器是一个http.HandlerFunc，它将HTTP连接升级为WebSocket连接
var UP = websocket.Upgrader{
	ReadBufferSize:  1024,
	WriteBufferSize: 1024,
}
var conns []*websocket.Conn // 客户端连接切片，存储所有的客户端连接

// websocket处理请求
func websocketHandler(res http.ResponseWriter, req *http.Request) {
	conn, err := UP.Upgrade(res, req, nil) // 服务升级
	if err != nil {
		fmt.Println(err)
		return
	}
	defer conn.Close()
	conns = append(conns, conn)
	for {
		// 消息类型，消息，错误
		t, p, err := conn.ReadMessage()
		if err != nil {
			break
		}
		for index := range conns {
			conns[index].WriteMessage(websocket.TextMessage, []byte(fmt.Sprintf("你说的是：%s吗？", string(p))))
		}
		fmt.Println(t, string(p))
	}
	fmt.Println("服务关闭")
}

func websocket服务端() {
	http.HandleFunc("/", websocketHandler)
	http.ListenAndServe(":8080", nil)
}

client.go 客户端

// websocket 发送消息
func send(conn *websocket.Conn) {
	for {
		reader := bufio.NewReader(os.Stdin)
		l, _, _ := reader.ReadLine()
		conn.WriteMessage(websocket.TextMessage, l)
	}
}

func websocket客户端() {
	dl := websocket.Dialer{}
	conn, _, err := dl.Dial("ws://127.0.0.1:8080", nil)
	if err != nil {
		fmt.Println(err)
		return
	}
	go send(conn)
	for {
		t, p, err := conn.ReadMessage()
		if err != nil {
			break
		}
		fmt.Println(t, string(p))
	}
}

完整代码

server.go 服务端

package main

import (
	"fmt"
	"github.com/gorilla/websocket"
	"io"
	"net"
	"net/http"
	"net/rpc"
)

// tcp处理客户端发送过来的信息
func tcpHandler(conn net.Conn) {
	defer conn.Close()
	for {
		var buf []byte = make([]byte, 1024)
		// 等待客户端通过conn发送信息，如果客户端没有wrtie[发送]，那么协程就阻塞在这里
		n, err := conn.Read(buf)
		if err == io.EOF {
			fmt.Println(conn.RemoteAddr().String() + " 退出连接")
			break
		}
		// 客户端发送的内容显示到服务器的终端
		fmt.Print(string(buf[:n]))
	}
}

// http处理请求
func httpHandler(res http.ResponseWriter, req *http.Request) {
	switch req.Method {
	case "GET":
		fmt.Println("这里是get请求")
		res.Write([]byte("这里是get请求"))
	case "POST":
		defer req.Body.Close()
		// 1、 请求类型是aplication/x-www-form-urlencode时解析form数据
		//req.ParseForm()
		//fmt.Println(req.PostForm) //打印form数数据
		//fmt.Println(req.PostForm.Get("username"), req.PostForm.Get("password"))

		// 2、请求类型是application/json时从req.Body读取数据
		b, err := io.ReadAll(req.Body)
		if err != nil {
			fmt.Println("获取请求数据错误", err)
			return
		}
		fmt.Println(string(b))
		result := `{"code":0,"message":"ok","data":{}}` // 请求成功，返回数据
		res.Write([]byte(result))
	}
}

// RPC
type Server struct{}
type Req struct {
	Num1 int
	Num2 int
}
type Res struct {
	Num int
}

func (s Server) Add(req Req, res *Res) error {
	res.Num = req.Num1 + req.Num2
	return nil
}

// websocke 连接的升级器。升级器是一个http.HandlerFunc，它将HTTP连接升级为WebSocket连接
var UP = websocket.Upgrader{
	ReadBufferSize:  1024,
	WriteBufferSize: 1024,
}
var conns []*websocket.Conn // 客户端连接切片，存储所有的客户端连接

// websocket处理请求
func websocketHandler(res http.ResponseWriter, req *http.Request) {
	conn, err := UP.Upgrade(res, req, nil) // 服务升级
	if err != nil {
		fmt.Println(err)
		return
	}
	defer conn.Close()
	conns = append(conns, conn)
	for {
		// 消息类型，消息，错误
		t, p, err := conn.ReadMessage()
		if err != nil {
			break
		}
		for index := range conns {
			conns[index].WriteMessage(websocket.TextMessage, []byte(fmt.Sprintf("你说的是：%s吗？", string(p))))
		}
		fmt.Println(t, string(p))
	}
	fmt.Println("服务关闭")
}

func main() {
	//TCP服务端()
	//HTTP服务端()
	//RPC服务端()
	websocket服务端()
}

func TCP服务端() {
	fmt.Println("服务器开始监听")
	listen, err := net.Listen("tcp", "0.0.0.0:8080")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer listen.Close()
	for { // 循环等待客户端来连接
		conn, err := listen.Accept()
		if err != nil {
			fmt.Println(err)
		} else {
			fmt.Printf("客户端 %v 连接成功\n", conn.RemoteAddr().String())
		}
		// 这里开启协程
		go tcpHandler(conn)
	}
}

func HTTP服务端() {
	http.HandleFunc("/index", httpHandler) // 回调函数
	fmt.Println("http://localhost:8080")
	http.ListenAndServe(":8080", nil) // 绑定服务
}

func RPC服务端() {
	// 注册rpc服务
	rpc.Register(new(Server))
	rpc.HandleHTTP()
	listen, err := net.Listen("tcp", ":8080")
	if err != nil {
		fmt.Println(err)
		return
	}
	http.Serve(listen, nil)
}

func websocket服务端() {
	http.HandleFunc("/", websocketHandler)
	http.ListenAndServe(":8080", nil)
}

client.go 客户端

package main

import (
	"bufio"
	"fmt"
	"github.com/gorilla/websocket"
	"io"
	"net"
	"net/http"
	"net/rpc"
	"os"
	"strings"
)

func main() {
	//TCP客户端()
	//HTTP客户端()
	//RPC客户端()
	websocket客户端()
}

func TCP客户端() {
	conn, err := net.Dial("tcp", "127.0.0.1:8080")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer conn.Close()
	fmt.Println(conn.RemoteAddr().String(), "连接成功")
	var s string
	for { // 循环输入，给服务端发送消息
		// 从终端读取用户输入，并发送给服务器
		fmt.Scanln(&s)
		if s == "exit" {
			fmt.Println(conn.RemoteAddr().String(), "退出连接")
			break
		}
		conn.Write([]byte(s + "\r\n")) // 发送给服务端
	}
}

func HTTP客户端() {
	data := `{"username":"符华","password":"123456"}`
	//resp, err := http.Get("http://localhost:8080/index")
	resp, err := http.Post("http://localhost:8080/index", "application/json", strings.NewReader(data))
	//resp, err := http.PostForm("http://localhost:8080/index", url.Values{"username": {"符华"}, "password": {"123456"}})
	if err != nil {
		fmt.Println("请求错误", err)
		return
	}
	defer resp.Body.Close()

	b, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("获取返回数据错误", err)
		return
	}
	fmt.Println(string(b))
}

// RPC
type Req struct {
	Num1 int
	Num2 int
}
type Res struct {
	Num int
}

func RPC客户端() {
	req := Req{1, 2}
	client, err := rpc.DialHTTP("tcp", ":8080")
	if err != nil {
		fmt.Println(err)
		return
	}
	var res Res
	client.Call("Server.Add", req, &res)
	fmt.Println(res)
}

// websocket 发送消息
func send(conn *websocket.Conn) {
	for {
		reader := bufio.NewReader(os.Stdin)
		l, _, _ := reader.ReadLine()
		conn.WriteMessage(websocket.TextMessage, l)
	}
}

func websocket客户端() {
	dl := websocket.Dialer{}
	conn, _, err := dl.Dial("ws://127.0.0.1:8080", nil)
	if err != nil {
		fmt.Println(err)
		return
	}
	go send(conn)
	for {
		t, p, err := conn.ReadMessage()
		if err != nil {
			break
		}
		fmt.Println(t, string(p))
	}
}

ok，以上就是本篇笔记的全部内容了，就是一些简单的使用示例，关于理论概念的东西我没有记，因为太多了，不知道要怎么整理才能说明白说清楚，反正就是这么用的。文章来源地址https://www.toymoban.com/news/detail-679807.html

到了这里，关于【Java转Go】快速上手学习笔记（六）之网络编程篇一的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 🔥🔥Java开发者的Python快速进修指南：网络编程及并发编程

    🔥🔥Java开发者的Python快速进修指南：网络编程及并发编程

    今天我们将对网络编程和多线程技术进行讲解，这两者的原理大家都已经了解了，因此我们主要关注的是它们的写法区别。虽然这些区别并不是非常明显，但我们之所以将网络编程和多线程一起讲解，是因为在学习Java的socket知识时，我们通常会将它们结合使用，以实现服务器

    2024年02月05日
    浏览(67)
  • 【零基础入门学习Python---Python网络编程之django快速入门实践】

    【零基础入门学习Python---Python网络编程之django快速入门实践】

    🚀 Python 🚀 🌲 算法刷题专栏 | 面试必备算法 | 面试高频算法 🍀 🌲 越难的东西,越要努力坚持，因为它具有很高的价值，算法就是这样✨ 🌲 作者简介：硕风和炜，CSDN-Java领域优质创作者🏆，保研|国家奖学金|高中学习JAVA|大学完善JAVA开发技术栈|面试刷题|面经八股文|经验

    2024年02月16日
    浏览(39)
  • Java基础学习（17）网络编程

    Java基础学习（17）网络编程

    解释： 在网络通信协议下，不同计算机上运行的程序，进行的数据传输 应用场景 : 即时通信、网游对战、金融证券、国际贸易、邮件、等等 不管是什么场景，都是计算机跟计算机之间通过网络进行 数据传输 Java中可以使用 java.net 包下的技术轻松开发出常见的网络应用程序

    2024年02月05日
    浏览(73)
  • Linux 网络编程学习笔记——一、TCP/IP 协议族

    Linux 网络编程学习笔记——一、TCP/IP 协议族

    数据链路层实现了网卡接口的网络驱动程序，以处理数据在物理媒介（以太网、令牌环等）上的传输，不同的物理网络具有不同的电气特性，网络驱动程序隐藏了这些细节，为上层协议提供一个统一的接口。最常用的协议是 ARP（Address Resolve Protocol，地址解析协议）和 RARP（

    2024年02月02日
    浏览(71)
  • UNIX网络编程卷一 学习笔记 第三十一章 流

    UNIX网络编程卷一 学习笔记 第三十一章 流

    在大多数源自SVR 4的内核中，X/Open传输接口（X/Open Transport Interface，XTI，是独立于套接字API的另一个网络编程API）和网络协议通常就像终端IO系统那样也使用流系统（STREAMS system）实现。 我们将使用传输提供者接口（Transport Provider Interface，TPI）开发一个简单的TCP客户程序，TP

    2024年02月09日
    浏览(72)
  • UNIX网络编程卷一 学习笔记 第二十二章 高级UDP套接字编程

    UNIX网络编程卷一 学习笔记 第二十二章 高级UDP套接字编程

    TCP是一个字节流协议，又使用滑动窗口，因此没有记录边界或发送者数据发送能力超过接收者接收能力之类的事情，但对于UDP，每个输入操作对应一个UDP数据报（一个记录），因此当收取的数据报大于引用的输入缓冲区时就有问题。 UDP是不可靠协议，但有些应用确实有理由使

    2024年02月12日
    浏览(57)
  • Linux高性能服务器编程 学习笔记 第五章 Linux网络编程基础API

    Linux高性能服务器编程 学习笔记 第五章 Linux网络编程基础API

    我们将从以下3方面讨论Linux网络API： 1.socket地址API。socket最开始的含义是一个IP地址和端口对（ip，port），它唯一表示了使用TCP通信的一端，本书称其为socket地址。 2.socket基础API。socket的主要API都定义在sys/socket.h头文件中，包括创建socket、命名socket、监听socket、接受连接、发

    2024年02月07日
    浏览(53)
  • UNIX网络编程卷一 学习笔记 第二十七章 IP选项

    UNIX网络编程卷一 学习笔记 第二十七章 IP选项

    IPv4允许在20字节的首部固定部分后跟最多共40字节的选项。尽管已经定义了10种IPv4选项，但最常用的是源路径选项。我们可通过存取IP_OPTIONS套接字选项访问这些选项，我们存取该套接字选项时，所用的缓冲区中的值就是它们置于IP数据报中的格式。 IPv6允许在固定长度40字节的

    2024年02月14日
    浏览(51)
  • UNIX网络编程卷一 学习笔记 第二十九章 数据链路访问

    UNIX网络编程卷一 学习笔记 第二十九章 数据链路访问

    目前大多操作系统都为程序提供访问数据链路层的功能，此功能可提供以下能力： 1.能监视由数据链路层接收的分组，使得tcpdump之类的程序能运行，而无需专门的硬件设备来监视分组。如果结合使用网络接口进入混杂模式（promiscuous mode）的能力，那么应用甚至能监视本地电

    2024年02月10日
    浏览(42)
  • UNIX网络编程卷一 学习笔记 第二十八章 原始套接字

    UNIX网络编程卷一 学习笔记 第二十八章 原始套接字

    原始套接字提供普通的TCP和UDP套接字不具备的以下3个能力： 1.有了原始套接字，进程可以读写ICMPv4、IGMPv4、ICMPv6等分组。例如，ping程序就使用原始套接字发送ICMP回射请求并接收ICMP回射应答。多播路由守护程序mrouted也使用原始套接字发送和接收IGMPv4分组。 这个能力还使得使

    2024年02月11日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包