HTML5 WebSocket权威指南：实时Web应用开发秘籍

5星 · 超过95%的资源需积分: 10 138 浏览量更新于2024-07-23 收藏 6.75MB PDF 举报

《HTML5 WebSocket 定义指南》是一本深度探讨如何利用HTML5的新特性WebSocket构建实时网络应用的专业指南。本书旨在为希望学习这一技术的开发者提供全面的教程，无论你是否已经熟悉传统的Web开发，它都能帮助你理解实时通信的新范式。首先，章节一"HTML5 WebSocket 入门"引导读者了解WebSocket的基本概念。它解释了为什么现有的HTTP协议不足以支持实时数据传输，而WebSocket作为一种新的通信协议，如何通过长连接、双向通信的能力，实现实时更新和交互式用户体验。作者将从零开始介绍WebSocket的工作原理，以及它与HTML5其他技术（如AJAX）的对比。在第二章"WebSocket API"中，详细剖析了WebSocket API的核心功能，包括创建和管理WebSocket连接，发送和接收消息，以及错误处理等。读者可以了解到如何通过JavaScript在浏览器端操作WebSocket对象，实现与服务器端的无缝对接。第三章深入到WebSocket协议本身，讲解了握手过程、帧格式、数据类型和错误码等内容，让开发者能够对WebSocket通信的底层运作有深入理解。这包括WebSocket协议的升级过程和断开连接机制，这对于确保安全性和性能至关重要。第四章和第五章分别聚焦于实际应用案例，如即时消息和聊天系统的构建。章节四介绍了如何使用XMPP协议通过WebSocket实现即时通讯，而章节五则展示了如何利用STOMP（Simple Text Oriented Message Protocol）在WebSocket上进行消息传递，这两种方法都是现代Web应用中的常见实践。第六章展示了WebSocket在远程桌面应用中的应用，如VNC（Virtual Network Computing），通过Remote Framebuffer Protocol，实现在浏览器中远程控制计算机的功能，这对于远程工作和在线教育等领域具有重要意义。第七章专门探讨WebSocket的安全性问题，包括SSL/TLS加密、跨域策略、CSP（Content Security Policy）等，确保在享受实时通信的同时，应用程序和用户数据得到妥善保护。第八章关注的是部署和优化，涵盖了WebSocket在生产环境中的实施策略，包括性能调优、负载均衡、错误处理和监控等方面，帮助开发者确保实时应用的稳定运行。附录A提供了实用工具和技术，指导读者如何分析WebSocket通信日志，以便于调试和性能分析。附录B则是关于WebSocket的相关资源集合，包括示例代码、库、工具和社区资源，便于读者进一步学习和拓展。《HTML5 WebSocket 定义指南》是一本内容丰富、实用性强的技术书籍，适合任何希望通过HTML5 WebSocket提升实时应用能力的开发者阅读。无论是初次接触还是希望深入了解WebSocket的开发者，都能从中找到所需的知识和实践经验。

Chapter 2

The WebSocket API

This chapter introduces you to the WebSocket Application Programming Interface (API),

which you can use to control the WebSocket Protocol and create WebSocket applications.

In this chapter, we examine the building blocks of the WebSocket API, including its events,

methods, and attributes. To learn how to use the API, we write a simple client application,

connect to an existing, publicly available server (http://websocket.org), which allows us

to send and receive messages over WebSocket. By using an existing server, we can focus

on learning about the easy-to-use API that enables you to create WebSocket applications.

We also explain step-by-step how to use the WebSocket API to power HTML5 media using

binary data. Finally, we discuss browser support and connectivity.

This chapter focuses on the client application side of WebSocket, which enables you

to extend the WebSocket Protocol to your web applications. The subsequent chapters

will describe the WebSocket Protocol itself, as well as using WebSocket within your

environment.

Overview of the WebSocket API

As we mentioned in Chapter 1, WebSocket consists of the network protocol and an API

that enable you to establish a WebSocket connection between a client application and the

server. We will discuss the protocol in greater detail in Chapter 3, but let’s first take a look

at the API.

The WebSocket API is an interface that enables applications to use the WebSocket

Protocol. By using the API with your applications, you can control a full-duplex

communication channel through which your application can send and receive messages.

The WebSocket interface is very straightforward and easy to use. To connect to a remote

host, you simply create a new WebSocket object instance and provide the new object with

a URL that represents the endpoint to which you wish to connect.

A WebSocket connection is established by upgrading from the HTTP protocol to

the WebSocket Protocol during the initial handshake between the client and the server,

over the same underlying TCP connection. Once established, WebSocket messages can

be sent back and forth between the methods defined by the WebSocket interface. In your

application code, you then use asynchronous event listeners to handle each phase of the

connection life cycle.

The WebSocket API is purely (and truly) event driven. Once the full-duplex

connection is established, when the server has data to send to the client, or if resources

that you care about change their state, it automatically sends the data or notifications.

www.it-ebooks.info

CHAPTER 2 ■ THE WEBSOCKET API

With an event-driven API, you do not need to poll the server for the most updated

status of the targeted resource; rather, the client simply listens for desired notifications

and changes.

We will see different examples of using the WebSocket API in the subsequent

chapters when we talk about higher-level protocols, such as STOMP and XMPP. For

now, though, let’s take a closer look at the API.

Getting Started with the WebSocket API

The WebSocket API enables you to establish full-duplex, bidirectional communication

over the Web between your client application and server-side processes. The WebSocket

interface specifies the methods that are available for the client and how the client

interacts with the network.

To get started, you first create a WebSocket connection by calling the WebSocket

constructor. The constructor returns a WebSocket object instance. You can listen for

events on that object. These events tell you when the connection opens, when messages

arrive, when the connection closes, and when errors occur. You can interact with the

WebSocket instance to send messages or close the connection. The subsequent sections

explore each of these aspects of the WebSocket API.

The WebSocket Constructor

To establish a WebSocket connection to a server, you use the WebSocket interface to

instantiate a WebSocket object by pointing to a URL that represents the endpoint to which

you want to connect. The WebSocket Protocol defines two URI schemes, ws and wss for

unencrypted and encrypted traffic between the client and the server, respectively. The

ws (WebSocket) scheme is analogous to an HTTP URI scheme. The wss (WebSocket

Secure) URI scheme represents a WebSocket connection over Transport Layer Security

(TLS, also known as SSL), and uses the same security mechanism that HTTPS uses to

secure HTTP connections.

Note ■ We’ll discuss WebSocket security in depth in Chapter 7.

The WebSocket constructor takes one required argument, URL (the URL to which you

want to connect) and one optional argument, protocols (either a single protocol name

or an array of protocol names that the server must include in its response to establish the

connection). Examples of protocols you can use in the protocols argument are XMPP

(Extensible Messaging and Presence Protocol), SOAP (Simple Object Access Protocol), or

a custom protocol.

Listing 2-1 illustrates the one required argument in the WebSocket constructor,

which must be a fully qualified URL starting with the ws:// or wss:// scheme. In this

example, the fully qualified URL is ws://www.websocket.org. If there is a syntax error in

the URL, the constructor will throw an exception.

www.it-ebooks.info

CHAPTER 2 ■ THE WEBSOCKET API

Listing 2-1. Sample WebSocket Constructor

// Create new WebSocket connection

var ws = new WebSocket("ws://www.websocket.org");

When connecting to a WebSocket server, you can optionally use the second

argument to list the protocols your application supports, namely for protocol negotiation.

To ensure that the client and the server are sending and receiving messages they

both understand, they must use the same protocol. The WebSocket constructor enables

you to define the protocol or protocols that your client can use to communicate with

a server. The server in turn selects the protocol to use; only one protocol can be used

between a client and a server. These protocols are used over the WebSocket Protocol. One

of the great benefits of WebSocket, as you’ll learn in Chapters 3 through 6, is the ability

to layer widely used protocols over WebSocket, which lets you do great things like take

traditional desktop applications to the Web.

Note ■ The WebSocket Protocol (RFC 6455) refers to protocols you can use with

WebSocket as “subprotocols,” even though they are higher-level, fully formed protocols.

Throughout this book, we’ll generally refer to protocols that you can use with WebSocket

simply as “protocols” to avoid confusion.

Before we get too far ahead of ourselves, let’s return to the WebSocket constructor in

the API. During the initial WebSocket connection handshake, which you’ll learn more

about in Chapter 3, the client sends a Sec-WebSocket-Protocol header with the protocol

name. The server chooses zero or one protocol and responds with a Sec-WebSocket-Protocol

header with the same name the client requested; otherwise, it closes the connection.

Protocol negotiation is useful for determining which protocol or version of a protocol

a given WebSocket server supports. An application might support multiple protocols and

use protocol negotiation to select which protocol to use with a particular server. Listing 2-2

shows the WebSocket constructor with support for a hypothetical protocol, “myProtocol”:

Listing 2-2. Sample WebSocket Constructor with Protocol Support

// Connecting to the server with one protocol called myProtocol

var ws = new WebSocket("ws://echo.websocket.org", "myProtocol");

Note ■ In Listing 2-2, the hypothetical protocol “myProtocol” is a well-defined, perhaps

even registered and standardized, protocol name that both the client application and the

server can understand.

www.it-ebooks.info

CHAPTER 2 ■ THE WEBSOCKET API

The WebSocket constructor can also include an array of protocol names that the

client supports, which lets the server decide which one to use. Listing 2-3 shows a sample

WebSocket constructor with a list of protocols it supports, represented as an array:

Listing 2-3. Sample WebSocket Constructor with Protocol Support

// Connecting to the server with multiple protocol choices

var echoSocket = new

WebSocket("ws://echo.websocket.org", ["com.kaazing.echo",

"example.imaginary.protocol"])

echoSocket.onopen = function(e) {

// Check the protocol chosen by the server

console.log(echoSocket.protocol);

}

In Listing 2-3, because the WebSocket server at ws://echo.websocket.org only

understands the com.kaazing.echo protocol and not example.imaginary.protocol, the

server chooses the com.kaazing.echo protocol when the WebSocket open event fires.

Using an array gives you flexibility in enabling your application to use different protocols

with different servers.

We’ll discuss the WebSocket Protocol in depth in the next chapter, but in essence,

there are three types of protocols you can indicate with the protocols argument:

Registered protocols: Standard protocols that have been ·

officially registered according to RFC 6455

(The WebSocket Protocol) and with the IANA (Internet

Assigned Numbers Authority), the official governing body for

registered protocols. An example of a registered protocol is

Microsoft’s SOAP over WebSocket protocol. See

http://www.iana.org/assignments/websocket/websocket.xml

for more information.

Open protocols: Widely used and standardized protocols like ·

XMPP and STOMP, which have not been registered as official

standard protocols. We will examine how to use these types of

protocols with WebSocket in the subsequent chapters.

Custom protocols: Protocols that you’ve written and want to use ·

with WebSocket.

In this chapter, we focus on using the WebSocket API as you would for your own

custom protocol and examine using open protocols in the later chapters. Let’s take a look

at the events, objects, and methods individually and put them together into a working

example.

www.it-ebooks.info

CHAPTER 2 ■ THE WEBSOCKET API

WebSocket Events

The WebSocket API is purely event driven. Your application code listens for events on

WebSocket objects in order to handle incoming data and changes in connection status.

The WebSocket Protocol is also event driven. Your client application does not need to poll

the server for updated data. Messages and events will arrive asynchronously as the server

sends them.

WebSocket programming follows an asynchronous programming model, which

means that as long as a WebSocket connection is open, your application simply listens

for events. Your client does not need to actively poll the server for more information. To

start listening for the events, you simply add callback functions to the WebSocket object.

Alternatively, you can use the addEventListener() DOM method to add event listeners

to your WebSocket objects.

A WebSocket object dispatches four different events:

Open ·

Message ·

Error ·

Close ·

As with all web APIs, you can listen for these events using on<eventname> handler

properties, as well as using the addEventListener(); method.

WebSocket Event: Open

Once the server responds to the WebSocket connection request, the open event fires and a

connection is established. The corresponding callback to the open event is called onopen.

Listing 2-4 illustrates how to handle the event when the WebSocket connection is

established.

Listing 2-4. Sample Open Event Handler

// Event handler for the WebSocket connection opening

ws.onopen = function(e) {

console.log("Connection open...");

};

By the time the open event fires, the protocol handshake has completed and the

WebSocket is ready to send and receive data. If your application receives an open event,

you can be sure that a WebSocket server successfully handled the connection request and

has agreed to communicate with your application.

WebSocket Event: Message

WebSocket messages contain the data from the server. You may also have heard of

WebSocket frames, which comprise WebSocket messages. We’ll discuss the concept of

messages and frames in more depth in Chapter 3. For the purposes of understanding

www.it-ebooks.info

剩余199页未读，继续阅读

andynumen

粉丝: 0
资源: 2

HTML5 WebSocket权威指南：实时Web应用开发秘籍

The Definitive Guide to HTML5 WebSocket 无水印原版pdf

The Definitive Guide to HTML5 WebSocket

The Definitive Guide to HTML5 WebSocket(权威指南)(免积分)

Apress.The.Definitive.Guide.to.HTML5.2011

docidn.com_oreilly-java-performance-the-definitive-guide-

HTML5 WebSocket权威指南 PDF电子书下载 带书签目录 高清完整版

Netty Definitive Guide-权威指南-II

TheDefinitiveGuideToHTML5Websocket.pdf 英文原版

HTML5 WebSocket深度解析

HTML5 WebSocket技术详解

最新资源

HTML5 WebSocket权威指南 PDF电子书下载带书签目录高清完整版