oqqyx1234567

《Go Web编程实战派——从入门到精通》学习笔记之第4章用Go访问数据库

第4章用Go访问数据库
- 4.1 MySQL的安装与使用
- - 4.1.1 MySQL简介
  - 4.1.2 MySQL安装
  - 4.1.3 MySQL基础入门
  - 4.1.4 Go访问MySQL
- 4.2 Redis的安装及使用
- - 4.2.1 Redis的安装
  - 4.2.2 Redis基础入门
  - 4.2.3 Go访问Redis
- 4.3 MongoDB的安装及使用
- - 4.3.1 MongoDB的安装
  - 4.3.2 MongoDB基础入门
  - 4.3.3 Go访问MongoDB
- 4.4 Go的常见ORM库
- - 4.4.1 什么是ORM
  - 4.4.2 Gorm的安装及使用
  - 4.4.3 Beego ORM
- 4.5 SQLite的安装及使用
- - 4.5.1 SQLite的安装
  - 4.5.2 SQLite基础入门
  - 4.5.3 Go访问SQLite

第4章用Go访问数据库

4.1 MySQL的安装与使用

4.1.1 MySQL简介

RDBMS(Relational Database Management System，关系型数据库管理系统)。

4.1.2 MySQL安装

下载地址：https://dev.mysql.com/downloads/mysql/

（1）删除所有文件和目录，只留下bin目录和share目录。

（2）管理员身份运行CMD，切换到mysql\bin目录，初始化数据库mysqld --initialize --console，执行完成后，会输出 root 用户的初始默认密码，会出现data目录。

（3）安装mysqld install（默认名字mysql）或mysqld --install gomysql，gomysql是自己起的数据库服务名字

（4）启动服务net start mysql(gomysql)

（5）登录验证mysql -u root -p，输入root 用户的初始默认密码

（6）修改密码alter user 'root'@'localhost' identified by 'root';，并退出exti;

（7）停止服务net stop mysql(gomysql)

（8）卸载mysqld remove或mysqld --remove gomysql

（9）利用配置文件my.ini（根目录）登录，mysql
简单版本

[mysqld]
port=3306
basedir=D:\\soft\\mysql-8.0.26-winx64
max_connections=200
max_connect_errors=10
character-set-server=utf8mb4
default-storage-engine=INNODB
#default_authentication_plugin=mysql_native_password

[mysql]
default-character-set=utf8mb4

[client]
default-character-set=utf8mb4
port=3306
user=root
password=root

[mysqld]
#设置时区为东八区，此项设置后，在连接MySQL的时候可以不用每次都手动设置时区
#default-time-zone = '+8:00'
#解决导入脚本是function报错
#log_bin_trust_function_creators=1
# 设置3306端口
port=3306
# 设置mysql的安装目录
basedir=D:\\soft\\mysql-8.0.26-winx64
# 设置 mysql数据库的数据的存放目录，MySQL 8+ 不需要以下配置，系统自己生成即可，否则有可能报错
#datadir=D:\soft\mysql-8.0.26-winx64\data
# 允许最大连接数
max_connections=200
# 允许连接失败的次数。
max_connect_errors=10
# 服务端使用的字符集默认为utf8
character-set-server=utf8mb4
# 创建新表时将使用的默认存储引擎
default-storage-engine=INNODB
# 默认使用“mysql_native_password”插件认证
#default_authentication_plugin=mysql_native_password

[mysql]
# 设置mysql客户端默认字符集
default-character-set=utf8mb4

[client]
# 设置mysql客户端连接服务端时默认使用的端口
# 设置mysql客户端默认字符集
default-character-set=utf8mb4
## mysql -hlocalhost -uroot -P3306 -p
port=3306
user=root
password=root

4.1.3 MySQL基础入门

数据库管理

#创建数据库
CREATE DATABASE database_name;

#选择数据库
USE database_name;

#查看数据库
SHOW DATABASES [LIKE 'database_name'];

#修改数据库数据库使用的字符集和校对规则
ALTER DATABASE [数据库名] { 
	[DEFAULT] CHARACTER SET <字符集名> |
	[DEFAULT] COLLATE <校对规则名>
}
ALTER DATABASES test DEFAULTCHARACTER SET gb2312 COLLATE gb2312_chinese_ci;

#删除数据库
DROP DATABASE [IF EXISTS] database_name;

数据表操作

#查看数据表
show tables;#查看数据库中所有表
DESC[RIBE] user;	#表格信息展示表的字段信息
SHOW CREATE TABLE user;	#以SQL语句形式展示表信息
select * form user; #查看表内容

#创建数据表
CREATE TABLE <表名> (<列名1><类型1>[, ...]<列名n><类型n>)[表选项][分区选项];
CREATE TABLE IF NOT EXISTS `runoob_tbl` (
   `runoob_id` INT UNSIGNED AUTO_INCREMENT,
   `runoob_title` VARCHAR(100) NOT NULL,
   `runoob_author` VARCHAR(40) NOT NULL,
   `submission_date` DATE,
   PRIMARY KEY ( `runoob_id` )
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE 'user' (
	`id` int(11) NOT NULL AUTO INCREMENT, 
	`phone` varchar(30) DEFAULT '' COMMENT '手机号', 
	`password` varchar(80) DEFAULT '' COMMENT '密码', 
	`add_time` int(10) DEFAULT '0' COMMENT '添加时间', 
	`last_ip` varchar(50) DEFAULT '' COMMENT '最近ip', 
	`email` varchar(50) DEFAULT '' COMMENT '邮编', 
	`status` tinyint(4) DEFAULT '0' COMMENT '状态', 
	PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

#修改数据表
ALTER TABLE <表名> [修改选项]
#修改选项
ADD <列名> <类型> #增加新列
DROP COLUNM <列名> #删除旧列
CHANGE COLUMN <旧列名> <新列名> <新列类型>
ALTER COLUMN <列名> {SET DEFAULT <默认值>| DROP DEFAULT} 
MODIFY COLUMN <列名> <类型>
RENAME [TO] <新表名> 
CHARACTER SET <字符集名>
COLLATE <校对规则名>

ALTER TABLE user ADD username varchar(30) DEFAULT '' NULL;
ALTER TABLE user RENAME TO user_new;
ALTER TABLE user_new [DEFAULT] CHARACTER SET gb2312 [DEFAULT] COLLATE gb2312_chinese_ci;

#删除数据表
DROP TABLE [IF EXISTS] 表1 [, 表2, 表3 ...]
DROP TABLE user_new;

数据库语句

#插入数据
INSERT [INTO] 表名 [(列名1，列名2，...)] VALUES (值1，值2，...);
INSERT INTO `user` (`phone`, `password`, `add_time`, `last_ip`, `email`, `status`) VALUES ('138888888', DEFAULT, DEFAULT, '123.55.66.3', 'test@163.com', 1);

#查询数据
SELECT 列名称 FROM 表名称 [查询条件];
SELECT `phone`, `email` FROM user LIMIT 501;
SELECT * FROM user;
SELECT `phone`, `email` FROM user WHERE `status`>0;

#更新数据
UPDATE 表名称 SET 列名称=新值 WHERE更新条件;
UPDATE `user` SET `phone`='1888888' WHERE `id`=4;

#删除数据
DELETE FROM 表名称 WHERE删除条件;
DELETE FROM `user` WHERE `id`=4;
DELETE FROM `user` WHERE `status`<4;
DELETE FROM `user`;

4.1.4 Go访问MySQL

mysql –uroot –p123456 -Dtest<C:\test.sql
source C:\test.sql

创建数据库和数据表

CREATE DATABASE IF NOT EXISTS chapter4;

USE chapter4;

CREATE TABLE IF NOT EXISTS `user` (
	`uid` BIGINT(20) NOT NULL AUTO_INCREMENT,
	`name` VARCHAR(20) DEFAULT '',
	`phone` VARCHAR(20) DEFAULT '',
	PRIMARY KEY(`uid`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;

INSERT INTO `user` (`name`, `phone`) VALUES ('yx', '138888888');
INSERT INTO `user` (`uid`, `name`, `phone`) VALUES (111, 'yx', '138888888');

连接数据库

package main

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

func main() {
	db, err := sql.Open("mysql",
		"root:root@tcp(127.0.0.1:3306)/chapter4")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()
}

初始化连接

package main

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

var db *sql.DB

// 定义一个初始化数据库的函数
func initDB() (err error) {
	//连接数据库
	db, err = sql.Open("mysql", "root:root@tcp(127.0.0.1:3306)/chapter4")
	if err != nil {
		return err
	}
	// 尝试与数据库建立连接（校验dsn是否正确）
	err = db.Ping()
	if err != nil {
		return err
	}
	return nil
}

func main() {
	if err := initDB(); err != nil {
		fmt.Printf("init db failed, err: %v\n", err)
	}
}

设置最大连接数
n<=0，无限制，默认0。
不会超过数据库默认配置。

func (db *DB) SetMaxOpenConns(n int)

设置最大闲置连接数
n<=0，无限制，默认0。
不会超过数据库默认配置。

func (db *DB) SetMaxOpenConns(n int)

SQL查询

QueryRow()单行查询

func (db *DB) QueryRow(query string, args ...interface{}) *Row

package main

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

var db *sql.DB

// 定义一个初始化数据库的函数
func initDB() (err error) {
	//连接数据库
	db, err = sql.Open("mysql", "root:root@tcp(127.0.0.1:3306)/chapter4")
	if err != nil {
		return err
	}
	// 尝试与数据库建立连接（校验dsn是否正确）
	err = db.Ping()
	if err != nil {
		return err
	}
	return nil
}

type User struct {
	Uid int
	Name string
	Phone string
}

func queryRow() {
	var u User;
	if err := db.QueryRow("select uid, name, phone from user where uid=?;", 1).Scan(&u.Uid, &u.Name, &u.Phone); err != nil {
		fmt.Printf("scan failed, err:%v\n", err)
		return
	}
	fmt.Printf("uid:%d name:%s phone:%s\n", u.Uid, u.Name, u.Phone)
}

func main() {
	if err := initDB(); err != nil {
		fmt.Printf("init db failed, err: %v\n", err)
	}
	queryRow()
}

Query()多行查询

func (db *DB) Query(query string, args ...interface{}) (*Rows, error)

package main

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

var db *sql.DB

// 定义一个初始化数据库的函数
func initDB() (err error) {
	//连接数据库
	db, err = sql.Open("mysql", "root:root@tcp(127.0.0.1:3306)/chapter4")
	if err != nil {
		return err
	}
	// 尝试与数据库建立连接（校验dsn是否正确）
	err = db.Ping()
	if err != nil {
		return err
	}
	return nil
}

type User struct {
	Uid int
	Name string
	Phone string
}

func queryMultiRow() {
	var u User;
	rows, err := db.Query("select uid, name, phone from user where uid>?;", 0)
	if err != nil {
		fmt.Printf("query failed, err:%v\n", err)
		return
	}
	defer rows.Close()

	for rows.Next() {
		err := rows.Scan(&u.Uid, &u.Name, &u.Phone)
		if err != nil {
			fmt.Printf("scan failed, err:%v\n", err)
			return
		}
		fmt.Printf("uid:%d name:%s phone:%s\n", u.Uid, u.Name, u.Phone)
	}
}

func main() {
	if err := initDB(); err != nil {
		fmt.Printf("init db failed, err: %v\n", err)
	}
	queryMultiRow()
}

Exec()执行一次命令（查询、删除、更新、插入等）

func (db *DB) Exec(query string, args ...interface{}) (Result, error)
插入数据

package main

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

var db *sql.DB

// 定义一个初始化数据库的函数
func initDB() (err error) {
	//连接数据库
	db, err = sql.Open("mysql", "root:root@tcp(127.0.0.1:3306)/chapter4")
	if err != nil {
		return err
	}
	// 尝试与数据库建立连接（校验dsn是否正确）
	err = db.Ping()
	if err != nil {
		return err
	}
	return nil
}

func insertRow() {
	ret, err := db.Exec("insert into user(name, phone) values(?, ?);", "ml", "15906693677")
	if err != nil {
		fmt.Printf("insert failed, err:%v\n", err)
		return
	}
	
	uid, err := ret.LastInsertId()
	if err != nil {
		fmt.Printf("get lastinsert ID failed, err:%v\n", err)
		return
	}
	fmt.Printf("insert success, the id is %d.\n", uid)
	
}

func main() {
	if err := initDB(); err != nil {
		fmt.Printf("init db failed, err: %v\n", err)
	}
	insertRow()
}

更新数据

package main

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

var db *sql.DB

// 定义一个初始化数据库的函数
func initDB() (err error) {
	//连接数据库
	db, err = sql.Open("mysql", "root:root@tcp(127.0.0.1:3306)/chapter4")
	if err != nil {
		return err
	}
	// 尝试与数据库建立连接（校验dsn是否正确）
	err = db.Ping()
	if err != nil {
		return err
	}
	return nil
}

func updateRow() {
	ret, err := db.Exec("update user set name=? where uid=?;", "tt", 1)
	if err != nil {
		fmt.Printf("update failed, err:%v\n", err)
		return
	}
	
	n, err := ret.RowsAffected()
	if err != nil {
		fmt.Printf("get lastinsert ID failed, err:%v\n", err)
		return
	}
	fmt.Printf("update success, affected rows:%d\n", n)
}

func main() {
	if err := initDB(); err != nil {
		fmt.Printf("init db failed, err: %v\n", err)
	}
	updateRow()
}

删除数据

package main

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

var db *sql.DB

// 定义一个初始化数据库的函数
func initDB() (err error) {
	//连接数据库
	db, err = sql.Open("mysql", "root:root@tcp(127.0.0.1:3306)/chapter4")
	if err != nil {
		return err
	}
	// 尝试与数据库建立连接（校验dsn是否正确）
	err = db.Ping()
	if err != nil {
		return err
	}
	return nil
}

func deleteRow() {
	ret, err := db.Exec("delete from user where uid=?;", 2)
	if err != nil {
		fmt.Printf("delete failed, err:%v\n", err)
		return
	}
	
	n, err := ret.RowsAffected()
	if err != nil {
		fmt.Printf("get lastinsert ID failed, err:%v\n", err)
		return
	}
	fmt.Printf("update success, affected rows:%d\n", n)
}

func main() {
	if err := initDB(); err != nil {
		fmt.Printf("init db failed, err: %v\n", err)
	}
	deleteRow()
}

SQL执行过程：

客户端对SQL语句进行占位符替换，得到完整SQL语句；
客户端发送完整SQL语句到MySQL服务器端；
MySQL服务器端执行完整SQL语句，结果返回给客户端

预处理执行过程：

将SQL语句分为命令部分和数据部分；
命令部分发送给MySQL服务器端，MySQL服务器端执行SQL预处理；
数据部分发送给MySQL服务器端，MySQL服务器端对SQL语句进行占位符替换；
MySQL服务器端执行完整SQL语句，结果返回给客户端。

预处理优化MySQL服务器重复执行SQL语句的问题，提升性能。提前让服务器编译，一次编译多次执行。

MySQL预处理
func (db *DB) Prepare(query string) (*Stmt, error)

func prepareQuery() {
	stmt, err := db.Prepare("select uid, name, phone from `user` where uid > ?;")
	if err != nil {
		fmt.Printf("prepare failed, err:%v\n", err)
		return
	}
	defer stmt.Close()
	
	rows, err := stmt.Query(0)
	if err != nil {
		fmt.Printf("query failed, err:%v\n", err)
		return
	}
	defer rows.Close()
	
	// 循环读取结果集中的数据
	for rows.Next() {
		err := rows.Scan(&u.Uid, &u.Name, &u.Phone)
		if err != nil {
			fmt.Printf("scan failed, err:%v\n", err)
			return
		}
		fmt.Printf("uid:%d name:%s phone:%s\n", u.Uid, u.Name, u.Phone)
	}
}

func prepareInsert() {
	stmt, err := db.Prepare("insert into user(username, phone) values (?, ?);")
	if err != nil {
		fmt.Printf("prepare failed, err:%v\n", err)
		return
	}
	defer stmt.Close()
	
	_, err = stmt.Exec("barry", "18799887766")
	if err != nil {
		fmt.Printf("insert failed, err:%v\n", err)
		return
	}
	_, err = stmt.Exec("jim", "18988888888")
	if err != nil {
		fmt.Printf("insert failed, err:%v\n", err)
		return
	}
	fmt.Println("insert success.")
}

事务是一个最小的、不可再分的工作单位，对应一个完整业务，需多次执行DML（INSERT，UPDATE，DELETE等）语句。事务处理用来维护数据库的完整性，成批SQL语句要么都执行，要么不执行。

事务的ACID属性

属性	解释
原子性（Atomicity，不可分割性）	事务的所有操作要么全部完成，要么不执行。若执行错误，会被回滚（Rollback）到之前状态。
一致性（Consistency）	事务执行前后，未破坏数据库的完整性。
隔离性（Isolation，独立性）	允许多个事务同时读写数据。避免多个事务交叉执行导致数据不一致。分为不同级别，读未提交（read uncommitted）、读提交（read committed）、可重复读（repeatable）和串行化（serializable）。
持久性（Durability）	事务处理结束，对数据的修改是永久的。

开始事务
func (db *DB) Begin() (*Tx, error)
提交事务
func (tx *Tx) Commit() error
回滚事务
func (tx *Tx) Rollback() error

func transaction() {
	tx, err := db.Begin() // 开启事务
	if err != nil {
		if tx != nil {
			tx.Rollback() // 回滚
		}
		fmt.Printf("begin trans failed, err:%v\n", err)
		return
	}
	_, err = tx.Exec("update user set username='james' where uid=?", 1)
	if err != nil {
		tx.Rollback() // 回滚
		fmt.Printf("exec sql1 failed, err:%v\n", err)
		return
	}
	_, err = tx.Exec("update user set username='james' where uid=?", 3)
	if err != nil {
		tx.Rollback() // 回滚
		fmt.Printf("exec sql2 failed, err:%v\n", err)
		return
	}
	err = tx.Commit() // 提交事务
	if err != nil {
		tx.Rollback() // 回滚
		fmt.Printf("commit failed, err:%v\n", err)
		return
	}
	fmt.Println("exec transaction success!")
}

SQL注入指，通过执行恶意SQL语句，将SQL代码插入数据库查询中，控制数据库服务器。使用SQL注入漏洞绕过应用程序验证（登录验证，身份验证和授权）；绕过网页，获取数据库内容；恶意修改、删除和增加数据库内容。

sqlInject("xxx' or 1=1#")
sqlInject("xxx' union select * from user #")
sqlInject("xxx' and (select count(-) from user) <10 #")

func sqlInject(name string) {
	sqlStr := fmt.Sprintf("select uid, name, phone from user where name='%s'", name)
	fmt.Printf("SQL:%s\n", sqlStr)
	ret, err := db.Exec(sqlStr)
	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("get success, affected rows:%d\n", n)
}

SQL防御措施：

禁止变量直接写入SQL语句。
用户分级管理，控制用户权限。
检查用户输入，转换或过滤单引号、双引号、冒号等字符。
加密数据库信息。

4.2 Redis的安装及使用

Redis是一个开源、ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value型数据库。数据结构服务器，可用于缓存、事件发布或订阅、高速队列等场景。

4.2.1 Redis的安装

下载地址：https://github.com/tporadowski/redis/releases

redis-server.exe redis.windows.conf

redis-cli.exe -h 127.0.0.1 -p 6379

4.2.2 Redis基础入门

字符串（String）

Key和Value组成。类比变量。

keys *	//查看所有key

set key value	//创建
set abc " a b c"

get key	//读取key，不存在返回nil

set key new_value	//不存在创建，存在则修改

set key value NX	//不存在创建，存在则返回nil

append key value	//不存在创建，存在则拼接字符串，返回len(拼接后字符串)

//key对应string非数字，报错
incr key	//数字value+1

decr key	//数字value-1

incrby key n	//数字value+n

decrby key n	//数字value-n

del key	//删除，存在返回1，不存在返回0

哈希（Hash）

Key，Field和Value组成。类比结构体。

hset key field value	//添加1个键值对
hmset key field1 value1 [field2 value2]	//添加多个键值对
hsetnx key field value	//已存在字段则不修改

hget key field 	//获得1个字段值
hmget key field1 [field2]	//获得多个字段值
hgetall key 	//获得所有字段名和值
HEXISTS key field	//字段存在返回1，不存在返回0
hlen key 	//获得字段数量

列表（List）

类比管道。

lpush key value	//左边插入值
rpush key value	//右边插入值

llen key 	//获得列表长度

lrange key 开始索引 结束索引	//0最左边数据，-1最右边数据

lpop key	//弹出最左边数据
rpop key	//弹出最右边数据

集合（Set）

数据无序，不重复。

sadd key value1 value2 ***	//添加set元素

scard key	//返回集合中元素数量

smembers key	//返回集合中所有元素

有序集合（Sorted Sets）

集合中的数据有序。关联double类型分数。元素不能重复，分数可以重复。

zadd key score1 member1 [score2 member2]	//添加数据

zadd key NX score member	//不存在则修改数据，存在则不修改

//按分数值递增获取分数区间[min max]的数据
zrangebyscore key min max [WITHSCORES] [LIMIT offset count]

//指定成员排名，分数递增
zrank key member

zscore key member	//获取成员分数，不是成员或key不存在返回nil

zcount key min max 	//获取指定分数区间，成员个数

4.2.3 Go访问Redis

Redis连接

package main

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

func main() {
	conn, err := redis.Dial("tcp", "localhost:6379")
	if err != nil {
		fmt.Println("conn redis failed, err:", err)
		return
	}
	defer conn.Close()
}

Redis设置和获取字符串

package main

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

func main() {
	conn, err := redis.Dial("tcp", "localhost:6379")
	if err != nil {
		fmt.Println("conn redis failed, err:", err)
		return
	}
	defer conn.Close()
	
	res, err := conn.Do("Set", "username", "jack");
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(res)

	res, err = redis.String(conn.Do("Get", "username"))
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(res)
}

Redis批量设置和获取字符串

package main

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

func main() {
	conn, err := redis.Dial("tcp", "localhost:6379")
	if err != nil {
		fmt.Println("conn redis failed, err:", err)
		return
	}
	defer conn.Close()
	
	res, err := conn.Do("MSet", "username", "jack", "phone", "123456789")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(res)
	
	res2, err := redis.Strings(conn.Do("MGet", "username", "phone"))
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("%T\n", res2)
	fmt.Println(res2)

Redis hash操作

package main

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

func main() {
	conn, err := redis.Dial("tcp", "localhost:6379")
	if err != nil {
		fmt.Println("conn redis failed, err:", err)
		return
	}
	defer conn.Close()
	
	res, err := conn.Do("HSet", "names", "jim", "barry")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(res)

	res2, err := conn.Do("HGet", "names", "jim")
	//res2, err := redis.Strings(conn.Do("HGet", "names", "jim"))
	if err != nil {
		fmt.Println("hget error: ", err)
		return
	}
	fmt.Printf("%T\n", res2)
	fmt.Println(res2)
	fmt.Println(string(res2.([]uint8)))

设置过期时间

	res, err := conn.Do("expire", "names", 10)
	if err != nil {
		fmt.Println("expire error: ", err)
		return
	}
	fmt.Println(res)

Redis队列


package main

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

func main() {
	conn, err := redis.Dial("tcp", "localhost:6379")
	if err != nil {
		fmt.Println("conn redis failed, err:", err)
		return
	}
	defer conn.Close()
	
	res, err := conn.Do("lpush", "Queue", "jim", "barry", 9)
	if err != nil {
		fmt.Println("lpush error: ", err)
		return
	}
	fmt.Println(res)

	for {
		r, err := redis.String(conn.Do("lpop", "Queue"))
		if err != nil {
			fmt.Println("lpop error: ", err)
			break
		}
		fmt.Println(r)
	}
	
	res4, err := redis.Int(conn.Do("llen", "Queue"))
	if err != nil {
		fmt.Println("llen error: ", err)
		return
	}
	fmt.Println(res4)
}

Redis连接池

建立网络连接耗时，连接池实现多个客户端与服务器连接且不释放，需要时获取已建立的连接，使用完后还给连接池。

package main

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

var pool *redis.Pool

func init() {
	pool = &redis.Pool{
		MaxIdle:     16,	//最大空闲连接数
		MaxActive:   1024,	//最大激活连接数
		IdleTimeout: 300,	//最大空闲连接等待时间
		Dial: func() (redis.Conn, error) {
			return redis.Dial("tcp", "localhost:6379")
		},
	}
}

func main() {
	c := pool.Get()
	defer c.Close()

	_, err := c.Do("Set", "username", "jack")
	if err != nil {
		fmt.Println(err)
		return
	}
	
	r, err := redis.String(c.Do("Get", "username"))
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(r)
}

Redis管道

客户端发送多个命令到服务器端而无须等待响应，最后一次性读取多个响应。

package main

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

func main() {
	c, err := redis.Dial("tcp", "localhost:6379")
	if err != nil {
		fmt.Println("conn redis failed, err:", err)
		return
	}
	defer c.Close()

	c.Send("SET", "username1", "jim")	//输出缓冲区写入命令
	c.Send("SET", "username2", "jack")

	c.Flush()	//清空输出缓冲区，并写入服务器端

	v, err := c.Receive()	//FIFO顺序读取服务器端响应
	fmt.Printf("v:%v,err:%v\n", v, err)
	v, err = c.Receive()
	fmt.Printf("v:%v,err:%v\n", v, err)

	v, err = c.Receive() // 一直等待
	fmt.Printf("v:%v,err:%v\n", v, err)
}

Redis并发

package main

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

func main() {
	conn, err := redis.Dial("tcp", "localhost:6379")
	if err != nil {
		fmt.Println("connect redis error :", err)
		return
	}
	defer conn.Close()
	conn.Send("HSET", "students", "name", "jim", "age", "19")
	conn.Send("HSET", "students", "score", "100")
	conn.Send("HGET", "students", "age")
	conn.Flush()

	res1, err := conn.Receive()
	fmt.Printf("Receive res1:%v\n", res1)
	res2, err := conn.Receive()
	fmt.Printf("Receive res2:%v\n", res2)
	res3, err := conn.Receive()
	fmt.Printf("Receive res3:%s\n", res3)
}

Redis事务

MULTI：开启事务
EXEC：执行事务
DISCARD：取消事务
WATCH：监视事务中的建变化，一旦改变则取消事务

package main

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

func main() {
	conn, err := redis.Dial("tcp", "localhost:6379")
	if err != nil {
		fmt.Println("connect redis error :", err)
		return
	}
	defer conn.Close()
	
	conn.Send("MULTI")
	conn.Send("INCR", "foo")
	conn.Send("INCR", "bar")
	r, err := conn.Do("EXEC")
	if err != nil {
		conn.Send("DISCARD")
		//conn.Do("DISCARD")
	}
	fmt.Println(r)
}

4.3 MongoDB的安装及使用

4.3.1 MongoDB的安装

下载地址：https://www.mongodb.com/try/download/community
（1）创建/MongoDB/data/db目录
（2）运行 MongoDB 服务器，mongod.exe --dbpath c:\data\db
（3）连接 MongoDB ，mongo.exe

4.3.2 MongoDB基础入门

MongoDB简介

基于分布式文件存储的非关系型数据库（NoSQL），为Web应用提供可扩展的高性能数据存储解决方案。

数据库操作

启动数据库
mongod

数据库连接
mongodb://[username:password@]host1[:port1][, host2[:port2], ...[/[database][?options]]

mongodb://localhost
mongodb://localhost, localhost:27018, localhost:27019

创建数据库
use DATABASE_NAME

use mongo_db

删除数据库
db.dropDatabase()

集合操作

创建集合
db.createCollection(name, options)

db.createCollection("my_collection")

删除集合
db.collection.drop()

db.my_collection.drop()

文档操作

插入文档
db.collection.insert(document)
db.collection.save(document)

db.my_collection.insert({"name": "tt", "address": "hz"})

查询文档
db.collection.find(query, projection)

db.my_collection.find({})
db.my_collection.find({"name": "tt", "address": "hz"})
db.my_collection.find({"name": {"$ne": "hz"}})
db.my_collection.find({}).count()
db.my_collection.find({}).limit(1)
db.my_collection.find({}).sort({"name": 1})

修改文档
db.collection.update(, , {upsert: , multi: , writeConcern: })

db.my_collection.update({'name': 'barry'}, {$set: {'address': 'hz'}})

db.collection.save(, {writeConcern: })

db.my_collection.save({"_id": ObjectId("deetete"), "name": "jack", "address": "hz"})

删除文档
db.collection.remove(, {justOne: , writeConcern: })

do.my_collection.remove({'name': 'jack'})

去重文档
db.collection.distinct(field, query, options)

db.my_collection.distinct("name", {"address": {"$ne": "sh"}})

4.3.3 Go访问MongoDB

连接数据库

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)
func main() {
	var (
		client     *mongo.Client
		err        error
		db         *mongo.Database
		collection *mongo.Collection
	)
	//连接MongoDB
	if client, err = mongo.Connect(context.TODO(), options.Client().ApplyURI("mongodb://localhost:27017").SetConnectTimeout(5*time.Second)); err != nil {
		fmt.Print(err)
		return
	}
	
	//检查连接
	err = client.Ping(context.TODO(), nil)
	if err != nil {
		fmt.Print(err)
		return
	}
	
	//选择数据库 my_db
	db = client.Database("my_db")

	//选择表 my_collection
	collection = db.Collection("my_collection")
	fmt.Println(collection)
}

插入一条数据

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)

type ExecTime struct {
	StartTime int64 `bson:"startTime"` //开始时间
	EndTime   int64 `bson:"endTime"`   //结束时间
}

type LogRecord struct {
	JobName string `bson:"jobName"` //任务名
	Command string `bson:"command"` //shell命令
	Err     string `bson:"err"`     //脚本错误
	Content string `bson:"content"` //脚本输出
	Tp      ExecTime                //执行时间
}

func main() {
	var (
		client     *mongo.Client
		err        error
		collection *mongo.Collection
		iResult    *mongo.InsertOneResult
		id         primitive.ObjectID
	)
	
	
	if client, err = mongo.Connect(context.TODO(), options.Client().ApplyURI("mongodb://localhost:27017").SetConnectTimeout(5*time.Second)); err != nil {
		fmt.Print(err)
		return
	}
	
	//选择数据库my_db里的某个表
	collection = client.Database("my_db").Collection("my_collection")

	//插入某一条数据
	logRecord := LogRecord{
		JobName: "job1",
		Command: "echo 1",
		Err:     "",
		Content: "1",
		Tp: ExecTime{
			StartTime: time.Now().Unix(),
			EndTime:   time.Now().Unix() + 10,
		},
	}
	if iResult, err = collection.InsertOne(context.TODO(), logRecord); err != nil {
		fmt.Print(err)
		return
	}
	
	//_id:默认生成一个全局唯一ID
	id = iResult.InsertedID.(primitive.ObjectID)
	fmt.Println("自增ID", id.Hex())
}

批量插入数据

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
	"time"
)

type ExecTime struct {
	StartTime int64 `bson:"startTime"` //开始时间
	EndTime   int64 `bson:"endTime"`   //结束时间
}

type LogRecord struct {
	JobName string `bson:"jobName"` //任务名
	Command string `bson:"command"` //shell命令
	Err     string `bson:"err"`     //脚本错误
	Content string `bson:"content"` //脚本输出
	Tp      ExecTime                //执行时间
}

func main() {
	var (
		client     *mongo.Client
		err        error
		collection *mongo.Collection
		result    *mongo.InsertManyResult
		id         primitive.ObjectID
	)
	
	
	if client, err = mongo.Connect(context.TODO(), options.Client().ApplyURI("mongodb://localhost:27017").SetConnectTimeout(5*time.Second)); err != nil {
		fmt.Print(err)
		return
	}
	
	//选择数据库my_db里的某个表
	collection = client.Database("my_db").Collection("test")

	//批量插入
	result, err = collection.InsertMany(context.TODO(), []interface{}{
		LogRecord{
			JobName: "job multil1",
			Command: "echo multil1",
			Err:     "",
			Content: "1",
			Tp: ExecTime{
				StartTime: time.Now().Unix(),
				EndTime:   time.Now().Unix() + 10,
			},
		},
		LogRecord{
			JobName: "job multil2",
			Command: "echo multil2",
			Err:     "",
			Content: "2",
			Tp: ExecTime{
				StartTime: time.Now().Unix(),
				EndTime:   time.Now().Unix() + 10,
			},
		},
	});
	if err != nil {
		log.Fatal(err)
	}
	if result == nil {
		log.Fatal("result nil")
	}
	
	for _, v := range result.InsertedIDs {
		id = v.(primitive.ObjectID)
		fmt.Println("自增ID", id.Hex())
	}
}

查询数据

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
	"time"
)

type ExecTime struct {
	StartTime int64 `bson:"startTime"` //开始时间
	EndTime   int64 `bson:"endTime"`   //结束时间
}

type LogRecord struct {
	JobName string `bson:"jobName"` //任务名
	Command string `bson:"command"` //shell命令
	Err     string `bson:"err"`     //脚本错误
	Content string `bson:"content"` //脚本输出
	Tp      ExecTime                //执行时间
}

//查询实体
type FindByJobName struct {
	JobName string `bson:"jobName"` //任务名
}

func main() {
	var (
		client     *mongo.Client
		err        error
		collection *mongo.Collection
		cursor     *mongo.Cursor
	)
	
	
	if client, err = mongo.Connect(context.TODO(), options.Client().ApplyURI("mongodb://localhost:27017").SetConnectTimeout(5*time.Second)); err != nil {
		fmt.Print(err)
		return
	}
	
	//选择数据库my_db里的某个表
	collection = client.Database("my_db").Collection("test")
	cond := FindByJobName{JobName: "job multil1"}
	if cursor, err = collection.Find(
		context.TODO(),
		cond,
		options.Find().SetSkip(0),
		options.Find().SetLimit(2)); err != nil {
		fmt.Println(err)
		return
	}
	defer func() {
		if err = cursor.Close(context.TODO()); err != nil {
			log.Fatal(err)
		}
	}()

	//遍历游标获取结果数据
	for cursor.Next(context.TODO()) {
		var lr LogRecord
		//反序列化Bson到对象
		if cursor.Decode(&lr) != nil {
			fmt.Print(err)
			return
		}
		fmt.Println(lr)
	}
	
	var results []LogRecord
	if err = cursor.All(context.TODO(), &results); err != nil {
		log.Fatal(err)
	}
	
	for _, result := range results {
		fmt.Println(result)
	}
}

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
	"time"
)

type ExecTime struct {
	StartTime int64 `bson:"startTime"` //开始时间
	EndTime   int64 `bson:"endTime"`   //结束时间
}

type LogRecord struct {
	JobName string `bson:"jobName"` //任务名
	Command string `bson:"command"` //shell命令
	Err     string `bson:"err"`     //脚本错误
	Content string `bson:"content"` //脚本输出
	Tp      ExecTime                //执行时间
}

//查询实体
type FindByJobName struct {
	JobName string `bson:"jobName"` //任务名
}

func main() {
	var (
		client     *mongo.Client
		err        error
		collection *mongo.Collection
		cursor     *mongo.Cursor
	)
	
	
	if client, err = mongo.Connect(context.TODO(), options.Client().ApplyURI("mongodb://localhost:27017").SetConnectTimeout(5*time.Second)); err != nil {
		fmt.Print(err)
		return
	}
	
	//选择数据库my_db里的某个表
	collection = client.Database("my_db").Collection("test")
	filter := bson.M{"jobName":"job multil1"}
	if cursor, err = collection.Find(
		context.TODO(),
		filter,
		options.Find().SetSkip(0),
		options.Find().SetLimit(2)); err != nil {
		log.Fatal(err)
	}
	defer func() {
		if err = cursor.Close(context.TODO()); err != nil {
			log.Fatal(err)
		}
	}()
	
	var results []LogRecord
	if err = cursor.All(context.TODO(), &results); err != nil {
		log.Fatal(err)
	}
	
	for _, result := range results {
		fmt.Println(result)
	}
}

BSON复合查询

BSON，JSON的二进制表示。
两大类型表示BSON数据：
一、D类型
4个子类

D：BSON文档，有序map
M：无序map
A：一个BOSN数组
E：D中的一个元素

bson.D{{
	"name",
	bson.D{{
		"$in",
		bson.A{"Jim", "Jack"},
	}}
}}

二、Raw类型
验证字节切片，反序列化BSON

package main

import (
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
)

func main() {
	testM := bson.M{
		"jobName": "job multi1",
	}
	var raw bson.Raw
	tmp, _ := bson.Marshal(testM)
	bson.Unmarshal(tmp, &raw)

	fmt.Println(testM)
	fmt.Println(raw)
}

（1）聚合查询

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
	"time"
)

func main() {
	var (
		client     *mongo.Client
		collection *mongo.Collection
		err        error
		cursor     *mongo.Cursor
	)
	
	if client, err = mongo.Connect(context.TODO(), options.Client().ApplyURI("mongodb://localhost:27017").SetConnectTimeout(5*time.Second)); err != nil {
		fmt.Print(err)
		return
	}
	
	collection = client.Database("my_db").Collection("test")
	//按照jobName分组,countJob中存储每组的数目
	groupStage := mongo.Pipeline{bson.D{
		{"$group", bson.D{
			{"_id", "$jobName"},
			{"countJob", bson.D{
				{"$sum", 1},
			}},
		}},
	}}
	if cursor, err = collection.Aggregate(context.TODO(), groupStage, ); err != nil {
		log.Fatal(err)
	}
	defer func() {
		if err = cursor.Close(context.TODO()); err != nil {
			log.Fatal(err)
		}
	}()
	var results []bson.M
	if err = cursor.All(context.TODO(), &results); err != nil {
		log.Fatal(err)
	}
	for _, result := range results {
		fmt.Println(result)
	}
}

（2）

在这里插入代码片

（3）

4.4 Go的常见ORM库

4.4.1 什么是ORM

4.4.2 Gorm的安装及使用

package main

import (
	_ "github.com/mattn/go-sqlite3"
	"github.com/jinzhu/gorm"
	"crypto/md5"
	"encoding/hex"
	"fmt"
	"log"
	"os"
)

// 数据表结构体类
type GormUser struct {
	ID       uint   `json:"id"`
	Phone    string `json:"phone"`
	Name     string `json:"name"`
	Password string `json:"password"`
}

//md5加密
func md5Password(str string) string {
	h := md5.New()
	h.Write([]byte(str))
	return hex.EncodeToString(h.Sum(nil))
}

func main() {
	db, err := gorm.Open("sqlite3", `D:\soft\sqlite\gorm.db`)
	if err != nil {
		panic(err)
	}
	defer db.Close()
	
	db.DB().SetMaxIdleConns(10)
	db.DB().SetMaxOpenConns(10)
	
	db.AutoMigrate(&GormUser{})
		
	//创建用户
	GormUser := GormUser{
		Phone:    "13888888888",
		Name:     "Shirdon",
		Password: md5Password("666666"), //用户密码
	}
	db.Save(&GormUser) //保存到数据库
	//db.Create(&GormUser) //保存到数据库
	
	//删除用户
	//var GormUser = new(GormUser)
	db.Where("phone = ?", "13888888888").Delete(&GormUser)
	
	//查询用户
	//var GormUser = new(GormUser)
	db.Where("phone = ?", "18888888888").Find(&GormUser)
	//db.First(&GormUser, "phone = ?", "18888888888")
	fmt.Println(GormUser)
	
	//更新用户及错误处理
	//var GormUser = new(GormUser)
	err = db.Model(&GormUser).Where("phone = ?", "18888888888").Update("phone", "13888888888").Error
	if err != nil {
		panic(err)
	}
	
	//事务处理
	//开启事务
	tx := db.Begin()
	/*
	GormUser := GormUser{
		Phone:    "18888888888",
		Name:     "Shirdon",
		Password: md5Password("666666"), //用户密码
	}
	*/
	if err := tx.Create(&GormUser).Error; err != nil {
		//事务回滚
		tx.Rollback()
		fmt.Println(err)
	}
	db.First(&GormUser, "phone = ?", "18888888888")
	//事务提交
	tx.Commit()
	
	//日志处理
	db.LogMode(true)
	db.SetLogger(log.New(os.Stdout, "\r\n", 0))
}

4.4.3 Beego ORM

4.5 SQLite的安装及使用

SQLite是一个进程内的库，实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。

4.5.1 SQLite的安装

下载地址：https://www.sqlite.org/download.html
（1）下载sqlite-dll-win64-x64-3360000.zip和sqlite-tools-win32-x86-3360000.zip文件
（2）启动sqlite3

4.5.2 SQLite基础入门

数据库管理

sqlite3 test.db -- 创建数据库
sqlite3 testDB.db .dump > testDB.sql -- 导出数据库到txt文件
sqlite3 testDB.db < testDB.sql -- txt文件导入数据库

.open test.db -- 创建数据库
.databases -- 查看数据库
.quit -- 退出
ATTACH DATABASE 'test.db' as 'TEST'; -- 附加数据库
DETACH DATABASE 'TEST'; -- 分离数据库

数据表操作

-- 创建数据表
CREATE TABLE database_name.table_name(
   column1 datatype  PRIMARY KEY(one or more columns),
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
);

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

-- 查看数据表
.tables
 
-- 得到表的完整信息
.schema COMPANY

-- 删除数据表
DROP TABLE database_name.table_name;
DROP TABLE COMPANY;

数据库语句

-- 新增数据
INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)]  
VALUES (value1, value2, value3,...valueN);

INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (6, 'Kim', 22, 'South-Hall', 45000.00 );

INSERT INTO COMPANY VALUES (7, 'James', 24, 'Houston', 10000.00 );

-- 查询数据
SELECT column1, column2, columnN FROM table_name;
.header on
.mode column
SELECT * FROM COMPANY;
SELECT ID, NAME, SALARY FROM COMPANY;
 
#修改数据
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

UPDATE COMPANY SET ADDRESS = 'Texas' WHERE ID = 6;
UPDATE COMPANY SET ADDRESS = 'Texas', SALARY = 20000.00;


#删除数据
DELETE FROM table_name WHERE [condition];

DELETE FROM COMPANY WHERE ID = 7;
DELETE FROM COMPANY;

4.5.3 Go访问SQLite

安装msys2
配置gcc目录，set Path=%Path%;C:\msys64\mingw64\bin
go get github.com/mattn/go-sqlite3

sqlite3 test.db < test.sql

创建数据库和数据表

test.sql

CREATE TABLE `user` (
	`uid` INT PRIMARY KEY NOT NULL,
	`name` TEXT NOT NULL,
	`phone` CHAR(50)
);

INSERT INTO `user` (`uid`, `name`, `phone`) VALUES (15, 'yx', '138888888');
INSERT INTO `user` (`uid`, `name`, `phone`) VALUES (111, 'yx', '138888888');

连接数据库

package main

import (
	"database/sql"
	_ "github.com/mattn/go-sqlite3"
	"log"
)

func main() {
	db, err := sql.Open("sqlite3.exe", `D:\soft\sqlite\test.db`)
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()
}

初始化连接

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/mattn/go-sqlite3"
)

var db *sql.DB

// 定义一个初始化数据库的函数
func initDB() (err error) {
	//连接数据库
	db, err = sql.Open("sqlite3", `D:\soft\sqlite\test.db`)
	if err != nil {
		return err
	}
	// 尝试与数据库建立连接（校验dsn是否正确）
	err = db.Ping()
	if err != nil {
		return err
	}
	return nil
}

func main() {
	if err := initDB(); err != nil {
		fmt.Printf("init db failed, err: %v\n", err)
	}
}

设置最大连接数
n<=0，无限制，默认0。
不会超过数据库默认配置。

func (db *DB) SetMaxOpenConns(n int)

设置最大闲置连接数
n<=0，无限制，默认0。
不会超过数据库默认配置。

func (db *DB) SetMaxOpenConns(n int)

SQL查询

QueryRow()单行查询

func (db *DB) QueryRow(query string, args ...interface{}) *Row

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/mattn/go-sqlite3"
)

var db *sql.DB

// 定义一个初始化数据库的函数
func initDB() (err error) {
	//连接数据库
	db, err = sql.Open("sqlite3", `D:\soft\sqlite\test.db`)
	if err != nil {
		return err
	}
	// 尝试与数据库建立连接（校验dsn是否正确）
	err = db.Ping()
	if err != nil {
		return err
	}
	return nil
}

type User struct {
	Uid int
	Name string
	Phone string
}

func queryRow() {
	var u User;
	if err := db.QueryRow("select uid, name, phone from user where uid=?;", 111).Scan(&u.Uid, &u.Name, &u.Phone); err != nil {
		fmt.Printf("scan failed, err:%v\n", err)
		return
	}
	fmt.Printf("uid:%d name:%s phone:%s\n", u.Uid, u.Name, u.Phone)
}

func main() {
	if err := initDB(); err != nil {
		fmt.Printf("init db failed, err: %v\n", err)
	}
	queryRow()
}

Query()多行查询

func (db *DB) Query(query string, args ...interface{}) (*Rows, error)

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/mattn/go-sqlite3"
)

var db *sql.DB

// 定义一个初始化数据库的函数
func initDB() (err error) {
	//连接数据库
	db, err = sql.Open("sqlite3", `D:\soft\sqlite\test.db`)
	if err != nil {
		return err
	}
	// 尝试与数据库建立连接（校验dsn是否正确）
	err = db.Ping()
	if err != nil {
		return err
	}
	return nil
}

type User struct {
	Uid int
	Name string
	Phone string
}

func queryMultiRow() {
	var u User;
	rows, err := db.Query("select uid, name, phone from user where uid>?;", 0)
	if err != nil {
		fmt.Printf("query failed, err:%v\n", err)
		return
	}
	defer rows.Close()

	for rows.Next() {
		err := rows.Scan(&u.Uid, &u.Name, &u.Phone)
		if err != nil {
			fmt.Printf("scan failed, err:%v\n", err)
			return
		}
		fmt.Printf("uid:%d name:%s phone:%s\n", u.Uid, u.Name, u.Phone)
	}
}

func main() {
	if err := initDB(); err != nil {
		fmt.Printf("init db failed, err: %v\n", err)
	}
	queryMultiRow()
}

Exec()执行一次命令（查询、删除、更新、插入等）

func (db *DB) Exec(query string, args ...interface{}) (Result, error)

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/mattn/go-sqlite3"
)

var db *sql.DB

// 定义一个初始化数据库的函数
func initDB() (err error) {
	//连接数据库
	db, err = sql.Open("sqlite3", `D:\soft\sqlite\test.db`)
	if err != nil {
		return err
	}
	// 尝试与数据库建立连接（校验dsn是否正确）
	err = db.Ping()
	if err != nil {
		return err
	}
	return nil
}

//插入数据
func insertRow() {
	ret, err := db.Exec("insert into user(uid, name, phone) values(?, ?, ?);", 12, "ml", "15906693677")
	if err != nil {
		fmt.Printf("insert failed, err:%v\n", err)
		return
	}
	
	uid, err := ret.LastInsertId()
	if err != nil {
		fmt.Printf("get lastinsert ID failed, err:%v\n", err)
		return
	}
	fmt.Printf("insert success, the id is %d.\n", uid)
	
}

//更新数据
func updateRow() {
	ret, err := db.Exec("update user set name=? where uid=?;", "tt", 12)
	if err != nil {
		fmt.Printf("update failed, err:%v\n", err)
		return
	}
	
	n, err := ret.RowsAffected()
	if err != nil {
		fmt.Printf("get lastinsert ID failed, err:%v\n", err)
		return
	}
	fmt.Printf("update success, affected rows:%d\n", n)
}

//删除数据
func deleteRow() {
	ret, err := db.Exec("delete from user where uid=?;", 12)
	if err != nil {
		fmt.Printf("delete failed, err:%v\n", err)
		return
	}
	
	n, err := ret.RowsAffected()
	if err != nil {
		fmt.Printf("get lastinsert ID failed, err:%v\n", err)
		return
	}
	fmt.Printf("delete success, affected rows:%d\n", n)
}

func main() {
	if err := initDB(); err != nil {
		fmt.Printf("init db failed, err: %v\n", err)
	}
	insertRow()
	updateRow()
	deleteRow()
}

你可能感兴趣的:(Go,学习,整理,go)

我们一起成长感悟郑珍容
我们一起成长7感悟感恩姚老师的分享，非常的荣幸作为义工让我又机会听到这么好的音频。今天的主题，相对于生命的困境，你现在所做的义工或者帮助他人遇到的困难简直就是小巫见大巫。今天的音频，让我反思，我是否有在帮助他人的时候，遇到一点困难我就会感觉到痛苦，难受、想放弃？过去一定有的，但是从学习金刚智慧开始，我很开心，我很享受帮助他人的善行。一个终极的问题，曾经思考了很久，一直不见清晰的回答，今天从老师的音
新媒体运营小白，有哪些书籍可以推荐？ y耳朵
为了转行运营，我曾花了3个月的时间，看了不下百本书，可以说市面上大部分跟运营有关的书籍，我都看过了，因此关于书的推荐也有一些自己的小见解。看书不一定要多，但一定要****精，我根据豆瓣评分、推荐热度和自己的转行经历，挑出了13本值得运营小白看的书，收藏好这份书单，不需要你浪费时间去找书了。先看下统计好的书单：整理不易，看完记得点个赞哦！感谢你的支持。入门篇：1.《运营之光》（豆瓣评分：8.0)推荐
感恩日记美玲_
1，感恩小妹一大早，就发来了给妈妈洗浴后的照片。看到老妈平安健康，心中很是喜悦。祈愿老妈～在世的菩萨，健健康康平平安安，有妈在，家就在。让在外的儿女逢年过节有归心似箭的心情。2，感恩姚老师咖啡冥想研究生滴2期的义工团队，及时通报我参加学习事宜。让我这次学习不再，毫无准备，手忙脚乱。做好学习安排。3，感恩永红接受我的邀请，参与姚老师咖啡冥想研究生延续班，4，感恩丰盛10门的素娜，提议的语音好方法，更
世界十大名牌皮鞋都适合什么性格的人？我信了你滴鞋
前面介绍了《世界公认的五大名鞋，穿过三个以上都是不一般的人》，大概讲了5大名鞋品牌的故事，受到广大读者的关注和讨论，因此在原来的基础上重新整理了世界十大知名皮鞋品牌及特点，揭开他们神秘的面纱，看看到底是哪些人在穿这些鞋子？他们为什么能被公认为是世界排名靠前的品牌？能进入十大名皮鞋的，制造的手工工艺已相近，不同的是品牌设计理念与鞋材选用。正因为每个品牌不同的设计理念，制造出不一样的美丽的产品，适合不
三角洲行动内测资格怎么获得三角洲行动内测服怎么进入会飞滴鱼儿
手游内测资格怎么获得？这是每款新游戏开放内测的时候，玩家问的最多的一个问题，其实现在大多数游戏在上线之前官方都会开启几轮的内测测试，每轮测试之后，官方会收集全部运行过程中的数据，来进行优化和改进，至此这也是每款游戏的定律，但是有一个问题的就是，不管哪款游戏，开启测试的时候，名额都是有限的，经常都有很多玩家想要测试资格，却无论怎么也不会获得，本期小编就来给大家整理几个方法，让大家抢先一步！游戏内测资
Python开发游戏？也太好用了吧七步编程工具 Github python python 游戏开发语言
程序员宝藏库：https://gitee.com/sharetech_lee/CS-Books-Store当然可以啦！现在日常能够用到和想到的场景，绝大多数都可以用Python实现。效果怎么样暂且不提，但是得益于丰富的第三方工具包，的确让Python能够很容易处理各种各样的场景。对于游戏开发也是这样，如果真的要想商业化，Python在游戏开发方面肯定没办法和C++相提并论，但是如果用于日常学习和自
借力创新共同进步徐立华
借力创新共同进步文/徐立华2021年8月22日为期3天的第七届线上教育行走全国教师公益研修夏令营活动落下来了帷幕，但是美仁们的行走热情并没有减弱，从24日到26日每个学习群里都在进行着活动后的继续分享活动，26日晚上海的周连秀老师给我们分享了作为不擅长写作的她做志愿者的计划和行动，在周老师的分享中，我深深被她的教育智慧所折服。周老师不擅长写作，但是她又非常想参加教育行走活动，怎么办呢？思考之后，她
ruby和python哪个好学 hakesashou python基础知识 ruby python 开发语言
Ruby和python都挺好学的。建议学习Python，语法的话，Python相对更简洁。而且Python应用场合更广泛，运维、网站开发、数据处理、科学研究都可以。Ruby和Python十分相似，有很多共同点，但也有一些不同之外，以下是Python和Ruby的对比：1、Python和Ruby都是面向对象的语言，都是动态和灵活的。二者的主要区别在于他们解决问题的方式。Ruby提供了不同的方法，而Py
1.8，69 知行思合一
运气动力学万维钢老师提出的名词，不愧是物理博士出身，good1idea，创意一些新名词。开文引用查理芒格的话：得到你想要的东西，最保险的办法，就是让自己配得上你想要的那个东西。接着举例《绝命毒师》Breakingbad导演文斯·吉里根接受采访说的话，引出成功的经验——运气。我们现在所处的这个社会不管是美国还是中国，大体上都是一个精英社会——人们可以靠天赋和努力去争取财富和地位，而不像历史上那样家庭
深度学习-点击率预估-研究论文2024-09-14速读 sp_fyf_2024 深度学习人工智能
深度学习-点击率预估-研究论文2024-09-14速读1.DeepTargetSessionInterestNetworkforClick-ThroughRatePredictionHZhong,JMa,XDuan,SGu,JYao-2024InternationalJointConferenceonNeuralNetworks,2024深度目标会话兴趣网络用于点击率预测摘要：这篇文章提出了一种新
【NumPy】深入解析numpy.zeros()函数二七830 numpy
欢迎莅临我的个人主页这里是我深耕Python编程、机器学习和自然语言处理（NLP）领域，并乐于分享知识与经验的小天地！博主简介：我是二七830，一名对技术充满热情的探索者。多年的Python编程和机器学习实践，使我深入理解了这些技术的核心原理，并能够在实际项目中灵活应用。尤其是在NLP领域，我积累了丰富的经验，能够处理各种复杂的自然语言任务。技术专长：我熟练掌握Python编程语言，并深入研究了机
20220226号今日份（6）张雅苑Momo
考虑以下必备行程安排：1作息规律2三餐规律3早茶下午茶4晨练运动5阅读笔记6挚爱亲朋联络20220226号今日份快乐是有哪一些呢？1：视频号直播的持续今天已经是第221/190天啦今天主讲人在分享事上练的能力，事上见2：持续吉他练习今天已经第25天啦3：今天持续带动某人整理屋子，要加油哦，要持续哦今天的过程持续比较轻松愉快4：今天老佛爷入院的第四天，上阵父子兵，期待他们仨早起凯旋归来如何成为自己喜
关于华德福亲子课跟你在一起
为什么要上亲子课？关于华德福亲子课：亲子课是为那些准备上幼儿园的孩子提供一个短期适应的过程，有了这个时期安全感的建立相信入园时会很轻松。也为那些还在思考和判断比较的家庭提供一个更深入、更贴近真识的了解华德福教育的机会。亲子班的开设并不只是为了给孩子提供一个适合他年龄的环境，更主要的是让家长参与，从老师的言行中学习要给孩子什么，认识这个年龄阶段的孩子状态，学习如何看待孩子的呈现，如何引导孩子渡过不同
高效能写作必备书青青的鱼
有人认为写作只是作家的事，和我们没什么关系，其实这是一种误解。写作对于处在快速发展社会中的我们是很重要的一件事，它是我们沟通和学习的重要途径。写作可以抒发情感和阐述思想，以达到与外界沟通的目的。不管你是写工作报告，还是发一个邮件，甚至小到发个短信，都需要组织语言清晰表达你的思想或目的。对于以学习为目的，写作就更重要了，写作是一个需要不断思考、搜集、整理、总结你大脑中过去所学的知识的过程，通过写作不
Go编程语言前景怎么样？参加培训好就业吗 QFdongdong
Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C或C++代码的速度，而且更加安全、支持并行进程。不仅可以开发web,可以开发底层，目前知乎就是用golang开发。区块链首选语言就是go,以-太坊，超级账本都是基于go语言，还有go语言版本的btcd.Go的目标是希望提升现有编程语言对程序库等依赖性(dependency)的管理，这些软件元素会被应用程序反复调用。由
2022-09-23 怀洋
2022.09.23今日阅读《为何家会伤人》能拿到结果才是会学习。就像书中说的：火车质量再好，也只有在火车轨道上才能跑得快，在公路上，它就跑不动；你知识掌握得再好，也只有走上考试轨道才能取得好成绩，上不了这个轨道，也拿不到好成绩。在学校里的学习情况是以考试成绩来衡量的，那成年人也要学习，是不是会学习，有没有学以致用就要看是否有了好的结果。所以不能一味的只学习，可能还会因为学习没有改变而陷入更大的焦
杨蕊今日份总结羊鑫
2020年10月24日周二新的一周开始了！到了学校先打扫了一下卫生，然后给孩子们录了今天写作业的视频，今天书写的作业笔画是横折竖折。字根“五”今天孩子们的书写质量还是可以的，但是短横长横的掌握情况不是很理想，周六周天孩子们来的时候再给孩子们进行复习回顾一下，重点说一下这个知识点。去楼上把几个坏掉的凳子用固体胶粘好。下午去南鑫拿了几张照片去那边压膜。回到比德弗校区之后把玩具架和齐老师一起全都整理了一
尹吭【谦虚组】精进打卡2018.06.12 老黑1983
内容：【日精进打卡第171天】【知～学习】《六项精进》2遍共330遍《大学》2遍共346遍••••••【经典名句分享】人不知而不愠不亦君子乎【行～实践】一、修身：（对自己个人）俯卧撑20个五组修身：（利他：告知中医的一些治疗项目）修身：（帮扶：帮扶对象离职）二、齐家：（对家庭和家人）1、送女儿上学三、建功：（对工作）1、湿疹和疣案例页调整｛积善｝：发愿从2017年12月25日起1年内365善事。今
知错不责白开水的幸福时光
上课做卷子时，班上有三个同学半天了还找不到试卷。别的同学已经埋头做题了，他们三个有的钻在桌子兜里，有的蹲在地上，哗哗啦啦地整理凌乱的书桌，找试卷。我在教室里转了两圈，他们还在低头找试卷。换做以前，我肯定会质问他们：“连个东西都看不住，人家都开始做了，你们还找不到，快点找！”这话已经到嗓子眼儿上了，又被自己硬生生咽了下去。我在心里与自己对话：别批评他们了，他们又不是坐着不动，他们已经在四处寻找了，不
感悟不断学习的重要。小琳er
在这个不断变化的世界里，如果把人看成是静态的，那就有些太落伍了。其实，人随着时间的推移，也是在不断变化的。尽管有时候这种变化是被动的，但是这也是人为适应环境所作出的本能反应。人如果能主动去接受这种变化，并视这样的变化是积极的，那人能做且必须做的就是——不断学习。学习，可以说是人想改变命运、实现自由的最好方式。一个开放的人，也注定是一个肯学习、愿意接受新鲜事物的人。图片发自App这个世界没有天生的王
教师资格考试中学《教育知识与能力》知识点｜高频考点汇总小山丘
温馨提示：更多汇总详情留言小编哦！！！认知过程之易混知识点剖析社会中心课程论情绪——重要考点皮亚杰教你带孩子斯金纳强化规律你的心理足够强大吗?教育心理学的效应德育有规律常考人物思想之夸美纽斯中学常考教学原则孔子及《论语》中的重要教育思想教育学创立阶段人物之赫尔巴特学习策略分类知识点梳理教师资格证辨析题作答思路综合课程的类型班杜拉的学习理论马斯洛需要层次理论记忆类型的四大分类柏拉图和他的《理想国》感
2019-1-27晨间日记将军将离
今天是什么日子起床：十点就寝：十二点天气：阴心情：时好时坏纪念日:追番又追不下去的一天任务清单昨日完成的任务，最重要的三件事：和我妈聊天，吃好多肉改进：早睡习惯养成：不能熬夜周目标·完成进度坚持不下来学习·信息·阅读看小说健康·饮食·锻炼吃了好多肉人际·家人·朋友被我妈嫌工作·思考果然是三分钟热度，海贼王看了三十多集看不下去了，好长啊最美好的三件事1.吃饭2.睡觉3.看动漫思考·创意·未来坚持
第三周第二天2019-11-12 曲超king
今天学习字符串1、chars[5]={'A','S'},数组里面是单个的字符，由‘’chars[5]={"aasd"},数组里面是字符串，由“”chars[5]={"a"}也是一个字符串。其中的5代表字符串的长度每个字符串在结束位置都有\0,\0占一个元素。{\0}表示空的字符串。在输出时，%c代表字符输出，%s代表字符串输出。2、字符的长度一定要比总长度少一位，因为隐藏一个\0，系统自己默认规定
【中国国际航空-注册_登录安全分析报告】风控牛验证码接口安全评测系列安全行为验证极验网易易盾智能手机
前言由于网站注册入口容易被黑客攻击，存在如下安全问题：1.暴力破解密码，造成用户信息泄露2.短信盗刷的安全问题，影响业务及导致用户投诉3.带来经济损失，尤其是后付费客户，风险巨大，造成亏损无底洞所以大部分网站及App都采取图形验证码或滑动验证码等交互解决方案，但在机器学习能力提高的当下，连百度这样的大厂都遭受攻击导致点名批评，图形验证及交互验证方式的安全性到底如何？请看具体分析一、中国国际航空PC
Numpy 学习沐辰老爹
创建指定数值的数组a=np.full((3,5),np.pi)高级通用函数的特性#1.指定输出x=np.arange(10)y=np.empty(10)np.multiply(x,10,out=y)#2.聚合x=np.arange(10)x_sum=np.add.reduce(x)#类似的可用于logical_and等np.logical_and([condition1,condition2,co
Gobelieve 架构 weixin_34099526 数据库 golang json
Gobelievegithub地址声明:转简书JackieF的文章,为了自己方便copy了一份,加一些自己的东西.链接：https://www.jianshu.com/p/8121d6e85282IMCore主要分三大块:im客户连接服务器（可分布式部署，暂无负载均衡模块)imr路由查询服务器（主要解决im分布式部署的问题）ims存储服务器(主从部署)基础模块1.数据包协议包：header(12)
超过晚上9点不打卡和点评别有余味
一开营宇彤老师就说到：点评导师们，为了让大家积极练习，你们能及时点评，每天晚上9点前打完卡，写不完作业的，点评官就不点评了。原因:声音学习，不同于演讲不同于写作，可以深夜耕耘，“深耕”。声音就得早早练，如果半夜练习，哪能放的开。邻居会同意吗？家人会同意吗？为了家庭，邻居和谐，深夜不练声。给大家养成好习惯在坚持星球第二期声音训练营打卡第5天，宇彤老师上午又在群里抛出要一个问题：“参加写作，演讲学习，
Go 面向包的设计和架构分层云满笔记 golang 架构 directory layout src project
标题Go面向包的设计和架构分层序前项目架构分层工具包项目应用项目cmd/internal/internal/pkg/pkg/vendor/面向包的设计和验证包的位置依赖包导入应用级别的策略数据的发送和接收错误处理测试捕获错误不建议的目录结论Go面向包的设计和架构分层序本篇内容主要讲解golang项目的面向包设计准则和基础的架构分层。信息来自原文ArdanLabs:Package-Oriented-
机器学习流形数据降维：UMAP 降维算法小嗷犬 Python 机器学习 #数据分析及可视化机器学习算法人工智能
✅作者简介：人工智能专业本科在读，喜欢计算机与编程，写博客记录自己的学习历程。个人主页：小嗷犬的个人主页个人网站：小嗷犬的技术小站个人信条：为天地立心，为生民立命，为往圣继绝学，为万世开太平。本文目录UMAP简介理论基础特点与优势应用场景在Python中使用UMAP安装umap-learn库使用UMAP可视化手写数字数据集UMAP简介UMAP（UniformManifoldApproximatio
【美食分享】油炸牛奶吴老师教语文
一直宅在家里，闺女感觉很无聊，又不想学习，干嘛呢？突发奇想：做一道菜！啥菜呢？通过多方搜索，发现有一道菜看起来比较诱人：油炸牛奶。说做就做，这个喜欢拖延的娃，居然这次没有拖延。一个下午的忙碌，居然还真的做出了一道色香味俱全的菜肴。不信，晒图为证：这道菜，看着就很诱人，外焦里嫩。轻轻夹起一块，咬上一口，嫩嫩的，香香的，糯糯的，滑滑的，哇，唇齿留香，美味无比！闺女盯着我，期待地眼光看着我：“咋样？好吃
设计模式介绍 tntxia 设计模式
设计模式来源于土木工程师克里斯托弗亚历山大（http://en.wikipedia.org/wiki/Christopher_Alexander）的早期作品。他经常发表一些作品，内容是总结他在解决设计问题方面的经验，以及这些知识与城市和建筑模式之间有何关联。有一天，亚历山大突然发现，重复使用这些模式可以让某些设计构造取得我们期望的最佳效果。亚历山大与萨拉-石川佳纯和穆雷西乐弗斯坦合作
android高级组件使用(一) 百合不是茶 android RatingBar Spinner
1、自动完成文本框（AutoCompleteTextView） AutoCompleteTextView从EditText派生出来，实际上也是一个文本编辑框，但它比普通编辑框多一个功能：当用户输入一个字符后，自动完成文本框会显示一个下拉菜单，供用户从中选择，当用户选择某个菜单项之后，AutoCompleteTextView按用户选择自动填写该文本框。使用AutoCompleteTex
[网络与通讯]路由器市场大有潜力可挖掘 comsci 网络
如果国内的电子厂商和计算机设备厂商觉得手机市场已经有点饱和了,那么可以考虑一下交换机和路由器市场的进入问题..... 这方面的技术和知识,目前处在一个开放型的状态,有利于各类小型电子企业进入 &nbs
自写简单Redis内存统计shell 商人shang Linux shell 统计Redis内存
#!/bin/bash address="192.168.150.128:6666,192.168.150.128:6666" hosts=(${address//,/ }) sfile="staticts.log" for hostitem in ${hosts[@]} do ipport=(${hostitem
单例模式(饿汉 vs懒汉) oloz 单例模式
package 单例模式; /* * 应用场景:保证在整个应用之中某个对象的实例只有一个 * 单例模式种的《懒汉模式》 * */ public class Singleton { //01 将构造方法私有化，外界就无法用new Singleton()的方式获得实例 private Singleton(){}; //02 申明类得唯一实例 priva
springMvc json支持杨白白 json springmvc
1.Spring mvc处理json需要使用jackson的类库，因此需要先引入jackson包 2在spring mvc中解析输入为json格式的数据:使用@RequestBody来设置输入 @RequestMapping("helloJson") public @ResponseBody JsonTest helloJson() {
android播放，掃描添加本地音頻文件小桔子
最近幾乎沒有什麽事情，繼續鼓搗我的小東西。想在項目中加入一個簡易的音樂播放器功能，就像華為p6桌面上那麼大小的音樂播放器。用過天天動聽或者QQ音樂播放器的人都知道，可已通過本地掃描添加歌曲。不知道他們是怎麼實現的，我覺得應該掃描設備上的所有文件，過濾出音頻文件，每個文件實例化為一個實體，記錄文件名、路徑、歌手、類型、大小等信息。具體算法思想，
oracle常用命令 aichenglong oracle dba 常用命令
1 创建临时表空间 create temporary tablespace user_temp tempfile 'D:\oracle\oradata\Oracle9i\user_temp.dbf' size 50m autoextend on next 50m maxsize 20480m extent management local
25个Eclipse插件 AILIKES eclipse插件
提高代码质量的插件1. FindBugsFindBugs可以帮你找到Java代码中的bug，它使用Lesser GNU Public License的自由软件许可。2. CheckstyleCheckstyle插件可以集成到Eclipse IDE中去，能确保Java代码遵循标准代码样式。3. ECLemmaECLemma是一款拥有Eclipse Public License许可的免费工具，它提供了
Spring MVC拦截器+注解方式实现防止表单重复提交 baalwolf spring mvc
原理：在新建页面中Session保存token随机码，当保存时验证，通过后删除，当再次点击保存时由于服务器端的Session中已经不存在了，所有无法验证通过。 1.新建注解： ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
《Javascript高级程序设计(第3版)》闭包理解 bijian1013 JavaScript
“闭包是指有权访问另一个函数作用域中的变量的函数。”--《Javascript高级程序设计(第3版)》看以下代码： <script type="text/javascript"> function outer() { var i = 10; return f
AngularJS Module类的方法 bijian1013 JavaScript AngularJS Module
AngularJS中的Module类负责定义应用如何启动，它还可以通过声明的方式定义应用中的各个片段。我们来看看它是如何实现这些功能的。一.Main方法在哪里如果你是从Java或者Python编程语言转过来的，那么你可能很想知道AngularJS里面的main方法在哪里？这个把所
[Maven学习笔记七]Maven插件和目标 bit1129 maven插件
插件(plugin)和目标(goal) Maven，就其本质而言，是一个插件执行框架，Maven的每个目标的执行逻辑都是由插件来完成的，一个插件可以有1个或者几个目标，比如maven-compiler-plugin插件包含compile和testCompile，即maven-compiler-plugin提供了源代码编译和测试源代码编译的两个目标使用插件和目标使得我们可以干预
【Hadoop八】Yarn的资源调度策略 bit1129 hadoop
1. Hadoop的三种调度策略 Hadoop提供了3中作业调用的策略， FIFO Scheduler Fair Scheduler Capacity Scheduler 以上三种调度算法，在Hadoop MR1中就引入了，在Yarn中对它们进行了改进和完善.Fair和Capacity Scheduler用于多用户共享的资源调度 2. 多用户资源共享的调度
Nginx使用Linux内存加速静态文件访问 ronin47
Nginx是一个非常出色的静态资源web服务器。如果你嫌它还不够快，可以把放在磁盘中的文件，映射到内存中，减少高并发下的磁盘IO。先做几个假设。nginx.conf中所配置站点的路径是/home/wwwroot/res，站点所对应文件原始存储路径：/opt/web/res shell脚本非常简单，思路就是拷贝资源文件到内存中，然后在把网站的静态文件链接指向到内存中即可。具体如下：
关于Unity3D中的Shader的知识 brotherlamp unity unity资料 unity教程 unity视频 unity自学
首先先解释下Unity3D的Shader，Unity里面的Shaders是使用一种叫ShaderLab的语言编写的，它同微软的FX文件或者NVIDIA的CgFX有些类似。传统意义上的vertex shader和pixel shader还是使用标准的Cg/HLSL 编程语言编写的。因此Unity文档里面的Shader，都是指用ShaderLab编写的代码，然后我们来看下Unity3D自带的60多个S
CopyOnWriteArrayList vs ArrayList bylijinnan java
package com.ljn.base; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; /** * 总述： * 1.ArrayListi不是线程安全的，CopyO
内存中栈和堆的区别 chicony 内存
1、内存分配方面：堆：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式是类似于链表。可能用到的关键字如下：new、malloc、delete、free等等。栈：由编译器(Compiler)自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中
回答一位网友对Scala的提问 chenchao051 scala map
本来准备在私信里直接回复了，但是发现不太方便，就简要回答在这里。问题写道对于scala的简洁十分佩服，但又觉得比较晦涩，例如一例，Map("a" -> List(11,111)).flatMap(_._2)，可否说下最后那个函数做了什么，真正在开发的时候也会如此简洁？谢谢先回答一点，在实际使用中，Scala毫无疑问就是这么简单。
mysql 取每组前几条记录 daizj mysql 分组最大值最小值每组三条记录
一、对分组的记录取前N条记录：例如：取每组的前3条最大的记录 1.用子查询： SELECT * FROM tableName a WHERE 3> (SELECT COUNT(*) FROM tableName b WHERE b.id=a.id AND b.cnt>a. cnt) ORDER BY a.id,a.account DE
HTTP深入浅出 http请求 dcj3sjt126com http
HTTP(HyperText Transfer Protocol)是一套计算机通过网络进行通信的规则。计算机专家设计出HTTP，使HTTP客户（如Web浏览器）能够从HTTP服务器(Web服务器)请求信息和服务，HTTP目前协议的版本是1.1.HTTP是一种无状态的协议，无状态是指Web浏览器和Web服务器之间不需要建立持久的连接，这意味着当一个客户端向服务器端发出请求，然后We
判断MySQL记录是否存在方法比较 dcj3sjt126com mysql
把数据写入到数据库的时，常常会碰到先要检测要插入的记录是否存在，然后决定是否要写入。　　我这里总结了判断记录是否存在的常用方法：　　sql语句： select count ( * ) from tablename; 　　然后读取count(*)的值判断记录是否存在。对于这种方法性能上有些浪费，我们只是想判断记录记录是否存在，没有必要全部都查出来。
对HTML XML的一点认识 e200702084 html xml
感谢http://www.w3school.com.cn提供的资料 HTML 文档中的每个成分都是一个节点。节点根据 DOM，HTML 文档中的每个成分都是一个节点。 DOM 是这样规定的：整个文档是一个文档节点每个 HTML 标签是一个元素节点包含在 HTML 元素中的文本是文本节点每一个 HTML 属性是一个属性节点注释属于注释节点 Node 层次
jquery分页插件 genaiwei jquery Web 前端分页插件
//jquery页码控件// 创建一个闭包 (function($) { // 插件的定义 $.fn.pageTool = function(options) { var totalPa
Mybatis与Ibatis对照入门于学习 Josh_Persistence mybatis ibatis 区别联系
一、为什么使用IBatis/Mybatis 对于从事 Java EE 的开发人员来说，iBatis 是一个再熟悉不过的持久层框架了，在 Hibernate、JPA 这样的一站式对象 / 关系映射（O/R Mapping）解决方案盛行之前，iBaits 基本是持久层框架的不二选择。即使在持久层框架层出不穷的今天，iBatis 凭借着易学易用、
C中怎样合理决定使用那种整数类型？秋风扫落叶 c 数据类型
如果需要大数值(大于32767或小于32767), 使用long 型。否则, 如果空间很重要 (如有大数组或很多结构), 使用 short 型。除此之外, 就使用 int 型。如果严格定义的溢出特征很重要而负值无关紧要, 或者你希望在操作二进制位和字节时避免符号扩展的问题, 请使用对应的无符号类型。但是, 要注意在表达式中混用有符号和无符号值的情况。 &nbs
maven问题 zhb8015 maven问题
问题1： Eclipse 中新建maven项目无法添加src/main/java 问题 eclipse创建maevn web项目，在选择maven_archetype_web原型后，默认只有src/main/resources这个Source Floder。按照maven目录结构，添加src/main/ja
(二)androidpn-server tomcat版源码解析之--push消息处理 spjich java androdipn 推送
在 (一)androidpn-server tomcat版源码解析之--项目启动这篇中，已经描述了整个推送服务器的启动过程，并且把握到了消息的入口即XmppIoHandler这个类，今天我将继续往下分析下面的核心代码，主要分为3大块，链接创建，消息的发送，链接关闭。先贴一段XmppIoHandler的部分代码 /** * Invoked from an I/O proc
用js中的formData类型解决ajax提交表单时文件不能被serialize方法序列化的问题中华好儿孙 JavaScript Ajax Web 上传文件 FormData
var formData = new FormData($("#inputFileForm")[0]); $.ajax({ type:'post', url:webRoot+"/electronicContractUrl/webapp/uploadfile", data:formData, async: false, ca
mybatis常用jdbcType数据类型 ysj5125094 mybatis mapper jdbcType
MyBatis 通过包含的jdbcType 类型 BIT FLOAT CHAR

《Go Web编程实战派——从入门到精通》学习笔记之第4章 用Go访问数据库

《Go Web编程实战派——从入门到精通》学习笔记之第4章 用Go访问数据库

第4章 用Go访问数据库

4.1 MySQL的安装与使用

4.1.1 MySQL简介

4.1.2 MySQL安装

4.1.3 MySQL基础入门

4.1.4 Go访问MySQL

4.2 Redis的安装及使用

4.2.1 Redis的安装

4.2.2 Redis基础入门

4.2.3 Go访问Redis

4.3 MongoDB的安装及使用

4.3.1 MongoDB的安装

4.3.2 MongoDB基础入门

4.3.3 Go访问MongoDB

4.4 Go的常见ORM库

4.4.1 什么是ORM

4.4.2 Gorm的安装及使用

4.4.3 Beego ORM

4.5 SQLite的安装及使用

4.5.1 SQLite的安装

4.5.2 SQLite基础入门

4.5.3 Go访问SQLite

你可能感兴趣的:(Go,学习,整理,go)

《Go Web编程实战派——从入门到精通》学习笔记之第4章用Go访问数据库

《Go Web编程实战派——从入门到精通》学习笔记之第4章用Go访问数据库

第4章用Go访问数据库