Golang语言系列-09-接口

接口

接口的定义和实现

package main

import "fmt"

/*
[接口]
接口（interface）定义了一个对象的行为规范，只定义规范不实现，由具体的对象来实现规范的细节

在Go语言中接口（interface）是一种类型，一种抽象的类型，interface是一组method(方法)的集合

接口做的事情就像是定义一个协议（规则），只要一台机器有洗衣服和甩干的功能，我就称它为洗衣机。不关心属性（数据），只关心行为（方法）。
为了保护你的Go语言职业生涯，请牢记接口（interface）是一种类型

[为什么要使用接口？]
type Cat struct{}
func (c Cat) Say() string { return "喵喵喵" }

type Dog struct{}
func (d Dog) Say() string { return "汪汪汪" }

func main() {
	c := Cat{}
	fmt.Println("猫:", c.Say())
	d := Dog{}
	fmt.Println("狗:", d.Say())
}
上面的代码中定义了猫和狗，然后它们都会叫，你会发现 main 函数中明显有重复的代码，
如果我们后续再加上猪、青蛙等动物的话，我们的代码还会一直重复下去。
那我们能不能把它们当成“能叫的动物”来处理呢？
Go语言中为了解决类似上面的问题，就设计了接口这个概念。
接口区别于我们之前所有的具体类型，接口是一种抽象的类型。
当你看到一个接口类型的值时，你不知道它是什么，唯一知道的是通过它的方法能做什么。

Go语言提倡面向接口编程
每个接口由数个方法组成，接口的定义格式如下
type 接口类型名 interface{
    方法名1( 参数列表1 ) 返回值列表1
    方法名2( 参数列表2 ) 返回值列表2
    …
}
其中：
	接口名：使用type将接口定义为自定义的类型名。Go语言的接口在命名时，一般会在单词后面添加er，
           如有写操作的接口叫Writer，有字符串功能的接口叫Stringer等。
           接口名最好要能突出该接口的类型含义。
	方法名：当方法名首字母是大写且这个接口类型名首字母也是大写时，这个方法可以被接口所在的包（package）之外的代码访问。
	参数列表、返回值列表：参数列表和返回值列表中的参数变量名可以省略

[实现接口的条件]
一个对象只要 全部实现 了接口中的方法，那么就实现了这个接口。换句话说，接口就是一个需要实现的方法列表
如果接口中有没被实现的方法，那么就会报错.
结构体实现接口中的方法，要么全部实现，要么就一个别实现，否则报错

[接口类型变量]
那实现了接口有什么用呢？
接口类型变量能够存储所有实现了该接口的实例。 例如上面的示例中，Sayer类型的变量能够存储dog和cat类型的变量。
*/

// 示例
// 由于猫、狗、人都能叫
// 所以定义一个能叫的接口
type speaker interface {
	speak() //只要实现了speak方法的变量都是speaker类型, 方法签名
}

//定义结构体
type cat struct{}

type dog struct{}

type person struct{}

// 定义相对应的方法，实现接口
func (c cat) speak() {
	fmt.Println("喵喵喵~")
}

func (d dog) speak() {
	fmt.Println("旺旺旺~")
}

func (p person) speak() {
	fmt.Println("啊啊啊~")
}

// 定义一个函数
func da(x speaker) {
	// 接收一个参数,传进来什么,我就打什么
	x.speak() // 挨打了就要叫
}

func main() {
	var c1 cat
	var d1 dog
	var p1 person

	da(c1)
	da(d1)
	da(p1)

	var ss speaker // 定义一个接口类型:speaker 的变量:ss
	ss = c1
	fmt.Printf("%T\n", ss) //main.cat
	ss = d1
	fmt.Printf("%T\n", ss) //main.dog
	ss = p1
	fmt.Printf("%T\n", ss) //main.person
}

package main

import "fmt"

// 定义支付接口
type payer interface {
	pay()
}

// 定义支付函数
func pay(p payer) {
	p.pay()
}

// 定义结构体
type weixin struct {
	name string
}

// 定义结构体方法 实现接口中的方法
func (w weixin) pay() {
	fmt.Printf("尊敬的[%s],欢迎使用微信支付~\n", w.name)
}

// 定义结构体
type alipay struct {
	name string
}

// 定义结构体方法 实现接口中的方法
func (a alipay) pay() {
	fmt.Printf("欢迎[%s]使用阿里支付~\n", a.name)
}

func main() {
	var w weixin
	var a alipay
	w.name = "Alnk"
	a.name = "tom"
	pay(w)
	pay(a)

	////实现接口以后就不用每次都这么写重复的代码了
	//p1 := weixin{"Alnk"}
	//p1.pay()
	//p2 := alipay{"tom"}
	//p2.pay()
}

package main

import "fmt"

// 接口示例2
// 不管什么牌子的车都能跑

// 定义一个car接口类型
// 不管是什么结构体，只要有run方法都能是carer类型
type carer interface {
	run() //只要实现了run方法的变量都是carer类型, 方法签名
}

//drive 定义一个函数
func drive(c carer) {
	c.run()
}

// falali 定义一个结构体
type falali struct {
	name string
}

// falali 的run方法
func (f falali) run() {
	fmt.Printf("%s的速度70\n", f.name)
}

// baoshijie 定义一个结构体
type baoshijie struct {
	name string
}

// baoshijie 的run方法
func (b baoshijie) run() {
	fmt.Printf("%s的速度100\n", b.name)
}

func main() {
	f := falali{"法拉利"}
	//f.run()
	drive(f)

	b := baoshijie{"保时捷"}
	drive(b)
}

package main

import "fmt"

// 接口的实现

// 定义一个动物接口
type animal interface {
	move()
	eat(string)
}

// 定义一个猫的结构体
type cat struct {
	name string
	feet int8
}

// 猫结构体方法
func (c cat) move() {
	fmt.Println("走猫步...")
}

// 猫结构体方法
func (c cat) eat(food string) {
	fmt.Printf("猫吃%s...\n", food)
}

// 定义一个鸡的结构体
type chicken struct {
	feet int8
}

// 鸡结构体方法
func (c chicken) move() {
	fmt.Println("鸡动!")
}

// 鸡结构体方法
func (c chicken) eat(food string) {
	fmt.Printf("吃%s...\n", food)
}

func main() {
	var a1 animal          //定义一个接口类型的变量
	fmt.Printf("%T\n", a1) //<nil>

	// 定义一个cat类型的变量bc
	bc := cat{
		name: "淘气",
		feet: 4,
	}
	a1 = bc
	a1.eat("小黄鱼")          //猫吃小黄鱼...
	fmt.Printf("%T\n", a1) //main.cat
	fmt.Println(a1)        //{淘气 4}
	fmt.Println(bc)        //{淘气 4}

	kfc := chicken{feet: 2}
	a1 = kfc
	fmt.Printf("%T\n", a1) //main.chicken
	a1.eat("饲料")           //吃饲料...
}

值接收者和指针接收者的区别

package main

import "fmt"

// 使用值接收者和指针接收者的区别？
// 使用值接收者实现接口,结构体类型和结构体指针类型的变量都能存
// 使用指针接收者实现接口,只能存结构体指针类型的变量

// Mover接口和一个dog结构体
type Mover interface {
	move()
}

type dog struct{}

//// 值接收者实现接口
//func (d dog) move() {
//	fmt.Println("狗会动")
//}
//// 实现接口的是dog类型
//func main() {
//	var x Mover
//	var wangcai = dog{} // 旺财是dog类型
//	x = wangcai         // x可以接收dog类型
//	x.move()
//	var fugui = &dog{} // 富贵是*dog类型
//	x = fugui          // x可以接收*dog类型
//	x.move()
//}
//
///*
//从上面的代码中我们可以发现，使用值接收者实现接口之后，
//不管是 dog结构体 还是 结构体指针*dog类型 的变量都可以赋值给该接口变量。
//因为Go语言中有对指针类型变量求值的语法糖，
//dog指针fugui内部会自动求值*fugui
//*/

// 指针接收者实现接口
func (d *dog) move() {
	fmt.Println("狗会动")
}

func main() {
	var x Mover
	//var wangcai = dog{} // 旺财是dog类型
	//x = wangcai         // x不可以接收dog类型
	var fugui = &dog{} // 富贵是*dog类型
	x = fugui          // x可以接收*dog类型
	x.move()
}

// 此时实现Mover接口的是*dog类型，所以不能给x传入dog类型的wangcai，此时x只能存储*dog类型的值fugui

package main

import "fmt"

// 注意：这是一道你需要回答“能”或者“不能”的题！
// 首先请观察下面的这段代码，然后请回答这段代码能不能通过编译？

type People interface {
	Speak(string) string
}

type Student struct{}

func (stu *Student) Speak(think string) (talk string) {
	if think == "sb" {
		talk = "你是个大帅比"
	} else {
		talk = "您好"
	}
	return
}

func main() {
	var peo People
	peo = Student{}
	//peo = &Student{} //注意这里要返回指针类型才行，因为方法中接收的是指针类型

	think := "bitch"
	fmt.Println(peo.Speak(think))
}

接口和类型的关系

package main

import "fmt"

// 一个类型可以实现多个接口
// 同一个结构体可以实现多个接口
// 接口还可以嵌套

// 接口
type animal interface {
	mover
	eater
}

// 接口
type mover interface {
	move()
}

// 接口
type eater interface {
	eat(string)
}

// cat结构体
type cat struct {
	name string
	feet int8
}

// cat实现了mover接口
func (c *cat) move() {
	fmt.Println("走猫步...")
}

// cat实现了eater接口
func (c *cat) eat(food string) {
	fmt.Printf("猫吃%s...\n", food)
}

func main() {
	c1 := cat{
		name: "tom",
		feet: 4,
	}

	var a1 animal

	a1 = &c1
	a1.move()     // 走猫步...
	a1.eat("小黄鱼") // 猫吃小黄鱼...

	var m1 mover
	m1 = &c1
	m1.move() // 走猫步...

	var e1 eater
	e1 = &c1
	e1.eat("鱼仔") // 猫吃鱼仔...
}

空接口

package main

import "fmt"

// 空接口
// 空接口是指没有定义任何方法的接口
// 因此任何类型都实现了空接口
// 空接口类型的变量可以存储任意类型的变量

// interface:关键字
// interface{}:空接口类型

// 空接口的应用:
// 1.空接口作为函数的参数
// 2.空接口作为map的值

// 空接口作为函数参数
func show(a interface{}) {
	fmt.Printf("type:%T --- value:%v\n", a, a)
}

func main() {
	// 空接口作为map的值
	var m1 map[string]interface{}
	m1 = make(map[string]interface{}, 16)
	m1["name"] = "周林"
	m1["age"] = 9000
	m1["merried"] = true
	m1["hobby"] = [...]string{"唱", "跳", "rap"}
	fmt.Printf("%#v\n", m1) //map[string]interface {}{"age":9000, "hobby":[3]string{"唱", "跳", "rap"}, "merried":true, "name":"周林"}

	// 空接口作为函数参数
	show(false) //type:bool --- value:false
	show(nil)   //type:<nil> --- value:<nil>
	show(m1)    //type:map[string]interface {} --- value:map[age:9000 hobby:[唱 跳 rap] merried:true name:周林]

	// 空接口作为map的键和值
	var m2 map[interface{}]interface{}
	m2 = make(map[interface{}]interface{}, 5)
	m2[1] = "a"
	m2["b"] = true
	m2[true] = 1
	fmt.Printf("%#v\n", m2) //map[interface {}]interface {}{true:1, 1:"a", "b":true}
	show(m2)                //type:map[interface {}]interface {} --- value:map[true:1 1:a b:true]
}

类型断言

package main

import "fmt"

/*
[类型断言]
空接口可以存储任意类型的值，那我们如何获取其存储的具体数据呢

一个接口的值（简称接口值）是由一个 具体类型 和 具体类型的值 两部分组成的
这两部分分别称为 接口的动态类型 和 接口的动态值

想要判断空接口中的值这个时候就可以使用类型断言，其语法格式：
x.(T)
其中：
	x：表示类型为interface{}的变量
	T：表示断言x可能是的类型
该语法返回两个参数，第一个参数是x转化为T类型后的变量，第二个值是一个布尔值，若为true则表示断言成功，为false则表示断言失败

因为空接口可以存储任意类型值的特点，所以空接口在Go语言中的使用十分广泛

重点：关于接口需要注意的是，只有当 [有两个或两个以上的具体类型] 必须以相同的方式进行处理时才需要定义接口。
不要为了接口而写接口，那样只会增加不必要的抽象，导致不必要的运行时损耗
*/

// 类型断言1
func assign(a interface{}) {
	fmt.Printf("%T\n", a)
	str, ok := a.(string)
	if !ok {
		fmt.Println("猜错了")
	} else {
		fmt.Println("传进来的是一个字符串: ", str)
	}
}

// 类型断言2
// x.(type)
// x表示类型为interface{}的变量
// type获取x变量的动态类型
func assign2(a interface{}) {
	fmt.Printf("%T\n", a)
	switch t := a.(type) {
	case string:
		fmt.Println("这是一个字符串:", t)
	case int:
		fmt.Println("这是一个int:", t)
	case int64:
		fmt.Println("这是一个int64:", t)
	case bool:
		fmt.Println("这是一个bool:", t)
	case []int:
		fmt.Println("这是一个slice:", t)
	case map[string]int:
		fmt.Println("是一个map[string]int:", t)
	case func():
		fmt.Println("这是一个函数类型:", t)
	}
}

func main() {
	//assign("100")
	assign2(true)
	assign2("啊哈哈")
	assign2(int64(200))
	assign2([]int{1, 2, 3})
	assign2(map[string]int{"a": 1})
}

接口练习

session中间件开发练习

目录结构

02session中间件开发
├── main.go //测试session中间件
└── session
    ├── docs
    │   ├── README
    │   └── 架构图.png
    ├── memory.go
    ├── memory_session_mgr.go
    ├── session.go
    └── session_mgr.go

README

设计一个通用的Session服务，支持内存存储和redis存储

session模块设计
    本质上k-v系统，通过key进行增删改查
    session可以存储在内存或者redis（2个版本）

    每一个用户 ---> 一个session ---> 多个key-value
    session ---> sessionMgr （多个session对应一个sessionMrg  多对一）

接口设计
Session接口设计：
    Set()
    Get()
    Del()
    Save()：session存储，redis的实现延迟加载

SessionMgr接口设计：
    Init()：初始化，加载redis地址
    CreateSeesion()：创建一个新的session
    GetSession()：通过sessionId获取对应的session对象

MemorySeesion设计：
    定义MemorySeesion对象（字段：sessionId、存kv的map，读写锁）
    构造函数，为了获取对象
    Set()
    Get()
    Del()
    Save()

MemorySeesionMgr设计：
    定义MemorySeesionMgr对象（字段：存放所有session的map，读写锁）
    构造函数
    Init()
    CreateSeesion()
    GetSession()

RedisSession设计：
    定义RedisSeesion对象（字段：sessionId，存kv的map，读写锁，redis连接池，记录内存中map是否被修改的标记）
    构造函数
    Set()：将session存到内存中的map
    Get()：取数据，实现延迟加载
    Del()
    Save()：将session存到redis

RedisSessionMgr设计：
    定义RedisSessionMgr对象（字段：redis地址、redis密码、连接池、读写锁，大map）
    构造函数
    Init()
    CreateSeesion()
    GetSession()

调用示例
如果要在多个函数中使用，设置一个全局的 session.NewMemorySessionMgr() 变量
// 设置session
memSess := session.NewMemorySessionMgr()
s1, id1, err := memSess.CreateSession() // 创建一条session
if err != nil {
    panic(err)
}
s1.Set("name", "alnk")   // 在一条session中设置值
s1.Set("isLogin", false) // 在一条session中设置值
s1.Set("isVip", false)   // 在一条session中设置值

// 获取一条session
ms1, _ := memSess.GetSession(id1) // 获取单个session
// 获取单个session里面的key-value
name1, err := ms1.Get("name")
login1, err := ms1.Get("isLogin")
vip1, err := ms1.Get("isVip")
fmt.Println(name1, login1, vip1)

### redisSession功能未完成

架构图.png

session.go

package session

// 只定义session接口规范
// 其他的模块只要实现这些规范即可

type Session interface {
	Set(key string, value interface{}) error
	Get(key string) (interface{}, error)
	Del(key string) error
	Save() error
}

session_mgr.go

package session

// 定义接口规范

// SessionMgr 定义管理者，管理所有的session
type SessionMgr interface {
	// 初始化
	Init(addr string, options ...string) (err error)
	CreateSession() (session Session, sessionId string, err error)
	GetSession(sessionId string) (session Session, err error)
}

memory.go

package session

import (
	"errors"
	"sync"
)

// 实现Session接口

type MemorySession struct {
	sessionId string
	// 存key-value
	data   map[string]interface{}
	rwlock sync.RWMutex // 读写锁，不然如果数据量太大，map读写会出问题
}

// 构造函数
func NewMemorySession(id string) *MemorySession {
	s := &MemorySession{
		sessionId: id,
		data:      make(map[string]interface{}, 16),
	}
	return s
}

func (m *MemorySession) Set(key string, value interface{}) (err error) {
	// 加锁
	m.rwlock.Lock()
	defer m.rwlock.Unlock()
	// 设置值
	m.data[key] = value
	return
}

func (m *MemorySession) Get(key string) (value interface{}, err error) {
	m.rwlock.Lock()
	defer m.rwlock.Unlock()
	value, ok := m.data[key]
	if !ok {
		err = errors.New("key not exists in session")
		return
	}
	return
}

func (m *MemorySession) Del(key string) (err error) {
	m.rwlock.Lock()
	defer m.rwlock.Unlock()
	delete(m.data, key)
	return
}

func (m *MemorySession) Save() (err error) {
	return
}

memory_session_mgr.go

package session

import (
	"errors"
	"github.com/satori/go.uuid"
	"sync"
)

// 实现 SessionMgr 接口

// MemorySessionMgr设计：
// 定义MemorySessionMgr对象（字段：存放所有session的map，读写锁）
// 构造函数
// Init()
// CreateSession()
// GetSession()

// 定义对象
type MemorySessionMgr struct {
	sessionMap map[string]Session
	rwlock     sync.RWMutex
}

// 构造函数
func NewMemorySessionMgr() SessionMgr {
	sr := &MemorySessionMgr{
		sessionMap: make(map[string]Session, 1024),
	}
	return sr
}

func (s *MemorySessionMgr) Init(addr string, option ...string) (err error) {
	return
}

// 创建一条session
func (s *MemorySessionMgr) CreateSession() (session Session, sessionId string, err error) {
	s.rwlock.Lock()
	defer s.rwlock.Unlock()
	// go get github.com/satori/go.uuid
	// 用uuid作为 sessionId
	id := uuid.NewV4()
	// 转 string
	sessionId = id.String()
	// 创建单个session
	session = NewMemorySession(sessionId)
	// 加入到大map
	s.sessionMap[sessionId] = session
	return
}

// 获取一条session
func (s *MemorySessionMgr) GetSession(sessionId string) (session Session, err error) {
	s.rwlock.Lock()
	defer s.rwlock.Unlock()
	session, ok := s.sessionMap[sessionId]
	if !ok {
		err = errors.New("session not exists")
		return
	}
	return
}

main.go

package main

import (
	"02session中间件开发/session"
	"fmt"
)

var memSess = session.NewMemorySessionMgr() // 设置为全局变量，好让所以的函数都能调用

func main() {
	s, id, err := memSess.CreateSession() // 创建一条session
	if err != nil {
		panic(err)
	}
	fmt.Println("id:", id)

	// 在session中设置值
	name := "tom"
	isLogin := true
	isVip := true
	s.Set("name", name)       // 在一条session中设置值
	s.Set("isLogin", isLogin) // 在一条session中设置值
	s.Set("isVip", isVip)     // 在一条session中设置值

	// 获取一条session
	rs, err := memSess.GetSession(id)
	fmt.Printf("rs:%#v\n", rs)
	fmt.Println(rs)
}