[大数据] 【Go】网络编程、Redis

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 大数据 -> 【Go】网络编程、Redis -> 正文阅读

[大数据]【Go】网络编程、Redis

文章目录

1 TCP编程

1.1 C/S模型

// 查看本机所有端口信息
netstat -an
// 查看所有端口 pid
netstat -anb

C/S模型

Server

package main

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

func doProcess(conn net.Conn)  {
	// 延时关闭连接
	defer conn.Close()

	for{
		// 创建切片用于读取数据
		buf := make([]byte, 1024)
		// case1 阻塞在此处 等待读取数据
		// case2 客户端关闭或者读取出错 err
		//fmt.Printf("server wait client ip[%s] write something..\n", conn.RemoteAddr().String())
		n, err := conn.Read(buf)
		if err == io.EOF{
			fmt.Printf("conn.Read close: %s\n", err)
			break
		}else if err != nil{
			fmt.Printf("conn.Read err : %s\n", err)
			break
		}

		// 显示实际读取的内容
		fmt.Printf("read byte[%d] info[%s]\n", n, string(buf[:n]))

		// 判断退出的程序
		if n == 4 && "exit" == string(buf[:n]){
			fmt.Printf("[Exit] gorutine\n")
			break
		}
	}

}

func main() {
	// [1] 监听端口
	listen, err := net.Listen("tcp", "192.168.19.1:8888")
	fmt.Println("[1] 监听端口 192.168.19.1:8888...")
	if err != nil{
		fmt.Printf("Listen err : %s\n", err)
		return
	}
	// 延时关闭
	defer listen.Close()

	// listen type : *net.TCPListener  val : &{0xc042090000}
	fmt.Printf("listen type : %T  val : %v\n", listen, listen) 

	// [2] 阻塞等待客户端连接
	for{
		fmt.Println("[2] 阻塞等待客户端连接 192.168.19.1:8888...")
		conn, err := listen.Accept()
		if err != nil{
			fmt.Printf("Accept err : %s\n", err)
			continue
		}

		// conn type : *net.TCPConn  val : &{{0xc04207a240}}
		fmt.Printf("conn type : %T  val : %v\n", conn, conn)
		// conn client ip: 192.168.19.1:13749  server ip: 192.168.19.1:8888
		fmt.Printf("conn client ip: %s  server ip: %s\n", conn.RemoteAddr(), conn.LocalAddr())

		// 创建一个协程进行处理
		go doProcess(conn)
	}
}

Client

package main

import (
	"bufio"
	"fmt"
	"net"
	"os"
	"strings"
)

func main() {
	// [1] 连接服务器
	conn, err := net.Dial("tcp", "192.168.19.1:8888")
	if err != nil{
		fmt.Printf("net.Dial err : %s\n", err)
		return
	}
	// 延时关闭连接
	defer conn.Close()

	// client conn success conn type : *net.TCPConn  val : &{{0xc042092000}}
	fmt.Printf("client conn success conn type : %T  val : %v \n", conn, conn)


	// 发送为服务器
	for{
		// [2] 从终端读入行 发送数据到服务器
		reader := bufio.NewReader(os.Stdin)
		readString, err := reader.ReadString('\n')
		// 去除回车
		readString = strings.Trim(readString, "\r\n")

		if err != nil{
			fmt.Printf("reader.ReadString err : %s\n", err)
			return
		}

		n, err := conn.Write([]byte(readString))
		if err != nil{
			fmt.Printf("conn.Write err : %s\n", err)
			return
		}
		fmt.Printf("client send byte[%d] info[%s]\n", n, readString)
		
		if "exit" == readString {
			fmt.Printf("[Exit] gorutine\n")
			break
		}
	}
}

1.2 others

2 Redis

2.1 简介

port:6379

在这里插入图片描述

2.2 CLI操作：快速入门

DOC操作

在这里插入图片描述

// 默认有16个数据库 
// [1] 添加字典 key-val  默认0号数据库
127.0.0.1:6379> set k1 xhh
OK
127.0.0.1:6379> get k1
"xhh"

// [2] 切换到1号数据库
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> get k1
(nil)

// [3] 查看当前数据库key-val数量
127.0.0.1:6379> dbsize
(integer) 1

// [4] 清空数据库
flushdb  // 清空当前数据库
flushall // 清空所有数据库

2.3 string

string是redis最基本类型，二进制安全的，除了存储字符串外也可以存储图片数据
一个key对应一个val 类似于addr := "henan-loyang"
一个字符串最大为512M

set/get/del

// set不存在则创建，存在则为修改
127.0.0.1:6379> set addr henan-loyang
OK
127.0.0.1:6379> get addr
"henan-loyang"
127.0.0.1:6379> del addr
(integer) 1

// setex(set with expire)
// SETEX key seconds value
// 设置生存时间 seconds秒为单位  5秒后超时清除
127.0.0.1:6379> setex k1 5 newxhh
OK
127.0.0.1:6379> get k1
"newxhh"
127.0.0.1:6379> get k1
(nil)

// 同时设置和获取多个key-val
127.0.0.1:6379> mset k1 xhh k2 abc k3 mcy
OK
127.0.0.1:6379> mget k1 k2 k3
1) "xhh"
2) "abc"
3) "mcy"

2.4 hash

类似于:var user1 map[string]string
方便用于存储对象、结构变量

_op_ key field [field ...]

hset/hget/hgetall/hdel
hmset/hmget // 一次设置多个值
hlen // 统计hash有几个元素
hexists key field // 判断field是否存在

// [1] 存放name和age
127.0.0.1:6379[1]> hset user1 name "xhh"
(integer) 1
127.0.0.1:6379[1]> hset user1 age 18
(integer) 1

// [2] 获取name和age
127.0.0.1:6379[1]> hget user1 name
"xhh"
127.0.0.1:6379[1]> hget user1 age
"18"

// [获取多个]
127.0.0.1:6379[1]> hgetall user1
1) "name"
2) "xhh"
3) "age"
4) "18"

2.5 list

本质是链表，用法理解为栈
按照插入的顺序排序，可以头插和尾插（采用的是头插，遍历时刚好相反）

在这里插入图片描述

_op_ key field [field ...]

lpush/rpush // 左or右加入
lrange // 执行区间元素
lpop/rpop // 左or右出
del
llen // 返回链表的长度

// 插入city
127.0.0.1:6379> lpush city bj tj ly
(integer) 3
// 获取全部
127.0.0.1:6379> lrange city 0 -1
1) "ly"
2) "tj"
3) "bj"

2.6 set

无序集合，不能重复，底层HashTable

sadd
smembers // 获取全部
sismember // 判断是否是成员
srem // 删除成员

// 添加元素到集合emails
127.0.0.1:6379> sadd emails xhh@123 mcy@456
(integer) 2
// 获取集合内容
127.0.0.1:6379> smembers emails
1) "xhh@123"
2) "mcy@456"

2.7 Go操作Redis

【版本一】安装第三方开源redis库

在GOPATH路径下执行以下指令

# E:\ShareDir\Code\GoCode>
# 下载到src下面
go get github.com/garyburd/redigo/redis

【版本二】安装第三方开源redis库

把命令封装为函数

// v新版本
go get gopkg.in/redis.v4

import "gopkg.in/redis.v4"

写入和读取字符串

package main

import (
	"fmt"
	"github.com/garyburd/redigo/redis"
)

func main() {
	// 连接
	conn, err := redis.Dial("tcp", "localhost:6379")
	if err != nil{
		fmt.Printf("redis.Dial err: %s\n", err)
		return
	}
	// 延时关闭
	defer conn.Close()
	fmt.Printf("conn success conn type %T\n", conn) // *redis.conn

	// 写入字符串
	_, err = conn.Do("set", "k1", "xhhinfo")
	if err != nil{
		fmt.Printf("conn.Do err: %s\n", err)
		return
	}
	fmt.Printf("write success cli [set k1 xhhinfo]\n")

	// 读取字符串
	retStr, err := redis.String(conn.Do("get", "k1"))
	if err != nil{
		fmt.Printf("redis.String err: %s\n", err)
		return
	}
	fmt.Printf("read success cli [get k1]: %s\n", retStr)
}

批量操作多个

package main

import (
	"fmt"
	"github.com/garyburd/redigo/redis"
)

func main() {
	// 连接
	conn, err := redis.Dial("tcp", "localhost:6379")
	if err != nil{
		fmt.Printf("redis.Dial err: %s\n", err)
		return
	}
	// 延时关闭
	defer conn.Close()
	fmt.Printf("conn success conn type %T\n", conn) // *redis.conn

	// 写入字符串
	_, err = conn.Do("hmset", "person1", "name", "xhh", "age", "18")
	if err != nil{
		fmt.Printf("conn.Do err: %s\n", err)
		return
	}
	fmt.Printf("write success cli [hmset person1 name xhh age 18]\n")

	// 批量读取
	strs, err := redis.Strings(conn.Do("hmget", "person1", "name", "age"))
	if err != nil{
		fmt.Printf("redis.String err: %s\n", err)
		return
	}

	for idx, str := range strs{
		fmt.Printf("read success cli [hget person1 name age] line[%d]: %s\n", idx, str)
	}
}

/*
	conn success conn type *redis.conn
	write success cli [hmset person1 name xhh age 18]
	read success cli [hget person1 name age] line[0]: xhh
	read success cli [hget person1 name age] line[1]: 18
 */

2.8 连接池

package main

import (
	"fmt"
	"github.com/garyburd/redigo/redis"
)

// [1] 定义全局的连接池
var (
	pool *redis.Pool
)

// [2] 初始化连接池
func init()  {
	pool = &redis.Pool{
		MaxIdle:         8, // 最大空闲连接数
		MaxActive:       0, // 最懂连接数 0:无限
		IdleTimeout:     100, // 最大空闲时间
		Dial: func() (redis.Conn, error) {
			return redis.Dial("tcp", "localhost:6379")
		},
	}
}

func main() {
	// [3] 从连接池中取出连接
	conn := pool.Get()
	defer conn.Close() // 关闭连接，即放回连接池

	_, _ = conn.Do("set", "name", "xhh")
	str, _ := redis.String(conn.Do("get", "name"))

	fmt.Printf("read str: %s\n", str)

	// [x] 最终关闭连接池  关闭后就无法再取出连接
	pool.Close()
}