工厂模式
工厂模式(Factory Pattern)是最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。
介绍
**意图:**定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。
**主要解决:**主要解决接口选择的问题。
**何时使用:**我们明确地计划不同条件下创建不同实例时。
**如何解决:**让其子类实现工厂接口,返回的也是一个抽象的产品。
**关键代码:**创建过程在其子类执行。
应用实例: 1、您需要一辆汽车,可以直接从工厂里面提货,而不用去管这辆汽车是怎么做出来的,以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。
优点: 1、一个调用者想创建一个对象,只要知道其名称就可以了。 2、扩展性高,如果想增加一个产品,只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现,调用者只关心产品的接口。
**缺点:**每次增加一个产品时,都需要增加一个具体类和对象实现工厂,使得系统中类的个数成倍增加,在一定程度上增加了系统的复杂度,同时也增加了系统具体类的依赖。这并不是什么好事。
使用场景: 1、日志记录器:记录可能记录到本地硬盘、系统事件、远程服务器等,用户可以选择记录日志到什么地方。 2、数据库访问,当用户不知道最后系统采用哪一类数据库,以及数据库可能有变化时。 3、设计一个连接服务器的框架,需要三个协议,“POP3”、“IMAP”、“HTTP”,可以把这三个作为产品类,共同实现一个接口。
**注意事项:**作为一种创建类模式,在任何需要生成复杂对象的地方,都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式,而简单对象,特别是只需要通过 new 就可以完成创建的对象,无需使用工厂模式。如果使用工厂模式,就需要引入一个工厂类,会增加系统的复杂度。
简单工厂模式
type Person struct {
Name string
Age int
}
func (p Person) Greet() {
fmt.Printf("Hi, my name is %s", p.Name)
}
// NewSimpleFactory
// 简单工厂模式是最常用、最简单的。它就是一个接受一些参数,然后返回 Person 实例的函数
// 和 p:=&Person {}这种创建实例的方式相比,简单工厂模式可以确保我们创建的实例具有需要的参数,进而保证实例的方法可以按预期执行。
// 例如,通过 NewPerson 创建 Person 实例时,可以确保实例的 name 和 age 属性被设置。
func NewSimpleFactory(name string, age int) *Person {
return &Person{
Name: name,
Age: age,
}
}
func TestNewSimpleFactory(t *testing.T){
p1 := NewSimpleFactory("张三", 12)
p1.Greet()
}
工厂方法模式
type Person struct {
Name string
Age int
}
func (p Person) Greet() {
fmt.Printf("Hi, my name is %s", p.Name)
}
// NewFactoryMethod
// 在简单工厂模式中,依赖于唯一的工厂对象,如果我们需要实例化一个产品,就要向工厂中传入一个参数,获取对应的对象;
// 如果要增加一种产品,就要在工厂中修改创建产品的函数。这会导致耦合性过高,这时我们就可以使用工厂方法模式。
// 在工厂方法模式中,依赖工厂方法,我们可以通过实现工厂接口来创建多种工厂,
// 将对象创建从由一个对象负责所有具体类的实例化,变成由一群子类来负责对具体类的实例化,从而将过程解耦。
func NewFactoryMethod(age int) func(string) Person {
return func(name string) Person {
return Person{
Name: name,
Age: age,
}
}
}
func TestNewFactoryMethod(t *testing.T){
kidFactory := NewFactoryMethod(5)
kid1 := kidFactory("张三")
teenFactory := NewFactoryMethod(12)
teen1 := teenFactory("李四")
kid1.Greet()
teen1.Greet()
}
抽象工厂方法
type IPerson interface {
Greet()
}
type kid struct {
name string
age int
}
func (p kid) Greet() {
fmt.Printf("Hi! My name is %s, my age is %d", p.name, p.age)
}
type teen struct {
name string
age int
}
func (p teen) Greet() {
fmt.Printf("Hi! My name is %s, my age is %d", p.name, p.age)
}
// NewAbstractIPerson
// Here, NewAbstractIPerson returns an interface, and not the person struct itself
// 通过返回接口,可以在你不公开内部实现的情况下,让调用者使用你提供的各种功能,
// 也可以强制用户在初始一个 person 的时候使用我们的构造函数。
// 上面这个代码,定义了一个不可导出的结构体 person,在通过 NewAbstractIPerson 创建实例的时候返回的是接口,而不是结构体。
func NewAbstractIPerson(name string, age int) IPerson {
if age < 12 {
return kid{
name: name,
age: age,
}
}
return teen{
name: name,
age: age,
}
}
func TestNewAbstractIPerson(t *testing.T){
kid1 := NewAbstractIPerson(5, "张三")
teen1 := NewAbstractIPerson(12, "李四")
kid1.Greet()
teen1.Greet()
}
go http 抽象工厂实现
// We define a Doer interface, that has the method signature
// of the `http.Client` structs `Do` method
type Doer interface {
Do(req *http.Request) (*http.Response, error)
}
// This gives us a regular HTTP client from the `net/http` package
func NewHTTPClient() Doer {
return &http.Client{}
}
type mockHTTPClient struct{}
func (*mockHTTPClient) Do(req *http.Request) (*http.Response, error) {
// The `NewRecorder` method of the httptest package gives us
// a new mock request generator
res := httptest.NewRecorder()
// calling the `Result` method gives us
// the default empty *http.Response object
return res.Result(), nil
}
// This gives us a mock HTTP client, which returns
// an empty response for any request sent to it
func NewMockHTTPClient() Doer {
return &mockHTTPClient{}
}