分类 golang 中的文章

First_beego

2021年11月26日
| golang

使用beego创建api项目，实现增删改查，简单记录

1.mac安装beego和bee工具

1
2

go get -u github.com/beego/beego/v2
go get -u github.com/beego/bee/v2
  • 如果需要bee设置为全局变量，添加zshrc全局alias，在~/.zshrc中编辑添加alias bee=xxx/bee
  • beego官方文档

2.使用bee工具创建项目

1

bee api app_delivery -conn="root:root****@tcp(127.0.0.1:3306)/test-beego
  • 创建后orm.RegisterDataBase(“default”, “mysql”, beego.AppConfig.String(“sqlconn”))有报错，通过参数接收下beego.AppConfig.String(“sqlconn”）,因为有两个返回值

3.models层user.go实现代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

package models

import (
	"fmt"
	"github.com/beego/beego/v2/client/orm"
	beego "github.com/beego/beego/v2/server/web"
	_ "github.com/go-sql-driver/mysql"
)

func init() {
	orm.Debug = true
	orm.RegisterDriver("mysql", orm.DRMySQL)
	db,_ := beego.AppConfig.String("sqlconn")
	orm.RegisterDataBase("default", "mysql", db)
	orm.RegisterModel(new(User))
	orm.RunSyncdb("default", false, true)
}


type User struct {
	Id           int       `orm:"column(id);pk"`
	Name         string    `orm:"column(name)"`
	UserId        string    `orm:"column(User_id)"`
}

func AddUser(user *User) error{
	o:= orm.NewOrm()
	_, err := o.Insert(user)
	return err
}

func GetUser(user_id string) (*User, bool){
	o := orm.NewOrm()
	User := User{UserId: user_id}
	err := o.Read(&User,"User_id")
	if err == orm.ErrNoRows {
		fmt.Println("User not find")
		return &User, false
	} else if err == orm.ErrMissPK {
		fmt.Println("cant not find prikey")
		return &User, false
	} else {
		return &User, true
	}
}

func DeleteUser(user_id string) bool {
	o := orm.NewOrm()
	User := User{UserId: user_id}
	num, err := o.Delete(&User,"user_id")
	if err == nil {
		fmt.Println("delete num:", num)
		return true
	} else {
		return false
	}
}

func GetUserAll() []User{
	o := orm.NewOrm()
	qs:= o.QueryTable("user")
	var users []User
	count, err := qs.All(&users)
	if err != nil{
		fmt.Println("get all User failed")
	}
	fmt.Println("the count User is ",count)
	return users
}

4.controllers层user.go实现代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

package controllers

import (
	"test-beego/models"
	"encoding/json"
	"fmt"
	beego "github.com/beego/beego/v2/server/web"

)

type UserController struct{
	beego.Controller
}

type Result struct {
	ErrNo    int           `json:"errno"`
	ErrMsg   string        `json:"errmsg"`
	Data     interface{}   `json:"data"`
}


func (d *UserController) CreateUser(){
	var user models.User
	var r Result
	defer func() {
		d.Data["json"] = r
		d.ServeJSON()
	}()
	err := json.Unmarshal(d.Ctx.Input.RequestBody, &user)
	if err !=nil{
		r.ErrMsg = fmt.Sprintf(" json unmarshal failed")
	}
	err :=models.AddUser(&User)
	if err != nil{
		r.ErrMsg=fmt.Sprintf("add user failed")
	}
	r.Data = user
}

func (d *UserController) GetUser(){
	var r Result
	defer func() {
		d.Data["json"] = r
		d.ServeJSON()
	}()
	r.Data,_ = models.GetUser(d.GetString(":user_id"))
	fmt.Println(d.GetString(":user_id"))
}

func (d *UserController) DeleteUser(){
	var r Result
	defer func() {
		d.Data["json"] = r
		d.ServeJSON()
	}()
	DelUserId := d.GetString(":user_id")
	IsTrue:=models.DeleteUser(DelUserId)
	if !IsTrue {
		r.ErrMsg =fmt.Sprintf("delete User failed")
	}
	var arry []string
	arry = append(arry, DelUserId)
	mp:= make(map[string][]string)
	mp["success_list"]= arry
	r.Data = mp
}

func (d *UserController) GetUserAll(){
	var r Result
	defer func() {
		d.Data["json"] = r
		d.ServeJSON()
	}()
	r.Data = models.GetUserAll()
}
//TODO 懒得写了
func (c *UserController) EditTask(){

}

5.路由router.go代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package routers

import (
	"app_delivery/controllers"
	beego "github.com/beego/beego/v2/server/web"
)

func init() {
	ns := beego.NewNamespace("/v1")
	beego.AddNamespace(ns)
	beego.Router("/api/users", &controllers.DeliveryController{}, "post:CreateUser")
	beego.Router("/api/users/?:user_id", &controllers.DeliveryController{}, "get:GetUser")
	beego.Router("/api/users/?:user_id", &controllers.DeliveryController{}, "delete:DeleteUser")
	beego.Router("/api/users/getall", &controllers.DeliveryController{}, "get:GetUserAll")
}

6. Main.go主要代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package main

import (
	_ "app_delivery/routers"
	beego "github.com/beego/beego/v2/server/web"
	_ "github.com/go-sql-driver/mysql"
)

func main() {
	if beego.BConfig.RunMode == "dev" {
		beego.BConfig.WebConfig.DirectoryIndex = true
		beego.BConfig.WebConfig.StaticDir["/swagger"] = "swagger"
	}
	beego.Run()
}
……

阅读全文

golang中的map

2019年11月16日
| golang

golang中map学习

哈希表

哈希表是一个无序的key/value对的集合，其中所有的key都是不同的，然后通过给定的key可以在常数时间复杂度内检索、更新或删除对应的value；

golang中的map

在Go语言中，一个map就是一个哈希表的引用，map类型可以写为map[K]V，其中K和V分别对应key和value。map中所有的key都有相同的类型，所有的value也有着相同的类型，但是key和value之间可以是不同的数据类型。

……

阅读全文

go解决leetcode-242

2019年8月4日
| golang

解决思路：使用map来解决问题；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

package main

import (
	"fmt"
	"reflect"
)

func isAnagram(s string, t string) bool {
	// var m1 map[string]int
	// var m2 map[string]int
	//map申明后默认是nil，得用make进行实例化
	m1 := make(map[string]int)
	m2 := make(map[string]int)

	for _, i := range s {
		m1[string(i)]++
	}
	for _, j := range t {
		m2[string(j)]++
	}
	return reflect.DeepEqual(m1, m2)
	//map不能直接用“==”进行比较

}

func main() {
	s := "hello"
	t := "lelho"
	// isAnagram(s, t)
	fmt.Println(isAnagram(s, t))

}

自己实现map比较函数equal，如下：

……

阅读全文

go实现单链表反转

2019年4月24日
| golang leetcode

单链表核心代码如下：

1.迭代方法：

1
2
3
4
5
6
7
8

func reverseList(node *ListNode) *ListNode {
	cur := node
	var pre *ListNode
	for cur != nil {
		cur.Next, pre, cur = pre, cur, cur.Next
	}
	return pre
}

理解：cur指向当前节点，pre是前节点初始为nil，反转过程：

1
2
3
4

next := cur.next //新建一个临时节点用于保存cur.next，不然会丢失
cur.next = pre
pre = cur
cur = next

2.递归方式

……

阅读全文

go实现选择排序

2019年4月22日
| golang
选择排序：对于给定的一组记录，经过第一轮比较之后得到最小记录，然后将该记录与第一个记录的位置进行交换；接着对对不包括第一个记录以外的其他记录进行第二轮比较，得到的最小记录与第二个记录进行位置交换；重复该过程，直到进行比较的记录只有一个为止。

具体实现如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package main

import "fmt"

func SelectSort(data []int) {
	length := len(data)
	for i := 0; i < length; i++ {
		tmp := data[i]
		flag := i
		for j := i + 1; j < length; j++ {
			if data[j] < tmp {
				tmp = data[j]
				flag = j
			}
		}

		if flag != i {
			data[flag] = data[i]
			data[i] = tmp
		}
		fmt.Println(data) //为了看具体排序的过程

	}
}

func main() {
	data := []int{44, 38, 65, 97, 76, 14, 27, 48}
	SelectSort(data)
	fmt.Println(data)
}

输出结果如下：

……

阅读全文

go语言中使用defer、panic、recover处理异常

2019年4月19日
| golang

go语言中的异常处理，没有try…catch等，而是使用defer、panic、recover来处理异常。

知识点：defer、panic、recover，异常处理

1、首先，panic 是用来表示非常严重的不可恢复的错误的。在Go语言中这是一个内置函数，如果在程序中遇到异常，或者调用panic函数，程序会立即退出（除非recover）。如下代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

package main

import "fmt"

func main() {
	a := 10
	b := 0
	c := a / b

	fmt.Println(c)
}

程序的输出如下：

……

阅读全文

goroute应用-模拟远程调用RPC

2019年4月19日
| golang

在本例中，使用通道代替socket实现RPC过程，客户端和服务器运行在同一个进程，服务器和客户端在两个goroute中。

应用知识：goroute，select，RPC过程

1、客户端请求和接收封装

下面的代码封装了向服务器请求数据，等待服务器返回数据，如果请求方超时，利用select，该函数还会处理超时逻辑。如下：

1
2
3
4
5
6
7
8
9

func RPCClient(ch chan string, req string) (string, error) {
	ch <- req
	select {
	case ack := <-ch:
		return ack, nil
	case <-time.After(time.Second):
		return "", errors.New("Time out")
	}
}

2、服务器接收和反馈数据

服务器接收到客户端的任意数据后，先打印再通过通道返回给客户端一个固定的字符串（hello），表示服务器已经收到请求。

……

阅读全文

goroute之间通信-共享全局变量(理解go的多并发)

2019年4月5日
| golang

1、go语言中goroute之间通信有两种方式：

  • 通过全局变量，这种方式得加锁
  • 通过channel进行通信

下面是一个通过全局变量进行通信的例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

package main

import (
	"fmt"
	"sync"
	"time"
)

var (
	m    = make(map[int]uint64)
	lock sync.Mutex
)

type task struct {
	n int
}

func calc(t *task) {
	var sum uint64
	sum = 1
	for i := 1; i < t.n; i++ {
		sum *= uint64(i)
	}
	lock.Lock()
	m[t.n] = sum
	lock.Unlock()
}

func main() {
	for i := 0; i < 20; i++ {
		t := &task{n: i}
		go calc(t)
	}
	time.Sleep(10 * time.Second)

	lock.Lock()
	for k, v := range m {
		fmt.Printf("%d!=%v\n", k, v)
	}
	lock.Unlock()

}

输出结果如下：

……

阅读全文

  1. 1
  2. 2