Golang se conectar ao banco de dados MySQL CRUD

Desta vez, aprenderemos a usar o Golang para conectar-se ao banco de dados MySQL e a usar o Golang para implementar a operação CRUD do banco de dados.

Ambiente de construção

Primeiro, criamos um projeto Golang e configuramos o projeto GOPATH. Esta etapa pode se referir ao meu blog Instalação do ambiente Golang e desenvolvimento da IDEA Golang .

Como estamos usando um banco de dados MySQL, precisamos obter o driver de banco de dados MySQL da Golang.
Executamos o go getcomando no diretório GOPATH do projeto para obter o driver MySQL. Após a execução do comando, o pacote do driver MySQL será baixado diretamente da Internet para o GOPATHdiretório em seu srcdiretório.

go get -u github.com/go-sql-driver/mysql

Após a criação do ambiente do projeto Golang, também precisamos criar uma tabela de banco de dados.

CREATE TABLE `tb_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(11) DEFAULT NULL,
  `password` varchar(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `nameindex` (`name`(10))
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Estrutura do projeto

Estrutura de gravação

Para poder encapsular facilmente os dados obtidos no banco de dados, criamos uma estrutura Golang para encapsular nossos dados.
Criamos um beanpacote e, em seguida, criamos um user.goarquivo sob o pacote .

user.go

package bean

type User struct {
	id int
	name string
	password string
}

func (user *User) GetId() int {
	return user.id
}

func (user *User) SetId(id int) {
	user.id = id
}

func (user *User) GetName() string {
	return user.name
}

func (user *User) SetName(name string) {
	user.name = name
}

func (user *User) GetPassword() string {
	return user.password
}

func (user *User) SetPassword(password string) {
	user.password = password
}

Escreva uma ferramenta de conexão com o banco de dados

Como você precisa obter uma conexão com o banco de dados toda vez que se conectar a um banco de dados, encapsulamos diretamente a operação de conexão com o banco de dados como um método, para que você não precise executar a etapa de obter uma conexão todas as vezes.
Criamos um utilpacote e criamos um initdb.goarquivo sob o pacote .

initdb.go

package util

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

//我们先将数据库配置信息定义成为常量
const (
	userName = "root"
	password = "admin"
	ip       = "127.0.0.1"
	port     = "3306"
	dbName   = "db_database08"
)

//初始化数据库连接，返回数据库连接的指针引用
func InitDB() *sql.DB {
	//Golang数据连接："用户名:密码@tcp(IP:端口号)/数据库名?charset=utf8"
	path := strings.Join([]string{userName, ":", password, "@tcp(", ip, ":", port, ")/", dbName, "?charset=utf8"}, "")
	//打开数据库,前者是驱动名，所以要导入： _ "github.com/go-sql-driver/mysql"
	db, err := sql.Open("mysql", path)
	if err != nil {
		//如果打开数据库错误，直接panic
		panic(err)
	}
	//设置数据库最大连接数
	db.SetConnMaxLifetime(10)
	//设置上数据库最大闲置连接数
	db.SetMaxIdleConns(5)
	//验证连接
	if err := db.Ping(); err != nil {
		panic(err)
	}
	//将数据库连接的指针引用返回
	return db
}

Operação CRUD

Inserir operação

Criamos um insertpacote, criamos um insert.goarquivo sob o pacote

package main

import (
	"fmt"
	"mysql/util"
)

func main() {
	//使用工具获取数据库连接
	db := util.InitDB()
	//开启事务
	tx, err := db.Begin()
	if err != nil {
		//事务开启失败，直接panic
		panic(err)
	}
	//准备SQL语句
	sql := "insert into tb_user (`name`, `password`) values (?, ?)"
	//对SQL语句进行预处理
	stmt, err := db.Prepare(sql)
	if err != nil {
		panic(err)
	}
	result, err := stmt.Exec("阿部多瑞","123")
	if err != nil {
		//SQL执行失败，直接panic
		panic(err)
	}
	//提交事务
	tx.Commit()
	//返回插入记录的id
	fmt.Println(result.LastInsertId())
}

Selecionar operação

Criamos um selectpacote, criamos um select.goarquivo sob o pacote

package main

import (
	"fmt"
	"mysql/bean"
	"mysql/util"
)

func main() {
	//使用工具获取数据库连接
	db := util.InitDB()
	//准备SQL语句
	sql := "select * from tb_user"
	//对SQL语句进行预处理
	stmt, err := db.Prepare(sql)
	if err != nil {
		panic(err)
	}
	rows, err := stmt.Query()
	if err != nil {
		//SQL执行失败，直接panic
		panic(err)
	}
	var users []bean.User
	for rows.Next() {
		var id int
		var name, password string
		err := rows.Scan(&id, &name, &password)
		if err != nil {
			//读取结果集失败
			panic(err)
		}
		var user bean.User
		user.SetId(id)
		user.SetName(name)
		user.SetPassword(password)
		users = append(users, user)
	}
	fmt.Println(users)
}

Atualizar operação

Criamos um updatepacote, criamos um update.goarquivo sob o pacote

package main

import (
	"mysql/util"
)

func main() {
	//使用工具获取数据库连接
	db := util.InitDB()
	//开启事务
	tx, err := db.Begin()
	if err != nil {
		//事务开启失败，直接panic
		panic(err)
	}
	//准备SQL语句
	sql := "update tb_user set `password` = ? where `id` = ?"
	//对SQL语句进行预处理
	stmt, err := db.Prepare(sql)
	if err != nil {
		panic(err)
	}
	_, err = stmt.Exec("789", 1)
	if err != nil {
		//SQL执行失败，直接panic
		panic(err)
	}
	//提交事务
	tx.Commit()
}

Excluir operação

Criamos um deletepacote, criamos um delete.goarquivo sob o pacote

package main

import (
	"mysql/util"
)

func main() {
	//使用工具获取数据库连接
	db := util.InitDB()
	//开启事务
	tx, err := db.Begin()
	if err != nil {
		//事务开启失败，直接panic
		panic(err)
	}
	//准备SQL语句
	sql := "delete from tb_user where `id` = ?"
	//对SQL语句进行预处理
	stmt, err := db.Prepare(sql)
	if err != nil {
		panic(err)
	}
	_, err = stmt.Exec(1)
	if err != nil {
		//SQL执行失败，直接panic
		panic(err)
	}
	//提交事务
	tx.Commit()
}