桥梁模式(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{
"[email protected]"})
n := NewErrorNotification(sender)
err := n.Notify("test msg")
t.Log(err)
}