看了两天 go 语言，是时候练练手了。
go 的 routine（例程） 和 chan（通道） 简直是神器，实现多线程（在 go 里准确的来说是 多例程）简直不要太轻松。
于是动手码了一个傻瓜版的黑框聊天器。
server 端：
监听 tcp 连接；支持自定义客户端命令；支持消息分发；理论上支持广播；...
我要评论
package main
import (
"fmt"
"net"
"io"
"strconv"
"time"
"strings"
)
const (
normal_message = iota
list_message
)
var clientsenders = make(map[string] chan string)
func send (addr string, conn *net.conn){
senderchan := clientsenders[addr]
for s := range senderchan{
(*conn).write([]byte(s))
}
}
func sendusersinfo(addr string){
senderchan := clientsenders[addr]
if nil != senderchan{
ls := strconv.itoa(list_message)
cs := strconv.itoa(normal_message) + "已登录客户端列表：\n"
i := 1
for k := range clientsenders{
a := ""
if k == addr {
a = "（我）"
}
cs = cs + strconv.itoa(i) + "）" + k + a + "\n"
ls += k + "\n"
i ++
}
cs += "发送消息，可使用 1<-这是给1号客户端的消息\n（请使用英文以获取最佳体验）\n"
senderchan <- cs
time.sleep(time.millisecond * 300)
senderchan <- ls
// 发送格式化的列表
fmt.println("已发送“登录用户信息”", addr)
} else{
fmt.println("客户端接受通道不存在", addr)
}
}
func serve (conn *net.conn){
connect := *conn
addr := connect.remoteaddr().string()
fmt.println(addr, "接入服务")
senderchan := make(chan string, 3)
clientsenders[addr] = senderchan
// 启动发送
go send(addr, conn)
// 发送当前用户信息
go sendusersinfo(addr)
buff := make([]byte, 10240)
for {
n, err := connect.read(buff)
if err != nil {
if err == io.eof {
fmt.println("客户端断开链接，", addr)
delete(clientsenders, addr)
return
} else{
fmt.println(err)
}
}
msg := string(buff[:n])
// 刷新客户端列表
if msg == "ls\n" {
go sendusersinfo(addr)
continue
}
// 提取数据
msgs := strings.split(msg, "<-")
if len(msg) < 2{
senderchan <- string("数据格式不正确，请联系开发者")
continue
}
aimaddr := msgs[0]
aimsender := clientsenders[aimaddr]
if aimsender == nil {
senderchan <- string("客户端已下线，使用 ls 命令获取最新的客户端列表")
continue
}
aimsender <- strconv.itoa(normal_message) + "[from:" + addr + "]:" + strings.join(msgs[1:], "<-")
}
}
func main(){
addr := ":8080"
listener, err := net.listen("tcp", addr)
if err != nil{
fmt.println(err)
return
}
// 启动消息调度器
defer listener.close()
// 启动连接监听
for {
conn, err := listener.accept()
if err != nil {
fmt.println(err)
continue
}
go serve(&conn)
}
}
客户端：
支持断线重连；支持给特定其他客户端发信息
package main
import (
"net"
"fmt"
"io"
"os"
"bufio"
"sync"
"time"
"strings"
"strconv"
)
var conn *net.conn
var addrs []string
const (
normal_message = iota
list_message
)
func read(conn2 *net.conn){
defer func() {
fmt.println("尝试重连")
go connectserver()
}()
connect := *conn2
buff := make([]byte, 20140)
for {
n, err := connect.read(buff)
if err != nil {
if err == io.eof{
fmt.println("结束")
(*conn2).close()
conn = nil
return
} else{
fmt.println(err)
}
}
msg := string(buff[:n])
t, err := strconv.atoi(string(msg[0]))
msg = msg[1:]
switch t {
case normal_message:
fmt.print(msg)
break
case list_message:
// 解析客户端列表数据
addrs = strings.split(msg, "\n")
fmt.println("已接收客户端列表。\n")
break
default:
fmt.print(msg)
break
}
}
}
func connectserver(){
addr := "192.168.99.236:8080"
fmt.println("等待服务器开启中")
conn2, err := net.dial("tcp", addr)
if err != nil {
fmt.print(err)
fmt.println("连接失败，10s后尝试")
time.sleep(10 * time.second)
go connectserver()
return
}
fmt.println("已连接")
conn = &conn2
go read(&conn2)
}
func send (){
inputreader := bufio.newreader(os.stdout)
for {
input, err := inputreader.readstring('\n')
if err != nil {
if err == io.eof{
return
} else{
fmt.println(err)
}
}
if input == "ls\n" {
(*conn).write([]byte(input))
continue
}
msgs := strings.split(input, "<-")
if len(msgs) < 2 {
fmt.println("发送的姿势不正确，应该像这样 1<-给1号发送消息\n")
continue
}
index, err := strconv.atoi(msgs[0])
if err != nil {
fmt.println("发送的姿势不正确，应该像这样 1<-给1号发送消息\n")
continue
}
if len(addrs) <= index {
fmt.println("不存在第" + strconv.itoa(index) + "个客户端\n")
continue
}
addr := addrs[index-1]
input = addr + "<-" + strings.join(msgs[1:], "<-")
if nil != conn {
(*conn).write([]byte(input))
}
}
}
func main (){
var wg sync.waitgroup
wg.add(2)
go connectserver()
go send()
wg.wait()
defer func() {
if nil != conn {
(*conn).close()
}
}()
}
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持移动技术网。
如对本文有疑问， 点击进行留言回复！！
网友评论