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
}
}
}
转载请注明出处哟~
https://www.cnblogs.com/lichengguo
