个人项目

1
2
3
4
5
6
7
8
9

func main() {
    http.HandleFunc("/", handler)
    http.HandleFunc("/count", counter)
    log.Fatal(http.ListenAndServe("localhost:8000", nil))
}

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)
}

1
2
3
4
5
6
7

package http

type Handler interface {
    ServeHTTP(w ResponseWriter, r *Request)
}

func ListenAndServe(address string, h Handler) error

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

func main() {
	r := gee.New()
	r.GET("/", func(w http.ResponseWriter, req *http.Request) {
		fmt.Fprintf(w, "URL.Path = %q\n", req.URL.Path)
	})

	r.GET("/hello", func(w http.ResponseWriter, req *http.Request) {
		for k, v := range req.Header {
			fmt.Fprintf(w, "Header[%q] = %q\n", k, v)
		}
	})

	r.Run(":9999")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

obj = map[string]interface{}{
    "name": "geektutu",
    "password": "1234",
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
encoder := json.NewEncoder(w)
if err := encoder.Encode(obj); err != nil {
    http.Error(w, err.Error(), 500)
}

1
2
3
4

c.JSON(http.StatusOK, gee.H{
    "username": c.PostForm("username"),
    "password": c.PostForm("password"),
})

  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
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102

package gee

import (
	"encoding/json"
	"fmt"
	"net/http"
)

type H map[string]interface{}

type Context struct {
	// origin objects
	W   http.ResponseWriter
	Req *http.Request

	// req info
	Path   string            // 其实就是 pattern
	Method string            // 请求方法
	Params map[string]string // 存储Path传递的参数

	// resp info
	StatusCode int // 响应码

	// middleware
	handlers []HandlerFunc // 存储中间件
	index    int           // 记录当前执行到第几个中间件

	// engine pointer
	engine *Engine
}

func NewContext(w http.ResponseWriter, req *http.Request) *Context {
	return &Context{
		W:      w,
		Req:    req,
		Path:   req.URL.Path,
		Method: req.Method,
		index:  -1,
	}
}

// 获取传递的参数
func (c *Context) Param(key string) string {
	return c.Params[key]
}

// 获取Form的数据
func (c *Context) PostForm(key string) string {
	return c.Req.FormValue(key)
}

// 获取Query的数据
func (c *Context) Query(key string) string {
	return c.Req.URL.Query().Get(key)
}

func (c *Context) Status(code int) {
	c.StatusCode = code
	c.W.WriteHeader(code)
}

func (c *Context) SetHeader(key string, value string) {
	c.W.Header().Set(key, value)
}

func (c *Context) String(code int, format string, values ...interface{}) {
	c.SetHeader("Content-Type", "text/plain")
	c.Status(code)
	c.W.Write([]byte(fmt.Sprintf(format, values...)))
}

func (c *Context) Data(code int, data []byte) {
	c.Status(code)
	c.W.Write(data)
}

func (c *Context) JSON(code int, obj interface{}) {
	c.SetHeader("Content-Type", "application/json")
	c.Status(code)
	encoder := json.NewEncoder(c.W)
	if err := encoder.Encode(obj); err != nil {
		http.Error(c.W, err.Error(), 500)
	}
}

func (c *Context) HTML(code int, name string, data interface{}) {
	c.SetHeader("Content-Type", "text/html")
	c.Status(code)
	if err := c.engine.htmlTemplates.ExecuteTemplate(c.W, name, data); err != nil {
		c.String(500, err.Error())
	}
}

// middleware
func (c *Context) Next() {
	c.index++
	s := len(c.handlers)
	for c.index < s {
		c.handlers[c.index](c)
		c.index++
	}
}

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

type Cache struct {
	MaxEntries int
	OnEvicted func(key Key, value interface{})
    
	ll    *list.List	// 真正存储 entry 指针的地方
	cache map[interface{}]*list.Element	// 存储 key - entry，用于快速找到 entry
}

type Key interface{}

type entry struct {
	key   Key
	value interface{}
}

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

// Add adds a value to the cache.
func (c *Cache) Add(key Key, value interface{}) {
	if c.cache == nil {
		c.cache = make(map[interface{}]*list.Element)
		c.ll = list.New()
	}
	if ee, ok := c.cache[key]; ok {
		c.ll.MoveToFront(ee)
		ee.Value.(*entry).value = value
		return
	}
	ele := c.ll.PushFront(&entry{key, value})	// ll 中存储的其实是 entry 对象的指针
	c.cache[key] = ele
	if c.MaxEntries != 0 && c.ll.Len() > c.MaxEntries {
		c.RemoveOldest()
	}
}

1
2
3
4
5

type cache struct {
	mu         sync.Mutex // 支持并发, 必须有锁
	lru        *lru.Cache
	cacheBytes int64	  // 缓存容量 Byte
}

1
2
3
4
5
6
7
8

/*
	                        是
接收 key --> 检查是否被缓存 -----> 返回缓存值 ⑴
                |  否                         是
                |-----> 是否应当从远程节点获取 -----> 与远程节点交互 --> 返回缓存值 ⑵
                            |  否
                            |-----> 调用`回调函数`，获取值并添加到缓存 --> 返回缓存值 ⑶
*/

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

// Getter 未命中时从数据源获取数据
type Getter interface {
	Get(key string) ([]byte, error) // 回调函数
}

// 函数类型实现某一个接口，称之为接口型函数。
// 方便使用者在调用时既能够传入函数作为参数，也能够传入实现了该接口的结构体作为参数。
// 是一个将函数转换为接口的技巧

type GetterFunc func(key string) ([]byte, error)

// Get 实现Getter接口
func (f GetterFunc) Get(key string) ([]byte, error) {
	return f(key)
}

1
2
3
4
5
6
7
8

type Hash func(data []byte) uint32

type Map struct {
    hash     Hash			// 可更换用户自定义的哈希函数，默认为crc32.ChecksumIEE()
	replicas int			// 虚拟节点倍数，即一个真实节点对应replicas个虚拟节点
	keys     []int 			// 哈希环，存储每个节点的hash值
	hashMap  map[int]string	// 节点哈希值 - 真实节点名称
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func (m *Map) Add(keys ...string) {	// keys是节点名称
	for _, key := range keys {
		for i := 0; i < m.replicas; i++ {	// 每个真实节点都创建replicas个虚拟节点
            hash := int(m.hash([]byte(strconv.Itoa(i) + key)))	// 求 虚拟节点("i+key") 的哈希值
			m.keys = append(m.keys, hash)						// 加入哈希环
			m.hashMap[hash] = key								// 虚拟节点 - 真实节点
		}
	}
	sort.Ints(m.keys)											// 排序
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func (m *Map) Get(key string) string {	// key是查找键值对的建
	if len(m.keys) == 0 {
		return ""
	}
	hash := int(m.hash([]byte(key)))	
	// 二分查找
	idx := sort.Search(len(m.keys), func(i int) bool {
        return m.keys[i] >= hash		// 在哈希环上查找所在的节点(真实/虚拟)
	})
	return m.hashMap[m.keys[idx%len(m.keys)]] // 根据节点值在hashMap中查找对应的真实节点
}

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

// HTTPPool 承载节点间 HTTP 通信的核心数据结构
type HTTPPool struct {
	self        string                 // 记录自己的地址，包括主机名/IP 和端口
	basePath    string                 // 节点间通讯地址的前缀，默认是 /_geecache/
	mu          sync.Mutex             // 保护peers和httpGetters
	peers       *consistenthash.Map    // 根据具体的 key 选择节点
	httpGetters map[string]*httpGetter // 映射远程节点与对应的 httpGetter, 每一个远程节点对应一个 httpGetter
}

type PeerPicker interface {	
	PickPeer(key string) (peer PeerGetter, ok bool)		// 根据传入的key，选择相应的节点
}

type PeerGetter interface {
	Get(group string, key string) ([]byte, error)		// 根据传入的key 和 选择的节点，查找缓存值
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 根据具体的 key，选择节点，返回节点对应的 HTTP 客户端
func (p *HTTPPool) PickPeer(key string) (PeerGetter, bool) {
	p.mu.Lock()
	defer p.mu.Unlock()
	if peer := p.peers.Get(key); peer != "" && peer != p.self {		// 似乎哈希环也存在于客户端
		p.Log("Pick peer %s", peer)
		return p.httpGetters[peer], true
	}
	return nil, false
}

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

// 实例化一致性哈希算法，并且添加传入的节点。
func (p *HTTPPool) Set(peers ...string) {
	p.mu.Lock()
	defer p.mu.Unlock()
	p.peers = consistenthash.NewMap(defaultReplicas, nil)
	p.peers.Add(peers...)
	p.httpGetters = make(map[string]*httpGetter, len(peers))
	for _, peer := range peers {
		p.httpGetters[peer] = &httpGetter{
			baseURL: peer + p.basePath,
		}
	}
}

 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

// Get 向指定节点查找缓存值
func (h *httpGetter) Get(in *pb.Request, out *pb.Response) error {
	u := fmt.Sprintf(
		// baseURL 表示将要访问的远程节点的地址
		// 例如 http://example.com/_geecache/
		"%v%v/%v", h.baseURL, url.QueryEscape(in.GetGroup()), url.QueryEscape(in.GetKey()),
	)
	res, err := http.Get(u)
	if err != nil {
		return err
	}
	defer res.Body.Close()

	if res.StatusCode != http.StatusOK {
		return fmt.Errorf("server returned: %v", res.Status)
	}

	bytes, err := ioutil.ReadAll(res.Body)
	if err != nil {
		return fmt.Errorf("reading response body: %v", err)
	}
	if err = proto.Unmarshal(bytes, out); err != nil {
		return fmt.Errorf("decoding response body: %v", err)
	}

	return nil
}

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

// call 代表正在进行中，或已经结束的请求。每个 call 使用 sync.WaitGroup 锁避免重入。
type call struct {
	wg  sync.WaitGroup
	val interface{}
	err error
}

// Group 是 singleflight 的主数据结构，管理不同 key 的请求(call)。
type Group struct {
	mu sync.Mutex			// 锁
	m  map[string]*call		// 管理不同 key 的 call请求
}

 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

// 针对相同的 key，无论 Do 被调用多少次，函数 fn 都只会被调用一次，等待 fn 调用结束了，返回返回值或错误。
func (g *Group) Do(key string, fn func() (interface{}, error)) (interface{}, error) {
	g.mu.Lock()
	if g.m == nil {
		g.m = make(map[string]*call)
	}
	if c, ok := g.m[key]; ok {		// 若本次的 key 已经有 call请求正在进行中
		g.mu.Unlock()
		c.wg.Wait() 				// 如果请求正在进行中，则等待
		return c.val, c.err
	}
	c := new(call)
	c.wg.Add(1)  // 发起请求前加锁
	g.m[key] = c // 添加到 g.m，表明 key 已经有对应的请求在处理
	g.mu.Unlock()

	c.val, c.err = fn() // 调用 fn，发起请求
	c.wg.Done()         // 请求结束

	g.mu.Lock()
	delete(g.m, key) // 更新 g.m
	g.mu.Unlock()

	return c.val, c.err
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

.
|-- clause			// 5. 生成sql语句
|   |-- clause.go			// 组合sql子句为完整句子
|   `-- generator.go		// 生成拼合用到的sql子句 
|-- cmd
|   |-- gee.db
|   `-- main.go
|-- dialect			// 3. 抽象出各个数据库差异的部分
|   |-- dialect.go			// Go的数据类型 转换成 数据库的数据类型
|   `-- sqlite3.go			// 这是个示例：sqlite3的数据类型转换。要支持其他数据库，还需要添加对应数据库的
|-- geeorm.go		// 2. 与用户交互的入口：交互前的准备工作（比如连接/测试），交互后的收尾工作（关闭连接）
|-- schema			// 4. 负责 对象 --> 表 的转换
|   `-- schema.go			// schema就是存放 要转换成的表 的信息
`-- session			// 1. 用来和数据库交互
    |-- hooks.go			// 钩子
    |-- raw.go				// 直接调用 SQL 语句进行原生交互的部分
    |-- record.go			// 用户直接调用的增删查改接口
    |-- record_test.go
    |-- table.go			// "表"的增删查
    `-- transaction.go		// 事务

1
2
3
4

type User struct {
    Name string `geeorm:"PRIMARY KEY"`
    Age  int
}

1

CREATE TABLE `User` (`Name` text PRIMARY KEY, `Age` integer);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// 1. 要转换成的
// Schema 代表一张表
type Schema struct {
	Model      interface{}       // 被映射的对象
	Name       string            // 表名
	Fields     []*Field          // 所有的字段信息
	FieldNames []string          // 所有的字段名
	fieldMap   map[string]*Field // 映射 [字段名: *Field]
}
// Field 字段的信息
type Field struct {
	Name string // 字段名
	Type string // 类型
	Tag  string // 约束条件
}

// 2. 转换对象，示例
type User struct {
	name string `geeorm:"primary"`
	age  int    `geeorm:"age"`
}

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

// 1. 得到该结构体的类型元数据
modelType := reflect.Indirect(reflect.ValueOf(dest)).Type()
// 2. 建立Schema实例，也即映射到的表结构
schema := &Schema{	
    Model:    dest,
    Name:     modelType.Name(), // 结构体的名称作为表名
    fieldMap: make(map[string]*Field),
}
// 3. 得到该结构体所有的字段
for i := 0; i < modelType.NumField(); i++ {
    p := modelType.Field(i)
    field := &Field{
        Name: p.Name,
        Type: d.DataTypeOf(reflect.Indirect(reflect.New(p.Type))),	// 会通过reflect.Kind转换类型
    }
}
// 4. 在tag中寻找约束条件，比如主键之类的
if v, ok := p.Tag.Lookup("geeorm"); ok {
    field.Tag = v
}
// 5. 往Schema中添加结构体的字段
schema.Fields = append(schema.Fields, field)
schema.FieldNames = append(schema.FieldNames, p.Name)
schema.fieldMap[p.Name] = field

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// CreateTable 创建表
func (s *Session) CreateTable() error {
	table := s.RefTable()		// table就是schema，也就是表的信息
	var columns []string
	for _, field := range table.Fields {
		columns = append(columns, fmt.Sprintf("%s %s %s", field.Name, field.Type, field.Tag))
	}
	desc := strings.Join(columns, ",")
	_, err := s.Raw(fmt.Sprintf("CREATE TABLE %s (%s);", table.Name, desc)).Exec()
	return err
}

 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

// Type SQL 语句种类
type Type int

const (
	INSERT Type = iota
	VALUES
	SELECT
	LIMIT
	WHERE
	ORDERBY
	UPDATE
	DELETE
	COUNT
)

// Clause 组合 SQL 独立语句为完整句子
type Clause struct {
	sql     map[Type]string        // SQL 语句
	sqlVars map[Type][]interface{} // 参数
}

// Set 按照SQL语句的Name和参数, 得到子句
func (c *Clause) Set(name Type, vars ...interface{}) {
	if c.sql == nil {
		c.sql = make(map[Type]string)
		c.sqlVars = make(map[Type][]interface{})
	}
	sql, vars := generators[name](vars...)
	c.sql[name] = sql
	c.sqlVars[name] = vars
}

// Build 按照传入子句类型的顺序，构造最终的SQL语句
func (c *Clause) Build(orders ...Type) (string, []interface{}) {
	var sqls []string
	var vars []interface{}
	for _, order := range orders {
		if sql, ok := c.sql[order]; ok {
			sqls = append(sqls, sql)
			vars = append(vars, c.sqlVars[order]...)
		}
	}
	return strings.Join(sqls, " "), vars
}

1
2
3
4
5

SELECT col1, col2, ...
    FROM table_name
    WHERE [ conditions ]
    GROUP BY col1
    HAVING [ conditions ]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

func _select(values ...interface{}) (string, []interface{}) {
	// SELECT $fields FROM $tableName
	tableName := values[0]
	fields := strings.Join(values[1].([]string), ",")
	return fmt.Sprintf("SELECT %v FROM %s", fields, tableName), []interface{}{}
}

func _limit(values ...interface{}) (string, []interface{}) {
	// LIMIT $num
	return "LIMIT ?", values
}

func _where(values ...interface{}) (string, []interface{}) {
	// WHERE $desc
	desc, vars := values[0], values[1:]
	return fmt.Sprintf("WHERE %s", desc), vars
}

func _orderBy(values ...interface{}) (string, []interface{}) {
	return fmt.Sprintf("ORDER BY %s", values[0]), []interface{}{}
}

1
2
3
4
5
6
7
8

var clause Clause
clause.Set(LIMIT, 3)
clause.Set(SELECT, "User", []string{"*"})
clause.Set(WHERE, "Name = ?", "Tom")
clause.Set(ORDERBY, "Age ASC")
sql, vars := clause.Build(SELECT, WHERE, ORDERBY, LIMIT)
// sql:  SELECT * FROM User WHERE Name = ? ORDER BY Age ASC LIMIT ?
// vars: "Tom", 3 

1
2
3
4

INSERT INTO table_name(col1, col2, col3, ...) VALUES
    (A1, A2, A3, ...),
    (B1, B2, B3, ...),
    ...

1
2
3
4

s := geeorm.NewEngine("sqlite3", "gee.db").NewSession()
u1 := &User{Name: "Tom", Age: 18}
u2 := &User{Name: "Sam", Age: 25}
s.Insert(u1, u2, ...)

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

// Insert 插入 values 到 sql
func (s *Session) Insert(values ...interface{}) (int64, error) {
	recordValues := make([]interface{}, 0)
	for _, value := range values { // 这里写的其实不好，插入对象其实要属于同一个表中
		table := s.Model(value).RefTable()                             // 获取表的结构
		s.clause.Set(clause.INSERT, table.Name, table.FieldNames)      // 构造插入语句前半段, 按理来说只需要构造一次
		recordValues = append(recordValues, table.RecordValues(value)) // 得到每个对象内的参数值
	}

	s.clause.Set(clause.VALUES, recordValues...)
	sql, vars := s.clause.Build(clause.INSERT, clause.VALUES) // 对同一个表，一次性插入多个对象
	result, err := s.Raw(sql, vars...).Exec()
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}

1
2
3

s := geeorm.NewEngine("sqlite3", "gee.db").NewSession()
var users []User
s.Find(&users);		// 取出 User 表中的所有行，并存储到 User 对象Slice

 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

// Find 获取 values表 中所有对象, values 是对象类型的切片地址
func (s *Session) Find(values interface{}) error {
	destSlice := reflect.Indirect(reflect.ValueOf(values))
	destType := destSlice.Type().Elem() // 切片包含的元素的type
	table := s.Model(reflect.New(destType).Elem().Interface()).RefTable()

	s.clause.Set(clause.SELECT, table.Name, table.FieldNames)
	sql, vars := s.clause.Build(clause.SELECT, clause.WHERE, clause.ORDERBY, clause.LIMIT)
	rows, err := s.Raw(sql, vars...).QueryRows()
	if err != nil {
		return err
	}

	for rows.Next() {
		dest := reflect.New(destType).Elem() // 利用反射 创建 destType 的实例 dest
		var values []interface{}
		for _, name := range table.FieldNames {
			values = append(values, dest.FieldByName(name).Addr().Interface())
		}
		if err := rows.Scan(values...); err != nil {
			return err
		} // 调用 rows.Scan() 将该行记录每一列的值依次赋值给 values 中的每一个字段
		destSlice.Set(reflect.Append(destSlice, dest)) // 向切片中添加元素
	}
	return rows.Close()
}

1
2
3

s := geeorm.NewEngine("sqlite3", "gee.db").NewSession()
var users []User
s.Where("Age > 18").Limit(3).Find(&users)	// 链式调用

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

func (s *Session) Limit(num int) *Session {
	s.clause.Set(clause.LIMIT, num)
	return s
}

func (s *Session) Where(desc string, args ...interface{}) *Session {
	var vars []interface{}
	s.clause.Set(clause.WHERE, append(append(vars, desc), args...)...)
	return s
}

func (s *Session) OrderBy(desc string) *Session {
	s.clause.Set(clause.ORDERBY, desc)
	return s
}

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

// First 返回第一行数据, 并构造成对象, 参数为对象地址
func (s *Session) First(value interface{}) error {
	dest := reflect.Indirect(reflect.ValueOf(value))
	destSlice := reflect.New(reflect.SliceOf(dest.Type())).Elem()
	if err := s.Limit(1).Find(destSlice.Addr().Interface()); err != nil {	// 链式调用
		return err
	}
	if destSlice.Len() == 0 {
		return errors.New("NOT FOUND")
	}
	dest.Set(destSlice.Index(0))	// 对原对象进行设置
	return nil
}

 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

const (
	BeforeQuery  = "BeforeQuery"
	AfterQuery   = "AfterQuery"
	BeforeUpdate = "BeforeUpdate"
	AfterUpdate  = "AfterUpdate"
	BeforeDelete = "BeforeDelete"
	AfterDelete  = "AfterDelete"
	BeforeInsert = "BeforeInsert"
	AfterInsert  = "AfterInsert"
)

// CallMethod 调用注册的 method
// method 是对象拥有的方法名, value 是对象的地址
func (s *Session) CallMethod(method string, value interface{}) {
	// s.RefTable().Model 或 value 即当前会话正在操作的对象,
	// 使用 MethodByName 方法反射得到该对象的方法。
	fm := reflect.ValueOf(s.RefTable().Model).MethodByName(method)
	if value != nil {
		fm = reflect.ValueOf(value).MethodByName(method)	// 得到该对象定义好的 method
	}
	param := []reflect.Value{reflect.ValueOf(s)} // 每一个钩子的入参类型均是 *Session
	if fm.IsValid() {
		if v := fm.Call(param); len(v) != 0 {
			if err, ok := v[0].Interface().(error); ok {
				log.Error(err)
			}
		}
	}
	return
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func (s *Session) Find(values interface{}) error {
	s.CallMethod(BeforeQuery, nil)
    // ...
    for rows.Next() {
        dest := reflect.New(destType).Elem()
        // ...
        s.CallMethod(AfterQuery, dest.Addr().Interface())	// 钩子的位置放在查询完单行数据之后
        // ...
	}
	return rows.Close()
}

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

type Account struct {
	ID       int `geeorm:"PRIMARY KEY"`
	Password string
}
// 定义 AfterQuery 方法
func (account *Account) AfterQuery(s *Session) error {
	log.Info("after query", account)
	account.Password = "******"
	return nil
}

func TestSession_CallMethod(t *testing.T) {
	s := NewSession().Model(&Account{})
	_ = s.DropTable()
	_ = s.CreateTable()
	_, _ = s.Insert(&Account{1, "123456"}, &Account{2, "qwerty"})

	u := &Account{}

	err := s.First(u)
	if err != nil || u.ID != 1001 || u.Password != "******" {
		t.Fatal("Failed to call hooks after query, got", u)
	}
}

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

func main() {
	db, _ := sql.Open("sqlite3", "gee.db")
	defer func() { _ = db.Close() }()
	_, _ = db.Exec("CREATE TABLE IF NOT EXISTS User(`Name` text);")

	tx, _ := db.Begin()	// 开启事务
	_, err1 := tx.Exec("INSERT INTO User(`Name`) VALUES (?)", "Tom")
	_, err2 := tx.Exec("INSERT INTO User(`Name`) VALUES (?)", "Jack")
	if err1 != nil || err2 != nil {
		_ = tx.Rollback()	// 若发生错误，就回滚
		log.Println("Rollback", err1, err2)
	} else {
		_ = tx.Commit()		// 若正常执行，就提交
		log.Println("Commit")
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

func (s *Session) Begin() (err error) {
	log.Info("transaction begin")
	if s.tx, err = s.db.Begin(); err != nil {	// 得到 sql.tx对象
		log.Error(err)
	}
	return
}

func (s *Session) Commit() (err error) {
	log.Info("transaction commit")
	if err = s.tx.Commit(); err != nil {		// 封装 Commit 方法
		log.Error(err)
	}
	return
}

func (s *Session) Rollback() (err error) {
	log.Info("transaction rollback")
	if err = s.tx.Rollback(); err != nil {		// 封装 Rollback 方法
		log.Error(err)
	}
	return
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

type txFunc func(*session.Session) (interface{}, error)
// 主要做的事情就是，省略了用户自己调用 sql.tx.Begin() 和 sql.tx.Commit()、sql.tx.Rollback()
func (engine *Engine) Transaction(f txFunc) (result interface{}, err error) {
	s := engine.NewSession()
    // 开启事务
	if err := s.Begin(); err != nil {
		return nil, err
	}
    // 结束事务
	defer func() {
		if p := recover(); p != nil {
			_ = s.Rollback()
			panic(p)
		} else if err != nil {
			_ = s.Rollback()
		} else {
			err = s.Commit()
		}
	}()
    // 这是用户传进来的所有操作
	return f(s)
}

1
2
3

CREATE TABLE new_table AS SELECT col1, col2, ... from old_table
DROP TABLE old_table
ALTER TABLE new_table RENAME TO old_table;

 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

// difference returns a - b 即: 新表 - 旧表 = 新增字段，旧表 - 新表 = 删除字段
// a: a表的字段  b: bb字段
func difference(a []string, b []string) (diff []string) {
	mapB := map[string]bool{}
	for _, v := range b {
		mapB[v] = true
	}

	for _, v := range a {
		if _, exist := mapB[v]; !exist {
			diff = append(diff, v)
		}
	}
	return
}

// Migrate 迁移表
// value: 新表的结构体对象
func (engine *Engine) Migrate(value interface{}) error {
	// 利用事务 保持原子性
	_, err := engine.Transaction(func(s *session.Session) (result interface{}, err error) {
		if !s.Model(value).HasTable() {
			log.Infof("table %s doesn't exist", s.RefTable().Name)
			return nil, s.CreateTable()
		}
		// table 是新表的结构
		table := s.RefTable()
		// 查询旧表
		rows, _ := s.Raw(fmt.Sprintf("SELECT * FROM %s LIMIT 1", table.Name)).QueryRows()
		columns, _ := rows.Columns()
		// 增加的列
		addCols := difference(table.FieldNames, columns)
		// 删去的列
		delCols := difference(columns, table.FieldNames)
		log.Infof("added cols %v, deleted cols %v", addCols, delCols)

		// 在旧表中添加列
		for _, col := range addCols {
			f := table.GetField(col)
			sqlStr := fmt.Sprintf("ALTER TABLE %s ADD COLUMN %s %s;", table.Name, f.Name, f.Type)
			if _, err = s.Raw(sqlStr).Exec(); err != nil {
				return
			}
		}

		if len(delCols) == 0 {
			return
		}
		// 只选旧表中指定列(即新表的所有列)，转移到新表，删除旧表，新表改名为旧表
		tmp := "tmp_" + table.Name
		fieldStr := strings.Join(table.FieldNames, ", ")
		s.Raw(fmt.Sprintf("CREATE TABLE %s AS SELECT %s from %s;", tmp, fieldStr, table.Name))
		s.Raw(fmt.Sprintf("DROP TABLE %s;", table.Name))
		s.Raw(fmt.Sprintf("ALTER TABLE %s RENAME TO %s;", tmp, table.Name))
		_, err = s.Exec()
		return
	})
	return err
}