概念
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
网友评论