Netty介绍

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

供了一种新的方式来使开发网络应用程序，这种新的方式使得它很容易使用和有很强的扩展性。Netty的内部实现时很复杂的，但是Netty提供了简单易用的api从网络处理代码中解耦业务逻辑。Netty是完全基于NIO实现的，所以整个Netty都是异步的。

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

Netty框架的组成 ：

Netty除了提供传输和协议，在其他各领域都有发展。Netty为开发者提供了一套完整的工具，看下面表格：

Development Area Netty FeaturesDesign(设计)各种传输类型，阻塞和非阻塞套接字统一的API
使用灵活
简单但功能强大的线程模型
无连接的DatagramSocket支持
链逻辑，易于重用Ease of Use(易于使
用)提供大量的文档和例子
除了依赖jdk1.6+，没有额外的依赖关系。某些功能依赖jdk1.7+，其他特性可能有相
关依赖，但都是可选的。Performance(性能)比Java APIS更好的吞吐量和更低的延迟
因为线程池和重用所有消耗较少的资源
尽量减少不必要的内存拷贝Robustness(鲁棒性)鲁棒性，可以理解为健壮性
链接快或慢或超载不会导致更多的OutOfMemoryError
在高速的网络程序中不会有不公平的read/writeSecurity(安全性)完整的SSL/TLS和StartTLS支持
可以在如Applet或OSGI这些受限制的环境中运行Community(社区)版本发布频繁
社区活跃


整个Netty的API都是异步的，异步处理不是一个新的机制，这个机制出来已经有一些时间了。对网络应用来说，IO一般是性
能的瓶颈，使用异步IO可以较大程度上提高程序性能，因为异步变的越来越重要。
异步处理提倡更有效的使用资源，它允许你创建一个任务，当有事件发生时将获得通知并等待事件完成。这样就不会阻塞，不管事件完成与否都会及时返回，资源利用率更高，程序可以利用剩余的资源做一些其他的事情。 

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就可以轻松实现相关功能。 

java自带的NIO有两个版本，NIO版本１实现了非阻塞功能，JDK7之后出现NIO2，增加了异步功能和一些文件操作的api，但是无论NIO版本１和２都是有缺陷的，比如平台不兼容，ByteBuf扩展性差等，后来就出现了netty，netty对NIO进行了一下封装和优化设计，让我们用它提供的简单api就可以些出性能强大的服务器，但是踪其底层，都是一样的

回调一般是异步处理的一种技术。一个回调是被传递到并且执行完该方法。 

代码：

package netty.in.action;    public class Worker {        public void doWork() {          Fetcher fetcher = new MyFetcher(new Data(1, 0));          fetcher.fetchData(new FetcherCallback() {              @Override              public void onError(Throwable cause) {                  System.out.println("An error accour: " + cause.getMessage());              }                @Override              public void onData(Data data) {                  System.out.println("Data received: " + data);              }          });      }        public static void main(String[] args) {          Worker w = new Worker();          w.doWork();      }    } package netty.in.action;  public interface Fetcher {      void fetchData(FetcherCallback callback);  }package netty.in.action;  public class MyFetcher implements Fetcher {        final Data data;        public MyFetcher(Data data) {          this.data = data;      }        @Override      public void fetchData(FetcherCallback callback) {          try {              callback.onData(data);          } catch (Exception e) {              callback.onError(e);          }      }  }package netty.in.action;    public interface FetcherCallback {      void onData(Data data) throws Exception;        void onError(Throwable cause);  }    package netty.in.action;    public class Data {        private int n;      private int m;        public Data(int n, int m) {          this.n = n;          this.m = m;      }        @Override      public String toString() {          int r = n / m;          return n + "/" + m + " = " + r;      }  }

第二种技术是使用Futures。Futures是一个抽象的概念，它表示一个值，该值可能在某一点变得可用。一个Future要么获得计算完的结果，要么获得计算失败后的异常。Java在java.util.concurrent包中附带了Future接口，它使用Executor异步执行。例如下面的代码，每传递一个Runnable对象到ExecutorService.submit()方法就会得到一个回调Future，能使用它检测是否执行完成。  
代码：

package netty.in.action;import java.util.concurrent.Callable;  import java.util.concurrent.ExecutorService;  import java.util.concurrent.Executors;  import java.util.concurrent.Future;   public class FutureExample {      public static void main(String[] args) throws Exception {          ExecutorService executor = Executors.newCachedThreadPool();          Runnable task1 = new Runnable() {                 @Override                 public void run() {                     //do something                     System.out.println("i am task1.....");                 }          };          Callable<Integer> task2 = new Callable<Integer>() {                 @Override                 public Integer call() throws Exception {                     //do something                     return new Integer(100);                 }          };         Future<?> f1 = executor.submit(task1);         Future<Integer> f2 = executor.submit(task2);         System.out.println("task1 is completed? " + f1.isDone());         System.out.println("task2 is completed? " + f2.isDone());         //waiting task1 completed         while(f1.isDone()){             System.out.println("task1 completed.");             break;         }         //waiting task2 completed         while(f2.isDone()){             System.out.println("return value by task2: " + f2.get());             break;         }      }  }