精通Go设计模式： idiomatic编程与并发模式

格式模式

需积分: 10 190 浏览量更新于2024-07-17 收藏 4.28MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

"Go设计模式，由Mario Castro Contreras撰写，由Packt Publishing于2017年出版，旨在帮助读者学习和理解Go语言中惯用、高效、清晰且可扩展的设计模式和并发模式，采用测试驱动开发(TDD)的方法进行讲解。这本书包含了对Go编程模式的深入探讨，并涉及版权和免责声明，以及出版商对书中信息准确性的努力和责任限制。" Go设计模式是编程中的关键组成部分，它们是解决常见问题的最佳实践和模板，能够提升代码的可读性、可维护性和复用性。在Go语言中，设计模式特别重要，因为Go是一种静态类型的语言，同时强调简洁和并发能力。本书"Go Design Patterns"涵盖了以下几个方面： 1. **惯用模式**：惯用模式是Go社区普遍接受的编程习惯，例如接口的使用、错误处理（通过多重返回值和错误检查）以及依赖注入等。这些模式有助于写出符合Go语言精神的代码。 2. **高效模式**：Go语言的性能是其一大亮点，高效模式通常涉及内存管理、数据结构选择和算法优化，确保程序在执行速度和资源消耗上达到最佳。 3. **并发模式**：Go语言内置的goroutines和channels使其在并发编程方面独具优势。书中可能介绍了如何利用这些工具实现并发，如worker池模式、频道同步和死锁预防等。 4. **测试驱动开发(TDD)**：TDD是一种软件开发方法，强调先编写测试，然后编写最小化的代码来使测试通过。这种做法可以提高代码质量，减少错误，同时也方便后期维护。 5. **设计原则与模式**：书中可能涵盖了软件设计的原则，如单一职责原则(SRP)、开闭原则(OCP)、里氏替换原则(LSP)、接口隔离原则(ISP)和依赖倒置原则(DIP)。此外，经典的GOF设计模式，如工厂模式、单例模式、观察者模式等也可能有涉及，但会结合Go语言的特性进行解释。 6. **案例研究**：为了使理论更易于理解，书中的例子可能会基于真实的项目或问题，展示如何在实际场景中应用这些模式。 7. **最佳实践**：书中还会讨论一些Go语言特有的最佳实践，如包管理、错误处理策略和代码组织结构，这些都是编写高质量Go代码不可或缺的部分。 "Go Design Patterns"这本书对于想要提升Go编程技能，特别是想深入了解并发编程和惯用设计模式的开发者来说，是一份宝贵的资源。通过学习，读者能够更好地适应Go语言的思维方式，编写出更高效、可扩展和易于维护的代码。

资源详情

资源推荐

[ viii ]

Callback hell

285

Mutexes

286

An example with mutexes – concurrent counter

287

Presenting the race detector

288

Channels

291

Our first channel

291

Buffered channels

293

Directional channels

295

The select statement

296

Ranging over channels too!

300

Using it all – concurrent singleton

301

Unit test

301

Implementation

302

Summary

307

Chapter 9: Concurrency Patterns - Barrier, Future, and Pipeline Design

Patterns

308

Barrier concurrency pattern

309

Description

309

Objectives

309

An HTTP GET aggregator

309

Acceptance criteria

310

Unit test – integration

311

Implementation

314

Waiting for responses with the Barrier design pattern

318

Future design pattern

319

Description

319

Objectives

321

A simple asynchronous requester

321

Acceptance criteria

321

Unit tests

322

Implementation

326

Putting the Future together

330

Pipeline design pattern

330

Description

330

Objectives

330

A concurrent multi-operation

331

Acceptance criteria

331

Beginning with tests

331

Implementation

333

Preface

Welcome to the book Go Design Patterns! With this book, you'll learn basic and advanced

techniques and patterns with the Go language. Don't worry if you have never written Go

code before; this book will gradually introduce you to the various concepts in Go

programming. At the same time, experts will find many tips and tricks on the language, so I

encourage you to not miss any chapter. If you already know the classic design patterns,

you'll find this book very handy, not only as a reference book but also as a way to learn

idiomatic Go approaches to solve common problems that you may already know.

The book is divided in three sections:

Introduction to the Go language: This is the first part of the book, where you'll

learn the basic syntax, the tools that comes with the binary distributions, basic

testing, JSON parsing, and more. We leave concurrency for a later chapter to

focus on the way that the syntax and the compiler work in a typical Go app.

Classic design patterns in idiomatic Go: The second section presents the classic

design patterns but as we will see, they are quite different, partly because of the

lack of inheritance in Go, but also because we have different and more optimal

ways to solve the same problems. A newcomer to the language will find the

examples in this section very useful as a way to understand the roots of Go and

the idiomatic ways in which you can solve problems using Go in the same

manner as you would solve in languages such as Java or C++. Most examples are

presented by using TDD and some of them even show examples within Go

standard library that uses these patterns.

Concurrency patterns: The focus in this section is learning about concurrent

structures and parallel execution. You will learn most of the primitives in Go to

write concurrent apps, and we will develop some of the classical design patterns

with concurrent structures to maximize parallelism. Also, we will learn some of

the typical structures to develop concurrent apps in Go. You learn how a classical

pattern can become more complex if we need it to work in a concurrent way but

the idea is to understand Go concurrent primitives so that the reader finishes the

book knowing how to write their own concurrent design patterns by using the

knowledge taken from the book.

The book will slowly raise the difficulty of some tasks. We have explained tips and tricks in

every chapter.

Preface

[ 2 ]

What this book covers

Chapter 1, Ready… Steady…Go!, attempts to help newcomers to the Go programming

language who have some background in any other programming language. It will begin by

showing how to install the Go environment in a Linux machine, moving to syntax, type and

flow control.

Chapter 2, Creational Patterns - Singleton, Builder, Factory, Prototype, and Abstract Factory

Design Patterns, introduces the problems that can arise when an object creation or

management is particularly complex or expensive using the Singleton, Builder, Factory, and

Abstract Factory design patterns.

Chapter 3, Structural Patterns - Composite, Adapter, and Bridge Design Patterns, deals with the

first set of Structural patterns about object composition to get some new functionality. Such

as creating an intermediate object and using of various objects as if there is only one.

Chapter 4, Structural Patterns - Proxy, Facade, Decorator, and Flyweight Design Patterns, is less

oriented to multi-object composition but focuses more on obtaining new functionality in

existing objects. The Decorator pattern is commonly used to follow the open-closed

principle. Facade is extensively used in API’s where you want a single source for many

sources of information and actions. Flyweight is not so common but it’s a very useful

pattern when the memory is becoming a problem caused by a large collection of similar

objects. Finally, the Proxy pattern wraps on an object to provide the same functionality, but

at the same time, adding something to the proxy’s functionality.

Chapter 5, Behavioral patterns - Strategy, Chain of Responsibility, Command, and Mediator

Design Patterns, deals with the first behavioral pattern to make objects react in an expected

or bounded way. We’ll start with the Strategy pattern, perhaps the most important design

pattern in object-oriented programming, as many design patterns have something in

common with it. Then we’ll move to the Chain of Responsibility to build chains of objects

that can decide which between them must deal with a particular case. Finally, Command

pattern to encapsulate actions that don’t necessarily need to be executed immediately or

must be stored.

Chapter 6, Behavioral Patterns - Template, Memento, and Interpreter Design Patterns, continues

with Behavioral patterns introducing the Interpreter pattern, a quite complex pattern to

create small languages and Interpreters for them. It can be very useful when a problem can

be solved by inventing a small language for it. The Memento pattern is in front of our eyes

every day with the Undo button in apps. The Template pattern helps developers by

defining an initial structure of an operation so that the final users of the code can finish it.

Preface

[ 3 ]

Chapter 7, Behavioral Patterns - Visitor, State, Mediator, and Observer Design Patterns, depicts

the Observer pattern, an important pattern that is becoming tremendously popular in

distributed systems and reactive programming. The Visitor pattern deals with complex

hierarchies of objects where you need to apply a particular action depending on the object.

Finally, the State pattern is commonly used in video games and finite state machines and

allows an object to change its behavior depending on its own state.

Chapter 8, Introduction to Go's Concurrency, explains with more detail the CSP concurrency

model used in Go by going through some examples using Goroutines and channels, as well

as mutexes and syncs.

Chapter 9, Concurrency Patterns - Barrier, Future, and Pipeline Design Patterns, will introduce

some of the CSP concurrency patterns that are idiomatic to the Go language by walking

through some examples and explanations. These are small but really powerful patterns so

we will provides a few examples of the use of each of them, as well as some schemas (if

possible) that will make the understanding of each of them easier.

Chapter 10, Concurrency Patterns - Workers Pool, and Publish or Subscriber Design Patterns,

talks about a couple of patterns with concurrent structures. We will explain every step in

detail so you can follow the examples carefully. The idea is to learn patterns to design

concurrent applications in idiomatic Go. We are using channels and Goroutines heavily,

instead of locks or sharing variables.

What you need for this book

Most of the chapters in this book are written following a simple TDD approach, here the

requirements are written first, followed by some unit tests and finally the code that satisfies

those requirements. We will use only tools that comes with the standard library of Go as a

way to better understand the language and its possibilities. This idea is key to follow the

book and understanding the way that Go solves problems, especially in distributed systems

and concurrent applications.

Who this book is for

This book is for both beginners and advanced-level developers in the Go programming

language. No knowledge of design patterns is expected.

剩余393页未读，继续阅读

qq_22973943

粉丝: 3
资源: 37

精通Go设计模式： idiomatic编程与并发模式

设计模式（Design Patterns）.pdf

Go Design Patterns epub

Go Design Patterns(pdf+epub+mobi+code_files).zip

Reactive Design Patterns - 深入理解反应式编程与设计

Cocoa Design Patterns：Objective-C与Mac/iPhone开发的经典指南

Concurrency Patterns: Fan-in and Fan-out with Goroutines

Concurrency Patterns：Golang中常见并发模式

wsl opensuse patterns-wsl-systemd

head first design patterns-深入浅出设计模式.pdf

design patterns elements of reusable object-oriented software下载

github c语言项目

23 design patterns in C++ code

hands-on design patterns with c++下载

java-design-patterns

modern c++ design: generic programming and design patterns pdf

dive into design patterns 中文

design patterns: elements of reusable object-oriented software pdf csdn

学习游戏设计分析应该看哪些书籍

design patterns: elements of reusable object-oriented software

最新资源