NettyInAction中文版资源-CSDN文库

Netty

需积分: 10 122 浏览量 2015-05-28 13:07:46 上传评论收藏 23.45MB PDF 举报

资源推荐

资源详情

资源评论

目录(?) [-]

为什么使用Netty1.

不是所有的网络框架都是一样的1.

Netty的功能非常丰富2.

异步设计2.

Callbacks回调1.

Futures2.

Java中的Blocking和non-blocking IO对比3.

NIO的问题和Netty中是如何解决这些问题的4.

跨平台和兼容性问题1.

扩展ByteBuffer2.

NIO对缓冲区的聚合和分散操作可能会操作内存泄露3.

Squashing the famous epoll bug4.

Summary5.

Netty In Action中文版 - 第一章：Netty介绍

本章介绍

Netty介绍

为什么要使用non-blocking IO(NIO)

阻塞IO(blocking IO)和非阻塞IO(non-blocking IO)对比

Java NIO的问题和在Netty中的解决方案

Netty是基于Java NIO的网络应用框架，如果你是Java网络方面的新手，那么本章将是你学习Java网络应用的开始；对于有

经验的开发者来说，学习本章内容也是很好的复习。如果你熟悉NIO和NIO2，你可以随时跳过本章直接从第二章开始学习。在你

的机器上运行第二章编写的Netty服务器和客户端。

Netty是一个NIO client-server(客户端服务器)框架，使用Netty可以快速开发网络应用，例如服务器和客户端协议。Netty提

供了一种新的方式来使开发网络应用程序，这种新的方式使得它很容易使用和有很强的扩展性。Netty的内部实现时很复杂的，但

是Netty提供了简单易用的api从网络处理代码中解耦业务逻辑。Netty是完全基于NIO实现的，所以整个Netty都是异步的。

网络应用程序通常需要有较高的可扩展性，无论是Netty还是其他的基于Java NIO的框架，都会提供可扩展性的解决方案。

Netty中一个关键组成部分是它的异步特性，本章将讨论同步(阻塞)和异步(非阻塞)的IO来说明为什么使用异步代码来解决扩展性

问题以及如何使用异步。

对于那些初学网络变成的读者，本章将帮助您对网络应用的理解，以及Netty是如何实现他们的。它说明了如何使用基本的

Java网络API，探讨Java网络API的优点和缺点并阐述Netty是如何解决Java中的问题的，比如Eploo错误或内存泄露问题。

在本章的结尾，你会明白什么是Netty以及Netty提供了什么，你会理解Java NIO和异步处理机制，并通过本书的其他章节加

强理解。

1.1 为什么使用Netty？

David John Wheeler说过“在计算机科学中的所有问题都可以通过间接的方法解决。”作为一个NIO client-server框架，Netty

提供了这样的一个间接的解决方法。Netty提供了高层次的抽象来简化TCP和UDP服务器的编程，但是你仍然可以使用底层地

API。

(David John Wheeler有一句名言“计算机科学中的任何问题都可以通过加上一层逻辑层来解决”，这个原则在计算机各技术领

域被广泛应用)

1.1.1 不是所有的网络框架都是一样的

Netty的“quick and easy(高性能和简单易用)”并不意味着编写的程序的性能和可维护性会受到影响。从Netty中实现的协议如

FTP，SMTP，HTTP，WebSocket，SPDY以及各种二进制和基于文本的传统协议中获得的经验导致Netty的创始人要非常小心它

的设计。Netty成功的提供了易于开发，高性能和高稳定性，以及较强的扩展性。

高调的公司和开源项目有RedHat, Twitter, Infinispan, and HornetQ, Vert.x, Finagle, Akka, Apache Cassandra,

Elasticsearch，以及其他人的使用有助于Netty的发展，Netty的一些特性也是这些项目的需要所致。多年来，Netty变的更广为人

机制和它的架构。NIO和Netty都大量使用了异步代码，并且封装的很好，我们无需了解底层的事件选择机制。下面我们来看看为

什么需要异步APIS。

1.2 异步设计

整个Netty的API都是异步的，异步处理不是一个新的机制，这个机制出来已经有一些时间了。对网络应用来说，IO一般是性

能的瓶颈，使用异步IO可以较大程度上提高程序性能，因为异步变的越来越重要。但是它是如何工作的呢？以及有哪些不同的模

式可用呢？

异步处理提倡更有效的使用资源，它允许你创建一个任务，当有事件发生时将获得通知并等待事件完成。这样就不会阻塞，

不管事件完成与否都会及时返回，资源利用率更高，程序可以利用剩余的资源做一些其他的事情。

本节将说明一起工作或实现异步API的两个最常用的方法，并讨论这些技术之间的差异。

1.2.1 Callbacks(回调)

回调一般是异步处理的一种技术。一个回调是被传递到并且执行完该方法。你可能认为这种模式来自JavaScript，在

Javascript中，回调是它的核心。下面的代码显示了如何使用这种技术来获取数据。下面代码是一个简单的回调

[java]

package netty.in.action; 01.

02.

public class Worker { 03.

04.

public void doWork() { 05.

Fetcher fetcher = new MyFetcher(new Data(1, 0)); 06.

fetcher.fetchData(new FetcherCallback() { 07.

@Override 08.

public void onError(Throwable cause) { 09.

System.out.println("An error accour: " + cause.getMessage()); 10.

} 11.

12.

@Override 13.

public void onData(Data data) { 14.

System.out.println("Data received: " + data); 15.

} 16.

}); 17.

} 18.

19.

public static void main(String[] args) { 20.

Worker w = new Worker(); 21.

w.doWork(); 22.

} 23.

24.

} 25.

[java]

package netty.in.action; 01.

02.

public interface Fetcher { 03.

void fetchData(FetcherCallback callback); 04.

} 05.

[java]

package netty.in.action; 01.

02.

public class MyFetcher implements Fetcher { 03.

04.

final Data data; 05.

06.

public MyFetcher(Data data){ 07.

this.data = data; 08.

} 09.

10.

@Override 11.

public void fetchData(FetcherCallback callback) { 12.

try { 13.

callback.onData(data); 14.

} catch (Exception e) { 15.

callback.onError(e); 16.

} 17.

} 18.

19.

} 20.

[java]

package netty.in.action; 01.

02.

public interface FetcherCallback { 03.

void onData(Data data) throws Exception; 04.

void onError(Throwable cause); 05.

} 06.

[java]

package netty.in.action; 01.

02.

public class Data { 03.

04.

private int n; 05.

private int m; 06.

07.

public Data(int n,int m){ 08.

this.n = n; 09.

this.m = m; 10.

} 11.

12.

@Override 13.

public String toString() { 14.

int r = n/m; 15.

return n + "/" + m +" = " + r; 16.

} 17.

} 18.

上面的例子只是一个简单的模拟回调，要明白其所表达的含义。Fetcher.fetchData()方法需传递一个FetcherCallback类型的

参数，当获得数据或发生错误时被回调。对于每种情况都提供了同意的方法：

FetcherCallback.onData()，将接收数据时被调用

FetcherCallback.onError()，发生错误时被调用

因为可以将这些方法的执行从"caller"线程移动到其他的线程执行；但也不会保证FetcherCallback的每个方法都会被执行。

回调过程有个问题就是当你使用链式调用

很多不同的方法会导致线性代码；有些人认为这种链式调用方法会导致代码难以阅读，但是我认为这是一种风格和习惯问题。例

如，基于Javascript的Node.js越来越受欢迎，它使用了大量的回调，许多人都认为它的这种方式利于阅读和编写。

1.2.2 Futures

第二种技术是使用Futures。Futures是一个抽象的概念，它表示一个值，该值可能在某一点变得可用。一个Future要么获得

计算完的结果，要么获得计算失败后的异常。Java在java.util.concurrent包中附带了Future接口，它使用Executor异步执行。例

如下面的代码，每传递一个Runnable对象到ExecutorService.submit()方法就会得到一个回调的Future，你能使用它检测是否执行

完成。

[java]

package netty.in.action; 01.

02.

import java.util.concurrent.Callable; 03.

import java.util.concurrent.ExecutorService; 04.

import java.util.concurrent.Executors; 05.

import java.util.concurrent.Future; 06.

07.

public class FutureExample { 08.

09.

public static void main(String[] args) throws Exception { 10.

ExecutorService executor = Executors.newCachedThreadPool(); 11.

Runnable task1 = new Runnable() { 12.

@Override 13.

public void run() { 14.

//do something 15.

System.out.println("i am task1....."); 16.

} 17.

}; 18.

Callable<Integer> task2 = new Callable<Integer>() { 19.

@Override 20.

public Integer call() throws Exception { 21.

//do something 22.

return new Integer(100); 23.

} 24.

}; 25.

Future<?> f1 = executor.submit(task1); 26.

Future<Integer> f2 = executor.submit(task2); 27.

System.out.println("task1 is completed? " + f1.isDone()); 28.

System.out.println("task2 is completed? " + f2.isDone()); 29.

//waiting task1 completed 30.

while(f1.isDone()){ 31.

System.out.println("task1 completed."); 32.

break; 33.

} 34.

//waiting task2 completed 35.

while(f2.isDone()){ 36.

System.out.println("return value by task2: " + f2.get()); 37.

break; 38.

} 39.

} 40.

41.

} 42.

有时候使用Future感觉很丑陋，因为你需要间隔检查Future是否已完成，而使用回调会直接收到返回通知。看完这两个常用

的异步执行技术后，你可能想知道使用哪个最好？这里没有明确的答案。事实上，Netty两者都使用，提供两全其美的方案。下一

节将在JVM上首先使用阻塞，然后再使用NIO和NIO2写一个网络程序。这些是本书后续章节必不可少的基础知识，如果你熟悉

Java网络AIPs，你可以快速翻阅即可。

1.3 Java中的Blocking和non-blocking IO对比

本节主要讲解Java的IO和NIO的差异，这里不过多赘述，网络已有很多相关文章。

1.4 NIO的问题和Netty中是如何解决这些问题的

本节中将介绍Netty是如何解决NIO中的一些问题和限制。Java的NIO相对老的IO APIs有着非常大的进步，但是使用NIO是

受限制的。这些问题往往是设计的问题，有些是缺陷知道的。

1.4.1 跨平台和兼容性问题

NIO是一个比较底层的APIs，它依赖于操作系统的IO APIs。Java实现了统一的接口来操作IO，其在所有操作系统中的工作

行为是一样的，这是很伟大的。使用NIO会经常发现代码在Linux上正常运行，但在Windows上就会出现问题。我建议你如果使用

NIO编写程序，就应该在所有的操作系统上进行测试来支持，使程序可以在任何操作系统上正常运行；即使在所有的Linux系统上

都测试通过了，也要在其他的操作系统上进行测试；你若不验证，以后就可能会出问题。

NIO2看起来很理想，但是NIO2只支持Jdk1.7+，若你的程序在Java1.6上运行，则无法使用NIO2。另外，Java7的NIO2中没

有提供DatagramSocket的支持，所以NIO2只支持TCP程序，不支持UDP程序。

Netty提供一个统一的接口，同一语义无论在Java6还是Java7的环境下都是可以运行的，开发者无需关心底层APIs就可以轻

松实现相关功能。

1.4.2 扩展ByteBuffer

ByteBuffer是一个数据容器，但是可惜的是JDK没有开发ByteBuffer实现的源码；ByteBuffer允许包装一个byte[]来获得一个

实例，如果你希望尽量减少内存拷贝，那么这种方式是非常有用的。若果你想将ByteBuffer重新实现，那么不要浪费你的时间

了，ByteBuffer的构造函数是私有的，所以它不能被扩展。Netty提供了自己的ByteBuffer实现，Netty通过一些简单的APIs对

ByteBuffer进行构造、使用和操作，以此来解决NIO中的一些限制。

1.4.3 NIO对缓冲区的聚合和分散操作可能会操作内存泄露

很多Channel的实现支持Gather和Scatter。这个功能允许从从多个ByteBuffer中读入或写入到过个ByteBuffer，这样做可以

提供性能。操作系统底层知道如何处理这些被写入/读出，并且能以最有效的方式处理。如果要分割的数据再多个不同的

ByteBuffer中，使用Gather/Scatter是比较好的方式。

例如，你可能希望header在一个ByteBuffer中，而body在另外的ByteBuffer中；

下图显示的是Scatter(分散)，将ScatteringByteBuffer中的数据分散读取到多个ByteBuffer中：

剩余93页未读，继续阅读

评论收藏

内容反馈

lsl_china

粉丝: 2
资源: 18

Netty In Action中文版

Netty_In_Action中文版

Netty-In-Action中文版

Netty IN Action中文版

Netty In Action中文版-高清.pdf

Netty In Action中文版.pdf

Netty in Action 中文版

netty in action 中文版

netty In Action中文版

《netty in action中文版》13章全

Netty in action中文版

Netty In Action 中文版

Netty in Action

netty in action 中文版 高清带目录 来个最便宜的

netty in action中文版

Netty In Action中文版+英文原版

最新资源

netty in action 中文版高清带目录来个最便宜的