Java基础知识强化之网络编程笔记24：Android网络通信之 AndroidAsync（基于nio的异步通信库）

 1 // url is the URL to download.
 2 AsyncHttpClient.getDefaultInstance().getString(url, new AsyncHttpClient.StringCallback() {
 3     // Callback is invoked with any exceptions/errors, and the result, if available.
 4     @Override
 5     public void onCompleted(Exception e, AsyncHttpResponse response, String result) {
 6         if (e != null) {
 7             e.printStackTrace();
 8             return;
 9         }
10         System.out.println("I got a string: " + result);
11     }
12 });

 1 // url is the URL to download.
 2 AsyncHttpClient.getDefaultInstance().getJSONObject(url, new AsyncHttpClient.JSONObjectCallback() {
 3     // Callback is invoked with any exceptions/errors, and the result, if available.
 4     @Override
 5     public void onCompleted(Exception e, AsyncHttpResponse response, JSONObject result) {
 6         if (e != null) {
 7             e.printStackTrace();
 8             return;
 9         }
10         System.out.println("I got a JSONObject: " + result);
11     }
12 });

 1 AsyncHttpClient.getDefaultInstance().getFile(url, filename, new AsyncHttpClient.FileCallback() {
 2     @Override
 3     public void onCompleted(Exception e, AsyncHttpResponse response, File result) {
 4         if (e != null) {
 5             e.printStackTrace();
 6             return;
 7         }
 8         System.out.println("my file is available at: " + result.getAbsolutePath());
 9     }
10 });

1 // arguments are the http client, the directory to store cache files, and the size of the cache in bytes
2 ResponseCacheMiddleware.addCache(AsyncHttpClient.getDefaultInstance(),
3                                   getFileStreamPath("asynccache"),
4                                   1024 * 1024 * 10);

 1 AsyncHttpClient.getDefaultInstance().websocket(get, "my-protocol", new WebSocketConnectCallback() {
 2     @Override
 3     public void onCompleted(Exception ex, WebSocket webSocket) {
 4         if (ex != null) {
 5             ex.printStackTrace();
 6             return;
 7         }
 8         webSocket.send("a string");
 9         webSocket.send(new byte[10]);
10         webSocket.setStringCallback(new StringCallback() {
11             public void onStringAvailable(String s) {
12                 System.out.println("I got a string: " + s);
13             }
14         });
15         webSocket.setDataCallback(new DataCallback() {
16             public void onDataAvailable(ByteBufferList byteBufferList) {
17                 System.out.println("I got some bytes!");
18                 // note that this data has been read
19                 byteBufferList.recycle();
20             }
21         });
22     }
23 });

 1 SocketIOClient.connect(AsyncHttpClient.getDefaultInstance(), "http://192.168.1.2:3000", new ConnectCallback() {
 2     @Override
 3     public void onConnectCompleted(Exception ex, SocketIOClient client) {
 4         if (ex != null) {
 5             ex.printStackTrace();
 6             return;
 7         }
 8         client.setStringCallback(new StringCallback() {
 9             @Override
10             public void onString(String string) {
11                 System.out.println(string);
12             }
13         });
14         client.on("someEvent", new EventCallback() {
15             @Override
16             public void onEvent(JSONArray argument, Acknowledge acknowledge) {
17                 System.out.println("args: " + arguments.toString());
18             }
19         });
20         client.setJSONCallback(new JSONCallback() {
21             @Override
22             public void onJSON(JSONObject json) {
23                 System.out.println("json: " + json.toString());
24             }
25         });
26     }
27 });

 1 AsyncHttpPost post = new AsyncHttpPost("http://myservercom/postform.html");
 2 MultipartFormDataBody body = new MultipartFormDataBody();
 3 body.addFilePart("my-file", new File("/path/to/file.txt");
 4 body.addStringPart("foo", "bar");
 5 post.setBody(body);
 6 AsyncHttpClient.getDefaultInstance().execute(post, new StringCallback() {
 7     @Override
 8     public void onCompleted(Exception e, AsyncHttpResponse source, String result) {
 9         if (e != null) {
10             ex.printStackTrace();
11             return;
12         }
13         System.out.println("Server says: " + result);
14     }
15 });

 1 AsyncHttpServer server = new AsyncHttpServer();
 2 List<WebSocket> _sockets = new ArrayList<WebSocket>();
 3 server.get("/", new HttpServerRequestCallback() {
 4     @Override
 5     public void onRequest(AsyncHttpServerRequest request, AsyncHttpServerResponse response) {
 6         response.send("Hello!!!");
 7     }
 8 });
 9 // listen on port 5000
10 server.listen(5000);
11 // browsing http://localhost:5000 will return Hello!!!

 1 server.websocket("/live", new WebSocketRequestCallback() {
 2     @Override
 3     public void onConnected(final WebSocket webSocket, AsyncHttpServerRequest request) {
 4         _sockets.add(webSocket);
 5         //Use this to clean up any references to your websocket
 6         websocket.setClosedCallback(new CompletedCallback() {
 7             @Override
 8             public void onCompleted(Exception ex) {
 9                 try {
10                     if (ex != null)
11                         Log.e("WebSocket", "Error");
12                 } finally {
13                     _sockets.remove(webSocket);
14                 }
15             }
16         });
17         webSocket.setStringCallback(new StringCallback() {
18             @Override
19             public void onStringAvailable(String s) {
20                 if ("Hello Server".equals(s))
21                     webSocket.send("Welcome Client!");
22             }
23         });
24     }
25 });
26 //..Sometime later, broadcast!
27 for (WebSocket socket : _sockets)
28     socket.send("Fireball!");

1 Future<String> string = client.getString("http://foo.com/hello.txt");
2 // this will block, and may also throw if there was an error!
3 String value = string.get();