适配器模式Golang

设计模式
适配器模式

适配器模式(Adapter Pattern) 就是作为两个不兼容接口之间的桥梁. 设计属于结构模式.
将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

优点 和 缺点

优点:

  1. 提高类的使用率
  2. 增加了透明度
  3. 将没有关系的类联合起来

缺点:

  1. 过多使用适配器会让代码变得复杂
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
type MusicPlayer interface {
	play(fileType string, fileName string)
}

type OutPlayer struct{
}

func (*OutPlayer)  playMp3(fileName string) {
	fmt.Println("play mp3: ", filename)
}

func (*OutPlayer) playWma(fileName string) {
    fmt.Println("play wma :", fileName)
}

// Adapter
type PlayerAdaptor struct{
	outPlayer OutPlayer
}

func (player *PlayerAdaptor) play(fileType string, fileName string) {
    switch fileType {
    case "mp3":
        player.outPlayer.playMp3(fileName)
    case "wma":
        player.outPlayer.playWma(fileName)
    default:
        fmt.Println("Can't use it")
    }
}

过滤模式Golang

设计模式
过滤模式

过滤器模式（Filter Pattern）或标准模式（Criteria Pattern）是一种设计模式，
这种模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来。
这种类型的设计模式属于结构型模式，它结合多个标准来获得单一标准。

装饰器模式Golang

设计模式
装饰器模式

装饰器模式(Decorator pattern) 允许像一个现有对象添加新的功能, 同时又不会改变结构.

有点 和 缺点

优点:

  1. 装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。
  2. 装饰器模式完全遵守开闭原则.

缺点:

  1. 装饰模式会增加许多子类，过度使用会增加程序得复杂性。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
type Shape interface {
	Draw()
}

type Circle struct{
	radius float64
}

func (c Circle) Draw() {
    fmt.Println("Draw circle:", c.radius)
}

type Rectangle struct{
	length float64
	width  float64
}

func (r Rectangle) Draw() {
	fmt.Println("Draw a rectangle")
}

type ShapeDecorator interface {
    Shape
}

type RedShapeDecorator struct {
    S Shape
}

func (d RedShapeDecorator) Draw() {
    d.S.Draw()
    d.setRedBorder()
}

func (d RedShapeDecorator) setRedBorder() {
    fmt.Println("Decorator:set red border")
}

代理模式Golang

设计模式
桥接模式

桥接模式(Bridge Pattern): 将抽象部分和现实分离, 使他们可以独立变化. 它是一种对象结构模式,
又称为柄体(Handle and Body)模式或接口(Interface)模式。
主要解决：主要解决在软件系统中，有时候面临着”一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；
由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

优点 和 缺点

优点:

  1. 分离抽象接口及其实现部分。
  2. 桥接模式提高了系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统。

缺点:

  1. 桥接模式的引入会增加系统的理解与设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
type AbstractMessage interface {
	SendMessage(text, to string)
}

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

type MessageSMS struct {
}


func ViaSMS() MessageImplementer {
	return &MessageSMS{}
}
func (m *MessageSMS) Send(text, to string) {
	fmt.Printf("send %s to %s via Email", 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)
}

原型模式Golang

设计模式
原型模式(Prototype Pattern)

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
原型模式通过克隆一个已经存在的对象实例来返回新的实例，而不是通过new去创建对象，多用于创建复杂的或者耗时的实例，因为这种情况下，复制一个已经存在的实例使程序运行更高效；

优点 和 缺点

优点：
1、性能提高。
2、逃避构造函数的约束。

缺点：
1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，
特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。
2、必须实现 Cloneable 接口。

1
2
3
4
5
6
7
8
type Example struct {
	Content string
}

func (e *Example) Clone() *Example {
	res := *e
	return &res
}

代理模式Golang

设计模式
代理模式

代理模式(Proxy Pattern): 给某一个对象提供一个代理, 并有代理对象控制原来对象的引用.

优点和缺点

代理模式能够协调调用者和被调用者, 在一定程度上降低系统的耦合度.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

type IObject interface { 
    ObjDo(action string)
}

type Object struct { 
    action string 
}

func (obj *Object) ObjDo(action string) {
	fmt.Printf("I can %s", action)
}

type ProxyObject struct {
	object *Object
}

func (p *ProxyObject) ObjDo(action string) {
	if p.object == nil {
		p.object = new(Object)
	}
	if action == "run" {
		p.object.ObjDo(action)
	}
}

适配器模式模式Golang

设计模式
适配器模式

将一个接口转换成客户希望的另一个接口，适配器模式使接口不兼容的那些类可以一起工作，其别名为包装器(Wrapper)。
适配器模式既可以作为类结构型模式，也可以作为对象结构型模式。

应用案例:

  1. 应用的最多的莫过于代码/接口升级，而又需要保证老接口的兼容性，这个时候，为了让老接口继续工作， 我们需要提供一个中间层，
    让老接口对外的接口不变，但实际上代码却调用了新代码。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
type targetInterface interface {
	operationA()
}

// someInterface 这是目标类targetClass实现的接口
type someInterface interface {
	operationB()
}

// targetClass 目标对象,需要被匹配的类
type targetClass struct{}

// operationB 目标对象的方法
func (*targetClass) operationB() {
	fmt.Println("调用到 targetClass的方法 operationB 成功!!")
}
// Adapter 适配器
type Adapter struct {
	targetClass // 继承类 targetClass ,类适配器写法
	// targetClass targetClass // 聚合类 targetClass, 对象适配器写法
}

// operationA 实现targetInterface方法
func (a *Adapter) operationA() {
	fmt.Println("调用接口 operationA")
	a.operationB() // 类适配器写法
	// a.targetClass.operationB() // 对象适配器写法
}


单例模式设计模式Golang

设计模式
单例模式

单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。

单例模式的主要使用场景有以下两个方面：

  1. 资源共享情况下避免资源操作导致的性能损耗，比如日志管理器，web网站计数器，应用配置管理对象等
  2. 方便对资源的控制，比如线程池和数据库连接池等
1
2
3
4
5
6
7
8
9
10
11
12
13
type singleton map[string]string

var (
	 once 		sync.Once
	 instance 	singleton
)
func New() singleton {
	once.Do(func() {
		instance = make(singleton)
	})
	return instance
}

享元模式Golang

设计模式
享元模式

享元模式(Flyweight Pattern): 主要是减少创建对象的数量, 以减少内存占用和提升性能.
何时使用：系统中有大量对象,这些对象消耗大量内存,这些对象的状态大部分可以外部化。

优点 和 缺点

优点: 大大减少对象的创建，降低系统的内存，使效率提高。
缺点: 外部状态具有固有化的性质, 提高了系统的复杂度, 需要分离出外部和内部状态.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
type Employee interface {
	report()
}

type Manager struct {
	title string
	department string
	reportContent string
}

func NewManager(department string) Manager {
    return Manager{
        title:      "manager",
        department: department,
    }
}

func (m *Manager) SetReportContent(reportContent string) {
    m.reportContent = reportContent
}

type EmployeeFactory struct {
    employeeMap map[string]Employee
}

func NewEmployeeFactory() *EmployeeFactory {
    return &EmployeeFactory{
        employeeMap: make(map[string]Employee),
    }
}

外观模式Golang

设计模式
外观模式

外观模式(Facade Pattern): 隐藏系统的复杂, 提供一个统一的接口, 用来访问子系统的一群接口.
这种类型的设计模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性。

优点 和 缺点

优点:

  1. 减少系统相互依赖。
  2. 提高灵活性。
  3. 提高了安全性。

缺点:

  1. 不能很好地限制客户使用子系统类，很容易带来未知风险。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
type Shape interface {
    Draw()
}

type Circle struct {
    radius float64
}

func (c Circle) Draw() {
    fmt.Println("Draw a circle:", c.radius)
}

type Rectangle struct {
    length float64
    width  float64
}

func (r Rectangle) Draw() {
    fmt.Printf("Draw a rectangle length:%f,width:%f", r.length, r.width)
}

type Square struct {
    width float64
}

func (s Square) Draw() {
    fmt.Printf("Draw a square:%f", s.width)
}

type ShapeMaker struct {
    circle    Circle
    rectangle Rectangle
    square    Square
}

func (maker ShapeMaker) DrawCircle() {
    maker.circle.Draw()
}
func (maker ShapeMaker) DrawRectangle() {
    maker.rectangle.Draw()
}
func (maker ShapeMaker) DrawSquare() {
    maker.square.Draw()
}

Powered by Hexo and Hexo-theme-hiker

Copyright © 2018 - 2021 Noonde All Rights Reserved.

UV : | PV :