Go Design Patterns电子书

Go Design Patterns

Go Design Patterns

Credits

About the Author

About the Reviewer

www.PacktPub.com

Why subscribe?

Customer Feedback

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. Ready... Steady... Go!

A little bit of history

Installing Go

Linux

Go Linux advanced installation

Windows

Mac OS X

Setting the workspace - Linux and Apple OS X

Starting with Hello World

Integrated Development Environment - IDE

Types

Variables and constants

Operators

Flow control

The if... else statement

The switch statement

The for…range statement

Functions

What does a function look like?

What is an anonymous function?

Closures

Creating errors, handling errors and returning errors.

Function with undetermined number of parameters

Naming returned types

Arrays, slices, and maps

Arrays

Zero-initialization

Slices

Maps

Visibility

Zero-initialization

Pointers and structures

What is a pointer? Why are they good?

Structs

Interfaces

Interfaces - signing a contract

Testing and TDD

The testing package

What is TDD?

Libraries

The Go get tool

Managing JSON data

The encoding package

Go tools

The golint tool

The gofmt tool

The godoc tool

The goimport tool

Contributing to Go open source projects in GitHub

Summary

2. Creational Patterns - Singleton, Builder, Factory, Prototype, and Abstract Factory Design Patterns

Singleton design pattern - having a unique instance of a type in the entire program

Description

Objectives

Example - a unique counter

Requirements and acceptance criteria

Writing unit tests first

Implementation

A few words about the Singleton design pattern

Builder design pattern - reusing an algorithm to create many implementations of an interface

Description

Objectives

Example - vehicle manufacturing

Requirements and acceptance criteria

Unit test for the vehicle builder

Implementation

Wrapping up the Builder design pattern

Factory method - delegating the creation of different types of payments

Description

Objectives

The example - a factory of payment methods for a shop

Acceptance criteria

First unit test

Implementation

Upgrading the Debitcard method to a new platform

What we learned about the Factory method

Abstract Factory - a factory of factories

Description

The objectives

The vehicle factory example, again?

Acceptance criteria

Unit test

Implementation

A few lines about the Abstract Factory method

Prototype design pattern

Description

Objective

Example

Acceptance criteria

Unit test

Implementation

What we learned about the Prototype design pattern

Summary

3. Structural Patterns - Composite, Adapter, and Bridge Design Patterns

Composite design pattern

Description

Objectives

The swimmer and the fish

Requirements and acceptance criteria

Creating compositions

Binary Tree compositions

Composite pattern versus inheritance

Final words on the Composite pattern

Adapter design pattern

Description

Objectives

Using an incompatible interface with an Adapter object

Requirements and acceptance criteria

Unit testing our Printer adapter

Implementation

Examples of the Adapter pattern in Go's source code

What the Go source code tells us about the Adapter pattern

Bridge design pattern

Description

Objectives

Two printers and two ways of printing for each

Requirements and acceptance criteria

Unit testing the Bridge pattern

Implementation

Reuse everything with the Bridge pattern

Summary

4. Structural Patterns - Proxy, Facade, Decorator, and Flyweight Design Patterns

Proxy design pattern

Description

Objectives

Example

Acceptance criteria

Unit test

Implementation

Proxying around actions

Decorator design pattern

Description

Objectives

Example

Acceptance criteria

Unit test

Implementation

A real-life example - server middleware

Starting with the common interface, http.Handler

A few words about Go's structural typing

Summarizing the Decorator design pattern - Proxy versus Decorator

Facade design pattern

Description

Objectives

Example

Acceptance criteria

Unit test

Implementation

Library created with the Facade pattern

Flyweight design pattern

Description

Objectives

Example

Acceptance criteria

Basic structs and tests

Implementation

What's the difference between Singleton and Flyweight then?

Summary

5. Behavioral Patterns - Strategy, Chain of Responsibility, and Command Design Patterns

Strategy design pattern

Description

Objectives

Rendering images or text

Acceptance criteria

Implementation

Solving small issues in our library

Final words on the Strategy pattern

Chain of responsibility design pattern

Description

Objectives

A multi-logger chain

Unit test

Implementation

What about a closure?

Putting it together

Command design pattern

Description

Objectives

A simple queue

Acceptance criteria

Implementation

More examples

Chain of responsibility of commands

Rounding-up the Command pattern up

Summary

6. Behavioral Patterns - Template, Memento, and Interpreter Design Patterns

Template design pattern

Description

Objectives

Example - a simple algorithm with a deferred step

Requirements and acceptance criteria

Unit tests for the simple algorithm

Implementing the Template pattern

Anonymous functions

How to avoid modifications on the interface

Looking for the Template pattern in Go's source code

Summarizing the Template design pattern

Memento design pattern

Description

Objectives

A simple example with strings

Requirements and acceptance criteria

Unit test

Implementing the Memento pattern

Another example using the Command and Facade patterns

Last words on the Memento pattern

Interpreter design pattern

Description

Objectives

Example - a polish notation calculator

Acceptance criteria for the calculator

Unit test of some operations

Implementation

Complexity with the Interpreter design pattern

Interpreter pattern again - now using interfaces

The power of the Interpreter pattern

Summary

7. Behavioral Patterns - Visitor, State, Mediator, and Observer Design Patterns

Visitor design pattern

Description

Objectives

A log appender

Acceptance criteria

Unit tests

Implementation of Visitor pattern

Another example

Visitors to the rescue!

State design pattern

Description

Objectives

A small guess the number game

Acceptance criteria

Implementation of State pattern

A state to win and a state to lose

The game built using the State pattern

Mediator design pattern

Description

Objectives

A calculator

Acceptance criteria

Implementation

Uncoupling two types with the Mediator

Observer design pattern

Description

Objectives

The notifier

Acceptance criteria

Unit tests

Implementation

Summary

8. Introduction to Gos Concurrency

A little bit of history and theory

Concurrency versus parallelism

CSP versus actor-based concurrency

Goroutines

Our first Goroutine

Anonymous functions launched as new Goroutines

WaitGroups

Callbacks

Callback hell

Mutexes

An example with mutexes - concurrent counter

Presenting the race detector

Channels

Our first channel

Buffered channels

Directional channels

The select statement

Ranging over channels too!

Using it all - concurrent singleton

Unit test

Implementation

Summary

9. Concurrency Patterns - Barrier, Future, and Pipeline Design Patterns

Barrier concurrency pattern

Description

Objectives

An HTTP GET aggregator

Acceptance criteria

Unit test - integration

Implementation

Waiting for responses with the Barrier design pattern

Future design pattern

Description

Objectives

A simple asynchronous requester

Acceptance criteria

Unit tests

Implementation

Putting the Future together

Pipeline design pattern

Description

Objectives

A concurrent multi-operation

Acceptance criteria

Beginning with tests

Implementation

The list generator

Raising numbers to the power of 2

Final reduce operation

Launching the Pipeline pattern

Final words on the Pipeline pattern

Summary

10. Concurrency Patterns - Workers Pool and Publish/Subscriber Design Patterns

Workers pool

Description

Objectives

A pool of pipelines

Acceptance criteria

Implementation

The dispatcher

The pipeline

An app using the workers pool

No tests?

Wrapping up the Worker pool

Concurrent Publish/Subscriber design pattern

Description

Objectives

Example - a concurrent notifier

Acceptance criteria

Unit test

Testing subscriber

Testing publisher

Implementation

Implementing the publisher

Handling channels without race conditions

A few words on the concurrent Observer pattern

Summary