博客

桥梁模式(Bridge)(Handle / Body)

1.意图

将抽象部分与它的实现部分分离，使它们都可以独立地变化。

2.适用性

以下一些情况使用Bridge模式:

• 你不希望在抽象和它的实现部分之间有一个固定的绑定关系。例如这种情况可能是因为，在程序运行时刻实现部分应可以被选择或者切换。
• 类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。这时Bridge模式使你可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充。
• 对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译。
• (C++)你想对客户完全隐藏抽象的实现部分。在C++中，类的表示在类接口中是可见的。
• 正如在意图一节的第一个类图中所示的那样，有许多类要生成。这样一种类层次结构说明你必须将一个对象分解成两个部分。Rumbaugh称这种类层次结构为“嵌套的普化”(nested generalizations)。
• 你想在多个对象间共享实现(可能使用引用计数)，但同时要求客户并不知道这一点。一个简单的例子便是Coplien的String类，在这个类中多个对象可以共享同一个字符串表示(StringRep)。

3.结构

4.代码

package bridge

/*
# 桥接模式
桥接模式分离抽象部分和实现部分。使得两部分独立扩展。
桥接模式类似于策略模式，区别在于策略模式封装一系列算法使得算法可以互相替换。
策略模式使抽象部分和实现部分分离，可以独立变化。

抽象类和它的实现构成了桥接的关系，使它们可以分别的变化。
礼物的类型可以随意变化，礼物也可以随便变化，但是无论如何变化，都不影响某种类型嵌入某种礼物


GG追MM，GG可以给MM送【不同种类】的【不同礼物】

*/

import (
	"fmt"
	"testing"
)

type GiftImpl interface {
	GiftName() string
}

type Book struct {}  //从GiftImpl继承

func (Book) GiftName() string {
	return "一本[%s]类型的[书]"
}

func NewBook() Book {
	return Book{}
}

type Flower struct {} // //从GiftImpl继承

func (Flower) GiftName() string {
	return "一朵[%s]类型的[花]"
}

func NewFlower() Flower {
	return Flower{}
}



type Gift interface {
	GiftType() string
}

type WarmGift struct {
	impl GiftImpl
}

func NewWarmGift(impl GiftImpl) WarmGift {
	return WarmGift{impl}
}


func (this WarmGift)GiftType() string {
	return fmt.Sprintf(this.impl.GiftName(),"温暖")
}

type WildGift struct {
	impl GiftImpl
}

func NewWildGift(impl GiftImpl) WildGift {
	return WildGift{impl}
}

func (this WildGift)GiftType() string {
	return fmt.Sprintf(this.impl.GiftName(),"狂野")
}


type MM struct {name string}
type GG struct {name string}

func (this GG)Chase(mm MM){
	var gift Gift

	gift = NewWarmGift(NewBook())
	this.Give(mm, gift)

	gift = NewWarmGift(NewFlower())
	this.Give(mm,gift)


	gift = NewWildGift(NewBook())
	this.Give(mm, gift)

	gift =NewWildGift(NewFlower())
	this.Give(mm,gift)
}

func (this GG)Give(mm MM,gift Gift)  {
	fmt.Println(this.name + "送给" + mm.name + gift.GiftType())
}

func TestGift(t *testing.T)  {

	gg:=GG{"[井上十三香]"}
	mm:=MM{"[川岛辣椒酱]"}
	gg.Chase(mm)

}

//---------------------------------------

















type AbstractMessage interface {
	SendMessage(text, to string)
}

type MessageImplementer interface {
	Send(text, to string)
}

type MessageSMS struct{}

func ViaSMS() MessageImplementer {
	return &MessageSMS{}
}

func (*MessageSMS) Send(text, to string) {
	fmt.Printf("send %s to %s via SMS", text, to)
}

type MessageEmail struct{}

func ViaEmail() MessageImplementer {
	return &MessageEmail{}
}

func (*MessageEmail) Send(text, to string) {
	fmt.Printf("send %s to %s via Email", text, to)
}

type CommonMessage struct {
	method MessageImplementer
}

func NewCommonMessage(method MessageImplementer) *CommonMessage {
	return &CommonMessage{
		method: method,
	}
}

func (m *CommonMessage) SendMessage(text, to string) {
	m.method.Send(text, to)
}

type UrgencyMessage struct {
	method MessageImplementer
}

func NewUrgencyMessage(method MessageImplementer) *UrgencyMessage {
	return &UrgencyMessage{
		method: method,
	}
}

func (m *UrgencyMessage) SendMessage(text, to string) {
	m.method.Send(fmt.Sprintf("[Urgency] %s", text), to)
}

func ExampleCommonSMS() {
	m := NewCommonMessage(ViaSMS())
	m.SendMessage("have a drink?", "bob")
	// Output:
	// send have a drink? to bob via SMS
}




func ExampleCommonEmail() {
	m := NewCommonMessage(ViaEmail())
	m.SendMessage("have a drink?", "bob")
	// Output:
	// send have a drink? to bob via Email
}

func ExampleUrgencySMS() {
	m := NewUrgencyMessage(ViaSMS())
	m.SendMessage("have a drink?", "bob")
	// Output:
	// send [Urgency] have a drink? to bob via SMS
}

func ExampleUrgencyEmail() {
	m := NewUrgencyMessage(ViaEmail())
	m.SendMessage("have a drink?", "bob")
	// Output:
	// send [Urgency] have a drink? to bob via Email
}







// IMsgSender IMsgSender
type IMsgSender interface {  //消息发送接口
	Send(msg string) error
}

// EmailMsgSender 发送邮件
// 可能还有 电话、短信等各种实现
type EmailMsgSender struct {
	emails []string
}

// NewEmailMsgSender NewEmailMsgSender
func NewEmailMsgSender(emails []string) *EmailMsgSender {
	return &EmailMsgSender{emails: emails}
}

// Send Send
func (s *EmailMsgSender) Send(msg string) error { //实现接口
	fmt.Println("发送邮件",msg)
	// 这里去发送消息
	return nil
}


// INotification 通知接口
type INotification interface {
	Notify(msg string) error
}

// ErrorNotification 错误通知
// 后面可能还有 warning 各种级别
type ErrorNotification struct { //
	sender IMsgSender
}

// NewErrorNotification NewErrorNotification
func NewErrorNotification(sender IMsgSender) *ErrorNotification {
	return &ErrorNotification{sender: sender}
}

// Notify 发送通知
func (n *ErrorNotification) Notify(msg string) error {
	return n.sender.Send(msg)
}


func TestErrorNotification_Notify(t *testing.T) {
	sender := NewEmailMsgSender([]string{"test@test.com"})
	n := NewErrorNotification(sender)
	err := n.Notify("test msg")

	t.Log(err)
}