本文介绍微服务核心模块，服务注册与发现。

什么是服务注册

将服务运行的IP与端口发送到服务中心注册，注册中心将运行服务的节点信息记录。

什么是服务发现

当需要调用某个服务提供的接口时，去注册中心，获取到对应服务的节点信息，发起请求调用服务。

注册中心

常用的服务注册中心有Etcd,Consul,Zookeeper等。下面分别介绍

目录结构

1
2
3
4
5
6
7
8
9

soa
├─consul
│      consul.go
│
├─etcd
│      etcd.go
│
└─service
        service.go

Serivce

公共的服务定义

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

package service

import (
	"math/rand"
	"net"
	"strconv"
	"time"
)

// Node 节点
type Node struct {
	// 服务ID
	ID string
	// 服务名称
	Name string
	// 服务地址
	Address string
	// 服务端口
	Port int
	// 服务标签
	Tags []string
}

// GetHost 获取服务完整的地址
func (Node Node) GetHost() string {
	return net.JoinHostPort(Node.Address, strconv.Itoa(Node.Port))
}

// Group
type Group struct {
	items  []Node
	cursor int
}

// Count return node count
func (group *Group) Count() int {
	return len(group.items)
}

// First return fist node
func (group *Group) First() Node {
	return group.items[0]
}

// Rand return a rand node
func (group *Group) Rand() Node {
	rand.Seed(time.Now().Unix()) // initialize global pseudo random generator

	return group.items[rand.Intn(group.Count())]
}

// Next return the next node
func (group *Group) Next() Node {
	if group.cursor == group.Count() {
		group.cursor = 0
	}

	Node := group.items[group.cursor]
	group.cursor++
	return Node
}

// Add add node
func (group *Group) Add(node Node)  {
	group.items = append(group.items, node)
}

因为某些原因，触发了我要深入了解下AOP。

什么是AOP

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。扩展功能不修改源代码实现。

主要应用场景：日志记录，性能统计，安全控制，事务处理，异常处理等等。

核心概念

• JoinPoint:连接点。是程序执行中的一个精确执行点，例如类中的一个方法。
• PointCut：切入点。指定哪些组件的哪些方法使用切面组件。
• Advice：通知，用于指定具体作用的位置，是方法之前或之后等等，分为前置通知，后置通知，异常通知，返回通知，环绕通知。
• Aspect: 切面。封装通用业务逻辑的组件，即我们想要插入的代码内容。

其内在设计模式为代理模式。

Go实现AOP

垃圾回收是golang开发者需要关注的重点知识。

什么是垃圾回收

垃圾回收（英语：Garbage Collection，缩写为GC）是一种自动内存管理机制. 垃圾回收器(Garbage Collector)尝试回收不再被程序所需要的对象所占用的内存.

经典算法

引用计算

将新引用对象的计数器加一，将不引用的对象的计数器减一。

标记-清除

找到不可达的对象，然后做上标记。回收标记对象。因为扫描时会冻结所有的线程，执行时程序会暂停、卡顿，即Stop The World。(Dio咋瓦鲁多)

Golang的GC

golang基于标记-清除算法进行优化，采用三色标记法。

• 原理
  首先将程序创建的对象都标记为白色。
  从root根出发扫描所有根对象，扫描所有可达的对象，标记为灰色。（root区域主要是程序运行到当前时刻的栈和全局数据区域。）
  从灰色对象中找到其引用对象，把灰色对象本身标记为黑色。
  监视对象中的内存修改，并重复上一步骤，知道灰色标记的对象不存在。
  此时，GC回收白色对象。
  最后将所有黑色标记的对象重置为白色。

• 三色标记法如何避免Stop the world的？
  因为三色标记法结束后仅剩黑色与白色对象。如果不碰触黑色对象，只清除白色对象，则不会影响程序的执行。故清除操作可以和用户程序并发执行。

针对新生成的对象，go采用了写屏障保证该对象不会被立刻清除。简单理解就是新生成的对象，一律被标记为灰色。

说实话我对原理的理解还是很生硬，仅记住三色标记法的原理。

如何进行GC优化

本文介绍golang中枚举的使用。

什么是枚举类型

是一组命名的常数，常量值可以是连续的，也可以是断续的。

说明

Golang中并没有真正的枚举类型，往往都是自己定义常量，当作枚举类型来使用。

简单用法

下面以订单状态来举例说明go中枚举类型的使用方式。

• 定义枚举常量

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

  type OrderState uint const( // 待确认 OrderConfirmed OrderState = iota + 1 // 待支付 OrderPaying // 待发货 OrderShipping // 待收货 OrderReceiving // 已收货 OrderReceived // 已完成 OrderCompleted ) func main() { var state =6 // 模拟从数据库中获取到的状态 if OrderState(state) == OrderCompleted { fmt.Println("订单已完成") } }

扩展

• 对于枚举常量，我们时常也需要展示类型的名称，如展示订单状态名称

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

  var ( OrderStateItems = map[OrderState]string{ OrderConfirmed: "待确认", OrderPaying: "待支付", OrderShipping: "待发货", OrderReceiving: "待收货", OrderReceived: "已收货", OrderCompleted: "已完成", } ) // OrderStateEnum 枚举类 type OrderStateEnum struct { // v 值 v OrderState } // Name 获取订单状态名称 func (e OrderStateEnum) Name() string { return OrderStateItems[e.v] } func main() { var e = OrderStateEnum{OrderCompleted} fmt.Println(e.Name()) }

• 检查枚举是否合法

  1 2 3 4 5 6 7 8 9

  // IsValid 检查枚举是否合法 func (e OrderStateEnum) IsValid() bool { _, ok := OrderStateItems[e.v] return ok } func main() { var e = OrderStateEnum{OrderCompleted} fmt.Println(e.IsValid()) }

本文介绍通过go实现常见的排序算法。

说明

虽然go的内置sort包实现了相关排序算法，但是我们要了解其原理，通过自己实现一次，加深印象。

冒泡排序

• 原理：比较两个相邻的元素，将值大的元素交换到右边。
  时间复杂度为O(n^2)
• Demo

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

  // BubbleSort 冒泡排序 // 比较两个元素，将最大的元素放在右边 func BubbleSort(a [] int) { // 从最后一个元素进行排序 for first := len(a) - 1;first>=1;first-- { // 遍历剩余元素 for second := first - 1;second>=0;second-- { // 找到大的 if a[first] < a[second] { // 交换 a[first], a[second] = a[second], a[first] } } } }

• Test

  1 2 3 4 5 6 7 8 9 10

  import ( "fmt" "testing" ) var a = []int{10,1,35,61,89,36,55} func TestBubbleSort(t *testing.T) { BubbleSort(a) fmt.Println(a) }

• 输出:

  1	[1 10 35 36 55 61 89]

  more >>

本文介绍一些关于微服务架构设计的相关知识点。

什么是微服务

每个微服务都可以运行在自己的进程里；一系列独立运行的服务共同构建起了整个系统；每个服务为独立的业务开发，一个微服务一般完成某个特定的功能，比如订单管理，用户管理等；微服务之间通过一些轻量级的通信机制进行通信，例如通过REST API或者RPC的方式进行调用

特点

• 针对特定服务发布，影响小，风险小，成本低。
• 频繁发布版本，快速持续迭代。
• 低成本扩容，弹性伸缩。

架构图

模块说明

本文介绍再golang中通过gorm对mysql的操作。

什么是Gorm

Golang写的，开发人员友好的ORM库。官方地址：http://gorm.book.jasperxu.com/.

安装

1

go get -u github.com/jinzhu/gorm

准备工作

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

// 创建数据库
create database test charset=utf8;

use test;

// 创建Users表
drop table if exists users;
create table users (
    id int unsigned not null primary key auto_increment comment '主键',
    username varchar(50) not null default '' comment '姓名',
    password varchar(32) not null default '' comment '密码',
    is_deleted tinyint unsigned not null default  0 comment  '是否删除',
    created_at  timestamp    default CURRENT_TIMESTAMP not null comment '创建时间',
    updated_at  timestamp    default CURRENT_TIMESTAMP not null on update CURRENT_TIMESTAMP comment '更新时间',
    key `idx_del`(`is_deleted`)
)engine=Innodb charset=utf8mb4 comment='示例';

创建Connection

1
2
3
4
5
6
7
8
9
10
11

// Connection 创建数据库连接
func Connection() *gorm.DB {
    // dsn的格式为 用户名:密码/tcp(主机地址)/数据库名称?charset=字符格式
	dsn := "root:123456@tcp(10.0.75.2)/test?charset=utf8&parseTime=True&loc=Local"
	db, err := gorm.Open("mysql", dsn)
	if err != nil {
		panic(err)
	}

	return db
}

本文介绍github.com/go-playground/validator/v10的用法。

验证器

在项目中经常对客户端发起的接口请求参数进行校验，通常开发者必须自己编写一套验证的规则，但是使用统一的数据验证器能减轻开发者的负担，以及简化代码。
程序员并不是偷懒，而是提高自己的效率。

安装

1

go get github.com/go-playground/validator/v10

使用

• required 必填项
  对于请求参数来说，使用的最多的就是必填项。数字0,空string、slices,map,pointer,interface,channel,function都会校验不通过。

  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

  import "github.com/go-playground/validator/v10" // 初始化验证器 var validate = validator.New() func main() { var err error // 空interface var m map[string]int // 空map var ch chan int // 空channel var s []int // 空slice var p *log.Logger // 空pointer var f func() // 空func items := map[string]interface{}{ "zero": 0, // 改成非0会输出nil，说明通过校验，没有错误 "string":"", "slice": s, "map": m, "pointer" : p, "interface": err, "channel" : ch, "function": f, } for idx, val := range items { fmt.Printf("%s:%v\n", idx, validate.Var(val, "required")) } }

  输出错误信息，说明校验都未通过:

  1 2 3 4 5 6 7 8

  function:Key: '' Error:Field validation for '' failed on the 'required' tag zero:Key: '' Error:Field validation for '' failed on the 'required' tag string:Key: '' Error:Field validation for '' failed on the 'required' tag slice:Key: '' Error:Field validation for '' failed on the 'required' tag map:Key: '' Error:Field validation for '' failed on the 'required' tag pointer:Key: '' Error:Field validation for '' failed on the 'required' tag interface:Key: '' Error:Field validation for '' failed on the 'required' tag channel:Key: '' Error:Field validation for '' failed on the 'required' tag

• 其他校验

  1 2 3 4 5 6 7 8 9

  func main() { // 验证邮箱格式 fmt.Println("ValidateEmail:",validate.Var("123456.qq.com", "required,email")) // failed fmt.Println("ValidateEmail:",validate.Var("123456@qq.com", "required,email")) // success // 校验数字范围,gt:大于,gte:大于等于,lt:小于,lte:小于等于 fmt.Println("ValidateNumber:", validate.Var(100, "required,gt=100,lt=120")) // failed fmt.Println("ValidateNumber:", validate.Var(110, "required,gte=100,lte=120")) // success }

本文介绍gin的一些知识点,如自定义Response,中间件等。

gin

Gin 是一个 go 写的 web 框架，具有高性能的优点。

初级的使用方式不介绍了，具体请查阅官方文档。官方地址：https://github.com/gin-gonic/gin

以下介绍基于gin开发项目的一些常用模块。

自定义Response

每个公司都会自定义接口的数据结构。故我们需要基于Json()自定义一个更方便好用的response

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

// Response 数据结构体
type Response struct {
    // StatusCode 业务状态码
	StatusCode int `json:"status_code"`

    // Message 提示信息
	Message    string      `json:"message"`

    // Data 数据，用interface{}的目的是可以用任意数据
	Data       interface{} `json:"data"`

    // Meta 源数据,存储如请求ID,分页等信息
	Meta       Meta        `json:"meta"`

    // Errors 错误提示，如 xx字段不能为空等
	Errors     []ErrorItem `json:"errors"`
}

// Meta 元数据
type Meta struct {
	RequestId      string                 `json:"request_id"`
	// 还可以集成分页信息等
}


// ErrorItem 错误项
type ErrorItem struct {
	Key   string `json:"key"`
	Value string `json:"error"`
}

// New return response instance
func New() *Response {
	return &Response{
		StatusCode: 200,
		Message:    "",
		Data:       nil,
		Meta: Meta{
			RequestId: uuid.NewV4().String(),
		},
		Errors: []ErrorItem{},
	}
}

封装gin.Context以自定义一些方便的方法

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

// Wrapper include context
type Wrapper struct {
	ctx *gin.Context
}

// WrapContext
func WrapContext(ctx *gin.Context) *Wrapper {
	return &Wrapper{ctx:ctx}
}

// Json 输出json,支持自定义response结构体
func (wrapper *Wrapper) Json(response *Response) {
	wrapper.ctx.JSON(200, response)
}

// Success 成功的输出
func (wrapper *Wrapper) Success( data interface{}) {
	response := New()
	response.Data = data
	wrapper.Json(response)
}

// Error 错误输出
func (wrapper *Wrapper) Error( statusCode int, message string) {
	response := New()
	response.StatusCode = statusCode
	response.Message = message
	wrapper.Json(response)
}

使用：

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

package main

import (
	"github.com/gin-gonic/gin"
	uuid "github.com/satori/go.uuid"
)

func main()  {
	router := gin.Default()
	router.GET("/", func(ctx *gin.Context) {
		WrapContext(ctx).Success("hello,world")
	})

	router.Run(":8088")
}

通过go run main.go运行后，浏览器访问localhost:8088

中间件

介绍一些常用的中间件，如跨域、Jwt校验、请求日志等。

本文介绍在golang中的日志使用方式。

官方自带Log包

• demo

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

  package main import "log" func init() { // 设置log前缀 log.SetPrefix("TRACE: ") // 设置日志内容：日期、时间、文件 log.SetFlags(log.Ldate | log.Ltime |log.Llongfile) } func main() { // 打印标准日志 log.Println("message") // 使用格式化输出日志 log.Printf("the result is :%s", "log") // 致命错误,直接退出程序 log.Fatal("fatal message") }

自定义Logger

指定目录存储日志

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

package main

import (
	"io"
	"log"
	"os"
)

var (
	LogComponent *Logger
)
// Logger
type Logger struct {
	// logPath 日志存储目录
	logPath string
	// info 记录信息
	info *log.Logger
	// error 记录错误
	error *log.Logger
	// 其他如debug,trace,warning如上
}

func (l *Logger) Info(message string) {
	l.info.Println(message)
}

func (l *Logger) Error(message string) {
	l.error.Println(message)
}

func getFile(filePath string) *os.File {
	file, err := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
	if err != nil {
		log.Fatalf("Failed to open %s:%v\n", filePath, err)
	}

	return file
}
// NewLogger 
func NewLogger(logPath string) *Logger {
	logger := &Logger{logPath:logPath}

	logger.info = log.New(io.MultiWriter(getFile(logPath + "info.log"), os.Stderr),
		"INFO: ",
		log.Ldate|log.Ltime|log.Llongfile)

	logger.error = log.New(io.MultiWriter(getFile(logPath+"error.log"), os.Stderr),
		"ERROR: ",
		log.Ldate|log.Ltime|log.Llongfile)

	return logger
}

func init() {
	// 将日志放在log目录下，用绝对路径会更好点
	LogComponent = NewLogger("./log/")
}

func main() {
	LogComponent.Info("Special Information")
	LogComponent.Error("Something has failed")
}