design pattern

Author: coolpest

behavioral/Command/command.go

@@ -0,0 +1,44 @@
+package Command
+
+import "fmt"
+
+type Person struct {
+	name string
+	cmd  Command
+}
+
+type Command struct {
+	person *Person
+	method func()
+}
+
+func NewCommand(p *Person, method func()) Command {
+	return Command{person: p, method: method}
+}
+
+func (c *Command) Execute() {
+	c.method()
+}
+
+func NewPerson(name string, cmd Command) Person {
+	return Person{name, cmd}
+}
+
+func (p *Person) Talk() {
+	fmt.Println(fmt.Sprintf("%s is talking.\n", p.name))
+	p.cmd.Execute()
+}
+
+func (p *Person) PassOn() {
+	fmt.Println(fmt.Sprintf("%s is passing on.\n", p.name))
+	p.cmd.Execute()
+}
+
+func (p *Person) Gossip() {
+	fmt.Println(fmt.Sprintf("%s is gossiping.\n", p.name))
+	p.cmd.Execute()
+}
+
+func (p *Person) Listen() {
+	fmt.Println(fmt.Sprintf("%s is Listening.\n", p.name))
+}

behavioral/Command/command_test.go

@@ -0,0 +1,12 @@
+package Command
+
+import "testing"
+
+func TestPerson_Talk(t *testing.T) {
+	laowang := NewPerson("wang", NewCommand(nil, nil))
+	laozhang := NewPerson("zhang", NewCommand(&laowang, laowang.Listen))
+	laofeng := NewPerson("feng", NewCommand(&laozhang, laozhang.Gossip))
+	laoding := NewPerson("ding", NewCommand(&laofeng, laofeng.PassOn))
+
+	laoding.Talk()
+}

behavioral/Iterator/iterator.go

@@ -0,0 +1,33 @@
+package Iterator
+
+type Iterator interface {
+	Index() int
+	Value() interface{}
+	HasNext() bool
+	Next()
+}
+
+type ArrayIterator struct {
+	array []interface{}
+	index *int
+}
+
+func (a *ArrayIterator) Index() *int {
+
+	return a.index
+}
+
+func (a *ArrayIterator) Value() interface{} {
+	return a.array[*a.index]
+}
+
+func (a *ArrayIterator) HasNext() bool {
+	return *a.index+1 <= len(a.array)
+}
+
+func (a *ArrayIterator) Next() {
+	if a.HasNext() {
+
+		*a.index++
+	}
+}

behavioral/Iterator/iterator_test.go

@@ -0,0 +1,19 @@
+package Iterator
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestIterator(t *testing.T) {
+	array := []interface{}{1, 3, 9, 2, 8}
+	a := 0
+	iterator := ArrayIterator{array: array, index: &a}
+	for it := iterator; iterator.HasNext(); iterator.Next() {
+		index, value := it.Index(), it.Value().(int)
+		if value != array[*index] {
+			fmt.Println("error...")
+		}
+		fmt.Println(*index, value)
+	}
+}

behavioral/Responsibility_Chain/chain_of_responsibility.go

@@ -0,0 +1,24 @@
+package Responsibility_Chain
+
+import "strconv"
+
+type Handler interface {
+	Handler(handleID int) string
+}
+
+type handler struct {
+	name      string
+	next      Handler
+	handlerID int
+}
+
+func NewHandler(name string, next Handler, handleID int) *handler {
+	return &handler{name, next, handleID}
+}
+
+func (h *handler) Handler(handlerID int) string {
+	if h.handlerID == handlerID {
+		return h.name + " handled " + strconv.Itoa(handlerID)
+	}
+	return h.next.Handler(handlerID)
+}

behavioral/Responsibility_Chain/chain_of_responsibility_test.go

@@ -0,0 +1,15 @@
+package Responsibility_Chain
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestHandler_Handler(t *testing.T) {
+	micheal := NewHandler("Micheal", nil, 1)
+	mike := NewHandler("Mike", micheal, 2)
+	r := mike.Handler(1)
+	fmt.Println(r)
+	r = mike.Handler(2)
+	fmt.Println(r)
+}

behavioral/Strategy/strategry_test.go

@@ -0,0 +1,10 @@
+package Strategy
+
+import "testing"
+
+func TestContext_Execute(t *testing.T) {
+	strategy := NewStrategyB()
+	context := NewContext()
+	context.SetStrategy(strategy)
+	context.Execute()
+}

behavioral/Strategy/strategy.go

@@ -0,0 +1,44 @@
+package Strategy
+
+import "fmt"
+
+type Strategy interface {
+	Execute()
+}
+
+type strategyA struct {
+}
+
+func (s *strategyA) Execute() {
+	fmt.Println("A plan executed.")
+}
+
+func NewStrategyA() Strategy {
+	return &strategyA{}
+}
+
+type strategyB struct {
+}
+
+func (s *strategyB) Execute() {
+	fmt.Println("B plan executed.")
+}
+
+func NewStrategyB() Strategy {
+	return &strategyB{}
+}
+
+type Context struct {
+	strategy Strategy
+}
+
+func NewContext() *Context {
+	return &Context{}
+}
+
+func (c *Context) SetStrategy(strategy Strategy) {
+	c.strategy = strategy
+}
+func (c *Context) Execute() {
+	c.strategy.Execute()
+}

behavioral/Template/template.go

@@ -0,0 +1,38 @@
+package Template
+
+import "fmt"
+
+type WorkerInterface interface {
+	GetUp()
+	Work()
+	Sleep()
+}
+
+type Worker struct {
+	WorkerInterface
+}
+
+func NewWorker(w WorkerInterface) *Worker {
+	return &Worker{WorkerInterface: w}
+}
+
+func (w *Worker) Daily() {
+	w.GetUp()
+	w.Work()
+	w.Sleep()
+}
+
+type Coder struct {
+}
+
+func (c *Coder) GetUp() {
+	fmt.Println("coder GetUp")
+}
+
+func (c *Coder) Work() {
+	fmt.Println("coder Work")
+}
+
+func (c *Coder) Sleep() {
+	fmt.Println("coder Sleep")
+}

behavioral/Template/template_test.go

@@ -0,0 +1,8 @@
+package Template
+
+import "testing"
+
+func TestWorker_Daily(t *testing.T) {
+	worker := NewWorker(&Coder{})
+	worker.Daily()
+}

behavioral/Visitor/visitor.go

@@ -0,0 +1,34 @@
+package Visitor
+
+import (
+	"fmt"
+)
+
+type IVisitor interface {
+	Visit()
+}
+
+type WeiboVisitor struct {
+}
+
+func (w WeiboVisitor) Visit() {
+	fmt.Println("这是微博")
+}
+
+type IQiYiVisitor struct {
+}
+
+func (i IQiYiVisitor) Visit() {
+	fmt.Println("这里是爱奇艺")
+}
+
+type IElement interface {
+	Accept(visitor IVisitor)
+}
+
+type Element struct {
+}
+
+func (el Element) Accept(v IVisitor) {
+	v.Visit()
+}

behavioral/Visitor/visitor_test.go

@@ -0,0 +1,9 @@
+package Visitor
+
+import "testing"
+
+func TestElement_Accept(t *testing.T) {
+	e := new(Element)
+	e.Accept(new(WeiboVisitor))
+	e.Accept(new(IQiYiVisitor))
+}

creational/Builder/builder.go

@@ -0,0 +1,37 @@
+package Builder
+
+type Builder interface {
+	Build()
+}
+
+type Director struct {
+	builder Builder
+}
+
+func NewDirector(b Builder) Director {
+	return Director{builder: b}
+}
+
+func (d *Director) Construct() {
+	d.builder.Build()
+}
+
+type ConcreteBuilder struct {
+	built bool
+}
+
+func NewConcreteBuilder() ConcreteBuilder {
+	return ConcreteBuilder{false}
+}
+
+func (b *ConcreteBuilder) Build() {
+	b.built = true
+}
+
+type Product struct {
+	Built bool
+}
+
+func (b *ConcreteBuilder) GetResult() Product {
+	return Product{b.built}
+}

creational/Builder/builder_test.go

@@ -0,0 +1,14 @@
+package Builder
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestConcreteBuilder_GetResult(t *testing.T) {
+	builder := NewConcreteBuilder()
+	director := NewDirector(&builder)
+	director.Construct()
+	product := builder.GetResult()
+	fmt.Println(product.Built)
+}