Golang语言系列-15-数据库

数据库

MySQL

连接数据库

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql" //这里只要导入即可，使用的是这个包的 init() 函数
)

/*
[Go语言操作MySQL]
Go语言中内置的database/sql包提供了保证SQL或类SQL数据库的泛用接口，并不提供具体的数据库驱动。
使用database/sql包时必须注入（至少）一个数据库驱动

下载数据库驱动
go get -u github.com/go-sql-driver/mysql
go get github.com/go-sql-driver/mysql
加-u和不加的区别
加上它可以利用网络来更新已有的代码包及其依赖包。
如果已经下载过一个代码包，但是这个代码包又有更新了，那么这时候可以直接用 -u 标记来更新本地的对应的代码包。
如果不加这个 -u 标记，执行 go get 一个已有的代码包，会发现命令什么都不执行。
只有加了 -u 标记，命令会去执行 git pull 命令拉取最新的代码包的最新版本，下载并安装
*/

func main() {
	// 1.拼接连接数据库的信息
	// 用户名:密码@tcp(ip:端口)/数据库的名字
	databaseInfo := "root:root123@tcp(192.168.3.121:3306)/sql_test"

	// 2.校验拼接信息格式是否正确，不会去校验数据库的账号密码是否正确
	db, err := sql.Open("mysql", databaseInfo)
	if err != nil {
		fmt.Printf("databaseInfo:%s invalid, err:%v\n", databaseInfo, err)
		return
	}

	// 3.连接数据库
	err = db.Ping() //尝试连接数据库
	if err != nil {
		fmt.Printf("Open %s failed, err:%v\n", databaseInfo, err)
		return
	}
	fmt.Println("connect database sucess!")
}

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
)

// 数据库连接对象可以在多个函数中使用

// 在全局中声明一个db变量，好让所有的函数都能调用
var db *sql.DB

// initDB 初始化连接
func initDB() (err error) {
	// 1.数据库信息
	databaseInfo := "root:root123@tcp(192.168.3.121:3306)/sql_test"
	// 2.校验
	db, err = sql.Open("mysql", databaseInfo)
	if err != nil {
		return
	}
	// 3.连接
	err = db.Ping()
	if err != nil {
		return
	}

	db.SetMaxOpenConns(10) //设置数据库连接池的最大连接数
	db.SetMaxIdleConns(5)  //设置空闲时间最大连接数

	return
}

func main() {
	// 初始化数据库连接
	err := initDB()
	if err != nil {
		fmt.Printf("init DB falied, err:%v\n", err)
		return
	}
	fmt.Println("connect database success!")
}

插入数据

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
)

// 在全局中声明一个db变量，好让所有的函数都能调用
var db *sql.DB

// initDB 初始化连接
func initDB() (err error) {
	// 1.数据库信息
	databaseInfo := "root:root123@tcp(192.168.3.121:3306)/sql_test"
	// 2.校验
	db, err = sql.Open("mysql", databaseInfo)
	if err != nil {
		return
	}
	// 3.连接
	err = db.Ping()
	if err != nil {
		return
	}
	db.SetMaxOpenConns(10) //设置数据库连接池的最大连接数
	db.SetMaxIdleConns(5)  //设置空闲时间最大连接数
	return
}

func main() {
	// 初始化数据库连接
	err := initDB()
	if err != nil {
		fmt.Printf("init DB falied, err:%v\n", err)
		return
	}
	fmt.Println("connect database success!")

	// 执行插入函数
	//insertNo1()
	//insertNo2("李四", 18)
	//insertNo2("王五", 90)
	//insertNo2("马六", 37)
	//insertNo2("马云", 58)
	//insertNo3()
}

//insertNo1 插入数据方法一
func insertNo1() {
	//1.写sql语句
	sqlStr := `insert into user(name, age) values("张三", 20)`
	//2.执行exec
	ret, err := db.Exec(sqlStr)
	if err != nil {
		fmt.Printf("insert failed, err:%v\n", err)
		return
	}
	//拿到插入的数据的在数据库表中的ID
	id, err := ret.LastInsertId()
	if err != nil {
		fmt.Printf("get id failed, err:%v\n", err)
		return
	}
	fmt.Printf("insert ID:%d\n", id)
	//拿到数据库中受影响的数据行数
	row, err := ret.RowsAffected()
	if err != nil {
		fmt.Printf("get RowsAffected failed, err:%v\n", err)
		return
	}
	fmt.Println("受影响的行数:", row)
}

//insertNo2 插入数据方法二
func insertNo2(name string, age int) {
	sqlStr := `insert into user(name, age) values(?, ?)`
	ret, err := db.Exec(sqlStr, name, age)
	if err != nil {
		fmt.Printf("insert failed, err:%v\n", err)
		return
	}
	//拿到插入的数据的在数据库表中的ID
	id, err := ret.LastInsertId()
	if err != nil {
		fmt.Printf("get id failed, err:%v\n", err)
		return
	}
	fmt.Printf("insert ID:%d\n", id)
	//拿到数据库中受影响的数据行数
	row, err := ret.RowsAffected()
	if err != nil {
		fmt.Printf("get RowsAffected failed, err:%v\n", err)
		return
	}
	fmt.Println("受影响的行数:", row)
}

/*
预处理插入多条数据 这种方式速度会快一点

普通SQL语句执行过程：
	客户端对SQL语句进行占位符替换得到完整的SQL语句
	客户端发送完整SQL语句到MySQL服务端
	MySQL服务端执行完整的SQL语句并将结果返回给客户端

预处理执行过程：
	把SQL语句分成两部分，命令部分与数据部分
	先把命令部分发送给MySQL服务端，MySQL服务端进行SQL预处理
	然后把数据部分发送给MySQL服务端，MySQL服务端对SQL语句进行占位符替换
	MySQL服务端执行完整的SQL语句并将结果返回给客户端

为什么要预处理？
	优化MySQL服务器重复执行SQL的方法，可以提升服务器性能，提前让服务器编译，一次编译多次执行，节省后续编译的成本。
	避免SQL注入问题。
*/
func insertNo3() {
	//1.拼写SQL语句
	sqlStr := `insert into user(name, age) values(?, ?)`
	//2.预处理SQL语句,发送到MySQL服务器
	stmt, err := db.Prepare(sqlStr)
	if err != nil {
		fmt.Printf("prepare failed, err:%v\n", err)
		return
	}
	//3.关闭连接，释放连接池的资源
	defer stmt.Close()
	//4.SQL数据
	var m = map[string]int{
		"六七强": 30,
		"王相机": 32,
		"天说":  72,
		"白慧姐": 40,
	}
	//5.发送数据到MySQL服务器
	for k, v := range m {
		stmt.Exec(k, v)
	}
}

删除数据

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
)

//在全局中声明一个db变量，好让所有的函数都能调用
var db *sql.DB

//initDB 初始化连接
func initDB() (err error) {
	//1.数据库信息
	databaseInfo := "root:root123@tcp(192.168.3.121:3306)/sql_test"
	//2.校验
	db, err = sql.Open("mysql", databaseInfo)
	if err != nil {
		return
	}
	//3.连接
	err = db.Ping()
	if err != nil {
		return
	}
	db.SetMaxOpenConns(10) //设置数据库连接池的最大连接数
	db.SetMaxIdleConns(5)  //设置空闲时间最大连接数
	return
}

//deleteRow 删除一行数据
func deleteRow(id int) {
	sqlStr := `delete from user where id=?`
	ret, err := db.Exec(sqlStr, id)
	if err != nil {
		fmt.Printf("delete id:%d failed, err:%v\n", id, err)
		return
	}
	//拿到被删除的行数
	n, err := ret.RowsAffected()
	if err != nil {
		fmt.Printf("get delete id failed, err:%v\n", err)
		return
	}
	fmt.Printf("delete %d row data sucess!\n", n)
}

func main() {
	//初始化数据库连接
	err := initDB()
	if err != nil {
		fmt.Printf("init DB falied, err:%v\n", err)
		return
	}
	fmt.Println("connect database success!")

	//删除一行
	deleteRow(15)
}

更新数据

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
)

// 在全局中声明一个db变量，好让所有的函数都能调用
var db *sql.DB

// initDB 初始化连接
func initDB() (err error) {
	//1.数据库信息
	databaseInfo := "root:root123@tcp(192.168.3.121:3306)/sql_test"
	//2.校验
	db, err = sql.Open("mysql", databaseInfo)
	if err != nil {
		return
	}
	//3.连接
	err = db.Ping()
	if err != nil {
		return
	}
	db.SetMaxOpenConns(10) //设置数据库连接池的最大连接数
	db.SetMaxIdleConns(5)  //设置空闲时间最大连接数
	return
}

// updateRow 修改一行数据
func updateRow(newAge int, id int) {
	sqlStr := `update user set age=? where id = ?`
	ret, err := db.Exec(sqlStr, newAge, id)
	if err != nil {
		fmt.Printf("update failed, err:%v\n", err)
		return
	}
	n, err := ret.RowsAffected() //获取受影响的行数
	if err != nil {
		fmt.Printf("get any rows failed, err:%v\n", err)
	}
	fmt.Printf("update %d rows data!\n", n)
}

func main() {
	//初始化数据库连接
	err := initDB()
	if err != nil {
		fmt.Printf("init DB falied, err:%v\n", err)
		return
	}
	fmt.Println("connect database success!")

	//修改一行
	updateRow(9000, 1)
}

查询数据

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
)

// 在全局中声明一个db变量，好让所有的函数都能调用
var db *sql.DB

// initDB 初始化连接
func initDB() (err error) {
	//1.数据库信息
	databaseInfo := "root:root123@tcp(192.168.3.121:3306)/sql_test"
	//2.校验
	db, err = sql.Open("mysql", databaseInfo)
	if err != nil {
		return
	}
	//3.连接
	err = db.Ping()
	if err != nil {
		return
	}
	db.SetMaxOpenConns(10) //设置数据库连接池的最大连接数
	db.SetMaxIdleConns(5)  //设置空闲时间最大连接数
	return
}

// 声明一个结构体，用来接收查询出来的数据
type user struct {
	id   int
	name string
	age  int
}

// queryOne 查看一行数据
func queryOne(id int) {
	var u1 user
	//1.写查询单条记录的sql语句
	sqlStr := `select id, name, age from user where id = ?`
	//2.执行并拿到结果
	//必须对db.QueryRow()调用Scan方法，因为该方法会释放数据库连接
	//Scan()从连接池里拿出一个连接出来去数据库查询数据
	db.QueryRow(sqlStr, id).Scan(&u1.id, &u1.name, &u1.age)
	//3.打印结果
	fmt.Printf("u1: %#v\n", u1)
}

// queryMore 查询多条数据
func queryMore(n int) (userInfo []user) {
	//1.sql语句
	sqlSstr := `select id, name, age from user where id > ?`
	//2.执行
	rows, err := db.Query(sqlSstr, n)
	if err != nil {
		fmt.Printf("exec %s query falied, err:%v\n", sqlSstr, err)
		return
	}
	//3.一定要关闭rows，节省数据库资源
	defer rows.Close()
	//4.循环读取数据
	for rows.Next() {
		var u1 user
		err := rows.Scan(&u1.id, &u1.name, &u1.age)
		if err != nil {
			fmt.Printf("Scan failed, err:%v\n", err)
			return
		}
		userInfo = append(userInfo, u1)
	}
	return userInfo
}

func main() {
	//初始化数据库连接
	err := initDB()
	if err != nil {
		fmt.Printf("init DB falied, err:%v\n", err)
		return
	}
	fmt.Println("connect database success!")

	//查1行
	queryOne(1)

	//查多行
	ret := queryMore(1)
	fmt.Printf("%#v\n", ret)
	fmt.Println(ret)
}

事务

/*
Go实现MySQL事务
事务：一个最小的不可再分的工作单元
通常一个事务对应一个完整的业务(例如银行账户转账业务，该业务就是一个最小的工作单元)，
同时这个完整的业务需要执行多次的DML(insert、update、delete)语句共同联合完成。
A转账给B，这里面就需要执行两次update操作

在MySQL中只有使用了Innodb数据库引擎的数据库或表才支持事务。
事务处理可以用来维护数据库的完整性，保证成批的SQL语句要么全部执行，要么全部不执行

通常事务必须满足4个条件（ACID）：
原子性（Atomicity，或称不可分割性）、
一致性（Consistency）、
隔离性（Isolation，又称独立性）、
持久性（Durability
*/

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
)

var db *sql.DB

// initDB 连接数据库
func initDB() (err error) {
	databaseInfo := "root:root123@tcp(192.168.3.121:3306)/sql_test"
	db, err = sql.Open("mysql", databaseInfo)
	if err != nil {
		return
	}
	err = db.Ping()
	if err != nil {
		return
	}
	db.SetMaxOpenConns(10)
	db.SetMaxIdleConns(5)
	return
}

// transactionDemo 事务提交
func transactionDemo() {
	// 1.开启事务
	tx, err := db.Begin()
	if err != nil {
		fmt.Printf("begin failed, err:%v\n", err)
		return
	}

	//2.执行多个sql操作
	sqlStr1 := `update user set age=age-2 where id = 1`
	sqlStr2 := `update user set age=age+2 where id = 2`

	//3.执行sqlStr1
	ret, err := tx.Exec(sqlStr1)
	if err != nil {
		//如果执行失败就回滚
		tx.Rollback()
		fmt.Println("执行SQL1出错了，已经回滚")
		return
	}
	n, err := ret.RowsAffected()
	if err != nil {
		//如果执行失败就回滚
		tx.Rollback()
		fmt.Println("get RowsAffected failed, err:", err)
		return
	}
	fmt.Printf("影响了%d行数据", n)

	//4.执行sqlStr2
	_, err = tx.Exec(sqlStr2)
	if err != nil {
		//如果执行失败就回滚
		tx.Rollback()
		fmt.Println("执行sqlStr2出错了，已经回滚")
		return
	}

	//5.上面两步sql都执行成功，那么就去提交
	err = tx.Commit()
	if err != nil {
		//提交失败 也要回滚
		tx.Rollback()
		fmt.Println("提交失败，回顾完成")
		return
	}
	fmt.Println("事务执行成功!")
}

func main() {
	err := initDB()
	if err != nil {
		fmt.Printf("connect database failed, err:%v\n", err)
		return
	}

	//调用事务执行函数
	transactionDemo()
}

sqlx库

/*
[sqlx库使用指南]

使用sqlx实现批量插入数据的例子，介绍了sqlx中可能被忽视了的 sqlx.In 和 DB.NamedExec 方法

sqlx可以认为是Go语言内置 database/sql 的超集
它在优秀的内置 database/sql 基础上提供了一组扩展
这些扩展中除了大家常用来查询的 Get 和 Select 外还有很多其他强大的功能

sqlx中的exec方法与原生sql中的exec使用基本一致，所以增删改应该跟原生的sql库差不多

安装方法:
	go get github.com/jmoiron/sqlx
*/

package main

import (
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	"github.com/jmoiron/sqlx"
)

var db *sqlx.DB

//initDB 初始化数据连接
func initDB() (err error) {
	//1.数据库连接信息
	//用户名:密码@tcp(IP:端口)/数据库名字
	databaseInfo := `root:root123@tcp(192.168.3.121:3306)/sql_test`

	//2.连接数据库
	db, err = sqlx.Connect("mysql", databaseInfo)
	if err != nil {
		return
	}

	//3.设置数据库连接池
	db.SetMaxOpenConns(10) //设置数据库连接池的最大连接数
	db.SetMaxIdleConns(5)  //设置最大空闲连接数
	return
}

//##########################################################################################################
//###################################### 查询 start #########################################################
//##########################################################################################################
type user struct {
	ID   int //注意这里的字段要大写，因为db.Get db.Select等用了反射
	Name string
	Age  int
}

//queryRowDemo 查询单条数据Get
func queryRowDemo(id int) {
	sqlStr := `select id, name, age from user where id = ?`

	var u user
	err := db.Get(&u, sqlStr, id)
	if err != nil {
		fmt.Printf("get failed, err:%v\n", err)
		return
	}
	fmt.Printf("%#v\n", u)
	fmt.Printf("id:%d name:%s age:%d\n", u.ID, u.Name, u.Age)
}

//queryMultiRowDemo 查询多行数据 Select
func queryMultiRowDemo(id int) {
	sqlStr := `select id, name, age from user where id > ?`

	var users []user
	err := db.Select(&users, sqlStr, id) //这个id是对应上面的 id > ? 中的问号
	if err != nil {
		fmt.Printf("select more rows failed, err:%v\n", err)
		return
	}

	//fmt.Printf("%#v\n", users)
	for _, v := range users {
		fmt.Printf("%#v\n", v)
	}
}

//##########################################################################################################
//###################################### 查询 end ###########################################################
//##########################################################################################################
//
//
//##########################################################################################################
//###################################### 插入 start #########################################################
//##########################################################################################################
//insertRowDemo 插入数据
func insertRowDemo() {
	sqlStr := `insert into user(name,age) values (?,?)`
	ret, err := db.Exec(sqlStr, "沙河娜扎", 99)
	if err != nil {
		fmt.Printf("insert failed, err:%v\n", err)
		return
	}
	theID, err := ret.LastInsertId() //新插入数据在数据库中的ID
	if err != nil {
		fmt.Printf("get lastinsertid failed, err:%v\n", err)
		return
	}
	fmt.Printf("insert sucess, the id is %d.\n", theID)

	theRow, err := ret.RowsAffected() //插入了多少行数据
	if err != nil {
		fmt.Printf("get rows failed, err:%v\n", err)
		return
	}
	fmt.Printf("插入了[%d]行数据\n", theRow)
}

//##########################################################################################################
//###################################### 插入 end #########################################################
//##########################################################################################################
//
//
//##########################################################################################################
//###################################### 更新 start #########################################################
//##########################################################################################################
//updateRowDemo 更新数据
func updateRowDemo() {
	sqlStr := `update user set age=? where id=?`

	ret, err := db.Exec(sqlStr, 10000, 1)
	if err != nil {
		fmt.Printf("update failed, err:%v\n", err)
		return
	}

	n, err := ret.RowsAffected() //操作影响了多少行
	if err != nil {
		fmt.Printf("get rowsaffected failed, err:%v\n", err)
		return
	}
	fmt.Printf("更新成功,影响了%d行数据\n", n)

}

//##########################################################################################################
//###################################### 更新 end ###########################################################
//##########################################################################################################
//
//
//##########################################################################################################
//###################################### 删除 start ########################################################
//##########################################################################################################
//deleteRowDemo 删除
func deleteRowDemo() {
	sqlStr := `delete from user where id = ?`

	ret, err := db.Exec(sqlStr, 12)
	if err != nil {
		fmt.Printf("delete failed, err:%v\n", err)
		return
	}

	n, err := ret.RowsAffected() //操作影响的行数
	if err != nil {
		fmt.Printf("get rows failed, err:%v\n", err)
		return
	}

	fmt.Printf("删除了%d行数据\n", n)
}

//##########################################################################################################
//###################################### 删除 end ###########################################################
//##########################################################################################################
//
//
func main() {
	//连接数据库初始化
	err := initDB()
	if err != nil {
		fmt.Printf("connect database failed, err:%v\n", err)
		return
	}

	//查询一条数据
	//queryRowDemo(2)

	//查询多条数据
	//queryMultiRowDemo(10)

	//插入一条数据
	//insertRowDemo()

	//更新一条数据
	//updateRowDemo()

	//删除了一行数据
	//deleteRowDemo()
}

sql注入

/*
[SQL注入问题]
我们任何时候都不应该自己拼接SQL语句！！！
*/

package main

import (
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	"github.com/jmoiron/sqlx"
)

//连接mysql
var db *sqlx.DB

func initDB() (err error) {
	databaseInfo := "root:root123@tcp(192.168.3.121:3306)/sql_test"
	db, err = sqlx.Connect("mysql", databaseInfo)
	if err != nil {
		return err
	}
	db.SetMaxOpenConns(20)
	db.SetMaxIdleConns(5)
	return err
}

//sql注入
type user struct {
	ID   int
	Name string
	Age  int
}

//SQL注入示例
func sqlInjectDemo(name string) {
	//自己拼接SQL语句
	//注意:我们任何时候都不应该自己拼接SQL语句！！！
	sqlStr := fmt.Sprintf("select id, name, age from user where name = '%s' ", name)
	fmt.Printf("SQL:%s\n", sqlStr)

	//可以使用这种方法防止SQL注入，或者使用之前预编译的方法 03mysql_insert_demo
	//sqlStr := "select id, name, age from user where name = ? "

	var users []user
	err := db.Select(&users, sqlStr)
	if err != nil {
		fmt.Printf("exec SQL failed, err:%v\n", err)
		return
	}

	for _, u := range users {
		fmt.Printf("user:%#v\n", u)
	}
}

func main() {
	err := initDB()
	if err != nil {
		fmt.Printf("connect databae failed, err:%v\n", err)
		return
	}

	//sql注入
	//sqlInjectDemo("王五") //客户端正常传入

	//sqlInjectDemo("xxx' or 1=1 #") //把数据库整个表查询出来了
	/*
		lichengguo@lichengguodeMacBook-Pro 09sql_injection_demo % ./09sql_injection_demo
		SQL:select id, name, age from user where name = 'xxx' or 1=1 #'
		user:main.user{ID:1, Name:"张三", Age:10000}
		user:main.user{ID:2, Name:"李四", Age:20}
		user:main.user{ID:3, Name:"王五", Age:90}
		user:main.user{ID:4, Name:"马六", Age:37}
		user:main.user{ID:5, Name:"马云", Age:58}
		user:main.user{ID:6, Name:"王相机", Age:32}
		user:main.user{ID:7, Name:"天说", Age:9000}
		user:main.user{ID:10, Name:"沙河小王子", Age:19}
		user:main.user{ID:11, Name:"沙河娜扎", Age:32}
	*/

	//sqlInjectDemo("xxx' union select * from user #")
	/*
		lichengguo@lichengguodeMacBook-Pro 09sql_injection_demo % ./09sql_injection_demo
		SQL:select id, name, age from user where name = 'xxx' union select * from user #'
		user:main.user{ID:1, Name:"张三", Age:10000}
		user:main.user{ID:2, Name:"李四", Age:20}
		user:main.user{ID:3, Name:"王五", Age:90}
		user:main.user{ID:4, Name:"马六", Age:37}
		user:main.user{ID:5, Name:"马云", Age:58}
		user:main.user{ID:6, Name:"王相机", Age:32}
		user:main.user{ID:7, Name:"天说", Age:9000}
		user:main.user{ID:10, Name:"沙河小王子", Age:19}
		user:main.user{ID:11, Name:"沙河娜扎", Age:32}
	*/
}

Redis

/*
安装: go get  github.com/go-redis/redis
*/

package main

import (
	"fmt"
	"github.com/go-redis/redis"
	"time"
)

//在全局中声明一个db变量，好让所有的函数都能调用
var rdb *redis.Client

//initClient 普通连接
func initClient() (err error) {
	//1.配置信息
	rdb = redis.NewClient(&redis.Options{
		Addr: "192.168.3.121:6379",
		DB:   0,
	})
	//2.尝试连接
	str, err := rdb.Ping().Result()
	if err != nil {
		return err
	}
	fmt.Println("str:", str) //str: PONG
	return
}

/*
连接Redis哨兵模式
var rdb *redis.Client

func initClient()(err error){
	rdb := redis.NewFailoverClient(&redis.FailoverOptions{
		MasterName:    "master",
		SentinelAddrs: []string{"x.x.x.x:26379", "xx.xx.xx.xx:26379", "xxx.xxx.xxx.xxx:26379"},
	})
	_, err = rdb.Ping().Result()
	if err != nil {
		return err
	}
	return nil
}
*/

/*
连接Redis集群
var rdb *redis.Client

func initClient()(err error){
	rdb := redis.NewClusterClient(&redis.ClusterOptions{
		Addrs: []string{":7000", ":7001", ":7002", ":7003", ":7004", ":7005"},
	})
	_, err = rdb.Ping().Result()
	if err != nil {
		return err
	}
	return nil
}

*/

//set/get示例 redisExample
func redisExample() {
	//1.插入值
	err := rdb.Set("score", 100, 0).Err() //set(key,values,失效时间 0表示永不失效)
	if err != nil {
		fmt.Printf("set score failed, err:%v\n", err)
		return
	}
	//2.取值
	//可以取到值的情况
	val, err := rdb.Get("score").Result()
	if err != nil {
		fmt.Printf("get score value failed, err:%v\n", err)
		return
	}
	fmt.Println("keys:score , val:", val)

	//键值对不存在或者值为nil的情况
	val2, err := rdb.Get("name").Result()
	if err == redis.Nil {
		fmt.Println("name does not exist")
	} else if err != nil {
		fmt.Printf("get name failed, err:%v\n", err)
		return
	} else {
		fmt.Println("keys: name val: ", val2)
	}
}

//zset示例
func redisExample2() {
	zsetKey := "language_rank"
	languages := []redis.Z{
		redis.Z{Score: 90.0, Member: "Golang"}, //Socre:相当于值 Member:相当于键
		redis.Z{Score: 98.0, Member: "Java"},
		redis.Z{Score: 95.0, Member: "Python"},
		redis.Z{Score: 97.0, Member: "JavaScript"},
		redis.Z{Score: 99.0, Member: "C/C++"},
	}

	//zadd
	num, err := rdb.ZAdd(zsetKey, languages...).Result()
	if err != nil {
		fmt.Printf("zadd failed, err:%v\n", err)
		return
	}
	fmt.Printf("zadd %d success!\n", num)

	//把Golang的分数加10
	newScore, err := rdb.ZIncrBy(zsetKey, 10.0, "Golang").Result()
	if err != nil {
		fmt.Printf("zincrby failed, err:%v\n", err)
		return
	}
	fmt.Printf("Golang's score is %f now.\n", newScore)

	//取分数最高的3个
	ret, err := rdb.ZRevRangeWithScores(zsetKey, 0, 2).Result()
	if err != nil {
		return
	}
	for _, z := range ret {
		fmt.Println(z)
	}

	//取95-100分的
	op := redis.ZRangeBy{
		Min: "95",
		Max: "100",
	}
	ret, err = rdb.ZRangeByScoreWithScores(zsetKey, op).Result()
	if err != nil {
		fmt.Printf("zrangebyscore failed, err:%v\n", err)
		return
	}
	for _, z := range ret {
		fmt.Println(z.Member, z.Score)
	}
}

//inserRedis1W 测试redis
func inserRedis1W() {
	startTime := time.Now().Unix()
	for i := 0; i < 10000; i++ {
		keyName := fmt.Sprintf("name%00000d", i)
		err := rdb.Set(keyName, "我是很占内存的一串字符串!!!!!!", time.Second*60).Err() //设置了key过期的时间
		if err != nil {
			fmt.Printf("insert failed, err:%v\n", err)
			return
		}
	}
	fmt.Printf("耗时:%v\n", time.Now().Unix()-startTime) //耗时:41
}

/*
pipLine 测试
Pipeline 主要是一种网络优化。它本质上意味着客户端缓冲一堆命令并一次性将它们发送到服务器。
这些命令不能保证在事务中执行。这样做的好处是节省了每个命令的网络往返时间（RTT）
*/
func pipLine() {
	startTime := time.Now().Unix()

	pipe := rdb.Pipeline()

	for i := 0; i < 10000; i++ {
		keyName := fmt.Sprintf("name%00000d", i)
		pipe.Set(keyName, "我是很占内存的一串字符串!!!!!!", time.Second*60)
	}

	pipe.Exec()

	fmt.Printf("耗时:%v\n", time.Now().Unix()-startTime) //耗时:0
}

func main() {
	err := initClient()
	if err != nil {
		fmt.Printf("connect redis server failed, err:%v\n", err)
		return
	}
	fmt.Println("redis connect sucess!")

	//set/get示例
	redisExample()

	//zadd
	//redisExample2()

	//测试插入1万键值对
	//inserRedis1W()

	//pipLine 测试
	//pipLine()

}

/*
192.168.3.121:6379> zrange language_rank 0 100
1) "Golang"
2) "Python"
3) "JavaScript"
4) "Java"
5) "C/C++"

192.168.3.121:6379> zrange language_rank 0 100 withscores
 1) "Golang"
 2) "90"
 3) "Python"
 4) "95"
 5) "JavaScript"
 6) "97"
 7) "Java"
 8) "98"
 9) "C/C++"
10) "99"
*/

消息队列NSQ

简介

github下载地址: https://github.com/nsqio/nsq/releases/tag/v1.2.0

简介
NSQ是目前比较流行的一个分布式的消息队列，本文主要介绍了NSQ及Go语言如何操作NSQ。

NSQ是Go语言编写的一个开源的实时分布式内存消息队列，其性能十分优异。 NSQ的优势：
    NSQ提倡分布式和分散的拓扑，没有单点故障，支持容错和高可用性，并提供可靠的消息交付保证
    NSQ支持横向扩展，没有任何集中式代理。
    NSQ易于配置和部署，并且内置了管理界面

NSQ组件
1.nsqd: nsqd是一个守护进程，它接收、排队并向客户端发送消息
启动nsqd，指定-broadcast-address=127.0.0.1来配置广播地址
./nsqd -broadcast-address=127.0.0.1

如果是在搭配nsqlookupd使用的模式下需要还指定nsqlookupd地址:
./nsqd -broadcast-address=127.0.0.1 -lookupd-tcp-address=127.0.0.1:4160
如果是部署了多个nsqlookupd节点的集群，那还可以指定多个-lookupd-tcp-address

2.nsqlookupd
nsqlookupd是维护所有nsqd状态、提供服务发现的守护进程。它能为消费者查找特定topic下的nsqd提供了运行时的自动发现服务。
它不维持持久状态，也不需要与任何其他nsqlookupd实例协调以满足查询。
因此根据你系统的冗余要求尽可能多地部署nsqlookupd节点。
它们小豪的资源很少，可以与其他服务共存。我们的建议是为每个数据中心运行至少3个集群

3.nsqadmin
一个实时监控集群状态、执行各种管理任务的Web管理平台。 启动nsqadmin，指定nsqlookupd地址
./nsqadmin -lookupd-http-address=127.0.0.1:4161
我们可以使用浏览器打开http://127.0.0.1:4171/访问如下管理界面

目录结构

├── README.md
├── consumer
│   └── main.go
└── producer
    └── main.go

consumer/main.go 文件

// nsq_consumer/main.go
package main

import (
	"fmt"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/nsqio/go-nsq"
)

// NSQ Consumer Demo

// MyHandler 是一个消费者类型
type MyHandler struct {
	Title string
}

// HandleMessage 是需要实现的处理消息的方法
func (m *MyHandler) HandleMessage(msg *nsq.Message) (err error) {
	fmt.Printf("%s recv from %v, msg:%v\n", m.Title, msg.NSQDAddress, string(msg.Body))
	return
}

// 初始化消费者
func initConsumer(topic string, channel string, address string) (err error) {
	config := nsq.NewConfig()
	config.LookupdPollInterval = 15 * time.Second
	c, err := nsq.NewConsumer(topic, channel, config)
	if err != nil {
		fmt.Printf("create consumer failed, err:%v\n", err)
		return
	}
	consumer := &MyHandler{
		Title: "dsb1号",
	}
	c.AddHandler(consumer)

	//if err := c.ConnectToNSQD(address); err != nil { // 直接连NSQD
	if err := c.ConnectToNSQLookupd(address); err != nil { // 通过lookupd查询
		return err
	}
	return nil

}

func main() {
	err := initConsumer("topic_demo", "first", "127.0.0.1:4161")
	if err != nil {
		fmt.Printf("init consumer failed, err:%v\n", err)
		return
	}
	c := make(chan os.Signal)        // 定义一个信号的通道
	signal.Notify(c, syscall.SIGINT) // 转发键盘中断信号到c
	<-c                              // 阻塞
}

producer/main.go文件

// nsq_producer/main.go
package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"

	"github.com/nsqio/go-nsq"
)

// NSQ Producer Demo 生产者

var producer *nsq.Producer

// 初始化生产者
func initProducer(str string) (err error) {
	config := nsq.NewConfig()
	producer, err = nsq.NewProducer(str, config)
	if err != nil {
		fmt.Printf("create producer failed, err:%v\n", err)
		return err
	}
	return nil
}

func main() {
	nsqAddress := "127.0.0.1:4150"
	err := initProducer(nsqAddress)
	if err != nil {
		fmt.Printf("init producer failed, err:%v\n", err)
		return
	}

	reader := bufio.NewReader(os.Stdin) // 从标准输入读取
	for {
		data, err := reader.ReadString('\n')
		if err != nil {
			fmt.Printf("read string from stdin failed, err:%v\n", err)
			continue
		}
		data = strings.TrimSpace(data)
		if strings.ToUpper(data) == "Q" { // 输入Q退出
			break
		}
		// 向 'topic_demo' publish 数据
		err = producer.Publish("topic_demo", []byte(data))
		if err != nil {
			fmt.Printf("publish msg to nsq failed, err:%v\n", err)
			continue
		}
	}
}