netty介绍

概念

Netty是一个NIO client-server(客户端服务器)框架，使用Netty可以快速开发网络应用，例如服务器和客户端协议。Netty提
供了一种新的方式来使开发网络应用程序，这种新的方式使得它很容易使用和有很强的扩展性。Netty的内部实现时很复杂的，但
是Netty提供了简单易用的api从网络处理代码中解耦业务逻辑。Netty是完全基于NIO实现的，所以整个Netty都是异步的。

异步设计

异步处理提倡更有效的使用资源，它允许你创建一个任务，当有事件发生时将获得通知并等待事件完成。这样就不会阻塞，
不管事件完成与否都会及时返回，资源利用率更高，程序可以利用剩余的资源做一些其他的事情。

Callbacks(回调)

回调一般是异步处理的一种技术。一个回调是被传递到并且执行完该方法，下面举一个例子。
Data类：

package com.beidao.netty.async.callbacks;

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;
    }
}

数据抓取接口：

package com.beidao.netty.async.callbacks;

/**
 * @author 0200759
 *
 */
public interface Fetcher {
    void fetchData(FetcherCallback callback);
}

数据抓取接口实现类：

package com.beidao.netty.async.callbacks;

public class MyFetcher implements Fetcher{

    final Data data;

    public MyFetcher(Data data){
        this.data = data;
    }
    /* 
     * excute method
     * @see com.beidao.netty.async.callbacks.Fetcher#fetchData(com.beidao.netty.async.callbacks.FetcherCallback)
     */
    public void fetchData(FetcherCallback callback) {
        try{
            //callback method
            callback.onData(data);
        } catch (Exception e) {
            //callback method
            callback.onError(e);
        }
    }

}

回调接口类：

package com.beidao.netty.async.callbacks;

/**
 * @author 0200759
 *
 */
public interface FetcherCallback {

    void onData(Data data) throws Exception;
    void onError(Throwable cause);
}

测试回调函数类：

package com.beidao.netty.async.callbacks;

/**
 * @author 0200759
 *
 */
public class Worker {

    public void doWork() {

        Fetcher fetcher = new MyFetcher(new Data(1, 0));
        fetcher.fetchData(new FetcherCallback() {

            public void onError(Throwable cause) {
                System.out.println("An error accour: " + cause.getMessage());
            }

            public void onData(Data data) throws Exception {
                //System.out.println(xx)，括号里面的“xx”如果不是String类型的话，就自动调用xx的toString()方法
                System.out.println("Data received: " + data);

            }
        });
    }

    public static void main(String[] args) {
        Worker w = new Worker();
        w.doWork();
    }

}

运行结果如下：

An error accour: / by zero

上面的例子只是一个简单的模拟回调，要明白其所表达的含义。Fetcher.fetchData()方法需传递一个FetcherCallback类型的
参数，当获得数据或发生错误时被回调。对于每种情况都提供了同意的方法：
- FetcherCallback.onData()，将接收数据时被调用
- FetcherCallback.onError()，发生错误时被调用

Futures

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

package com.beidao.netty.async.futures;

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) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Runnable task1 = new Runnable() {

            public void run() {
                System.out.println("i am task1...");
            }
        };

        Callable<Integer> task2 = new Callable<Integer>() {
            public Integer call() throws Exception{
                return new Integer(100);
            }
        };

        Future<?> f1 = executorService.submit(task1);
        Future<Integer> f2 = executorService.submit(task2);
        System.out.println("task1 is completed?" + f1.isDone());
        System.out.println("task2 is completed?" + f2.isDone());

        //waiting task1 completed
        while(f1.isDone()){
            //callback code
            System.out.println("task1 completed!");
            break;
        }

        //waiting task2 completed
        while (f2.isDone()) {
            //callback code
            System.out.println("task2 completed!");
            break;
        }
    }

}

下一篇博客将介绍netty的demo
源码地址：https://github.com/MAXAmbitious/netty-study