book

Go: Design Patterns for Real-World Projects

Name: Go: Design Patterns for Real-World Projects
ISBN: 9781788390552

by Vladimir Vivien, Mario Castro Contreras, Mat Ryer

June 2017

Beginner

1091 pages

22h 9m

English

Packt Publishing

Read now

Unlock full access

Go: Design Patterns for Real-World Projects
Go: Design Patterns for Real-World Projects
Credits
Preface
What this learning path covers
What you need for this learning path
Who this learning path is for
Reader feedback
Customer support
Downloading the example codeErrataPiracyQuestions
1. Module 1
1. A First Step in Go
The Go programming language

Playing with Go
No IDE requiredInstalling GoSource code examples
Your first Go program
Go in a nutshell
FunctionsPackagesThe workspaceStrongly typedComposite typesThe named typeMethods and objectsInterfacesConcurrency and channelsMemory management and safetyFast compilationTesting and code coverageDocumentationAn extensive libraryThe Go Toolchain
Summary
2. Go Language Essentials
The Go source fileOptional semicolonMultiple lines
Go identifiers
The blank identifierMuting package importsMuting unwanted function resultsBuilt-in identifiersTypesValuesFunctions
Go variables
Variable declarationThe zero-valueInitialized declarationOmitting variable typesShort variable declarationRestrictions for short variable declarationVariable scope and visibilityVariable declaration block
Go constants
Constant literalsTyped constantsUntyped constantsAssigning untyped constantsConstant declaration blockConstant enumerationOverriding the default enumeration typeUsing iota in expressionsSkipping enumerated values
Go operators
Arithmetic operatorsThe increment and decrement operatorsGo assignment operatorsBitwise operatorsLogical OperatorsComparison operatorsOperator precedence
Summary
3. Go Control Flow
The if statementThe if statement initialization
Switch statements
Using expression switchesThe fallthrough casesExpressionless switchesSwitch initializerType switches
The for statements
For conditionInfinite loopThe traditional for statementThe for range
The break, continue, and goto statements
The label identifierThe break statementThe continue statementThe goto statement
Summary
4. Data Types
Go types
Numeric types
Unsigned integer typesSigned integer typesFloating point typesComplex number typesNumeric literals
Boolean type
Rune and string types
The runeThe stringInterpreted and raw string literals
Pointers
The pointer typeThe address operatorThe new() functionPointer indirection - accessing referenced values
Type declaration
Type conversion
Summary
5. Functions in Go
Go functionsFunction declarationThe function typeVariadic parametersFunction result parametersNamed result parameters
Passing parameter values
Achieving pass-by-referenceAnonymous Functions and ClosuresInvoking anonymous function literalsClosures
Higher-order functions
Error signaling and handling
Signaling errorsError handlingThe error type
Deferring function calls
Using defer
Function panic and recovery
Function panicFunction panic recovery
Summary
6. Go Packages and Programs
The Go packageUnderstanding the Go packageThe workspaceCreating a workspaceThe import path
Creating packages
Declaring the packageMulti-File packagesNaming packagesUse globally unique namespacesAdd context to pathUse short names
Building packages
Installing a package
Package visibility
Package member visibility
Importing package
Specifying package identifiersThe dot identifierThe blank identifier
Package initialization
Creating programs
Accessing program argumentsBuilding and installing programs
Remote packages
Summary
7. Composite Types
The array typeArray initializationDeclaring named array typesUsing arraysArray length and capacityArray traversalArray as parameters
The slice type
Slice initializationSlice representationSlicingSlicing a sliceSlicing an arraySlice expressions with capacityMaking a sliceUsing slicesSlices as parametersLength and capacityAppending to slicesCopying slicesStrings as slices
The map type
Map initializationMaking MapsUsing mapsMap traversalMap functionsMaps as parameters
The struct type
Accessing struct fieldsStruct initializationDeclaring named struct typesThe anonymous fieldPromoted fieldsStructs as parametersField tags
Summary
8. Methods, Interfaces, and Objects
Go methodsValue and pointer receivers
Objects in Go
The struct as objectObject compositionField and method promotionThe constructor function
The interface type
Implementing an interfaceSubtyping with Go interfacesImplementing multiple interfacesInterface embeddingThe empty interface type
Type assertion
Summary
9. Concurrency
GoroutinesThe go statementGoroutine scheduling
Channels
The Channel typeThe send and receive operationsUnbuffered channelBuffered channelUnidirectional channelsChannel length and capacityClosing a channel
Writing concurrent programs
SynchronizationStreaming dataUsing for…range to receive dataGenerator functionsSelecting from multiple channelsChannel timeout
The sync package
Synchronizing with mutex locksSynchronizing access to composite valuesConcurrency barriers with sync.WaitGroup
Detecting race conditions
Parallelism in Go
Summary
10. Data IO in Go
IO with readers and writers
The io.Reader interface
Chaining readers
The io.Writer interface
Working with the io package
Working with files
Creating and opening filesFunction os.OpenFileFiles writing and readingStandard input, output, and error
Formatted IO with fmt
Printing to io.Writer interfacesPrinting to standard outputReading from io.ReaderReading from standard input
Buffered IO
Buffered writers and readersScanning the buffer
In-memory IO
Encoding and decoding data
Binary encoding with gobEncoding data as JSONControlling JSON mapping with struct tagsCustom encoding and decoding
Summary
11. Writing Networked Services
The net packageAddressingThe net.Conn TypeDialing a connectionListening for incoming connectionsAccepting client connections
A TCP API server
Connecting to the TCP server with telnetConnecting to the TCP server with Go
The HTTP package
The http.Client typeConfiguring the clientHandling client requests and responsesA simple HTTP serverThe default serverRouting requests with http.ServeMuxThe default ServeMux
A JSON API server
Testing the API server with cURLAn API server client in GoA JavaScript API server client
Summary
12. Code Testing
The Go test toolTest file namesTest organization
Writing Go tests
The test functionsRunning the testsFiltering executed testsTest loggingReporting failureSkipping testsTable-driven tests
HTTP testing
Testing HTTP server codeTesting HTTP client code
Test coverage
The cover tool
Code benchmark
Running the benchmarkSkipping test functionsThe benchmark reportAdjusting NComparative benchmarks
Summary
2. Module 2
1. Ready... Steady... Go!
A little bit of history
Installing Go
LinuxGo Linux advanced installationWindowsMac OS XSetting 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 statementThe switch statementThe for…range statement
Functions
What does a function look like?What is an anonymous function?ClosuresCreating errors, handling errors and returning errors.Function with undetermined number of parametersNaming returned types
Arrays, slices, and maps
ArraysZero-initializationSlicesMaps
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 packageWhat is TDD?
Libraries
The Go get tool
Managing JSON data
The encoding package
Go tools
The golint toolThe gofmt toolThe godoc toolThe 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 programDescriptionObjectivesExample - a unique counterRequirements and acceptance criteriaWriting unit tests firstImplementationA few words about the Singleton design pattern
Builder design pattern - reusing an algorithm to create many implementations of an interface
DescriptionObjectivesExample - vehicle manufacturingRequirements and acceptance criteriaUnit test for the vehicle builderImplementationWrapping up the Builder design pattern
Factory method - delegating the creation of different types of payments
DescriptionObjectivesThe example - a factory of payment methods for a shopAcceptance criteriaFirst unit testImplementationUpgrading the Debitcard method to a new platformWhat we learned about the Factory method
Abstract Factory - a factory of factories
DescriptionThe objectivesThe vehicle factory example, again?Acceptance criteriaUnit testImplementationA few lines about the Abstract Factory method
Prototype design pattern
DescriptionObjectiveExampleAcceptance criteriaUnit testImplementationWhat we learned about the Prototype design pattern
Summary
3. Structural Patterns - Composite, Adapter, and Bridge Design Patterns
Composite design patternDescriptionObjectivesThe swimmer and the fishRequirements and acceptance criteriaCreating compositionsBinary Tree compositionsComposite pattern versus inheritanceFinal words on the Composite pattern
Adapter design pattern
DescriptionObjectivesUsing an incompatible interface with an Adapter objectRequirements and acceptance criteriaUnit testing our Printer adapterImplementationExamples of the Adapter pattern in Go's source codeWhat the Go source code tells us about the Adapter pattern
Bridge design pattern
DescriptionObjectivesTwo printers and two ways of printing for eachRequirements and acceptance criteriaUnit testing the Bridge patternImplementationReuse everything with the Bridge pattern
Summary
4. Structural Patterns - Proxy, Facade, Decorator, and Flyweight Design Patterns
Proxy design patternDescriptionObjectivesExampleAcceptance criteriaUnit testImplementationProxying around actions
Decorator design pattern
DescriptionObjectivesExampleAcceptance criteriaUnit testImplementationA real-life example - server middlewareStarting with the common interface, http.HandlerA few words about Go's structural typingSummarizing the Decorator design pattern - Proxy versus Decorator
Facade design pattern
DescriptionObjectivesExampleAcceptance criteriaUnit testImplementationLibrary created with the Facade pattern
Flyweight design pattern
DescriptionObjectivesExampleAcceptance criteriaBasic structs and testsImplementationWhat's the difference between Singleton and Flyweight then?
Summary
5. Behavioral Patterns - Strategy, Chain of Responsibility, and Command Design Patterns
Strategy design patternDescriptionObjectivesRendering images or textAcceptance criteriaImplementationSolving small issues in our libraryFinal words on the Strategy pattern
Chain of responsibility design pattern
DescriptionObjectivesA multi-logger chainUnit testImplementationWhat about a closure?Putting it together
Command design pattern
DescriptionObjectivesA simple queueAcceptance criteriaImplementationMore examplesChain of responsibility of commandsRounding-up the Command pattern up
Summary
6. Behavioral Patterns - Template, Memento, and Interpreter Design Patterns
Template design patternDescriptionObjectivesExample - a simple algorithm with a deferred stepRequirements and acceptance criteriaUnit tests for the simple algorithmImplementing the Template patternAnonymous functionsHow to avoid modifications on the interfaceLooking for the Template pattern in Go's source codeSummarizing the Template design pattern
Memento design pattern
DescriptionObjectivesA simple example with stringsRequirements and acceptance criteriaUnit testImplementing the Memento patternAnother example using the Command and Facade patternsLast words on the Memento pattern
Interpreter design pattern
DescriptionObjectivesExample - a polish notation calculatorAcceptance criteria for the calculatorUnit test of some operationsImplementationComplexity with the Interpreter design patternInterpreter pattern again - now using interfacesThe power of the Interpreter pattern
Summary
7. Behavioral Patterns - Visitor, State, Mediator, and Observer Design Patterns
Visitor design patternDescriptionObjectivesA log appenderAcceptance criteriaUnit testsImplementation of Visitor patternAnother exampleVisitors to the rescue!
State design pattern
DescriptionObjectivesA small guess the number gameAcceptance criteriaImplementation of State patternA state to win and a state to loseThe game built using the State pattern
Mediator design pattern
DescriptionObjectivesA calculatorAcceptance criteriaImplementationUncoupling two types with the Mediator
Observer design pattern
DescriptionObjectivesThe notifierAcceptance criteriaUnit testsImplementationSummary
8. Introduction to Gos Concurrency
A little bit of history and theoryConcurrency versus parallelismCSP versus actor-based concurrency
Goroutines
Our first GoroutineAnonymous functions launched as new GoroutinesWaitGroups
Callbacks
Callback hell
Mutexes
An example with mutexes - concurrent counterPresenting the race detector
Channels
Our first channelBuffered channelsDirectional channelsThe select statementRanging over channels too!
Using it all - concurrent singleton
Unit testImplementation
Summary
9. Concurrency Patterns - Barrier, Future, and Pipeline Design Patterns
Barrier concurrency patternDescriptionObjectivesAn HTTP GET aggregatorAcceptance criteriaUnit test - integrationImplementationWaiting for responses with the Barrier design pattern
Future design pattern
DescriptionObjectivesA simple asynchronous requesterAcceptance criteriaUnit testsImplementationPutting the Future together
Pipeline design pattern
DescriptionObjectivesA concurrent multi-operationAcceptance criteriaBeginning with testsImplementationThe list generatorRaising numbers to the power of 2Final reduce operationLaunching the Pipeline patternFinal words on the Pipeline pattern
Summary
10. Concurrency Patterns - Workers Pool and Publish/Subscriber Design Patterns
Workers poolDescriptionObjectivesA pool of pipelinesAcceptance criteriaImplementationThe dispatcherThe pipelineAn app using the workers poolNo tests?Wrapping up the Worker pool
Concurrent Publish/Subscriber design pattern
DescriptionObjectivesExample - a concurrent notifierAcceptance criteriaUnit testTesting subscriberTesting publisherImplementationImplementing the publisherHandling channels without race conditionsA few words on the concurrent Observer pattern
Summary
3. Module 3
1. Chat Application with Web Sockets
A simple web serverSeparating views from logic using templatesDoing things onceUsing your own handlersProperly building and executing Go programs
Modeling a chat room and clients on the server
Modeling the clientModeling a roomConcurrency programming using idiomatic GoTurning a room into an HTTP handlerUsing helper functions to remove complexityCreating and using rooms
Building an HTML and JavaScript chat client
Getting more out of templates
Tracing code to get a look under the hood
Writing a package using TDDInterfacesUnit testsRed-green testingImplementing the interfaceUnexported types being returned to usersUsing our new trace packageMaking tracing optionalClean package APIs
Summary
2. Adding User Accounts
Handlers all the way down
Making a pretty social sign-in page
Endpoints with dynamic paths
Getting started with OAuth2
Open source OAuth2 packages
Tell the authorization providers about your app
Implementing external logging in
Logging inHandling the response from the providerPresenting the user dataAugmenting messages with additional data
Summary
3. Three Ways to Implement Profile Pictures
Avatars from the OAuth2 serverGetting the avatar URLTransmitting the avatar URLAdding the avatar to the user interfaceLogging outMaking things prettier
Implementing Gravatar
Abstracting the avatar URL processThe auth service and the avatar's implementationUsing an implementationThe Gravatar implementation
Uploading an avatar picture
User identificationAn upload formHandling the uploadServing the imagesThe Avatar implementation for local filesSupporting different file typesRefactoring and optimizing our codeReplacing concrete types with interfacesChanging interfaces in a test-driven wayFixing the existing implementationsGlobal variables versus fieldsImplementing our new designTidying up and testing
Combining all three implementations
Summary
4. Command-Line Tools to Find Domain Names
Pipe design for command-line tools
Five simple programs
SprinkleDomainifyCoolifySynonymsUsing environment variables for configurationConsuming a web APIGetting domain suggestionsAvailable
Composing all five programs
One program to rule them all
Summary
5. Building Distributed Systems and Working with Flexible Data
The system designThe database design
Installing the environment
Introducing NSQNSQ driver for GoIntroducing MongoDBMongoDB driver for GoStarting the environment
Reading votes from Twitter
Authorization with TwitterExtracting the connectionReading environment variablesReading from MongoDBReading from TwitterSignal channelsPublishing to NSQGracefully starting and stopping programsTesting
Counting votes
Connecting to the databaseConsuming messages in NSQKeeping the database updatedResponding to Ctrl + C
Running our solution
Summary
6. Exposing Data and Functionality through a RESTful Data Web Service API
RESTful API design
Sharing data between handlers
Context keys
Wrapping handler functions
API keysCross-origin resource sharing
Injecting dependencies
Responding
Understanding the request
Serving our API with one function
Using handler function wrappers
Handling endpoints
Using tags to add metadata to structsMany operations with a single handlerReading pollsCreating a pollDeleting a pollCORS supportTesting our API using curl
A web client that consumes the API
Index page showing a list of pollsCreating a new pollShowing the details of a poll
Running the solution
Summary
7. Random Recommendations Web Service
The project overviewProject design specifics
Representing data in code
Public views of Go structs
Generating random recommendations
The Google Places API keyEnumerators in GoTest-driven enumeratorQuerying the Google Places APIBuilding recommendationsHandlers that use query parametersCORSTesting our APIWeb application
Summary
8. Filesystem Backup
Solution designThe project structure
The backup package
Considering obvious interfaces firstTesting interfaces by implementing themHas the filesystem changed?Checking for changes and initiating a backupHardcoding is OK for a short while
The user command-line tool
Persisting small dataParsing argumentsListing the pathsString representations for your own typesAdding pathsRemoving pathsUsing our new tool
The daemon backup tool
Duplicated structuresCaching dataInfinite loopsUpdating filedb records
Testing our solution
Summary
9. Building a Q&A Application for Google App Engine
The Google App Engine SDK for GoCreating your applicationApp Engine applications are Go packagesThe app.yaml fileRunning simple applications locallyDeploying simple applications to Google App EngineModules in Google App EngineSpecifying modulesRouting to modules with dispatch.yaml
Google Cloud Datastore
Denormalizing data
Entities and data access
Keys in Google Cloud DatastorePutting data into Google Cloud DatastoreReading data from Google Cloud Datastore
Google App Engine users
Embedding denormalized data
Transactions in Google Cloud Datastore
Using transactions to maintain countersAvoiding early abstraction
Querying in Google Cloud Datastore
Votes
IndexingEmbedding a different view of entities
Casting a vote
Accessing parents via datastore.KeyLine of sight in code
Exposing data operations over HTTP
Optional features with type assertionsResponse helpersParsing path parametersExposing functionality via an HTTP APIHTTP routing in GoContext in Google App EngineDecoding key stringsUsing query parametersAnonymous structs for request dataWriting self-similar codeValidation methods that return an errorMapping the router handlers
Running apps with multiple modules
Testing locallyUsing the admin consoleAutomatically generated indexes
Deploying apps with multiple modules
Summary
10. Micro-services in Go with the Go kit Framework
Introducing gRPC
Protocol buffers
Installing protocol buffersProtocol buffers languageGenerating Go code
Building the service
Starting with testsConstructors in GoHashing and validating passwords with bcrypt
Modeling method calls with requests and responses
Endpoints in Go kitMaking endpoints for service methodsDifferent levels of errorWrapping endpoints into a Service implementation
An HTTP server in Go kit
A gRPC server in Go kit
Translating from protocol buffer types to our types
Creating a server command
Using Go kit endpointsRunning the HTTP serverRunning the gRPC serverPreventing a main function from terminating immediatelyConsuming the service over HTTP
Building a gRPC client
A command-line tool to consume the serviceParsing arguments in CLIsMaintaining good line of sight by extracting case bodiesInstalling tools from the Go source code
Rate limiting with service middleware
Middleware in Go kitManually testing the rate limiterGraceful rate limiting
Summary
11. Deploying Go Applications Using Docker
Using Docker locallyInstalling Docker toolsDockerfileBuilding Go binaries for different architecturesBuilding a Docker imageRunning a Docker image locallyInspecting Docker processesStopping a Docker instance
Deploying Docker images
Deploying to Docker Hub
Deploying to Digital Ocean
Creating a dropletAccessing the droplet's consolePulling Docker imagesRunning Docker images in the cloudAccessing Docker images in the cloud
Summary
Appendix. Good Practices for a Stable Go Environment
Installing Go
Configuring Go
Getting GOPATH right
Go tools
Cleaning up, building, and running tests on save
Integrated developer environments
Sublime Text 3Visual Studio Code
Summary
Bibliography

Content preview from Go: Design Patterns for Real-World Projects

Summary

Concurrency can be a complex topic in any language. This chapter covered the major topics to guide readers around the use of concurrency primitives in the Go language. The first section of the chapter outlined the crucial properties of goroutines, including the creation and usage of the go statement. Next, the chapter covered the mechanism of Go's runtime scheduler and the notion of channels used for communication between running goroutines. Lastly, users were introduced to several concurrency patterns used to create concurrent programs using goroutines, channels, and the synchronization primitives from the sync package.

Next, you will be introduced to the standard APIs to do data input and output in Go.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781788390552

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Go: Design Patterns for Real-World Projects

by Vladimir Vivien, Mario Castro Contreras, Mat Ryer

Summary

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

More than 5,000 organizations count on O’Reilly

Julian F.

Addison B.

Amir M.

Mark W.

You might also like

Go Design Patterns

Design Patterns in Go

API Design Patterns

Spring 5 Design Patterns

Publisher Resources