Go_TCP、UDP实现并发（服务端与客户端）

已于 2023-03-21 11:45:14 修改
阅读量3.8k 收藏 13
点赞数
分类专栏： Golang 文章标签： TCP并发服务器实现 Golang 并发
于 2022-02-13 21:02:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45477086/article/details/122901328
版权

Server端函数、接口：

Listen函数：

	func Listen(network, address string) (Listener, error)
		network：选用的协议：TCP、UDP， 	如：“tcp”或 “udp”
		address：IP地址+端口号, 			如：“127.0.0.1:8000”或 “:8000”
		}

Listener 接口：

// Listen：指定IP + 端口，创建Accept，也是一个socket，但这个socket不和客户端直接通信，只用于创建要通信的socket
type Listener interface {
			Accept() (Conn, error) // 阻塞监听客户端连接，返回一个用于通信的socket
			Close() error
			Addr() Addr
}

Conn 接口：

type Conn interface {
	Read(b []byte) (n int, err error)
	Write(b []byte) (n int, err error)
	Close() error
	LocalAddr() Addr
	RemoteAddr() Addr
	SetDeadline(t time.Time) error
	SetReadDeadline(t time.Time) error
	SetWriteDeadline(t time.Time) error
}

普通版：

TCP-服务端实现：

package main

import (
	"fmt"
	"net"
	"os"
)

func main() {
	// 监听该地址的连接请求，当有新的连接请求到来时，创建Accept实现连接
	listen, err := net.Listen("tcp", "127.0.0.1:8080")
	if err != nil {
		fmt.Println("net.Listen 出错了！！！", err)
		return
	}
	defer listen.Close()

	fmt.Println("服务端启动完毕，等待客户端建立连接...")

	// 与用户端进行通信连接
	accept, err := listen.Accept()
	if err != nil {
		fmt.Println("listen.Accept 出错了！！！", err)
		return
	}
	defer accept.Close()

	fmt.Println("与客户端建立连接成功...")

	// 读取客户端发送的数据
	bytes := make([]byte, 4096)
	n, err := accept.Read(bytes)
	if err != nil {
		fmt.Println("accept.Read 出错了！！！", err)
		return
	}
	fmt.Println("服务端读到：", string(bytes[:n]))

	// 使用键盘录入向客户端发送数据
	buf := make([]byte, 4096)
	len, err := os.Stdin.Read(buf)
	if err != nil {
		fmt.Println("os.Stdin.Read 出错了！！！", err)
		return
	}

	_, err = accept.Write(buf[:len])
	if err != nil {
		fmt.Println("accept.Write 出错了！！！", err)
		return
	}
}

TCP-客户端实现：

package main

import (
	"fmt"
	"net"
	"os"
)

func main() {
	// 发送建立连接请求，返回一个客户端连接对象
	dial, err := net.Dial("tcp", "127.0.0.1:8080")
	if err != nil {
		fmt.Println("net.Dial 出错了！！！", err)
		return
	}
	defer dial.Close()

	fmt.Println("与服务端建立连接成功...")
	
	// 使用键盘录入向服务端发送数据
	bytes := make([]byte, 4096)
	// n：键盘录入的数据字节长度
	n, err := os.Stdin.Read(bytes)
	if err != nil {
		fmt.Println("os.Stdin.Write 出错了！！！", err)
		return
	}

	// 返回值1：发送数据字节长度 = n
	_, err = dial.Write(bytes[:n])
	if err != nil {
		fmt.Println("dial.Write 出错了！！！", err)
		return
	}

	// 读取服务端发送的数据
	buf := make([]byte, 4096)
	read, err := dial.Read(buf)
	if err != nil {
		fmt.Println("dial.Read 出错了！！！", err)
		return
	}
	fmt.Println("客户端读到：", string(buf[:read]))
}

效果：只能是连接一次，且要客户端先写，服务端读到以后才能写。

TCP实现并发版：

服务端：

上面都是单机版的客户端通信，如果想要实现并发，需要使用Goroutine+循环实现

  • 循环读取客户端发送的数据
  • 如果客户端强制关闭连接需要做处理
  • 客户端发送exit时
package main

import (
	"fmt"
	"net"
	"os"
)

func main() {
	// 监听该地址的连接请求，当有新地连接请求到来时，创建Accept实现连接
	listen, err := net.Listen("tcp", "127.0.0.1:8080")
	if err != nil {
		fmt.Println("net.Listen 出错了！！！", err)
		return
	}
	defer listen.Close()

	fmt.Println("服务端启动完毕，等待客户端建立连接...")

	for {
		// 与用户端进行通信连接，Accept负责创建通信的Socket，所以放在循环里，来一个客户端就创建一个Socket
		accept, err := listen.Accept()
		if err != nil {
			fmt.Println("listen.Accept 出错了！！！", err)
			return
		}
		defer accept.Close()
		go ReadData(accept)
		go WriteData(accept)
	}
}

func ReadData(accept net.Conn) {
	// 获取连接客户端的网络地址
	addr := accept.RemoteAddr()
	fmt.Println(addr, "与客户端建立连接成功...")

	// 读取客户端发送的数据
	bytes := make([]byte, 4096)
	for {
		n, err := accept.Read(bytes)
		if n == 0 || "exit\n" == string(bytes[:n]) || "exit\r\n" == string(bytes[:n]) {
			fmt.Println("检测到客户端  ", addr, "  已经断开连接！！！")
			return
		} else if err != nil {
			fmt.Println("accept.Read 出错了！！！", err)
			return
		}
		fmt.Println("收到客户端", addr, "发送的数据：", string(bytes[:n]))
	}
}

func WriteData(accept net.Conn) {
	// 使用键盘录入向客户端发送数据
	bytes := make([]byte, 4096)
	for {
		n, err := os.Stdin.Read(bytes)
		if err != nil {
			fmt.Println("os.Stdin.Read 出错了！！！", err)
			return
		}

		_, err = accept.Write(bytes[:n])
		if err != nil {
			fmt.Println("accept.Write 出错了！！！", err)
			return
		}
	}
}

当客户端退出后，服务端依然可以发送信息，但没有客户端接收，会报错： write: broken pipe

解决：在发送之前判断客户端连接状态，且保证读到状态和发送消息一致，使用条件变量解决

package main

import (
	"bufio"
	"log"
	"net"
	"os"
)

func main() {
	listen, err := net.Listen("tcp", "127.0.0.1:8080")
	if err != nil {
		log.Fatal("net.Listen 出错了！！！", err)
	}
	defer listen.Close()

	log.Println("服务端启动完毕，等待客户端建立连接...")

	for {
		accept, err := listen.Accept()
		if err != nil {
			log.Println("listen.Accept 出错了！！！", err)
			continue
		}
		go handleConn(accept)
	}
}

func handleConn(conn net.Conn) {
	addr := conn.RemoteAddr()
	log.Println(addr, "与客户端建立连接成功...")

	scanner := bufio.NewScanner(conn)
	for scanner.Scan() {
		text := scanner.Text()
		if text == "exit" {
			log.Println("检测到客户端 ", addr, " 已经断开连接！！！")
			break
		}
		log.Println("收到客户端", addr, "发送的数据：", text)
	}

	if err := scanner.Err(); err != nil {
		log.Println("读取客户端数据出错了！！！", err)
	}

	conn.Close()
}

func handleStdin(conn net.Conn) {
	defer conn.Close()
	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		text := scanner.Text()
		if text == "exit" {
			log.Println("退出写入数据到客户端。")
			break
		}

		_, err := conn.Write([]byte(text + "\n"))
		if err != nil {
			log.Println("写入数据到客户端出错了！！！", err)
			break
		}
	}
}

func main() {
	conn, err := net.Dial("tcp", "127.0.0.1:8080")
	if err != nil {
		log.Fatal("连接服务端出错了！！！", err)
	}
	defer conn.Close()

	go handleStdin(conn)

	scanner := bufio.NewScanner(conn)
	for scanner.Scan() {
		text := scanner.Text()
		log.Println("收到服务端发送的数据：", text)
	}

	if err := scanner.Err(); err != nil {
		log.Fatal("读取服务端数据出错了！！！", err)
	}
}

在这里插入图片描述

TCP实现并发-客户端：

package main

import (
	"fmt"
	"net"
	"os"
)

func main() {
	//主动发送连接请求
	dial, err := net.Dial("tcp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("et.Dial出错了", err)
		return
	}
	defer dial.Close()

	// os.Stdin()：获取用户键盘录入，
	go func() {
		str := make([]byte, 4096)
		for {
			read, err := os.Stdin.Read(str)
			if err != nil {
				fmt.Println("os.Stdin.Read出错了", err)
				continue
			}

			// 读到的数据写给服务器，读多少写多少
			dial.Write(str[:read])
		}
	}()

	buf := make([]byte, 4096)
	// 回显服务器发送的数据，转成大写
	for {
		read, err := dial.Read(buf)

		// read=0的说明对端关闭连接，如果关闭连接这里就不需要往下读数据了
		if read == 0 {
			fmt.Println("检测到服务端端已经断开连接！")
			return
		}

		if err != nil {
			fmt.Println("回显服务器发送的数据dial.Read出错了", err)
			return
		}
		fmt.Println("客户端读到服务器的回显数据", string(buf[:read]))
	}
}

在这里插入图片描述

UDP实现并发-服务器：

由于UDP是“无连接”的，所以，服务器端不需要额外创建监听套接字，只需要指定好IP和port，然后监听该地址，等待客户端与之建立连接，即可通信。

创建监听地址：

	func ResolveUDPAddr(network, address string) (*UDPAddr, error)

创建监听连接：

	func ListenUDP(network string, laddr *UDPAddr) (*UDPConn, error)

接收udp数据：

	func (c *UDPConn) ReadFromUDP(b []byte) (int, *UDPAddr, error)

写出数据到udp：

	func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (int, error)

演示：

package main

import (
	"fmt"
	"net"
)

func main() {
	// 指定服务器的ip和端口，和TCP协议不一样，需要先写好再传给ListenUDP使用
	ServerAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("net.ResolveUDPAddr err：", err)
		return
	}

	fmt.Println("服务器启动成功！")
	// 创建用户通信的Socket
	udpConnect, err := net.ListenUDP("udp", ServerAddr)
	if err != nil {
		fmt.Println("net.ListenUDP err：", err)
		return
	}
	defer udpConnect.Close()

	fmt.Println("服务器创建Socket成功！")

	// 读写客户端的数据
	buf := make([]byte, 4096)
	count := 0
	for {
		// 返回值：n int（读到的字节数）， addr *UDPAddr（客户端的地址）， err error
		udpBytes, ConnectAddr, err := udpConnect.ReadFromUDP(buf)

		if err != nil {
			fmt.Println("udpConnect.ReadFromUDP err：", err)
			return
		}
		count++
		// 模拟处理数据
		fmt.Printf("服务器读到第%v条数据 %v ：%s\n", count, ConnectAddr, string(buf[:udpBytes]))

		go func() {
			// 回写数据到客户端
			udpConnect.WriteToUDP([]byte("回写数据到客户端\n"), ConnectAddr)
		}()
	}
}

UDP实现并发-客户端：

package main

import (
	"fmt"
	"net"
	"time"
)

func main() {
	dial, err := net.Dial("udp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("net.Dial出错：", err)
		return
	}
	defer dial.Close()

	for {
		// 发送数据
		dial.Write([]byte("我是客户端"))

		// 接收服务器返回的数据
		buf := make([]byte, 4096)
		read, err := dial.Read(buf)
		if err != nil {
			fmt.Println("accept.Read出错：", err)
			return
		}

		// 接收数据后处理数据
		fmt.Println("客户端获取到：", string(buf[:read]))
		time.Sleep(time.Second)
	}
}

在这里插入图片描述

itzhuzhu.
关注
  • 0
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Qt编写网络调试助手（TCP客户端+TCP服务端+UDP服务端）终极版
05-15
时隔半年，对网络调试助手工具进行所有代码重写，这次目录结果整齐的一逼，代码整齐的一逼，非常完善了，打死也不再改版了。这次真的打死也不再改版了。 旧版本1：http://www.qtcn.org/bbs/read-htm-tid-55540.html 旧版本2：http://www.qtcn.org/bbs/read-htm-tid-62636.html 基本功能： 1：16进制数据和ASCII数据收发。 2：定时器自动发送。 3：自动从配置文件加载最后一次的界面设置。 4：自动从配置文件加载数据发送下拉框的数据。可以将经常使用的数据填写在send.txt中。 5：可启用设备模拟回复，当收到某个数据时，模拟设备自动回复数据。对应数据格式填写在device.txt中。 6：可对单个在线连接发送数据，也可勾选全部进行发送。 7：支持多个客户端连接并发。 8：采用单线程。 9：四种模式，tcp服务器、tcp客户端、udp服务器、udp客户端。
TCP/UDP性能测试小工具
04-07
用于测试TCP与UDP通信程序性能，模拟并发客户端与服务端通信，自动统计各项指标。
Golang TCP/IP服务器/客户端应用程序，设计一个简单可靠帧传送通信协议。（并且正确处理基于流式控制协议，带来的应用层沾帧[沾包]问题）
最新发布
liulilittle的博客
01-24 1029
个人一个好的建议是，对于追求网络吞吐性能的TCP应用协议，人们在适用 Golang 应该直接废弃掉，没有任何意义的各种接口及封装实现，如返回 io.Reader，并且应当适用固定缓冲区的最大帧对齐，如：4K，即用户不要发送超过最大对齐（4K）的单帧报文。但这在一些特定场景的网络程序上面是有意义的，例如我们需要知道已用掉了多少的流量，因为这一次缓冲区发送并没有全部传送到远端，但已经传送了一部分也生产了网络带宽资源的浪费，所以，像这种问题，Golang 不提供类似接口，它这块的不自由，是会有一些问题的。
Qt编写网络调试助手（TCP客户端+TCP服务端+UDP服务端）终极版.zip
12-03
时隔半年，对网络调试助手工具进行所有代码重写，这次目录结果整齐的一逼，代码整齐的一逼，非常完善了，打死也不再改版了。这次真的打死也不再改版了。 旧版本1：http://www.qtcn.org/bbs/read-htm-tid-55540.html 旧版本2：http://www.qtcn.org/bbs/read-htm-tid-62636.html 基本功能： 1：16进制数据和ASCII数据收发。 2：定时器自动发送。 3：自动从配置文件加载最后一次的界面设置。 4：自动从配置文件加载数据发送下拉框的数据。可以将经常使用的数据填写在send.txt中。 5：可启用设备模拟回复，当收到某个数据时，模拟设备自动回复数据。对应数据格式填写在device.txt中。 6：可对单个在线连接发送数据，也可勾选全部进行发送。 7：支持多个客户端连接并发。 8：采用单线程。 9：四种模式，tcp服务器、tcp客户端、udp服务器、udp客户端。
TCP&UDP;测试工具
12-20
TCP UDP调试工具，支持服务端和客户端，支持ASCII和HEX收发，支持高并发连接
TCP&UDP;测试_BeetleX出品.rar
08-01
在编写一个网络服务的时候都比较关心这个服务能达到多少并发连接,而在这连接的基础上又能达到一个怎样的交互能力.编写服务已经是一件很花力气的事情,而还要去编写一个能够体现结果的测试工具就更加消耗工作时间.下面介绍一个测试工具只需要简单地设置一下就能对tcp/udp服务进行高并发和高吐吞的性能测试,并通过图形化的方式反映测试结果. 工具是采用用.NET编写,所以需要.NET FRAMEWORK才能运行.虽然.net在这方面的给人的感觉性能不怎么出色,但这个工作出色性能足够满足大部分服务端的压力测试. 工具非常简单易用,只需要设置几项内容就可以对于个服务端进行压测.在这里比较注意的就是测试模式这里,工具主要提供两种测试模式分别是 应答模式:当连接接收服务端响应后马上进行下一次请求消息发送 间隔模式:连接根据设置的间隔时间来进行发送请求消息
tcp/udp高并发和高吐吞性能测试工具
04-09
只需要简单地设置一下就能对tcp/udp服务进行高并发和高吐吞的性能测试,并通过图形化的方式反映测试结果.
Golang_14: Go语言 网络编程：TCP 与 UDP（socket 编程）
谢TS的博客
05-26 388
Go 语言的 net 包为网络 I/O 提供了可一个可移植的接口，包括 TCP/IP、UDP、域名解析 和 Unix域套接字。 尽管 net 包提供了对低级网络原语的访问，但大多数情况下只需要使用 Dial()、Listen() 和 Accept() 函数以及相关的 Conn 和 Listener 接口提供的基本方法。crypto/tls 包使用相同的接口实现了 TLS 版本的 Dial() 和 Listen() 功能。
go语言网络编程TCP和UDP
.
12-12 1783
TCP和UDP属于网络七层模型中传输层 TCP协议 TCP/IP(Transmission Control Protocol/Internet Protocol) 即传输控制协议/网间协议，是一种面向连接（连接导向）的、可靠的、基于字节流的传输层（Transport layer）通信协议，因为是面向连接的协议，数据像水流一样传输，会存在黏包问题。 UDP协议 Go语言实现TCP通信 一个TCP服务端可以同时连接很多个客户端，多个客户端可以同时像服务端发送消息，go语言中我们也可以使用线程来处理模拟多个客户端
使用go写一个高并发的端口扫描的代码
weixin_42593701的博客
02-13 37
你可以使用Go语言的net包来编写一个高并发的端口扫描的代码。具体的实现步骤如下：1.使用net.DialTCP函数来连接到指定的端口。2.使用net.ListenTCP函数来创建一个TCP服务器。3.使用net.SetConnDeadline来设置连接超时。4.使用for循环，循环遍历每个端口，检测端口是否开放。5.如果端口开放，则输出提示信息。 ...
网络编程16——UDP实现的并发服务器和客户端
qq_37299596的博客
05-12 501
TCP、UDP通信的各自优缺点 TCP： 面向连接的， 可靠，数据报传输。对于不稳定的网络层，采取完全弥补的通信方式，即丢包重传 优点：稳定，数据流量稳定、速度稳定、顺序稳定 缺点：传输速度慢，速率低，开销大 使用场景：数据的完整性要求较高，不追求效率，如大数据传输，文件传输 UDP：无连接的，不可靠的，数据报传输，对于不稳定的网络层，采取完全不弥补的通信方式。默认还原网络状况 优点：传输速度快，速率高，开销小 缺点：不稳定，数据流量、速度、顺序都不稳定 使用场景：对时效性要求较高，对稳定性其次，如游戏、视
go高性能并发服务器,开发go并发服务器和请求客户端
weixin_39629947的博客
08-11 348
服务端package mainimport ("strings""fmt""net")// 这是服务端接受参数,同时把参数返回回去,如果遇到参数为exit,那么断开连接func handleConn (conn net.Conn){// 获取连接着的ipaddrIP := conn.RemoteAddr().String()fmt.Printf("%s 已连接", addrIP)buf := m...
Go语言实现百万级WebSocket连接
源自开发者
12-28 680
WebSocket是一种在单个TCP连接上进行全双工通信的协议。在高并发环境下，如何有效地管理和维护数百万个WebSocket连接是一个挑战，尤其是在资源有限的情况下。Go语言以其轻量级的协程和高效的网络I/O处理能力，成为实现大规模WebSocket连接的理想选择。本文将详细介绍如何在Go中构建一个能够支持百万级WebSocket连接的服务，包括系统架构设计、性能优化策略以及具体的实现步骤和代码示例。
TCP网络编程——并发执行
_Cx330的博客
12-22 1902
目录 用多线程处理 用多进程处理 对于之前博客中的代码。当一个客户端和服务器建立连接以后，服务端accept()返回，然后准备循环接收客户端发送的数据。如果客户端暂时没有发送数据，服务端绘制recv()处阻塞住。此时如果其他客户端向服务端发起连接，就无法进行accept()。也就是说，服务器无法同时处理多个客户端。 为了解决这个问题，我们可以引入多线程和多进程。 服务器接收一个客户端的连接后，创建一个线程或者进程，然后在新创建的线程或进程中循环处理数据。主线程只负责监听客户端连接，使用acce
记一次UDP接入服务的性能测试
凌空摘星的博客
12-28 2003
记一次UDP接入服务的性能测试前言背景简介服务架构测试需求测试分析测试工具工具选型Jmeter 配置测试场景测试及优化过程数据接入服务Nginx + Keepalived总结用到的指令注意事项心得体会 前言 最近在项目上做了一个对数据接入服务器的性能测试，使用了UDP协议，而且调试过程还挺有意思的，在此记录一下。 背景简介 服务架构 服务器和数据流大致如下图： 终端设备的主要功能是上传GPS，使用的是UDP协议，由数据接入服务接收后转发至消息队列，最终由应用服务存储至数据库。其中数据接入服务部署了两台，由
tcp/udp高并发和高吐吞性能测试
sylgdxsgx的专栏
02-27 591
tcp/udp高并发和高吐吞性能测试1、tcp/udp高并发和高吐吞性能测试工具
性能测试流程-JMeter工具进行并发情况下UDP发送频率测试
罗小黑の窝
05-07 1141
上一篇博文详细说明使用i使用JMeter性能测试工具进行系统最大用户数与系统最大请求数的数据测试，本篇博文针对第三个点：并发情况下UDP发送频率测试，进行详情说明。 日志系统我们按照不同的发包频率对系统进行发包测试后访问常用接口得出系统在何种UDP发包频率下为最大承受极限，此指标我们使用JMeter性能测试工具来监控，判断条件为：验证在并发数为2和10时不同的...
Golang实现之TCP长连接-------服务端和客户端
以后会多把工作中总结的知识、问题处理思路和方法通过博客分享出来,欢迎大家关注和共同探讨!
06-26 2821
一、数据包的数据结构 (所有字段采用大端序)二、Server端 实现代码。三、Client端 实现代码。
java 实现 即时通讯程序的服务端和客户端，用Netty实现可以吗 ？ 聊天和传文件
05-05
是的，你可以使用 Netty 来实现 Java 即时通讯程序的服务端和客户端，包括聊天和传输文件功能。Netty 是一个高性能的网络编程框架，支持 TCP、UDP、HTTP、WebSocket 等协议，非常适合开发高并发、高可靠性的网络应用程序。 下面是一个简单的示例代码，实现了一个基于 Netty 的聊天室服务端和客户端，你可以参考它来实现你自己的即时通讯程序： 服务端代码： ```java public class ChatServer { private final int port; public ChatServer(int port) { this.port = port; } public void run() throws Exception { EventLoopGroup bossGroup = new NioEventLoopGroup(); EventLoopGroup workerGroup = new NioEventLoopGroup(); try { ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .childHandler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); pipeline.addLast("framer", new DelimiterBasedFrameDecoder(8192, Delimiters.lineDelimiter())); pipeline.addLast("decoder", new StringDecoder()); pipeline.addLast("encoder", new StringEncoder()); pipeline.addLast("handler", new ChatServerHandler()); } }) .option(ChannelOption.SO_BACKLOG, 128) .childOption(ChannelOption.SO_KEEPALIVE, true); ChannelFuture f = b.bind(port).sync(); System.out.println("ChatServer started on port " + port); f.channel().closeFuture().sync(); } finally { workerGroup.shutdownGracefully(); bossGroup.shutdownGracefully(); } } public static void main(String[] args) throws Exception { new ChatServer(8080).run(); } } ``` 客户端代码： ```java public class ChatClient { private final String host; private final int port; public ChatClient(String host, int port) { this.host = host; this.port = port; } public void run() throws Exception { EventLoopGroup group = new NioEventLoopGroup(); try { Bootstrap b = new Bootstrap(); b.group(group) .channel(NioSocketChannel.class) .handler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); pipeline.addLast("framer", new DelimiterBasedFrameDecoder(8192, Delimiters.lineDelimiter())); pipeline.addLast("decoder", new StringDecoder()); pipeline.addLast("encoder", new StringEncoder()); pipeline.addLast("handler", new ChatClientHandler()); } }); ChannelFuture f = b.connect(host, port).sync(); System.out.println("ChatClient connected to " + host + ":" + port); BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); while (true) { String line = in.readLine(); if (line == null) { break; } f.channel().writeAndFlush(line + "\r\n"); } } finally { group.shutdownGracefully(); } } public static void main(String[] args) throws Exception { new ChatClient("localhost", 8080).run(); } } ``` 其中，`ChatServerHandler` 和 `ChatClientHandler` 分别是服务端和客户端的消息处理器，你需要根据你的需求来实现它们。另外，你还需要实现文件传输功能的代码，可以参考 Netty 的官方文档和示例代码来完成。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

itzhuzhu.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值