数据类型有限，比如遇到不可序列化的数据Bitmap,InputStream, 或者LinkList链表等等数据类型就不太好用。

2. 利用static静态数据， public static成员变量；

3.基于外部存储的传输,  File/Preference/ Sqlite ，如果要针对第三方应用需要Content Provider

4.基于IPC的通信机制

    context 与Service之间的传输，如Activity与Service之间的通信，定义AIDL接口文件。

   示例： http://www.eoeandroid.com/thread-36249-1-1.html

5. 基于Application Context， 例子如下文：

    在当前Activity将两个值传到了Test中。但如果遇到不可序列化的数据，如Bitmap、InputStream等，intent就无能为力了。因此，我们很自然地会想到另外一种方法，静态变量。如下面的代码所示：

    public  class  Product  extends  Activity
   {
         public  static  Bitmap mBitmap;
         
   }

    对于上面的代码来说，其他任何类可以直接使用Product中的mBitmap变量。这么做很easy、也很cool，但却very very wrong。我们千万不要以为Davlik虚拟机的垃圾回收器会帮助我们回收不需要的内存垃圾。事实上，回收器并不可靠，尤其是手机上，是更加的不可靠。 因此，除非我们要使自己的程序变得越来越糟糕，否则尽量远离static。

注：如果经常使用static的Bitmap、Drawable等变量。可能就会抛出一个在Android系统中非常著名的异常（以前budget这个单词一直记不住什么意思，自从经常抛出这个异常后，这个单词终于烂熟于心了， ）

ERROR/AndroidRuntime(4958): Caused by: java.lang.OutOfMemoryError: bitmap size exceeds VM budget

    如果不使用static，总得有方法来代替它（尽管我很喜欢public static，我相信很多人也喜欢它，但为了我们的程序，建议还是忍痛割爱吧），那么这个新的解决方案就是本文的主题，这就是Application Context，相当于Web程序的Application，它的生命周期和应用程序一样长（这个我喜欢）。

    那么现在来看看如何使用这个Application Context。我们可以通过Context.getApplicationContext或Context.getApplication方法获得 Application Context。但要注意，我们获得的只是Context对象，而更理想的方法是获得一个类的对象。ok，说干就干，下面来定义一个类。

package  net.blogjava.mobile1;

import  android.app.Application;
import  android.graphics.Bitmap;

public  class  MyApp  extends  Application
{
     private  Bitmap mBitmap;

     public  Bitmap getBitmap()
    {
         return  mBitmap;
    }

     public  void  setBitmap(Bitmap bitmap)
    {
         this .mBitmap  =  bitmap;
    }
   
}

    上面这个类和普通的类没什么本质的不同。但该类是Application的子类。对了，这就是使用Application Context的第一步，定义一个继承自Application的类。然后呢，就在这个类中定义任何我们想使其全局存在的变量了，如本例中的 Bitmap。下面还需要一个重要的步骤，就是在<application>标签中使用android:name属性来指定这个类，代码如 下：

< application  android:name =".MyApp"  android:icon ="@drawable/icon"  android:label ="@string/app_name" >
 
</ application?

    接下来的最后一步就是向MyApp对象中存入Bitmap对象，或从MyApp对象中取出Bitmap对象了，存入Bitmap对象的代码如下：

    MyApp myApp  =  (MyApp)getApplication();
       
    Bitmap bitmap  =  BitmapFactory.decodeResource( this .getResources(), R.drawable.icon);
       
    myApp.setBitmap(bitmap);

    获得Bitmap对象的代码：

    ImageView imageview  =  (ImageView)findViewById(R.id.ivImageView);
       
    MyApp myApp  =  (MyApp)getApplication();
       
    imageview.setImageBitmap(myApp.getBitmap());
   
    上面两段代码可以在任何的Service、Activity中使用。全局的。

参考：

1.http://flyvenus.net/?p=229

2.http://blog.csdn.net/nokiaguy/archive/2010/11/10/5998986.aspx

Phonegap：快速开发跨平台HTML5应用的胶水层

      在分享这个项目之前先来回顾以前的三篇文章：

      《基于即时通信和LBS技术的位置感知服务（一）：提出问题及解决方案》（外网地址）

      在第一篇文章中我们提出了要让A与B在不同地方能即刻获取对方准确位置的需求。之后讨论了解决这一问题做出的方案选择，即放弃使用轮询（Pooling） 的方式在不同客户端进行数据的更新，理由是因为B不知道A何时需要自己的位置信息，所以B只能一直post自己的位置数据给服务器，而A要定时通过 RESTful Web请求去服务器获取B的信息。

      最后确定采用基于XMPP协议的PubSub（Publish/Subscribe，发布/订阅）方式进行异步消息实时传递。

      《基于即时通信和LBS技术的位置感知服务（二）：XMPP协议总结以及开源解决方案》（外网地址）

      第二篇文章主要是对XMPP协议进行总结，以及为什么要采用XMPP,最后介绍了XMPP协议的Java开源解决方案：Openfire+Smack+Spark。

      《基于即时通信和LBS技术的位置感知服务（三）：搭建Openfire服务器+测试2款IM客户端》（外网地址）

      第三篇文章详细讲解了基于XMPP协议的openfire服务架设，以及使用2款异构的基于XMPP协议的桌面客户端测试即时消息传递。

      特别提示：为了更好的了解本项目要解决的问题，强烈建议去看看前面的三篇连载。

      二、Location-Aware-Instant项目概括

      Location-Aware-Instant是一个运行在Android OS 上具有位置即时感知功能的Android应用程序客户端。与之前第三篇文章里介绍了2款桌面程序一样，遵循开放标准的XMPP协议。

      开发过程查找和参考了不少外文资料和相关项目，利用周末和晚上的时间、现在已经终于完成了90%。

      本程序的架构和技术基础：

      1. Android OS 应用开发技术：包括地图应用开发。

      2. Openfire服务器：基于XMPP协议的开源Java服务器端程序。

      3. Smack 开发库：对XMPP协议进行了封装的客户端实现的Java开发包。本项目采用的是ASmack Library（适合与Android OS 的Smack优化版）。

      本项目的实现原理。共分三个层次：

      1. 首先使用Openfire作为服务器，通过使用ASmack库开发出带有联系人列表的即时消息传递程序；

      2. 然后客户端发送和接收消息之间植入自己的拦截预处理逻辑，并通过定制特殊的命令，实现消息的自动应答功能；

      3. 最后一层在接收消息时，根据预处理命令判断是否对方的意图为定位请求，如果是则调用位置定位相关方法获取本地位置并自动恢复给发送请求一方，请求方根据预处理命令判断到来的消息是否与位置相关，如果有关则将对方的位置定位在Google 地图上。

      注意：本文的内容是描述一种应用，并非代码讲解（本项目可能以后会结合Android开发总结来讲解）。 

       三、项目功能展示

      由于只有一台测试手机HTC G6，而这个项目是与位置有关的，所以用Android 开发模拟器来最为双方通信的一端。

      测试帐号分别是test2@192.168.0.177(由于登录htc g6上的Location-Aware-Instant客户端)，test@192.168.0.177（用来登录模拟器上的Location-Aware-Instant客户端）。上面2个帐号格式是Jabber Id（XMPP协议中的帐号，可以参考前排第二篇介绍XMPP的文章），本来是使用test@im.comit.com.cn 在其他桌面客户端解析正常，但手机将im.comit.com.cn的域名解析成一个其他的IP，所以直接使用我本机的IP地址。

      本程序的logo：，logo来源自百度百科的XMPP介绍：，我简单的处理了一下。  

      1. 首先是登录界面（分别使用上面的2个帐号登录两款手机客户端）：

      HTC g6的登录界面      开发模拟器的登录界面

      2. 双方登录并连接到openfire服务器时，会出现双方的在线情况。也就是在服务器上注册了自己的状态为在线。

      HTC g6可以看到对方（test）      开发模拟器显示test2在线

      3. 操作（目前只加入了定位对方的功能，其实还有发送普通信息、删除联系人等功能，添加联系人）

      HTC g6     

      4. 先来看通过手机模拟器定位htc g6客户端的演示，即点击第三步中手机模拟器(右边)的”获取位置“选项操作。

      虽然测试环境在室内，无法获取GPS信号。但HTC g6插入了联通的3G卡所以即时在室内也是可以使用基站定位大概位置。

      此时手机模拟器在向G6发送位置感知的请求，G6应该回应自己所在的位置，不到2秒钟后，得到的结果如下图：

      我住在棠下，所以G6通过基站大概定位了我的位置，并将位置数据回应给手机模拟器，模拟器将G6所在的位置定位在地图上。

      5. 上面演示了通过模拟器定位到G6的位置，现在演示的是G6获取模拟器的位置。但是因为手机模拟器不能获取真实的位置信息，也就无法将自己的信息回复给 G6。解决的方法是在开发工具中输入一个自定义的位置数据。如下图，输入公司在所位置的经纬度（23.143791, 113.347533）。

      图中emulator 5554就是我们的模拟器（HT03GNX0404是HTC G6手机）。这样模拟器的位置就定位在公司做位置。

      现在尝试通过G6来感知模拟器这个客户端所在的位置，即点击第三步中HTC G6 (左边)的”获取位置“选项操作。结果如下图：

      G6客户端程序正在等待手机模拟器的回应，不到2秒钟后：

      OK，成功定位到公司所在位置，即G6即可感知到了手机模拟器的位置信息。

      到这里手机的位置感知服务基本框架已经出来了。能够即可感知对方的位置，是不是很Cool的体验！

      四、项目内容以及结构介绍（代码太长，截图分成上下两部分）

      图1      图2

      代码结构介绍：以下包名忽略了cn.com.comit.locationaware父包

      图1：chat包：与消息发送有关的类

               data包：联系人列表，消息等实体类

               dialogs包： 交互有关的对话框类

               exception包：异常相关的类

               map包：与地图和LBS有关的类

      图2：service包：封装Smack库和对方提供XMPP服务的封装类。

               util包：工具类包

               widget.quickantion包：联系人操作（如第三章第3步中的“获取位置”）操作选项控件类

               cn.com.comit.locationaware父包：入口以及辅助类

               Google APIs 2.2：引用的google android 地图开发包

               引用的库：asmack-2010.05.07.jar – Smack的Android优化版API库、trace.jar错误追踪相关包。

      五、结束语

      1. 传统网络操作方式我们用到 Restful Get获取数据、Post提交数据，但这不是万能的（虽然可以解决大多数的网络应用问题）。通过引入基于PubSub（发布/订阅）的即时通信有时候可以 取得意想不到的体验效果，本项目提出了一个研究方向和思路（虽然离商用还有很长的路要走，可路终究是找到了一条，并且迈出了“万里长征的第一步”）。

      2. 最近基于LBS的应用层出不穷，能够将LBS和即时通信进行整合运行，让研究的方向更明确（例如本项目的自动应答功能）。

      3. 将即时通信和LBS有机的结合或许可以称作为传说中的“微创新”，毕竟创新不一定是非得创造。

1 、采用嵌入式技术 （系统稳定） ，无需电脑就可以独立工作，同时支持 GPRS 、 CDMA 、 EDGE 、 3G 手机无线网络，也就是说只要是有手机网络的地方就能随时随地实现实时的视频监控。 

2 、 D1 高清晰网络视频服务器，兼容 D1 、 CIF 格式。

3 、 采用 H.264 视频压缩算法，轻松实现高清晰图像的低网络带宽传输 , 手机实时查看视频可达 20 帧，视频图象实时、流畅。 

4 、支持动态 IP 地址、 DNS ，支持局域网、 Internet （ ADSL 、有线通）

5 、可使用中心管理软件实现对多台视频服务器的集中监控和管理，方便组建大型视频监控系统。

6 、网络自适应技术，根据网络带宽自动调整视频帧率。

7 、随时随地的移动监控，专业的电脑远程同步监控录像功能

8 、手机端浏览实时图像的同时，电脑端可同步对图像进行浏览、录像、回放、管理

9 、宽实时视频传输，支持众多型号手机。

10 、支持远程云台控制功能，视角更广

11 、监控点之间随意切换，多部手机可同时监控 

12 、报警自动给指定手机发短信及给指定邮箱发邮件。

基本功能 

实时报警：监控场地发生意外情况时，通过活动视频向手机报警。

主动查看：平时也可以随时随地的查看监控场地的情况。

在线设置：可以通过手机对监控设备进行设置，比如是否入侵检测，开机关机，图像设置等。

服务器存储：在向手机报警的同时，将高清晰的图片存储到服务器上，以备查用。

 远程视频监控、手机视频监控系统解决方案
如今，以嵌入式技术为依托，以网络、通信技术为平台的网络视频监控，已经越来越成熟，应用范围越来越广阔。网络视频监控突破了地域的限制，实现了远程 监控，可是，随着 “ AnyTime、AnyWhere、 AnyDevice”(任何时间、任何地点、任何设备)等概念的提出，普通的网络视频监控已经不能满足用户日益增长的多元化需求。全新的解决方案?“手机 视频监控”使这个问题有了答案，这项应用将在安防行业中得到迅速推广和普及，同时，她也会逐渐走入人们的家庭生活中。

　　手机视频服务器，该设备在开启后，通过已连接的路由器，可直接连接到Internet网络(可独立运作于标准网络环境，无须外接计算机)，然后 将拍摄到的影音视频信号压缩成H.264格式，再发送到Internet。而用户端设备则变成了我们日常用的手机。手机通过GPRS或者CDMA(目前国 内普遍的两种上网方式)上网后，通过查看设备的动态域名+端口，就可以看到手机视频服务器中拍摄到的影音文件了。用户第一次启用这个设备时，要通过在同一 个网络中的电脑对其进行简单的设置(包括用户名、权限、域名、端口等)，以后每次启动，就不再需要设置了。实际上，是集数据采集、网络视频编码、压缩和网络连接为一体，因此严格的说他是一台网络视频服务器。她的应用范围很广，比如：企业、商场监控;幼儿园、托儿所等场所的远程观看;儿童、老人看护;家庭和别墅的安防监控等等。

　　某钻石专卖店数字监控方案

　　某钻石专卖店主营金银首饰和宝石等贵重饰品，为了店内安全，做到能及时处理突发事件，全面掌握犯罪证据，而且考虑到公司总部与店面两个城市的跨地区管理，采用以手机视频服务器为数字传输方式的远程数字监控方案。

　　随着科技的进步，以网络传输的手机视频服务器作为安防监控的第五代产品，在安防界脱颖而出。手机视频服务器把前端的模拟信号采集，通过硬件压缩 为数字信号传输。它独特的稳定性和无人职守，随时都可以在已有的局域网和广域网上访问浏览等优点深受广大终端客户和各地工程商的喜爱。手机视频服务器逐步 占领安防市场。

　　(1)案例分析：

　　钻石专卖店在两年以前就安装了一套以视频压缩卡为采集视频方式的硬盘录像解决方案。随着时间的推移，无论从前端摄像机部分还是从后端的电脑主机，以压缩卡为采集视频的方式毛病曾出不穷，电脑死机更是家常便饭，而且视频画面效果极差，画面速度延时严重。

　　加上公司总部和店面在跨地区的两个城市，鉴于硬盘录像机网络的弊端，不能随时进行网络远程传播。公司领导只能来往于两地奔波，而进行店面的管理，严重影响了工作效率。

　　(2)网络数字解决方案：

　　1、以塬有的线路为传输视频的方式，不改变任何的线路，且使用塬有的摄像机，直接在机房内用手机视频服务器连接塬有接入视频采集卡的模拟线路，设置好手机视频服务器IP为局域网IP，这样本地局域网内就可以实现监控和录像。

　　2、考虑到远程监控和录像，必须申请一条普通的ADSL宽带线路。手机视频服务器只有一个RJ45接口，直接接入ADSL的话，局域网内就不能 进行监控。为了实现本地远程双重监控，可在机房内设置一个普通路由器。实现局域网内本地监控，且局域网内各个电脑都能实现网上冲浪。

　　家庭监控方案

　　随着经济的快速发展，人们生活节奏的提高，照顾家庭的时间将越来越少。但现代科技的高速发展可以让远程照顾小孩、家庭宠物等成为一种可能。人们 在可以繁忙工作的同时，在远程就了解自己家庭概况，及时作出分析与判断。随着网络通讯技术及图像压缩处理技术以及传输技术的快速发展，使得家庭能够采用最 新的通讯和图像处理技术，通过网络传输数字图像，可为实现家庭监控系统提供高效可行而且价格低廉的解决方案。

　　家庭监控方案特点:

　　本方案立足以互联网、宽带ADSL应用方案，采用手机视频服务器 “传统摄像机”+“手机视频服务器”的方式，摄像机负责影像采集, 手机视频服务器负责把摄像机的模拟信号进行数字压缩，转换成数字信号，最后手机视频服务器通过路由器或交换机或ADSL将视频传输到局域网或互联网。

　　◆ NO-PC架构

　　◆ 预设二级域名

　　◆ 安装简单快捷

　　◆ 外围设备接入灵活

　　◆ 高性能 低成本 免维护 更安全

　　家庭监控标准版方案

　　由一台通过手机视频服务器并在网络端通过网线连接ADSL MODEM;

　　的自带拨号程序连通电源后会自动连接INTERNET，远端用户可以通过IE浏览器直接观看家中情况。

　　实际可应用的范围：

　　- 商业店铺：商场店铺的监控，收银、货架、出入口监控

　　- 居民住宅：室内远程图象报警、小区 / 大楼安全防范、物业的无人监控

　　- 教育行业：幼儿园、小学校的教学评估，家长远程监控

　　- 旅游行业：宾馆饭店的楼层管理、重点文物及景点的保护

　　主要应用：

　　1、店铺超市：店铺老板在家中或外地，只要通过 Internet 或手机随时可看到店铺实景情况，员工的工作情况，进行远程监控和管理。

　　2、企业：企业领导以及各部门需要随时了解员工工作情况，车间生产情况、流水线运作情况等，对突发事件需要进行即时处理。不需到场，只要上互联网或手机随时可看到外地各分部的实时情况。

　　3、家庭：可在办公室或外地通过互联网或手机随时看到家庭的现状。家庭窃案或其它事故发生，可快速查找到当时录像。

public class MultiUserServer extends Thread {
 private Socket client;
 
 public MultiUserServer(Socket c) {
  this.client = c;
 }

 public void run() {
  try {
   BufferedReader in = new BufferedReader(new InputStreamReader(client
     .getInputStream()));
   PrintWriter out = new PrintWriter(client.getOutputStream());
   // Mutil User but can't parallel
   while (true) {
    String str = in.readLine();
    System.out.println(str);
    SocketLog.debug("receive message: " + str);
    out.println("has receive....");
    out.flush();
    if (str.equals("end"))
     break;
   }
   client.close();
  } catch (IOException ex) {
  }
 }

 public static void main(String[] args) throws IOException {
  int port = 5678;
  if (args.length > 0)
   port = Integer.parseInt(args[0]);
  ServerSocket server = new ServerSocket(port);
  SocketLog.debug("the server socket application is created!");
  while (true) {
   // transfer location change Single User or Multi User
   MultiUserServer mu = new MultiUserServer(server.accept());
   mu.start();
  }
 }
}

client code:

public class Client {

 static Socket server;

 public static void main(String[] args) throws Exception {
  
  //set socket proxy.
  String proxyHost = "192.168.254.212";
  String proxyPort = "1080";
  System.getProperties().put("socksProxySet","true");
  System.getProperties().put("socksProxyHost",proxyHost);
  System.getProperties().put("socksProxyPort",proxyPort);
  
  String host = "132.201.69.80";
  int port = 13086;
  if (args.length > 1)
  {
   host = args[0];
   port = Integer.parseInt(args[1]);
  }
  System.out.println("connetioning:" + host + ":" + port);
  server = new Socket(host, port);
  BufferedReader in = new BufferedReader(new InputStreamReader(server
    .getInputStream()));
  PrintWriter out = new PrintWriter(server.getOutputStream());
  BufferedReader wt = new BufferedReader(new InputStreamReader(System.in));
  while (true) {
   String str = wt.readLine();
   out.println(str);
   out.flush();
   if (str.equals("end")) {
    break;
   }
   System.out.println(in.readLine());
  }
  server.close();
 }
}

2.nio:非阻塞通讯模式
２．１NIO 设计背后的基石：反应器模式，用于事件多路分离和分派的体系结构模式。
反应器模式的核心功能如下：
将事件多路分用
将事件分派到各自相应的事件处理程序

NIO 的非阻塞 I/O 机制是围绕 选择器和 通道构建的。 Channel 类表示服务器和客户机之间的
一种通信机制。Selector 类是 Channel 的多路复用器。 Selector 类将传入客户机请求多路分
用并将它们分派到各自的请求处理程序。
通道(Channel 类)：表示服务器和客户机之间的一种通信机制。
选择器(Selector类)：是 Channel 的多路复用器。Selector 类将传入的客户机请求多路分用并将它们
分派到各自的请求处理程序。

简单的来说：

NIO是一个基于事件的IO架构，最基本的思想就是：有事件我通知你，你再去做你的事情．
而且NIO的主线程只有一个，不像传统的模型，需要多个线程以应对客户端请求，也减轻
了JVM的工作量。
当Channel注册至Selector以后，经典的调用方法如下：

        while (somecondition) {
            int n = selector.select(TIMEOUT);
            if (n == 0)
                continue;
            for (Iterator iter = selector.selectedKeys().iterator(); iter
                    .hasNext();) {
                if (key.isAcceptable())
                    doAcceptable(key);
                if (key.isConnectable())
                    doConnectable(key);
                if (key.isValid() && key.isReadable())
                    doReadable(key);
                if (key.isValid() && key.isWritable())
                    doWritable(key);
                iter.remove();
            }
        }
nio中取得事件通知，就是在selector的select事件中完成的。在selector事件时有一个线程
向操作系统询问，selector中注册的Channel&&SelectionKey的键值对的各种事件是否有发生，
如果有则添加到selector的selectedKeys属性Set中去，并返回本次有多少个感兴趣的事情发生。
如果发现这个值>0，表示有事件发生，马上迭代selectedKeys中的SelectionKey，
根据Key中的表示的事件，来做相应的处理。
实际上，这段说明表明了异步socket的核心，即异步socket不过是将多个socket的调度（或者还有他们的线程调度）
全部交给操作系统自己去完成，异步的核心Selector，不过是将这些调度收集、分发而已。
2.2 nio example:
server code：

public class NonBlockingServer
{
    public Selector sel = null;
    public ServerSocketChannel server = null;
    public SocketChannel socket = null;
    public int port = 4900;
    String result = null;

    public NonBlockingServer()
    {
  System.out.println("Inside default ctor");
    }
   
 public NonBlockingServer(int port)
    {
  System.out.println("Inside the other ctor");
  this.port = port;
    }

    public void initializeOperations() throws IOException,UnknownHostException
    {
  System.out.println("Inside initialization");
  sel = Selector.open();
  server = ServerSocketChannel.open();
  server.configureBlocking(false);
  InetAddress ia = InetAddress.getLocalHost();
  InetSocketAddress isa = new InetSocketAddress(ia,port);
  server.socket().bind(isa);
    }
   
 public void startServer() throws IOException
    {
  System.out.println("Inside startserver");
        initializeOperations();
  System.out.println("Abt to block on select()");
  SelectionKey acceptKey = server.register(sel, SelectionKey.OP_ACCEPT ); 
 
  while (acceptKey.selector().select() > 0 )
  { 
    
   Set readyKeys = sel.selectedKeys();
   Iterator it = readyKeys.iterator();

   while (it.hasNext()) {
    SelectionKey key = (SelectionKey)it.next();
    it.remove();
               
    if (key.isAcceptable()) {
     System.out.println("Key is Acceptable");
     ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
     socket = (SocketChannel) ssc.accept();
     socket.configureBlocking(false);
     SelectionKey another = socket.register(sel,SelectionKey.OP_READ|SelectionKey.OP_WRITE);
    }
    if (key.isReadable()) {
     System.out.println("Key is readable");
     String ret = readMessage(key);
     if (ret.length() > 0) {
      writeMessage(socket,ret);
     }
    }
    if (key.isWritable()) {
     System.out.println("THe key is writable");
     String ret = readMessage(key);
     socket = (SocketChannel)key.channel();
     if (result.length() > 0 ) {
      writeMessage(socket,ret);
     }
    }
   }
  }
    }

    public void writeMessage(SocketChannel socket,String ret)
    {
  System.out.println("Inside the loop");

  if (ret.equals("quit") || ret.equals("shutdown")) {
   return;
  }
  try
  {

   String s = "This is context from server!-----------------------------------------";
   Charset set = Charset.forName("us-ascii");
   CharsetDecoder dec = set.newDecoder();
   CharBuffer charBuf = dec.decode(ByteBuffer.wrap(s.getBytes()));
   System.out.println(charBuf.toString());
   int nBytes = socket.write(ByteBuffer.wrap((charBuf.toString()).getBytes()));
   System.out.println("nBytes = "+nBytes);
    result = null;
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }

    }
 
    public String readMessage(SelectionKey key)
    {
  int nBytes = 0;
  socket = (SocketChannel)key.channel();
        ByteBuffer buf = ByteBuffer.allocate(1024);
  try
  {
            nBytes = socket.read(buf);
   buf.flip();
   Charset charset = Charset.forName("us-ascii");
   CharsetDecoder decoder = charset.newDecoder();
   CharBuffer charBuffer = decoder.decode(buf);
   result = charBuffer.toString();
    
        }
  catch(IOException e)
  {
   e.printStackTrace();
  }
  return result;
    }

    public static void main(String args[])
    {
     NonBlockingServer nb;
     if (args.length < 1)
     {
      nb = new NonBlockingServer();
     }
     else
     {
      int port = Integer.parseInt(args[0]);
      nb = new NonBlockingServer(port);
     }
  
  try
  {
   nb.startServer();
   System.out.println("the nonBlocking server is started!");
  }
  catch (IOException e)
  {
   e.printStackTrace();
   System.exit(-1);
  }
  
 }
}

client code:

public class Client {
 public SocketChannel client = null;

 public InetSocketAddress isa = null;

 public RecvThread rt = null;

 private String host;

 private int port;

 public Client(String host, int port) {
  this.host = host;
  this.port = port;
 }

 public void makeConnection() {
  String proxyHost = "192.168.254.212";
  String proxyPort = "1080";
  System.getProperties().put("socksProxySet", "true");
  System.getProperties().put("socksProxyHost", proxyHost);
  System.getProperties().put("socksProxyPort", proxyPort);

  int result = 0;
  try {
   client = SocketChannel.open();
   isa = new InetSocketAddress(host, port);
   client.connect(isa);
   client.configureBlocking(false);
   receiveMessage();
  } catch (UnknownHostException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  }
  long begin = System.currentTimeMillis();

  sendMessage();

  long end = System.currentTimeMillis();
  long userTime = end - begin;
  System.out.println("use tiem: " + userTime);
  try {
   interruptThread();
   client.close();
   System.exit(0);
  } catch (IOException e) {
   e.printStackTrace();
  }
 }

 public int sendMessage() {
    System.out.println("Inside SendMessage");
  String msg = null;
  ByteBuffer bytebuf;
  int nBytes = 0;
  try {
   msg = "It's message from client!";
   System.out.println("msg is "+msg);
   bytebuf = ByteBuffer.wrap(msg.getBytes());
   for (int i = 0; i < 1000; i++) {
    nBytes = client.write(bytebuf);
    System.out.println(i + " finished");
   }
   interruptThread();
   try {
    Thread.sleep(5000);
   } catch (Exception e) {
    e.printStackTrace();
   }
   client.close();
   return -1;

  } catch (IOException e) {
   e.printStackTrace();
  }

  return nBytes;

 }

 public void receiveMessage() {
  rt = new RecvThread("Receive THread", client);
  rt.start();

 }

 public void interruptThread() {
  rt.val = false;
 }

 public static void main(String args[]) {
  if (args.length < 2) {
   System.err.println("You should put 2 args: host,port");
  } else {
   String host = args[0];
   int port = Integer.parseInt(args[1]);
   Client cl = new Client(host, port);
   cl.makeConnection();
  }
  BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
  String msg;

 }

 public class RecvThread extends Thread {
  public SocketChannel sc = null;

  public boolean val = true;

  public RecvThread(String str, SocketChannel client) {
   super(str);
   sc = client;
  }

  public void run() {
   int nBytes = 0;
   ByteBuffer buf = ByteBuffer.allocate(2048);
   try {
    while (val) {
     while ((nBytes = nBytes = client.read(buf)) > 0) {
      buf.flip();
      Charset charset = Charset.forName("us-ascii");
      CharsetDecoder decoder = charset.newDecoder();
      CharBuffer charBuffer = decoder.decode(buf);
      String result = charBuffer.toString();
      System.out.println("the server return: " + result);
      buf.flip();

     }
    }

   } catch (IOException e) {
    e.printStackTrace();

   }

  }
 }
}
3：Socket网络框架 MINA
MINA是一个网络应用框架，在不牺牲性能和可扩展性的前提下用于解决如下问题：
1：快速开发自己的英勇。
2：高可维护性，高可复用性：网络I/O编码，消息的编/解码，业务逻辑互相分离。
3：相对容易的进行单元测试。

3.1 IoFilters：
IoFilter为MINA的功能扩展提供了接口。它拦截所有的IO事件进行事件的预处理和后处理(AOP)。我们可以把它想象成
Servlet的filters。
IoFilter能够实现以下几种目的：
事件日志
性能检测
数据转换(e.g. SSL support)，codec
防火墙…等等

3.2 codec: ProtocolCodecFactory
MINA提供了方便的Protocol支持。如上说讲，codec在IoFilters中设置。
通过它的Encoder和Decoder，可以方便的扩展并支持各种基于Socket的网络协议，比如HTTP服务器、FTP服务器、Telnet服务器等等。

要实现自己的编码/解码器(codec)只需要实现interface: ProtocolCodecFactory即可.
在MINA 1.0版本，MINA已经实现了几个常用的(codec factory):

DemuxingProtocolCodecFactory,
NettyCodecFactory,
ObjectSerializationCodecFactory,
TextLineCodecFactory
 
其中：
TextLineCodecFactory:
 A ProtocolCodecFactory that performs encoding and decoding between a text line data and a Java
 string object. This codec is useful especially when you work with a text-based protocols such as SMTP and IMAP.

ObjectSerializationCodecFactory:
A ProtocolCodecFactory that serializes and deserializes Java objects. This codec is very useful when
you have to prototype your application rapidly without any specific codec.

DemuxingProtocolCodecFactory：
A composite ProtocolCodecFactory that consists of multiple MessageEncoders and MessageDecoders. ProtocolEncoder
and ProtocolDecoder this factory returns demultiplex incoming messages and buffers to appropriate MessageEncoders
and MessageDecoders.

NettyCodecFactory:
A MINA ProtocolCodecFactory that provides encoder and decoder for Netty2 Messages and MessageRecognizers.

3.3 business logic: IoHandler

MINA中，所有的业务逻辑都有实现了IoHandler的class完成
interfaceHandles:
 all protocol events fired by MINA. There are 6 event handler methods, and they are all invoked by MINA automatically.
 当事件发生时，将触发IoHandler中的方法:
 sessionCreated, sessionOpened, sessionClosed, sessionIdle, exceptionCaught, messageReceived, messageSent
MINA 1.O中，IoHandler的实现类：
ChainedIoHandler, DemuxingIoHandler, IoHandlerAdapter, SingleSessionIoHandlerDelegate, StreamIoHandler
具体细节可参考javadoc。

3.4   MINA的高级主题：线程模式
MINA通过它灵活的filter机制来提供多种线程模型。
没有线程池过滤器被使用时MINA运行在一个单线程模式。
如果添加了一个IoThreadPoolFilter到IoAcceptor，将得到一个leader-follower模式的线程池。
如果再添加一个ProtocolThreadPoolFilter，server将有两个线程池；
一个(IoThreadPoolFilter)被用于对message对象进行转换，另外一个(ProtocolThreadPoolFilter)被用于处理业务逻辑。
SimpleServiceRegistry加上IoThreadPoolFilter和ProtocolThreadPoolFilter的缺省实现即可适用于需
要高伸缩性的应用。如果想使用自己的线程模型，请参考SimpleServiceRegistry的源代码，并且自己

初始化Acceptor。

IoThreadPoolFilter threadPool = new IoThreadPoolFilter();threadPool.start();
IoAcceptor acceptor = new SocketAcceptor();
acceptor.getFilterChain().addLast( "threadPool", threadPool);
ProtocolThreadPoolFilter threadPool2 = new ProtocolThreadPoolFilter();
threadPool2.start();
ProtocolAcceptor acceptor2 = new IoProtocolAcceptor( acceptor );
acceptor2.getFilterChain().addLast( "threadPool", threadPool2 );
...
threadPool2.stop();
threadPool.stop();

采用MINA进行socket开发，一般步骤如下：
1：
server:
IoAcceptor acceptor = new SocketAcceptor(); //建立client接收器
or client:
SocketConnector connector = new SocketConnector();  //建立一个连接器
2：server的属性配置：
        SocketAcceptorConfig cfg = new SocketAcceptorConfig();
        cfg.setReuseAddress(true);
        cfg.getFilterChain().addLast(
                    "codec",
                    new ProtocolCodecFilter( new ObjectSerializationCodecFactory() ) ); //对象序列化 codec factory
        cfg.getFilterChain().addLast( "logger", new LoggingFilter() );
3：绑定address和business logic
server:
        acceptor.bind(
                new InetSocketAddress( SERVER_PORT ),
                new ServerSessionHandler( ), cfg ); // 绑定address和handler

client:
        connector.connect(new InetSocketAddress( HOSTNAME, PORT ),
                        new ClientSessionHandler(msg), cfg );

下面的这个简单的example演示client和server传递object的过程：
Message.java
public class Message implements Serializable {

    private int type;
    private int status;
    private String msgBody;
   
    public Message(int type, int status, String msgBody)
    {
        this.type = type;
        this.status = status;
        this.msgBody = msgBody;
    }

    public String getMsgBody() {
        return msgBody;
    }

    public void setMsgBody(String msgBody) {
        this.msgBody = msgBody;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }
}

Client.java
public class Client
{
    private static final String HOSTNAME = "localhost";
    private static final int PORT = 8080;
    private static final int CONNECT_TIMEOUT = 30; // seconds

    public static void main( String[] args ) throws Throwable
    {
        SocketConnector connector = new SocketConnector();       
        // Configure the service.
        SocketConnectorConfig cfg = new SocketConnectorConfig();
        cfg.setConnectTimeout( CONNECT_TIMEOUT );
          cfg.getFilterChain().addLast(
                    "codec",
                    new ProtocolCodecFilter( new ObjectSerializationCodecFactory() ) );

        cfg.getFilterChain().addLast( "logger", new LoggingFilter() );
       
        IoSession session;
        Message msg = new Message(0,1,"hello");
        connector.connect(new InetSocketAddress( HOSTNAME, PORT ),
                        new ClientSessionHandler(msg), cfg );

    }
}

ClientSessionHandler.java
public class ClientSessionHandler extends IoHandlerAdapter
{
    private Object msg;
   
    public ClientSessionHandler(Object msg)
    {
        this.msg = msg;
    }

    public void sessionOpened( IoSession session )
    {
        session.write(this.msg);
    }

    public void messageReceived( IoSession session, Object message )
    {
        System.out.println("in messageReceived!");
        Message rm = (Message ) message;       
        SessionLog.debug(session, rm.getMsgBody());
        System.out.println("message is: " + rm.getMsgBody());
        session.write(rm);
    }

    public void exceptionCaught( IoSession session, Throwable cause )
    {
        session.close();
    }
}

Server.java
public class Server
{
    private static final int SERVER_PORT = 8080;

    public static void main( String[] args ) throws Throwable
    {
        IoAcceptor acceptor = new SocketAcceptor();
       
        // Prepare the service configuration.
        SocketAcceptorConfig cfg = new SocketAcceptorConfig();
        cfg.setReuseAddress( true );

        cfg.getFilterChain().addLast(
                    "codec",
                    new ProtocolCodecFilter( new ObjectSerializationCodecFactory() ) );
        cfg.getFilterChain().addLast( "logger", new LoggingFilter() );

        acceptor.bind(
                new InetSocketAddress( SERVER_PORT ),
                new ServerSessionHandler( ), cfg );

        System.out.println( "The server Listening on port " + SERVER_PORT );
    }
}

ServerSessionHandler.java
public class ServerSessionHandler extends IoHandlerAdapter
{
    public void sessionOpened( IoSession session )
    {
        // set idle time to 60 seconds
        session.setIdleTime( IdleStatus.BOTH_IDLE, 60 );
        session.setAttribute("times",new Integer(0));
    }

    public void messageReceived( IoSession session, Object message )
    {
        System.out.println("in messageReceived");
        int times = ((Integer)(session.getAttribute("times"))).intValue();
        System.out.println("tiems = " + times);
        // communicate 30 times,then close the session.
        if (times < 30)
        {
            times++;
            session.setAttribute("times", new Integer(times));          
         Message msg;
         msg = (Message) message;
         msg.setMsgBody("in server side: " + msg.getMsgBody()); 
         System.out.println("begin send msg: " + msg.getMsgBody());
         session.write(msg);
        }
        else
        {
            session.close();
        }
    }

    public void sessionIdle( IoSession session, IdleStatus status )
    {
        SessionLog.info( session, "Disconnecting the idle." );
        // disconnect an idle client
        session.close();
    }

    public void exceptionCaught( IoSession session, Throwable cause )
    {
        // close the connection on exceptional situation
        session.close();
    }
}
MINA自己附带的Demo已经很好的说明了它的运用。
值得一提的是它的SumUp：客户端发送几个数字，服务端求和后并返回结果。这个简单的程序演示了如何自己实现CODEC。

补充提示：
下载并运行MINA的demo程序还颇非周折:
运行MINA demo appli擦tion：
1:在JDK5
产生错误:
Exception in thread "main" java.lang.NoClassDefFoundError: edu/emory/mathcs/backport/java/util/concurrent/Executor
 at org.apache.mina.example.reverser.Main.main(Main.java:44)
 
察看mina的QA email:
http://www.mail-archive.com/mina-dev@directory.apache.org/msg02252.html

原来需要下载:backport-util-concurrent.jar并加入classpath
http://dcl.mathcs.emory.edu/util/backport-util-concurrent/

继续运行还是报错:
Exception in thread "main" java.lang.NoClassDefFoundError: org/slf4j/LoggerFactory

原来MINA采用了slf4j项目作为log，继续下载
slf4j-simple.jar等，并加入classpath:
http://www.slf4j.org/download.html