使用 Go 语言构建可扩展的 Web 应用程序和 RESTful 服务

5星 · 超过95%的资源需积分: 9 127 浏览量更新于2024-07-21 3 收藏 5.11MB PDF 举报

"Web.Development.with.Go.Building.Scalable.Web.Apps.and.RESTful.Services" 本书《Web Development with Go》旨在教会读者如何使用 Go 语言来开发可扩展的 Web 应用程序和 RESTful 服务。Go 语言是一种静态类型、编译型语言，具有快速、可靠和高效的特点，使其非常适合开发各种应用程序，包括系统编程、桌面开发、分布式系统、后端服务、DevOps 和云应用开发等。本书首先涵盖了 Go 语言的基本概念，然后深入探讨了使用 net/http 包进行 Web 开发的方法。随着每一章的发展，读者将学到如何逐步构建一个真实世界的 Web 系统。此外，本书还展示了如何将 Go 与其他技术集成，例如使用 MongoDB 作为持久化存储，并提供了一个完整的 REST API 示例，演示了如何使用 Beego 框架构建 Web 应用程序。同时，本书还介绍了如何将 Web 应用程序部署到云平台上，使用 Docker 容器技术来部署 Go Web 应用程序。本书的主要内容包括： 1. Go 语言基础知识，包括基本语法、数据类型、函数、错误处理等。 2. 使用 net/http 包进行 Web 开发的方法，包括处理 HTTP 请求、响应和会话等。 3. 使用 MongoDB 作为持久化存储的方法，包括数据模型设计、数据查询和数据更新等。 4. 使用 Beego 框架构建 Web 应用程序的方法，包括路由配置、模板引擎和中间件等。 5. 使用 Docker 容器技术部署 Go Web 应用程序的方法，包括容器化、镜像管理和容器编排等。 6. 使用 Google Cloud 平台部署 Web 应用程序的方法，包括云端存储、云端数据库和云端消息队列等。通过学习本书，读者将获得以下技能和知识： * 掌握 Go 语言的基本概念和语法 * 学会使用 net/http 包进行 Web 开发 * 学会使用 MongoDB 作为持久化存储 * 学会使用 Beego 框架构建 Web 应用程序 * 学会使用 Docker 容器技术部署 Go Web 应用程序 * 学会使用 Google Cloud 平台部署 Web 应用程序本书旨在教会读者如何使用 Go 语言来开发可扩展的 Web 应用程序和 RESTful 服务，并提供了一个完整的学习路径，帮助读者快速掌握 Go 语言的开发技能。

xix

Introduction

Go, often referred to as Golang, is a general-purpose programming language that was developed at Google in

November 2009.

Several programming languages are available for writing different kinds of software systems, and some

languages have existed for decades. Some mainstream programming languages are evolving by adding new

features in their newer versions, which are released with many new features in each version. Both C# and

Java provide too many features in their language specification.

At the same time, lots of innovations and evolutions are happening for the computer hardware and IT

infrastructure. Software systems are written with feature-rich programming languages, but we can’t leverage

the power of modern computers and IT infrastructures by using them. We are using programming languages

that were created in the era of single-core machines, and now we write applications for multicore machines

using these languages.

Just like everything else, computer programming languages are evolving. Go is an evolutionary

language for writing software systems for modern computers and IT infrastructures using a simple and

pragmatic programming language. On the Go web site at https://golang.org/, Go is defined as follows:

“Go is an open source programming language that makes it easy to build simple, reliable, and efficient

software.”

Go is designed for solving real-world problems instead of academic theories and intellectual thoughts.

Go is a pragmatic programming language that ignores the programming language theory (PLT) that has

evolved in the last three decades; it provides a simple programming model for building efficient software

systems with first-class support for concurrency. Go’s built-in Concurrency feature gives you an exciting

programming experience for writing highly efficient software systems by leveraging concurrency. For every

programming language, there is a design goal. Go is designed to be a simple programming language, and it

excels as a simple and pragmatic language.

Go is the language of choice for building many innovative software systems, including Docker,

Kubernetes, and others. Like Parse MBaaS by Facebook, many existing systems are re-engineering to Go.

I have assisted several organizations to successfully adopt Go, and the adoption process was extremely easy

thanks to Go’s simplicity and pragmatism. I am sure that you will be excited about Go when you develop

real-world software systems.

Go is a general-purpose programming language that can be used to build a variety of software

systems, including networked servers, system-level applications, infrastructure tools, DevOps, native

mobile applications, graphics, the Internet of Things (IoT), and machine learning. Go can be used for

building native mobile applications, and I predict that Go will be a great choice for building native Android

applications in the near future.

Go is a great choice of language for building web applications and back-end APIs. I highly recommend

Go for building massively scalable back-end RESTful APIs. I predict that Go will be the language of choice in

the enterprises for building back-end RESTful APIs, the backbone for building modern business applications

in this mobility era.

In this book, I assume that you have knowledge of at least one programming language and have some

experience in web programming. If you have prior knowledge of Go, it will help you follow along in this

book. If you are completely new to Go, I recommend the following tutorial before you start reading the book:

http://tour.golang.org/welcome/1.

Chapter 1

Getting Started with Go

Everything in this world is evolving, including computers and computer programming languages. Ideas and

approaches for building applications are also evolving, based on past experience. Although highly evolved

modern computers now have many CPU cores (32, 64, 128 and many more), we still cannot leverage the full

power of modern computer hardware by using most of our existing programming languages and tools. Our

programs still run slowly, even in high-powered servers with many CPU cores.

For the last decade, many existing programming languages have been evolving with many new features.

Language authors have been adding these features based on programming language theory (PLT) and other

intellectual thoughts, which make the languages more complex. In today’s computing, many people prefer a

minimalistic and pragmatic approach for writing applications.

Programming languages are used that excel in specific areas. Some programming languages are great

for rapid application development, but would not work well for writing high-performance applications.

Other programming languages are very efficient for writing these high-performance applications, but would

be difficult for writing applications in a productive manner. It would be great if there were a general-purpose

language for developing a variety of applications with a greater level of efficiency, performance, productivity,

and faster compilation time. The Go language meets these criteria.

This chapter shows you why Go is a great programming language for solving modern programming

challenges. You will learn use cases for adopting Go for your next application.

Introducing Go

Go, also referred to as Golang, is a general-purpose programming language, developed by a team at Google

and many contributors from the open source community (http://golang.org/contributors). The

language was announced in November 2009, and the first version was released in December 2012. Go is an

open source project that is distributed under a BSD-style license. The official web site of the Go project is

available at http://golang.org/. It is a statically typed, natively compiled, garbage-collected, concurrent

programming language that mostly belongs to the C family of languages in terms of basic syntax. Let’s look

at some of the features of Go to understand its design principles.

Minimalistic Language with Pragmatic Design

The Go programming language can be simply described in three words: simple, minimal, and pragmatic.

If you look deeply into the language design of Go, you see its simple and minimalistic approach, coupled

with a pragmatic design. You can observe this simplicity with all the Go language features, including the

type system. Today, many programming languages provide too many features that make applications more

complex for developers. The design goal of Go is to be a simple and minimal language that provides all the

necessary features for developing efficient software systems.

CHAPTER 1 ■ GETTING STARTED WITH GO

Although Go has fewer language features, productivity is not affected by its pragmatic design. A new Go

programmer can quickly learn the language and can easily start to develop production-quality applications.

Go has simply ignored many language features from the last three decades and focuses on real-world

practices instead of academics and programming language theory (PLT).

From a practical perspective, you might say that Go is an object-oriented programming (OOP)

language. But Go’s object-oriented approach is different from programming languages such as C++, Java,

and C#. Go is not a full-fledged OOP language from an academic perspective. Unlike many existing OOP

languages, Go does not support inheritance and does not even have a class keyword. It uses composition

over inheritance through its simple type system. Go’s interface type design shows its uniqueness when

compared with other object-oriented programming languages.

Is Go an OOP language? The answer is both yes and no. Go language includes all batteries required for

writing applications with an object-oriented approach, but it is not a complete OOP language because it

lacks some traditional OOP features.

■ Note Programming language theory (PLT) is a branch of computer science that deals with the design,

implementation, analysis, characterization, and classification of programming languages and their individual

features.

A Static Type Language with High Productivity

Go is a statically typed programming language, with its syntax loosely derived from the C language. Like C

and C++, it compiles natively to machine code, so Just-In-Time (JIT) compilation is not needed to run its

programs. (Programming languages such as Java and C# use JIT compilation to run applications.)

For writing applications, a dynamically typed language provides lots of productivity and expressiveness

because you don’t have to worry about the data types of the variables you use. In dynamically typed

languages, the type of expression is known only at runtime, which provides a greater level of productivity

and expressiveness in the syntax to quickly build applications, especially web applications. But when

working with a dynamic type language, the performance and maintainability of the applications are affected.

Sometimes the debugging experience of an application written in a dynamic type language can be very

difficult due to its lack of type safety. Even today, developers use static type languages to generate code for

their dynamic type languages. For example, JavaScript developers use statically typed languages such as

Microsoft TypeScript for type safety, which finally compiles to JavaScript code.

Although static type languages can provide type safety and performance, working with them can affect

the productivity of application development, and compiling larger programs can take a long time. It would

be great to have a language that provides the power of both static type and dynamic type language to blend

the performance and type safety of a static type language with the productivity of a dynamic type language.

Go is that perfect blend of the power of static type languages and the productivity of dynamic type

languages. Go can be called a modern C language that provides faster compilation than C, coupled with the

productivity of a dynamic type language.

Concurrency Is a Built-In Feature at the Language Level

Computer hardware has evolved to have many CPU cores and more power, but the power of modern

computers cannot be leveraged by using the current programming languages and tools. When production

applications are run on high-powered servers, there are performance problems, even though CPU utilization

is very low. In some programming environments, concurrency and parallelism are available for better

efficiency and performance, but these features are available as a separate library and framework, not as a

built-in feature at the language level, which adds more complexity when you write concurrent applications.

CHAPTER 1 ■ GETTING STARTED WITH GO

In Go, concurrency is built into the language and is designed for writing high-performance concurrent

applications for modern computers. Concurrency is one of the unique features of the Go language and it is

considered a major selling point. Go’s concurrency is implemented using two unique features: goroutines

and channels. A goroutine is a function that can run concurrently with other goroutines. It is a lightweight

thread of execution in which many goroutines execute in a single thread that enables more program

performance and efficiency. The most important feature of goroutine is that it is managed and executed by

Go runtime. Many programming languages provide support for writing concurrent programs, but they are

limited only to communication and synchronization among the threads being executed. And most of the

existing languages provide support for concurrency through a framework, but not a built-in feature in the

language, so it makes restrictions when concurrency is implemented with these languages.

Go provides channels that enable communication between goroutines and the synchronization of

their executions. With channels, you can send data from one goroutine to another. Channels also provide a

greater level of synchronization between goroutines and ensure that two goroutines are running in a known

state. Concurrency is a major reason for adopting Go as the language for building highly efficient software

systems with greater levels of performance.

Go Compiles Programs Quickly

One of the challenges of writing C and C++ applications is the time needed for compiling programs, which is

very painful for developers when they work on larger C and C++ applications. Go is a language designed for

solving the programming challenges of existing programming environments. Its compiler is very efficient for

compiling programs quickly; a large Go application can be compiled in few seconds, which is attractive to

many C and C++ developers who switch to the Go programming environment.

Go as a General-Purpose Language

Different programming languages are used to develop different kinds of applications. C and C++ have been

widely used for systems programming and for systems in which performance is very critical. At the same

time, working with C and C++ affect the productivity of application development. Some other programming

languages, such as Ruby and Python, offer rapid application development that enables better productivity.

Although the server-side JavaScript platform Node.js is good for building lightweight JSON APIs and

real-time applications, it gets a fail when CPU-intensive programming tasks are executed. Another set of

programming languages is used for building native mobile applications. Programming languages such as

Objective C and Swift are restricted for use only with mobile application development. Various programming

languages are used for a variety of use cases, such as systems programming, distributed computing, web

application development, enterprise applications, and mobile application development.

The greatest practical benefit of using Go is that it can be used to build a variety of applications, including

systems that require high performance, and also for rapid application development scenarios. Although Go

was initially designed as a systems programming language, it is also used for developing enterprise business

applications and powerful back-end servers. Go provides high performance while keeping high productivity

for application development, thanks to its minimalistic and pragmatic design. The Go ecosystem (which

includes Go tooling, the Go standard library, and the Go third-party library) provides essential tools and

libraries for building a variety of Go applications. The Go Mobile project adds support for building native

mobile applications for both Android and iOS platforms, enabling more opportunities with Go.

In the era of cloud computing, Go is a modern programming language that can be used to build

system-level applications; distributed applications; networking programs; games; web apps; RESTful

services; back-end servers; native mobile applications; and cloud-optimized, next-generation applications.

Go is the choice of many revolutionary innovative systems such as Docker and Kubernetes. A majority of

tools on the software containerization ecosystem are being written in Go.

剩余299页未读，继续阅读

ramissue

粉丝: 354
资源: 1487

使用 Go 语言构建可扩展的 Web 应用程序和 RESTful 服务

building-web-apps-with-go.pdf（通过go语言构建web程序）

Building RESTful Web services with Go 无水印原版pdf

Learning Go Web Development azw3

restful api

asp.net core mvc

Apache+mod_wsgi+django+web

uniapp django

springboot vue

用英语并使用sci期刊的语言风格来说Vue.js的概念和作用

springboot毕设外文翻译

最新资源