以下是小编精心整理的Go语言服务器开发之简易TCP客户端与服务端实现方法（共含10篇），供大家参考借鉴，希望可以帮助到有需要的朋友。同时，但愿您也能像本文投稿人“秃头国王”一样，积极向本站投稿分享好文章。
作者：books1958 字体：[增加 减小] 类型：
这篇文章主要介绍了Go语言服务器开发之简易TCP客户端与服务端实现方法,实例分析了基于Go语言实现的简易服务器的TCP客户端与服务器端实现技巧,需要的朋友可以参考下
本文实例讲述了Go语言服务器开发之简易TCP客户端与服务端实现方法，分享给大家供大家参考。具体实现方法如下：
Go语言具备强大的服务器开发支持，这里示范了最基础的服务器开发：通过TCP协议实现客户端与服务器的通讯。
一 服务端，为每个客户端新开一个goroutine
代码如下:
func ServerBase {
fmt.Println(“Starting the server...”)
//create listener
listener, err := net.Listen(“tcp”, “192.168.1.27:50000”)
if err != nil {
fmt.Println(“Error listening:”, err.Error())
return
}
// listen and accept connections from clients:
for {
conn, err := listener.Accept()
if err != nil {
fmt.Println(“Error accepting:”, err.Error())
return
}
//create a goroutine for each request.
go doServerStuff(conn)
}
}
func doServerStuff(conn net.Conn) {
fmt.Println(“new connection:”, conn.LocalAddr())
for {
buf := make([]byte, 1024)
length, err := conn.Read(buf)
if err != nil {
fmt.Println(“Error reading:”, err.Error())
return
}
fmt.Println(“Receive data from client:”, string(buf[:length]))
}
}
二 客户端 连接服务器，并发送数据
代码如下:
func ClientBase() {
//open connection:
conn, err := net.Dial(“tcp”, “192.168.1.27:50000”)
if err != nil {
fmt.Println(“Error dial:”, err.Error())
return
}
inputReader := bufio.NewReader(os.Stdin)
fmt.Println(“Please input your name:”)
clientName, _ := inputReader.ReadString(‘\n‘)
inputClientName := strings.Trim(clientName, “\n”)
//send info to server until Quit
for {
fmt.Println(“What do you send to the server? Type Q to quit.”)
content, _ := inputReader.ReadString(‘\n‘)
inputContent := strings.Trim(content, “\n”)
if inputContent == “Q” {
return
}
_, err := conn.Write([]byte(inputClientName + “ says ” + inputContent))
if err != nil {
fmt.Println(“Error Write:”, err.Error())
return
}
}
}
注：由于LiteIDE不支持同时运行多个程序，所以需要在终端通过 go run 命令来同时运行服务端和（一个或多个）客户端，可观察到服务器对并发访问的支持，
希望本文所述对大家的Go语言程序设计有所帮助。
作者：小小的我 字体：[增加 减小] 类型：转载
这篇文章主要介绍了GO语言实现简单TCP服务的方法,实例分析了Go语言实现TCP服务的技巧,需要的朋友可以参考下
本文实例讲述了GO语言实现简单TCP服务的方法，分享给大家供大家参考。具体实现方法如下：
代码如下:
package main
import (
“net”
“fmt”
)
var ( maxRead = 1100
msgStop = []byte(“cmdStop”)
msgStart = []byte(“cmdContinue”)
)
func main() {
hostAndPort := “localhost:54321”
listener := initServer(hostAndPort)
for {
conn, err := listener.Accept()
checkError(err, “Accept: ”)
go connectionHandler(conn)
}
}
func initServer(hostAndPort string) *net.TCPListener {
serverAddr, err := net.ResolveTCPAddr(“tcp”, hostAndPort)
checkError(err, “Resolving address:port failed: ‘” + hostAndPort + “‘”)
listener, err := net.ListenTCP(“tcp”, serverAddr)
checkError(err, “ListenTCP: ”)
println(“Listening to: ”, listener.Addr().String())
return listener
}
func connectionHandler(conn net.Conn) {
connFrom := conn.RemoteAddr().String()
println(“Connection from: ”, connFrom)
talktoclients(conn)
for {
var ibuf []byte = make([]byte, maxRead + 1)
length, err := conn.Read(ibuf[0:maxRead])
ibuf[maxRead] = 0 // to prevent overflow
switch err {
case nil:
handleMsg(length, err, ibuf)
default:
goto DISCONNECT
}
}
DISCONNECT:
err := conn.Close()
println(“Closed connection:” , connFrom)
checkError(err, “Close:” )
}
func talktoclients(to net.Conn) {
wrote, err := to.Write(msgStart)
checkError(err, “Write: wrote ” + string(wrote) + “ bytes.”)
}
func handleMsg(length int, err error, msg []byte) {
if length >0 {
for i := 0; ; i++ {
if msg[i] == 0 {
break
}
}
fmt.Printf(“Received data: %v”, string(msg[0:length]))
fmt.Println(“ length:”,length)
}
}
func checkError(error error, info string) {
if error != nil {
panic(“ERROR: ” + info + “ ” + error.Error()) // terminate program
}
}
希望本文所述对大家的Go语言程序设计有所帮助，
作者：露露 字体：[增加 减小] 类型：
TCP服务器程序（tsTserv.py）：
from socket import *from time import ctimeHOST = ‘‘PORT = 21567BUFSIZ = 1024ADDR = (HOST, PORT)tcpSerSock = socket(AF_INET, SOCK_STREAM)tcpSerSock.bind(ADDR)tcpSerSock.listen(5)while True: print ‘waiting for connection...‘ tcpCliSock, addr = tcpSerSock.accept print ‘...connected from:‘, addr while True: data = tcpCliSock.recv(BUFSIZ) if not data:break tcpCliSock.send(‘[%s] %s‘ %(ctime(), data)) tcpCliSock.close()tcpSerSock.close()
TCP客户端程序（tsTclnt.py）：
from socket import *HOST = ‘localhost‘PORT = 21567BUFSIZ = 1024ADDR = (HOST, PORT)tcpCliSock = socket(AF_INET, SOCK_STREAM)tcpCliSock.connect(ADDR)while True: data = raw_input(‘>‘) if not data: break tcpCliSock.send(data) data1 = tcpCliSock.recv(BUFSIZ) if not data1: break print data1tcpCliSock.close()
运行说明：先运行服务器程序，作用类似于打开服务器保持等待客户请求，再运行客户端程序，
运行界面如下：
服务器端：
D:\code\ex>python tsTserv.pywaiting for connection......connected from: (‘127.0.0.1‘, 2883)waiting for connection......connected from: (‘127.0.0.1‘, 2885)waiting for connection......connected from: (‘127.0.0.1‘, 2889)waiting for connection......connected from: (‘127.0.0.1‘, 2891)waiting for connection......connected from: (‘127.0.0.1‘, 2892)waiting for connection......connected from: (‘127.0.0.1‘, 2893)waiting for connection...
客户端：
D:\code\ex>python tsTclnt.py>1[Thu Feb 02 15:52:21 ] 1>2[Thu Feb 02 15:52:22 2012] 2>3[Thu Feb 02 15:52:22 2012] 3>5[Thu Feb 02 15:52:23 2012] 5>6[Thu Feb 02 15:52:24 2012] 6>D:\code\ex>
希望本文所述对大家的Python程序设计有所帮助。
作者：books1958 字体：[增加 减小] 类型：转载
这篇文章主要介绍了Go语言服务器开发实现最简单HTTP的GET与POST接口,实例分析了Go语言http包的使用技巧,需要的朋友可以参考下
本文实例讲述了Go语言服务器开发实现最简单HTTP的GET与POST接口，分享给大家供大家参考。具体分析如下：
Go语言提供了http包，可以很轻松的开发http接口。以下为示例代码：
代码如下:
package webserver
import (
“encoding/json”
“fmt”
“net/http”
“time”
)
func WebServerBase() {
fmt.Println(“This is webserver base!”)
//第一个参数为客户端发起http请求时的接口名，第二个参数是一个func，负责处理这个请求。
http.HandleFunc(“/login”, loginTask)
//服务器要监听的主机地址和端口号
err := http.ListenAndServe(“192.168.1.27:8081”, nil)
if err != nil {
fmt.Println(“ListenAndServe error: ”, err.Error())
}
}
func loginTask(w http.ResponseWriter, req *http.Request) {
fmt.Println(“loginTask is running...”)
//模拟延时
time.Sleep(time.Second * 2)
//获取客户端通过GET/POST方式传递的参数
req.ParseForm()
param_userName, found1 := req.Form[“userName”]
param_password, found2 := req.Form[“password”]
if !(found1 && found2) {
fmt.Fprint(w, “请勿非法访问”)
return
}
result := NewBaseJsonBean()
userName := param_userName[0]
password := param_password[0]
s := “userName:” + userName + “,password:” + password
fmt.Println(s)
if userName == “zhangsan” && password == “123456” {
result.Code = 100
result.Message = “登录成功”
} else {
result.Code = 101
result.Message = “用户名或密码不正确”
}
//向客户端返回JSON数据
bytes, _ := json.Marshal(result)
fmt.Fprint(w, string(bytes))
}
NewBaseJsonBean用于创建一个struct对象:
代码如下:
package webserver
type BaseJsonBean struct {
Code int `json:“code”`
Data interface{} `json:“data”`
Message string `json:“message”`
}
func NewBaseJsonBean() *BaseJsonBean {
return &BaseJsonBean{}
}
希望本文所述对大家的Go语言程序设计有所帮助，
作者：OSC首席键客 字体：[增加 减小] 类型：
1. singlechain.go代码如下：
代码如下:
//////////
//单链表 -- 线性表
package singlechain
//定义节点
type Node struct {
Data int
Next *Node
}
/*
* 返回第一个节点
* h 头结点
*/
func GetFirst(h *Node) *Node {
if h.Next == nil {
return nil
}
return h.Next
}
/*
* 返回最后一个节点
* h 头结点
*/
func GetLast(h *Node) *Node {
if h.Next == nil {
return nil
}
i := h
for i.Next != nil {
i = i.Next
if i.Next == nil {
return i
}
}
return nil
}
//取长度
func GetLength(h *Node) int {
var i int = 0
n := h
for n.Next != nil {
i++
n = n.Next
}
return i
}
//插入一个节点
//h: 头结点
//d:要插入的节点
//p:要插入的位置
func Insert(h, d *Node, p int) bool {
if h.Next == nil {
h.Next = d
return true
}
i := 0
n := h
for n.Next != nil {
i++
if i == p {
if n.Next.Next == nil {
n.Next = d
return true
} else {
d.Next = n.Next
n.Next = d.Next
return true
}
}
n = n.Next
if n.Next == nil {
n.Next = d
return true
}
}
return false
}
//取出指定节点
func GetLoc(h *Node, p int) *Node {
if p < 0 || p >GetLength(h) {
return nil
}
var i int = 0
n := h
for n.Next != nil {
i++
n = n.Next
if i == p {
return n
}
}
return nil
}
2. main.go代码如下：
代码如下:
package main
import “fmt”
import “list/singlechain”
func main {
//初始化一个头结点
var h singlechain.Node
//往链表插入10个元素
for i := 1; i <= 10; i++ {
var d singlechain.Node
d.Data = i
singlechain.Insert(&h, &d, i)
fmt.Println(singlechain.GetLoc(&h, i))
}
fmt.Println(singlechain.GetLength(&h))
fmt.Println(singlechain.GetFirst(&h))
fmt.Println(singlechain.GetLast(&h))
fmt.Println(singlechain.GetLoc(&h, 6))
}
希望本文所述对大家的Go语言程序设计有所帮助，
作者：不吃皮蛋 字体：[增加 减小] 类型：转载
代码如下:
package main
import (
// “fmt”
“io”
“log”
“net/http”
“text/template”
“time”
“database/sql”
“github.com/ziutek/mymysql/godrv”
)
// 留言结构
type Liuyan struct {
Id int
Name string
Content string
Time int
}
// 显示留言时间
func (l Liuyan) ShowTime() string {
t := time.Unix(int64(l.Time), 0)
return t.Format(“-01-02 15:04:05”)
}
func main() {
godrv.Register(“SET NAMES utf8”)
// 连接数据库
db, err := sql.Open(“mymysql”, “tcp:127.0.0.1:3306*go/root/123456”)
if err != nil {
panic(err)
}
defer db.Close()
// 准备模板
tpl, err := template.New(“liuyanbook”).Parse(html)
if err != nil {
panic(err)
}
// 显示留言页面 /
requestList := func(w http.ResponseWriter, req *http.Request) {
// 查询数据
rows, err := db.Query(“select * from liuyan”)
if err != nil {
log.Fatal(err)
}
defer rows.Close()
// 获取数据
lys := []Liuyan{}
for rows.Next() {
ly := Liuyan{}
err := rows.Scan(&ly.Id, &ly.Name, &ly.Content, &ly.Time)
if nil != err {
log.Fatal(err)
}
lys = append(lys, ly)
}
// 显示数据
err = tpl.ExecuteTemplate(w, “list”, lys)
if err != nil {
log.Fatal(err)
}
}
// 留言页面 /liuyan
requestLiuyan := func(w http.ResponseWriter, req *http.Request) {
err := req.ParseForm()
if err != nil{
log.Fatal(err)
}
if “POST” == req.Method {
if len(req.Form[“name”]) < 1 {
io.WriteString(w, “参数错误!\n”)
return
}
if len(req.Form[“content”]) < 1 {
io.WriteString(w, “参数错误!\n”)
return
}
name := template.HTMLEscapeString(req.Form.Get(“name”))
content := template.HTMLEscapeString(req.Form.Get(“content”))
// sql语句
sql, err := db.Prepare(“insert into liuyan(name, content, time) values(?, ?, ?)”)
if err != nil {
log.Fatal(err)
}
defer sql.Close()
// sql参数,并执行
_, err = sql.Exec(name, content, time.Now().Unix())
if err != nil {
log.Fatal(err)
}
// 跳转
w.Header().Add(“Location”, “/”)
w.WriteHeader(302)
// 提示信息
io.WriteString(w, “提交成功!\n”)
return
}
err = tpl.ExecuteTemplate(w, “liuyan”, nil)
if err != nil {
log.Fatal(err)
}
}
http.HandleFunc(“/”, requestList)
http.HandleFunc(“/liuyan”, requestLiuyan)
err = http.ListenAndServe(“:12345”, nil)
if err != nil {
log.Fatal(“ListenAndServe: ”, err)
}
}
// 网页模板
var html string = `{{define “list”}}{{/* 留言列表页面 */}}
给我留言
{{range .}}
{{.Id}}{{.Name}}{{.Content}}{{.ShowTime}}
{{end}}
{{end}}
{{define “liuyan”}}{{/* 发布留言页面 */}}
姓名:
内容:
{{end}}
希望本文所述对大家的Go语言程序设计有所帮助，
作者：不吃皮蛋 字体：[增加 减小] 类型：
golang,其实我的实现是利用container/list包实现的,其实container/list包很强大.
代码如下:
package main
import (
“fmt”
“container/list”
)
func main {
// 生成队列
l := list.New()
// 入队, 压栈
l.PushBack(1)
l.PushBack(2)
l.PushBack(3)
l.PushBack(4)
// 出队
i1 := l.Front()
l.Remove(i1)
fmt.Printf(“%d\n”, i1.Value)
// 出栈
i4 := l.Back()
l.Remove(i4)
fmt.Printf(“%d\n”, i1.Value)
}
希望本文所述对大家的Go语言程序设计有所帮助，
作者：books1958 字体：[增加 减小] 类型：转载
这篇文章主要介绍了Go语言实现Fibonacci数列的方法,实例分析了使用递归和不使用递归两种技巧,并对算法的效率进行了对比,需要的朋友可以参考下
本文实例讲述了Go语言实现Fibonacci数列的方法，分享给大家供大家参考。具体如下：
Fibonacci数列:1,1,2,3,5,8,13,21,,, (即从第三项起，每一项的值都等于前两项之后)
第一种，使用递归：
代码如下:
func fibonacci(a int) int {
if a == 1 || a == 2 {
return 1
}
return fibonacci(a-1) + fibonacci(a-2)
}
第二种，不使用递归：
代码如下:
func fibonacci_version2(index int) int {
if index == 1 || index == 2 {
return 1
}
a, b := 1, 1
for i := 3; i <= index; i++ {
a, b = b, (a + b)
}
return a + b
}
经过检验，使用非递归算法的效率要远远高于递归算法，
希望本文所述对大家的Go语言程序设计有所帮助。
作者：令狐不聪 字体：[增加 减小] 类型：
这篇文章主要介绍了go语言实现字符串base64编码的方法,实例分析了Go语言操作字符串的技巧及base64编码的使用技巧,需要的朋友可以参考下
本文实例讲述了go语言实现字符串base64编码的方法，分享给大家供大家参考。具体实现方法如下：
代码如下:
package main
import (
“fmt”
“encoding/base64”
)
func main {
var b bytes.Buffer
w := base64.NewEncoder(base64.URLEncoding, &b)
w.Write(data)
w.Close()
data := b.Bytes()
}
希望本文所述对大家的Go语言程序设计有所帮助，
这篇文章主要介绍了GO语言实现列出目录和遍历目录的方法,涉及ioutil.ReadDir()与filepath.Walk()的应用,是非常实用的技巧,需要的朋友可以参考下
GO语言获取目录列表用 ioutil.ReadDir()，遍历目录用 filepath.Walk()，使用方法课参考本文示例。
具体示例代码如下：
代码如下:
package main
import (
“fmt”
“io/ioutil”
“os”
“path/filepath”
“strings”
)
//获取指定目录下的所有文件，不进入下一级目录搜索，可以匹配后缀过滤。
func ListDir(dirPth string, suffix string) (files []string, err error) {
files = make([]string, 0, 10)
dir, err := ioutil.ReadDir(dirPth)
if err != nil {
return nil, err
}
PthSep := string(os.PathSeparator)
suffix = strings.ToUpper(suffix) //忽略后缀匹配的大小写
for _, fi := range dir {
if fi.IsDir() { // 忽略目录
continue
}
if strings.HasSuffix(strings.ToUpper(fi.Name()), suffix) { //匹配文件
files = append(files, dirPth+PthSep+fi.Name())
}
}
return files, nil
}
//获取指定目录及所有子目录下的所有文件，可以匹配后缀过滤，
func WalkDir(dirPth, suffix string) (files []string, err error) {
files = make([]string, 0, 30)
suffix = strings.ToUpper(suffix) //忽略后缀匹配的大小写
err = filepath.Walk(dirPth, func(filename string, fi os.FileInfo, err error) error { //遍历目录
//if err != nil { //忽略错误
// return err
//}
if fi.IsDir() { // 忽略目录
return nil
}
if strings.HasSuffix(strings.ToUpper(fi.Name()), suffix) {
files = append(files, filename)
}
return nil
})
return files, err
}
func main() {
files, err := ListDir(“D:\\Go”, “.txt”)
fmt.Println(files, err)
files, err = WalkDir(“E:\\Study”, “.pdf”)
fmt.Println(files, err)
}
希望本文所述对大家的GO语言程序设计有所帮助。
