海面模拟（一）

Mediator Pattern

  中介者模式定义一个中介对象来封装系列对象之间的交互。各个对象不需要显示地相互引用，从而使其耦合性松散,而且可以独立地改变它们之间的交互。

实现

  说起中介，就想到买房。

package mediator

import (
	"fmt"
	"gopkg.in/mgo.v2/bson"
)

type Mediator interface{

}

type RoomHash map[bson.ObjectId]*Room
type ConsumerHash map[bson.ObjectId]*Consumer


type RoomMediator struct {
	roomHash RoomHash
	consumerHash ConsumerHash
}

func NewRoomMediator()*RoomMediator{
	res := RoomMediator{}
	res.roomHash=make(RoomHash)
	res.consumerHash=make(ConsumerHash)
	return &res
}

func (this *RoomMediator)SetRoom(room *Room){
	if len(this.consumerHash)>0{
		var c *Consumer
		for _,v := range this.consumerHash{
			fmt.Println(v.Name +" buy " + room.Name)
			c = v
			break
		}
		delete(this.consumerHash,c.Id)
		return
	}
	this.roomHash[room.Id]=room
}

func (this *RoomMediator)SetConsumerHash(consumer *Consumer){
	if len(this.roomHash)>0{
		var r *Room
		for _,v := range this.roomHash{
			fmt.Println(consumer.Name +" buy "+ v.Name)
			r = v
			break
		}
		delete(this.roomHash,r.Id)
		return
	}
	this.consumerHash[consumer.Id]=consumer
}

  定义消费者。

package mediator

import "gopkg.in/mgo.v2/bson"

type Consumer struct{
	Id bson.ObjectId
	Name string
}

func NewConsumer(name string)*Consumer{
	return &Consumer{bson.NewObjectId(),name}
}

  定义房子。

package mediator

import "gopkg.in/mgo.v2/bson"

type Room struct{
	Id bson.ObjectId
	Name string
}

func NewRoom(name string)*Room{
	return &Room{bson.NewObjectId(),name}
}

使用

func main(){
   room_1 := mediator.NewRoom("凤鸣山水国际")
   room_2 := mediator.NewRoom("1137")
   consumer_1 := mediator.NewConsumer("wwt")
   consumer_2 := mediator.NewConsumer("wpy")

   m := mediator.NewRoomMediator()
   m.SetRoom(room_1)
   m.SetConsumerHash(consumer_1)
   m.SetConsumerHash(consumer_2)
   m.SetRoom(room_2)
}

使用场景

• 一组定义良好的对象，现在要进行复杂的通信。
• 定制一个分布在多个类中的行为，而又不想生成太多的子类。

优点

• 降低了系统对象之间的耦合性，使得对象易于独立的被复用。
• 提高系统的灵活性，使得系统易于扩展和维护。

缺点

• 中介者模式的缺点是显而易见的，因为这个“中介“承担了较多的责任，所以一旦这个中介对象出现了问题，那么整个系统就会受到重大的影响。
  

---

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以邮件