golang物联网之路一：来个简单的CRUD吧

互联网目前已进入其生命末期，而物联网则正在落地开发，随之而来的各种原生云则是让互联网进入生命末期的主要诱因。同时由于物联网的兴起，对云的要求则更加迫切，所以这里不得不掌握一门新的云语言来增强自身的技能属性，避免被时代抛弃，golang，作为新生代语言，则属于天选之子。

当然了，新语言学习，我一向认为单纯的看语法，按部就班的学习，是一件很枯燥且性价比极低的事情，所以这里，我们就从mysql的crud来学起吧。当然了，工欲善其事必先利其器，我们首先要在本地安装好mysql server， go sdk，goland等必备工具，由于安装过程寥寥几笔，无需浓墨重彩，我这里不需多言。下面展示的是安装好之后的代码步骤

代码层级

 代码层级很简单，dao放数据访问层，entity是实体层，service中则是增删改查的各种服务，main.go负责运行，而go.mod则是创建项目的时候，goland默认给我们创建的，注意这个go.mod非常重要，不要删除，否则会导致无法import一些包。

数据库连接connection.go

package dao

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

const(
	userName = "root"
	password = "root"
	ip       = "127.0.0.1"
	port     = "3306"
	dbName   = "test"
)

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)
	//验证连接
	errPing := db.Ping()
	if errPing != nil {
		panic(err)
	}
	return db;
}

　　注意，在写驱动前，需要利用 go get -u github.com/go-sql-driver/mysql 命令将驱动包安装到GOPATH指定的目录下，go env命令可以查看GOPATH目录，之后在goland中，确认GOPATH目录，就可以正常的引用包了，否则import的包怎么都会检测不到：

用户实体user.go

package entity

type User struct{
	userId int
	userName string
	userAddr string
}

//(user *User) 其实就是java中的this关键字，指向当前对象

func (user *User) GetUserId() int  {
	return user.userId
}

func (user *User) SetUserId(userId int)  {
	user.userId = userId
}

func (user *User) GetUserName() string {
	return user.userName
}

func (user *User) SetUserName(userName string)  {
	user.userName = userName
}

func (user *User) GetUserAddr() string  {
	return user.userAddr
}

func (user *User) SetUserAddr(userAddr string)  {
	user.userAddr = userAddr
}

　　需要注意，在go中，pulic，private，protected等修饰符是没有的， 方法首字母大写，则默认为public方法，方法首字母小写，则默认为private方法。

增删改查

package service

import (
	"firstgo/src/dao"
)

func CreateRecord() (int64,error){
	db := dao.InitDB()
	tx, err := db.Begin()
	if err != nil{
		panic(err)
	}

	sql := "insert into user (`user_name`, `user_addr`) values (?, ?)"
	stmt, err := db.Prepare(sql)
	if err != nil {
		panic(err)
	}
	result, err := stmt.Exec("testuser","china, beijing")
	if err != nil {
		//SQL执行失败，直接panic
		panic(err)
	}
	//提交事务
	tx.Commit()
	//返回插入记录的id
	return result.LastInsertId()
}

　　新增用户，驱动代码如上，注意返回值，在go中，是支持多返回值的。

package service

import (
	"firstgo/src/dao"
)

func DeleteRecord(userId int) (int64, error) {
	db := dao.InitDB()
	tx, err := db.Begin()
	if err != nil {
		panic(err)
	}

	sql := "delete from user where user_id = ? "
	stmt, err := db.Prepare(sql)
	if err != nil {
		panic(err)
	}
	result, err := stmt.Exec(userId)
	if err != nil {
		//SQL执行失败，直接panic
		panic(err)
	}
	//提交事务
	tx.Commit()
	return result.RowsAffected()
}

　　删除用户代码如上，需要注意的是 :=的写法，实际上是属于自动推导类型。

package service

import "firstgo/src/dao"

func UpdateRecord(userAddr string, userId int)(int64, error) {
	db := dao.InitDB()
	tx, err := db.Begin()
	if err != nil {
		panic(err)
	}

	sql := "update user set user_addr = ? where user_id = ? "
	stmt, err := db.Prepare(sql)
	if err != nil {
		panic(err)
	}
	result, err := stmt.Exec(userAddr, userId)
	if err != nil {
		//SQL执行失败，直接panic
		panic(err)
	}
	//提交事务
	tx.Commit()
	return result.RowsAffected()
}

　　更新代码如上，和删除方法类似，无需多言。

package service

import (
	_ "database/sql"
	"firstgo/src/dao"
	"firstgo/src/entity"
)

func QueryList() []entity.User {
	db := dao.InitDB()

	sql := "select * from user "
	stmt, err := db.Prepare(sql)
	if err != nil {
		panic(err)
	}

	rows, err := stmt.Query()
	if err != nil {
		//SQL执行失败，直接panic
		panic(err)
	}

	var users []entity.User
	for rows.Next() {
		var id int
		var name, password string
		err := rows.Scan(&id, &name, &password)
		if err != nil {
			//读取结果集失败
			panic(err)
		}

		var user entity.User
		user.SetUserId(id)
		user.SetUserName(name)
		user.SetUserAddr(password)
		users = append(users, user)
	}

	return users
}

　　查询列表方法如上，从代码中，可以看到go中数组的写法和我们正常写法不一样，需要适应。

//package名称需要设置为main，才会进入main方法运行
package main

import (
	"firstgo/src/service"
	"fmt"
)

func main() {

	//新增
	recordId, err := service.CreateRecord()
	if err == nil && recordId > 0 {
		fmt.Println("插入成功，id：", recordId)
	}

	//删除
	var removedRecordId = 1
	rowAffected, err := service.DeleteRecord(removedRecordId)
	if err == nil && rowAffected>0 {
		fmt.Println("删除成功，id:", removedRecordId )
	}

	//更新
	var userAddr = "shanghai, china"
	var updateRecordId = 3
	record, err := service.UpdateRecord(userAddr, updateRecordId)
	if err == nil && record>0{
		fmt.Println("更新成功，id:", updateRecordId)
	}

	//查询
	queryList := service.QueryList()
	if queryList != nil{
		fmt.Println("查询列表，list:", queryList)
	}
}

　　写好后，在main.go中运行起来即可。记住，main方法的运行一定要有个package为main的包，否则会报错。运行起来后，我们就可以看到如下输出了：

插入成功，id： 9
更新成功，id: 3
查询列表，list: [{2 testuser china, beijing} {3 testuser shanghai, china} {4 testuser china, beijing} {5 testuser china, beijing} {6 testuser china, beijing} {7 testuser china, beijing} {8 testuser china, beijing} {9 testuser china, beijing}]

Process finished with the exit code 0

　　是不是很简单？

参考

https://blog.csdn.net/qq_45193304/article/details/105464606