Go: Design Patterns for Real-World Projects

Book Image

Go: Design Patterns for Real-World Projects

By : Vladimir Vivien, Mario Castro Contreras, Mat Ryer

Book Image

Go: Design Patterns for Real-World Projects

By: Vladimir Vivien, Mario Castro Contreras, Mat Ryer

Overview of this book

The Go programming language has firmly established itself as a favorite for building complex and scalable system applications. Go offers a direct and practical approach to programming that lets programmers write correct and predictable code using concurrency idioms and a full-featured standard library. This practical guide is full of real-world examples to help you get started with Go in no time at all. You’ll start by understanding the fundamentals of Go, then get a detailed description of the Go data types, program structures, and Maps. After that, you’ll learn how to use Go concurrency idioms to avoid pitfalls and create programs that are exact in expected behavior. Next, you will get familiar with the tools and libraries that are available in Go to write and exercise tests, benchmarking, and code coverage. After that, you will be able to utilize some of the most important features of GO such as Network Programming and OS integration to build efficient applications. Then you’ll start applying your skills to build some amazing projects in Go. You will learn to develop high-quality command-line tools that utilize the powerful shell capabilities and perform well using Go’s built-in concurrency mechanisms. Scale, performance, and high availability lie at the heart of our projects, and the lessons learned throughout the sections will arm you with everything you need to build world-class solutions. You will get a feel for app deployment using Docker and Google App Engine. Each project could form the basis of a start-up, which means they are directly applicable to modern software markets. With these skills in hand, you will be able to conquer all your fears of application development and go on to build large, robust and succinct apps in Go. This Learning Path combines some of the best that Packt has to offer in one complete, curated package. It includes content from the following Packt products: 1. Learning Go Programming 2. Go Design Patterns 3. Go Programming Blueprints, Second Edition

Go: Design Patterns for Real-World Projects

Go: Design Patterns for Real-World Projects

Credits

Preface

Bibliography

Free Chapter

A First Step in Go

A First Step in Go

The Go programming language

Playing with Go

Your first Go program

Go in a nutshell

Go Language Essentials

Go Language Essentials

The Go source file

Go Control Flow

Go Control Flow

The if statement

Switch statements

The for statements

The break, continue, and goto statements

Data Types

Rune and string types

Type declaration

Type conversion

Functions in Go

Functions in Go

Passing parameter values

Higher-order functions

Error signaling and handling

Deferring function calls

Function panic and recovery

Go Packages and Programs

Go Packages and Programs

Creating packages

Building packages

Package visibility

Importing package

Package initialization

Creating programs

Remote packages

Composite Types

Composite Types

The struct type

Methods, Interfaces, and Objects

Methods, Interfaces, and Objects

The interface type

Concurrency

Writing concurrent programs

The sync package

Detecting race conditions

Parallelism in Go

Data IO in Go

IO with readers and writers

The io.Reader interface

The io.Writer interface

Working with the io package

Working with files

Formatted IO with fmt

Encoding and decoding data

Writing Networked Services

Writing Networked Services

The net package

A TCP API server

The HTTP package

A JSON API server

Code Testing

The Go test tool

Writing Go tests

Ready... Steady... Go!

Ready... Steady... Go!

A little bit of history

Starting with Hello World

Integrated Development Environment - IDE

Variables and constants

Arrays, slices, and maps

Zero-initialization

Pointers and structures

Testing and TDD

The Go get tool

Managing JSON data

Contributing to Go open source projects in GitHub

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

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

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

Factory method - delegating the creation of different types of payments

Abstract Factory - a factory of factories

Prototype design pattern

Structural Patterns - Composite, Adapter, and Bridge Design Patterns

Structural Patterns - Composite, Adapter, and Bridge Design Patterns

Composite design pattern

Adapter design pattern

Bridge design pattern

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

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

Proxy design pattern

Decorator design pattern

Facade design pattern

Flyweight design pattern

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

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

Strategy design pattern

Chain of responsibility design pattern

Command design pattern

Behavioral Patterns - Template, Memento, and Interpreter Design Patterns

Behavioral Patterns - Template, Memento, and Interpreter Design Patterns

Template design pattern

Memento design pattern

Interpreter design pattern

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

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

Visitor design pattern

State design pattern

Mediator design pattern

Observer design pattern

Introduction to Gos Concurrency

Introduction to Gos Concurrency

A little bit of history and theory

Using it all - concurrent singleton

Concurrency Patterns - Barrier, Future, and Pipeline Design Patterns

Concurrency Patterns - Barrier, Future, and Pipeline Design Patterns

Barrier concurrency pattern

Future design pattern

Pipeline design pattern

Concurrency Patterns - Workers Pool and Publish/Subscriber Design Patterns

Concurrency Patterns - Workers Pool and Publish/Subscriber Design Patterns

Concurrent Publish/Subscriber design pattern

Chat Application with Web Sockets

Chat Application with Web Sockets

A simple web server

Modeling a chat room and clients on the server

Building an HTML and JavaScript chat client

Tracing code to get a look under the hood

Adding User Accounts

Adding User Accounts

Handlers all the way down

Making a pretty social sign-in page

Endpoints with dynamic paths

Getting started with OAuth2

Tell the authorization providers about your app

Implementing external logging in

Three Ways to Implement Profile Pictures

Three Ways to Implement Profile Pictures

Avatars from the OAuth2 server

Implementing Gravatar

Uploading an avatar picture

Combining all three implementations

Command-Line Tools to Find Domain Names

Command-Line Tools to Find Domain Names

Pipe design for command-line tools

Five simple programs

Composing all five programs

Building Distributed Systems and Working with Flexible Data

Building Distributed Systems and Working with Flexible Data

The system design

Installing the environment

Reading votes from Twitter

Running our solution

Exposing Data and Functionality through a RESTful Data Web Service API

Exposing Data and Functionality through a RESTful Data Web Service API

RESTful API design

Sharing data between handlers

Wrapping handler functions

Injecting dependencies

Understanding the request

Serving our API with one function

Handling endpoints

A web client that consumes the API

Running the solution

Random Recommendations Web Service

Random Recommendations Web Service

The project overview

Representing data in code

Generating random recommendations

Filesystem Backup

Filesystem Backup

Solution design

The backup package

The user command-line tool

The daemon backup tool

Testing our solution

Building a Q&A Application for Google App Engine

Building a Q&A Application for Google App Engine

The Google App Engine SDK for Go

Google Cloud Datastore

Entities and data access

Google App Engine users

Transactions in Google Cloud Datastore

Querying in Google Cloud Datastore

Exposing data operations over HTTP

Running apps with multiple modules

Deploying apps with multiple modules

Micro-services in Go with the Go kit Framework

Micro-services in Go with the Go kit Framework

Introducing gRPC

Protocol buffers

Building the service

Modeling method calls with requests and responses

An HTTP server in Go kit

A gRPC server in Go kit

Creating a server command

Building a gRPC client

Rate limiting with service middleware

Deploying Go Applications Using Docker

Deploying Go Applications Using Docker

Using Docker locally

Deploying Docker images

Deploying to Digital Ocean

Good Practices for a Stable Go Environment

Good Practices for a Stable Go Environment

Cleaning up, building, and running tests on save

Integrated developer environments

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Handlers all the way down

For our chat application, we implemented our own http.Handler type (the room) in order to easily compile, execute, and deliver HTML content to browsers. Since this is a very simple but powerful interface, we are going to continue to use it wherever possible when adding functionality to our HTTP processing.

In order to determine whether a user is allowed to proceed, we will create an authorization wrapper handler that will perform the check and pass the execution on to the inner handler only if the user is authorized.

Our wrapper handler will satisfy the same http.Handler interface as the object inside it, allowing us to wrap any valid handler. In fact, even the authentication handler we are about to write could be later encapsulated inside a similar wrapper if required.

Chaining pattern when applied to HTTP handlers

The preceding diagram shows how this pattern could be applied in a more complicated HTTP handler scenario. Each object implements the http.Handler interface...