[golang]设计模式--2

抽象工厂方法

抽象工厂模式用于生成品族的工厂，所生成的对象是有关联的。
如果抽象工厂退化成生成的对象无关联则成为工厂函数模式。

abstractfactory.go

package creativeMode

import "log"

//抽象工厂

//订单主记录

type OrderMainDAO interface {
	SaveOrderMain()
}

//订单详细记录

type OrderDetailDAO interface {
	SaveOrderDetail()
}

//抽象工厂模式接口

type DAOFactory interface {
	CreateOrderMainDAO() OrderMainDAO
	CreateOrderDetailDAO() OrderDetailDAO
}

//关系型数据库的OrderMainDAO实现

type RDBMainDAO struct{}

func (*RDBMainDAO) SaveOrderMain() {
	log.Println("rdb main save")
}

// 关系型数据库的OrderDetail实现

type RDBDetailDAO struct{}

func (*RDBDetailDAO) SaveOrderDetail() {
	log.Println("rdb detail save")
}

//RDB 抽象工厂实现

type RDBDAOFactory struct{}

func (*RDBDAOFactory) CreateOrderMainDAO() OrderMainDAO {
	return &RDBMainDAO{}
}
func (*RDBDAOFactory) CreateOrderDetailDAO() OrderDetailDAO {
	return &RDBDetailDAO{}
}

// Xml 存储

type XMLMainDAO struct{}

func (*XMLMainDAO) SaveOrderMain() {
	log.Println("xml main save")
}

type XMLDetailDAO struct{}

func (*XMLMainDAO) SaveOrderDetail() {
	log.Println("xml detail save")
}

//XML 抽象实现

type XMLDAOFactory struct{}

func (*XMLDAOFactory) CreateOrderMainDAO() OrderMainDAO {
	return &XMLMainDAO{}
}

func (*XMLDAOFactory) CreateOrderDetailDAO() OrderDetailDAO {
	return &XMLMainDAO{}
}

abstractfactory_test.go

package creativeMode

import "testing"

func getMainAndDetail(factory DAOFactory) {
	factory.CreateOrderDetailDAO().SaveOrderDetail()
	factory.CreateOrderMainDAO().SaveOrderMain()
}

func TestRDB(t *testing.T) {
	var factory DAOFactory
	factory = &RDBDAOFactory{}
	getMainAndDetail(factory)
}

func TestXML(t *testing.T) {
	var factory DAOFactory
	factory = &XMLDAOFactory{}
	getMainAndDetail(factory)
}

创造者模式

将一个复杂对象的构建分离成多个简单对象的构建组合。
builder.go

package creativeMode

//创建则模式
//将一个复杂对象的构建分离为多个简单对象的构建组合

//生成器接口

type Builder interface {
	Part1()
	Part2()
	Part3()
}

type Director struct {
	builder Builder
}

func NewDirector(builder Builder) *Director {
	return &Director{
		builder: builder,
	}
}

//构建

func (d *Director) Construct() {
	d.builder.Part1()
	d.builder.Part2()
	d.builder.Part3()
}

type BuilderB struct {
	result string
}

func (b *BuilderB) Part1() {
	b.result += "1"
}

func (b *BuilderB) Part2() {
	b.result += "2"
}

func (b *BuilderB) Part3() {
	b.result += "3"
}

func (b *BuilderB) getResult() string {
	return b.result
}

type BuilderC struct {
	result int
}

func (b *BuilderC) Part1() {
	b.result += 1
}

func (b *BuilderC) Part2() {
	b.result += 2
}

func (b *BuilderC) Part3() {
	b.result += 3
}
func (b *BuilderC) getResult() int {
	return b.result
}

builder_test.go

package creativeMode

import (
	"log"
	"testing"
)

func TestBuilderB(t *testing.T) {
	builder := &BuilderB{}
	director := NewDirector(builder)
	director.Construct()
	res := builder.result
	if res != "123" {
		log.Println("Builder fail expect 123 acture ", res)
	}
}

func TestBuilderC(t *testing.T) {
	builder := &BuilderC{}
	director := NewDirector(builder)
	director.Construct()
	res := builder.result
	if res != 6 {
		log.Println("Builder fail expect 6 acture ", res)
	}
}