r1笔记day21 写一个负载均衡

这个是视频教程学习golang的例子，纯属练手，非生产使用：

学习了一下项目的规划，各个package怎么管理的。

step1：先定义一个负载均衡的接口Balancer，接口里面有DoBalance([]*Instance) (*Instance, error)  方法。

step2：创建instance的结构体，由于字段是小写的，写一个构造函数用来访问，同时，提供两个函数GetHost()、GetPort() 访问这个结构体。

step3：随机的调度方法：构造一个结构体RandomBalance，这个作为接收者，去实现step中的DoBalance([]*Instance) (*Instance, error)  方法。 

step4：轮询调度方法：构造一个结构体RandomRobinBalance，这个作为接收者，去实现step中的DoBalance([]*Instance) (*Instance, error)  方法。 

step5：main函数，利用构造函数创建实例加到切片中，然后开始调用具体的方法。具体调用是这样的：

              1、balancer := &balance.RandomBalance{} 实例化一个RandomBalance{} 结构体，然后balancer去调用RandomBalance{} 这个结构体实现的DoBalance([]*Instance) (*Instance, error)  方法，看 random.go中的文件，也就是随机调度的方法。

---

目录结构：

F:.
│
└─work02
    ├─balance
    │      balance.go
    │      instance.go
    │      mgr.go
    │      random.go
    │      roundrobin.go
    │
    └─main
            main.go

main.go

package main

import (
	"fmt"
	"go_dev/day6/homework/work02/balance"
	"math/rand"
	"time"
)

func main() {
	insts := make([]*balance.Instance, 10)
	for i := 0; i < 10; i++ {
		host := fmt.Sprintf("192.168.%d.%d", rand.Intn(255), rand.Intn(255))
		one := balance.NewInstance(host, 8080)
		insts = append(insts, one)
	}
	balancer := &balance.RandomBalance{}
	for {
		inst, err := balancer.DoBalance(insts)
		if err != nil {
			fmt.Println("do balance err")
			continue
		}
		fmt.Println(inst)

		time.Sleep(time.Second)
	}
}

balance.go

package balance

//定义一个接口，以及定义一个函数，再由具体负载均衡去实现此方法
type Balancer interface {
	DoBalance([]*Instance) (*Instance, error)
}

instance.go
 

package balance

type Instance struct {
	host string
	port int
}

//为了封装，写一个构造函数，这样instance就不需要对外暴露，也没需求
func NewInstance(host string, port int) *Instance {
	return &Instance{
		host: host,
		port: port,
	}
}

//提供访问接口
func (p *Instance) GetHost() string {
	return p.host
}

//提供访问接口
func (p *Instance) GetPort() int {
	return p.port
}

random.go

package balance

import (
	"errors"
	"math/rand"
)

type RandomBalance struct {
}

func (p *RandomBalance) DoBalance(insts []*Instance) (inst *Instance, err error) {
	if len(insts) == 0 {
		err = errors.New("No instancd")
		return
	}

	lens := len(insts)
	index := rand.Intn(lens)
	inst = insts[index]
	return
}

roudrobin.go

package balance

import (
	"errors"
)

type RandomRobinBalance struct {
	curIndex int
}

func (p *RandomRobinBalance) DoBalance(insts []*Instance) (inst *Instance, err error) {
	if len(insts) == 0 {
		err = errors.New("No instancd")
		return
	}

	lens := len(insts)
	if p.curIndex >= lens {
		p.curIndex = 0
	}
	inst = insts[p.curIndex]
	p.curIndex = (p.curIndex + 1) % lens //取余数方法很棒
	return
}