关于Golang面试宝典
最近几年，Go的热度持续飙升，国内外很多大公司都在大规模的使用Go。Google是Go语言诞生的地方，其他公司如Facebook、腾讯、阿里、字节跳动、百度、京东、小米等都在拥抱和转向Go。Go语言的开源项目也非常多，如kubernetes、docker、etcd。
随着市场对Go语言人才需求的增长，很多开发者都投入了Go语言的怀抱。本系列文章将以第一视角与大家一同开始Golang的面试之路，希望大家能够有所收获，拿下心仪的offer。
使用Go实现23种设计模式——创建型模式
单例模式
一个类只能生成一个实例，提供一个全局访问点供外部获取该实例
适用场景：
- 只要求生成一个全局对象
- 需要频繁实例化，而创建的对象又频繁被销毁
Go语言实现
type client struct{}
var (
c *client
once sync.Once
)
func GetClient() *client {
once.Do(func() {
c = &client{}
})
return c
}
单例模式优点
- 在内存中只有一个实例，减少了内存开销
- 避免对资源的多重占用
单例模式缺点
- 没有接口，无法继承，一定程度上违背了单一职责原则（一个类应该只关心内部逻辑，而不关心外面怎么样来实例化）
工厂模式
定义一个创建对象的接口，让子类决定实例化哪个类
适用场景
父工厂类中只有创建产品的抽象接口，将产品对象的实际创建工作推迟到具体子工厂类当中
Go语言实现
type Executor interface {
Run()
}
type syncExecutor struct {
}
func (e *syncExecutor) Run() {
fmt.Println("sync executor run")
}
type asyncExecutor struct {
}
func (e *asyncExecutor) Run() {
fmt.Println("async executor run")
}
func GetExecutor(sync bool) Executor {
if sync {
return &syncExecutor{}
} else {
return &asyncExecutor{}
}
}
工厂模式优点
- 符合开闭原则，有很强的扩展性、弹性和可维护性，修改时只需要添加对应的工厂类即可
- 使用了依赖倒置原则，依赖抽象而不是具体
- 使用者只需要知道产品的具体工厂，无需知道工厂中产品的创建过程，甚至不需要知道产品的类名
工厂模式缺点
- 每增加一个产品时，都需要一个具体类和一个具体创建者，使得类的个数成倍增加，导致系统复杂性增加
抽象工厂模式
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类
适用场景
系统中有多个产品类，但每次只使用其中的某一类产品
Go语言实现
type FactoryInterface interface {
CreateAnimal() ProductInterface
}
type ProductInterface interface {
Init()
}
type DogFactory struct {
}
type AnimalDog struct {
}
func (a *AnimalDog) Init() {
fmt.Printf("Dog ...\n")
}
func (f *DogFactory) CreateAnimal() ProductInterface {
return &AnimalDog{}
}
func main() {
var f FactoryInterface
f = new(DogFactory)
a := f.CreateAnimal()
a.Init()
}
抽象工厂模式优点
- 隔离了具体类的生产，客户并不知道什么将被创建
- 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象
- 新增具体工厂和产品族方便
抽象工厂模式缺点
- 增加新的产品等级结构复杂，需要修改抽象工厂及所有的具体工厂类
建造者模式
将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象（对复杂对象进行分模块创建）
适用场景
对象可以分模块初始化
Go语言实现
type Person struct {
name, sex, address string
age int
}
func (p *Person) PrintInfo() {
fmt.Printf("姓名: %s, 年龄: %d, 性别: %s, 住址: %s\n", p.name, p.age, p.sex, p.address)
}
type PersonBuilder struct {
person *Person
}
func NewPersonBuilder() *PersonBuilder {
return &PersonBuilder{person: &Person{}}
}
func (p *PersonBuilder) Name(name string) *PersonBuilder {
p.person.name = name
return p
}
func (p *PersonBuilder) Sex(sex string) *PersonBuilder {
p.person.sex = sex
return p
}
func (p *PersonBuilder) Address(address string) *PersonBuilder {
p.person.address = address
return p
}
func (p *PersonBuilder) Age(age int) *PersonBuilder {
p.person.age = age
return p
}
func (p *PersonBuilder) Build() *Person {
return p.person
}
func main() {
p := NewPersonBuilder().
Name("张三").
Age(18).
Sex("男").
Address("上海").
Build()
p.PrintInfo()
}
建造者模式优点
- 封装性好
- 扩展性好
建造者模式缺点
- 增加类数量，产生多余的Builder对象
- 如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大
原型模式
用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象
适用场景
- 不同对象之间相似度高
- 创建对象比较麻烦，但复制比较简单
Go语言实现
type Student struct {
name string
age int
sex string
}
func (s *Student) SetStudentInfo(name string, age int, sex string) {
s.name = name
s.age = age
s.sex = sex
}
func (s *Student) SetName(name string) {
s.name = name
}
func (s *Student) PrintInfo() {
fmt.Printf("学生姓名: %s, 年龄: %d, 性别: %s\n", s.name, s.age, s.sex)
}
func (s *Student) Clone() *Student {
return &Student{
name: s.name,
age: s.age,
sex: s.sex,
}
}
func main() {
s1 := &Student{}
s1.SetStudentInfo("张三", 18, "男")
s1.PrintInfo()
s2 := s1.Clone()
s2.SetName("李四")
s2.PrintInfo()
}
原型模式优点
- 性能优良
- 可以使用深克隆方式保存对象状态
原型模式缺点
- 需要为每个类实现一个克隆方法，该方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违反了开闭原则
- 深拷贝与浅拷贝的风险，容易出错
