http://code.google.com/p/cocoaasyncsocket/

CocoaAsyncSocket支持tcp和udp。其中：

• AsyncSocket类是支持TCP的
• AsyncUdpSocket是支持UDP的

AsyncSocket是封装了CFSocket和CFSteam的TCP/IP socket网络库。它提供了异步操作，本地cocoa类的基于delegate的完整支持。主要有以下特性：

• 队列的非阻塞的读和写，而且可选超时。你可以调用它读取和写入，它会当完成后告知你
• 自动的socket接收。如果你调用它接收连接，它将为每个连接启动新的实例，当然，也可以立即关闭这些连接
• 委托（delegate）支持。错误、连接、接收、完整的读取、完整的写入、进度以及断开连接，都可以通过委托模式调用
• 基于run loop的，而不是线程的。虽然可以在主线程或者工作线程中使用它，但你不需要这样做。它异步的调用委托方法，使用NSRunLoop。委托方法包括socket的参数，可让你在多个实例中区分
• 自包含在一个类中。你无需操作流或者socket，这个类帮你做了全部
• 支持基于IPV4和IPV6的TCP流

AsyncUdpSocket是UDP/IP socket网络库，包装自CFSocket。它的工作很像TCP版本，只不过是用于处理UDP的。它包括基于非阻塞队列的发送接收操作，完整的委托支持，基于runloop，自包含的类，以及支持IPV4和IPV6。

以下内容是根据官方网站参考:

http://code.google.com/p/cocoaasyncsocket/wiki/Reference_AsyncSocket

编写的示例。

准备工作：如何在iOS项目中使用

可按照官网链接执行：

http://code.google.com/p/cocoaasyncsocket/wiki/iPhone

基本上是两步：

1. 将CocoaAsyncSocket项目中的.h和.m文件拖拽到自己项目的Classes目录中
2. 添加framework：CFNetwork

编写简单的TCP连接

编写个简单的TCP连接应用。HTTP其实就是建立在TCP协议上的。这里就用向网站发起请求和获得响应来演示。

为了形象说明，先手工模拟一下HTTP。这需要用到telnet工具，这是个命令行工具，如果在命令行里敲：

C:\Users\Marshal Wu>telnet
‘telnet’ 不是内部或外部命令，也不是可运行的程序
或批处理文件。

 

说明你使用的是windows vista或者windows7，因为windows xp是默认安装该软件的。

我用的是Mac OSX，上面自带这个工具。如果你出现上面的问题，可参照vista下使用telnet的做法安装telnet。

然后，可以使用这个工具发出socket信息，并接收socket返回信息。下面说一下步骤，如图：

下面用CocoaAsyncSocket来实现。

首先是要实现相关的delegate：

#import <UIKit/UIKit.h>

#import "AsyncSocket.h"

@interface SocketDemosViewController : UIViewController<AsyncSocketDelegate>

 

然后，在实现代码中：

- (void)onSocket:(AsyncSocket *)sock didConnectToHost:(NSString *)host port:(UInt16)port{
    NSLog(@"did connect to host");
}

- (void)onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag{
    NSLog(@"did read data");
    NSString* message = [[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding] autorelease];
    NSLog(@"message is: \n%@",message);
}

 

AsyncSocketDelegate中的方法都是可选的。我实现了对建立连接后以及读取数据的监听。

这些监听需要创建和使用AsyncSocket实例时才能被用到。下面就是这部分代码：

- (void)viewDidLoad {
    [super viewDidLoad];
   
    AsyncSocket *socket=[[AsyncSocket alloc] initWithDelegate:self];
    [socket connectToHost:@"www.baidu.com" onPort:80 error:nil];
   
    [socket readDataWithTimeout:3 tag:1];
    [socket writeData:[@"GET / HTTP/1.1\n\n" dataUsingEncoding:NSUTF8StringEncoding] withTimeout:3 tag:1];

 

我把这部分代码直接写到controller的viewDidLoad中了。

执行的日志如下：

2011-07-19 17:17:46.545 SocketDemos[27120:207] did connect to host
2011-07-19 17:17:46.620 SocketDemos[27120:207] did read data
2011-07-19 17:17:46.621 SocketDemos[27120:207] message is:
HTTP/1.1 200 OK
Date: Tue, 19 Jul 2011 09:17:46 GMT
Server: BWS/1.0
Content-Length: 7691
Content-Type: text/html;charset=gb2312
Cache-Control: private
Expires: Tue, 19 Jul 2011 09:17:46 GMT
Set-Cookie: BAIDUID=9389BA38262D7997D220A564154CCA87:FG=1; expires=Tue, 19-Jul-41 09:17:46 GMT; path=/; domain=.baidu.com
P3P: CP=" OTI DSP COR IVA OUR IND COM "
Connection: Keep-Alive

这里的HTTP响应被截断了，因为我们不是要编写真的接收HTTP响应的功能，因此这个缺陷可以忽略。

本来HTTP请求应该是由服务器端来关闭，比如使用telent访问看到的是这样的结尾：

因此，HTTP响应没有完全接收下来，服务器端未断掉连接。可以在客户端关闭连接，这样：

[socket readDataWithTimeout:3 tag:1];
[socket writeData:[@"GET / HTTP/1.1\n\n" dataUsingEncoding:NSUTF8StringEncoding] withTimeout:3 tag:1];
[socket disconnect];

另外，可以实现delegate中的这个方法：

- (void)onSocketDidDisconnect:(AsyncSocket *)sock{
    NSLog(@"socket did disconnect");
}

 

这样就可以在日志中监控到关闭连接的信息。

TCP连接读取指定长度的数据

socket连接，经常碰到这样的需求，读取固定长度的字节。这可以通过下面的示例实现。

还是基于HTTP连接做演示。比如取2次，每次50字节。然后停止socket。

可以这样写：

- (void)viewDidLoad {
    [super viewDidLoad];
   
    socket=[[AsyncSocket alloc] initWithDelegate:self];
    [socket connectToHost:@"www.baidu.com" onPort:80 error:nil];
   
    data=[[NSMutableData dataWithLength:50] retain];
   
    [socket readDataToLength:50 withTimeout:5 tag:1];
    [socket readDataToLength:50 withTimeout:5 tag:2];
    [socket writeData:[@"GET / HTTP/1.1\n\n" dataUsingEncoding:NSUTF8StringEncoding] withTimeout:3 tag:1];

 

在delegate中，主要是这个方法起作用：

- (void)onSocket:(AsyncSocket *)sock didReadData:(NSData *)_data withTag:(long)tag{
    NSLog(@"did read data");
    NSString* message = [[[NSString alloc] initWithData:_data encoding:NSUTF8StringEncoding] autorelease];
    NSLog(@"message is: \n%@",message);
   
    if (tag==2) {
        [socket disconnect];
    }
}

日志类似这样：

标红色的是两次取出的字节内容。

编写服务器端Socket

编写了Echo示例，说明最简单的服务器端Socket写法。Echo就是回声，通过telnet发送什么，服务器端就返回什么。类似这样：

服务器端，需要监听客户端的连接。等待客户端发来信息。代码是这样的：

socket=[[AsyncSocket alloc] initWithDelegate:self];
NSError *err = nil;

if ([socket acceptOnPort:4322 error:&err]) {
    NSLog(@"accept ok.");
}else {
    NSLog(@"accept failed.");
}

if (err) {
    NSLog(@"error: %@",err);
}

 

这一步如果成功，应该只有一个日志信息：

2011-07-20 12:27:03.228 SocketDemos[611:707] accept ok.

这时如果有客户端与之建立连接，比如通过telnet。会依次调用AsyncSocket 的delegate的如下方法：

• onSocket:didAcceptNewSocket: AsyncSocket创建了新的Socket用于处理和客户端的请求，如果这个新socket实例你不打算保留（retain），那么将拒绝和该客户端连接
• onSocket:wantsRunLoopForNewSocket:，提供线程的runloop实例给AsyncSocket，后者将使用这个runloop执行socket通讯的操作
• onSocketWillConnect:，将要建立连接，这时可以做一些准备工作，如果需要的话
• onSocket:didConnectToHost:port:，这个方法是建立连接后执行的，一般会在这里调用写入或者读取socket的操作

在Echo示例中，不打算执行多线程，也不想支持多客户端连接，而且服务器端和客户端将建立长连接。直至客户端断开连接，服务器端才释放相应的socket。

代码如下：

- (void)onSocket:(AsyncSocket *)sock didAcceptNewSocket:(AsyncSocket *)newSocket{
    if (!acceptSocket) {
        acceptSocket=[newSocket retain];
        NSLog(@"did accept new socket");
    }
}

- (NSRunLoop *)onSocket:(AsyncSocket *)sock wantsRunLoopForNewSocket:(AsyncSocket *)newSocket{
    NSLog(@"wants runloop for new socket.");
    return [NSRunLoop currentRunLoop];
}

- (BOOL)onSocketWillConnect:(AsyncSocket *)sock{
    NSLog(@"will connect");
    return YES;
}

- (void)onSocket:(AsyncSocket *)sock didConnectToHost:(NSString *)host port:(UInt16)port{
    NSLog(@"did connect to host");
    [acceptSocket readDataWithTimeout:-1 tag:1];
}

- (void)onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag{
    NSLog(@"did read data");
    NSString* message = [[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding] autorelease];
    NSLog(@"message is: \n%@",message);
    [acceptSocket writeData:data withTimeout:2 tag:1];
}

- (void)onSocket:(AsyncSocket *)sock didWriteDataWithTag:(long)tag{
    NSLog(@"message did write");
    [acceptSocket readDataWithTimeout:-1 tag:1];
}

- (void)onSocket:(AsyncSocket *)sock willDisconnectWithError:(NSError *)err{
    NSLog(@"onSocket:%p willDisconnectWithError:%@", sock, err);
}

- (void)onSocketDidDisconnect:(AsyncSocket *)sock{
    NSLog(@"socket did disconnect");
    [acceptSocket release];
    acceptSocket=nil;
}

 

这里timeout设置为-1，这样就可以保持长连接状态。

编写简单的UDP应用

首先，编写发送UDP数据报的示例。这需要有个服务器端能接收到内容。用Java写了个简单的接收端：

public static void main(String[] args) throws IOException {
    InetSocketAddress address = new InetSocketAddress("0.0.0.0", 5555);
    DatagramSocket datagramSocket=new DatagramSocket(address);
   
    System.out.println("start udp server");
   
    byte[] buffer=new byte[1024];
   
    for(;;){
        DatagramPacket datagramPacket=new DatagramPacket(buffer, buffer.length);
        datagramSocket.receive(datagramPacket);
        System.out.println("receive data:"+new String(datagramPacket.getData(),0,datagramPacket.getLength()));
    }
}

 

下面写发送的代码：

AsyncUdpSocket *socket=[[AsyncUdpSocket alloc]initWithDelegate:self];

NSData *data=[@"Hello from iPhone" dataUsingEncoding:NSUTF8StringEncoding];
[socket sendData:data toHost:@"192.168.0.165" port:5555 withTimeout:-1 tag:1];
NSLog(@"send upd complete.");

 

执行后，在接收端成功输出如下内容：

下面，写个接收端的代码：

AsyncUdpSocket *socket=[[AsyncUdpSocket alloc] initWithDelegate:self];

NSError *error = nil;
[socket bindToPort:5555 error:&error];

if (error) {
    NSLog(@"error: %@",error);
}

[socket receiveWithTimeout:-1 tag:1];
NSLog(@"start udp server");

另外，至少写这个delegate方法：

- (BOOL)onUdpSocket:(AsyncUdpSocket *)sock
     didReceiveData:(NSData *)data
            withTag:(long)tag
           fromHost:(NSString *)host
               port:(UInt16)port{
    NSLog(@"received data: %@",[[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding] autorelease]);
    return YES;
}

 

发送端，还是用java写个测试代码：

public static void main(String[] args) throws IOException {
    DatagramSocket datagramSocket = new DatagramSocket();
    byte[] buffer = "Hello!".getBytes();
    DatagramPacket datagramPacket = new DatagramPacket(buffer,
            buffer.length, new InetSocketAddress("192.168.0.144", 5555));
    datagramSocket.send(datagramPacket);
}

 

在iPhone日志中：

2011-07-20 15:23:33.571 SocketDemos[795:707] start udp server
2011-07-20 15:23:47.395 SocketDemos[795:707] received data: Hello!

收到了数据报。

使用UDP发送和接收组播

这里主要关注的是接收，一方面是需求上要求，另一方面，碰到过Android Wifi获取组播问题，担心iOS也有类似的机制。后来测试发现没有那么麻烦（打开组播锁）。

为了测试，还是用java编写了个发送UDP广播的简单代码：

public static void main(String[] args) throws IOException {
    int port=3333;
    MulticastSocket socket=new MulticastSocket(port);
    InetAddress address=InetAddress.getByName("239.0.0.1");
    socket.joinGroup(address);
    byte[] data="Hello everyone.".getBytes();
    DatagramPacket datagramPacket=new DatagramPacket(data,data.length,address,port);
    socket.send(datagramPacket);
    System.out.println("send ok.");

 

编写的iOS代码：

AsyncUdpSocket *socket=[[AsyncUdpSocket alloc] initWithDelegate:self];

NSError *error = nil;
[socket bindToPort:3333 error:&error];
[socket enableBroadcast:YES error:&error];
[socket joinMulticastGroup:@"239.0.0.1" error:&error];

if (error) {
    NSLog(@"error: %@",error);
}

[socket receiveWithTimeout:-1 tag:1];
NSLog(@"start udp server");

 

delegate和上面接收普通UDP一模一样：

- (BOOL)onUdpSocket:(AsyncUdpSocket *)sock
     didReceiveData:(NSData *)data
            withTag:(long)tag
           fromHost:(NSString *)host
               port:(UInt16)port{
    NSLog(@"received data: %@",[[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding] autorelease]);
    return YES;
}

 

测试得到的日志：

2011-07-20 16:14:30.338 SocketDemos[860:707] start udp server
2011-07-20 16:14:42.829 SocketDemos[860:707] received data: Hello everyone.

说明是收到了。

发送组播和前面的UDP发送类似，只是多了要做join group的操作。这里就不多说了。

• zip文件上传
• zip文件上传后，在zip文件中加入自定义文本文件

在Grails实现复杂的数据录入上实现的本示例。示例如图：

准备工作：文件上传

首先说一下文件上传，在Grails中，借助Spring MVC的底层支持，实现还是很容易的。

视图：

<body>
<div style="margin-left: 15px;">
<g:message code="${flash.message}" />
<g:form action="uploadFile" method="post" enctype="multipart/form-data">
<input type="file" name="myFile" />
<input type="submit" value="上传" />
<input type="hidden" name="id" value="1"/>
</g:form>
</div>
</body>

 

在这里hidden了一个参数，是用于服务器端使用的。

在服务器端获取文件对象和id：

def uploadFile={
def id=params.id
def file=request.getFile("myFile")

下面的问题是：

• 如何异步的处理zip文件，同步处理是不可能的，那样浏览器端可能长期得不到响应
• 怎样向zip文件中加入文本文件
• 怎样动态生成文本文件，本例中是xml文件

异步并发的实现

先说异步问题，我希望尽量回避线程，简化开发，这样可以让具体实现人员比较容易上手。这里使用了java的并发api，可参见这里[cref 3801]。

写法类似这样：

class BookController {

    ExecutorService executorService=Executors.newFixedThreadPool(2)

 

创建了个实例变量，允许2个并发。

可这样调用：

executorService.submit(new Runnable(){
            public void run() {

 

如何向zip文件中加入文件

时间原因，没时间看apache commons compress等api是否能实现这个功能了。直接招呼java标准zip的api了。

基本思路是创建新的zip文件，将原zip文件中的各个entry加入到新的zip文件输出流中，最后，将自己的文本文件加入。

这里补充一句，从Grails中得到的file对象，生命周期应该是request作用域的。即，当上传文件请求到达服务器端后，在临时目录创建文件保存请求中的文件流。这个文件不可能长期保存，因为那样系统可能会因为文件增长瘫痪的。一般是通过一个Filter在生成响应发送给浏览器后删除本地的临时文件。

这样的话，异步线程的生命周期肯定会超过这个生命周期，因此要在request作用域内把该临时文件先复制到另外的目录下：

def path=request.session.servletContext.getRealPath("/WEB-INF")

def sourceFile=new File("""${path}/${id}.zip""")
def distFile=new File("""${path}/${id}-dist.zip""")

file.transferTo(sourceFile)

下面是完整的生成新zip文件，并且加入文本文件的代码：

executorService.submit(new Runnable(){
            public void run() {
                ZipFile zipFile=new ZipFile(sourceFile)
                ZipOutputStream outputStream=new ZipOutputStream(new FileOutputStream(distFile))
                Enumeration entries=zipFile.entries()
                while(entries.hasMoreElements()){
                    ZipEntry entry=entries.nextElement()
                    entry=new ZipEntry(entry.name)
                    println entry
                    outputStream.putNextEntry(entry)

                    if(!entry.isDirectory()){
                        InputStream inputStream=zipFile.getInputStream(entry)
                        byte[] buffer=new byte[1024*1024]
                        for(int i=inputStream.read(buffer);i!=-1;i=inputStream.read(buffer)){
                            outputStream.write(buffer,0,i)
                        }
                        inputStream.close()
                    }

                    outputStream.closeEntry()
                }
                zipFile.close()

                ZipEntry attachEntry=new ZipEntry("book.plist")
                outputStream.putNextEntry(attachEntry)

                InputStream inputStream=new FileInputStream(attachedFile)

               outputStream.write(getResults(id).getBytes())

                inputStream.close()

                outputStream.closeEntry()

                outputStream.close()
                println ">>>> zip create ok."
            }
        })

其中黑体中调用的是解决动态生成文本的内容，这里假定write方面里面的参数是String即可，是String.getBytes()。

动态生成自定义xml文本

这里可参阅groovy生成xml，这里使用到了MarkupBuilder。

代码如下：

    def getResults(def bookId){
        def writer=new StringWriter()
        def xmlResults=new MarkupBuilder(writer)

        xmlResults.plist(version:1.0){
            dict{
                key ‘key’
                string ’12′
            }
        }

        def content="""<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
${writer}
        """

        return content
    }

 

生成的文本类似这样：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version=’1.0′>
  <dict>
    <key>key</key>
    <string>12</string>
  </dict>
</plist>

完整源代码见：

http://easymorse.googlecode.com/svn/tags/BookProto-0.5/

还是借助编写断点续传客户端代码中的示例。另外，启动Grails项目（Grails实现复杂的数据录入），先测试一下静态资源文件：

链接是：

http://localhost:8080/BookProto/images/grails_logo.png

Grails降级后（Grails从1.4m1版本回退到1.3.7）后会不会使用的是jetty啊，测试一下：

故意找了个错误的链接，好了，确定了Tomcat及其版本。

测试代码和编写断点续传客户端代码中基本一致，除了链接不一样：

public static void receiveBinaryDemo() throws ClientProtocolException, IOException{
    HttpClient httpclient = new DefaultHttpClient();
   HttpGet httpget = new HttpGet("http://localhost:8080/BookProto/images/grails_logo.png");
    httpget.addHeader("Range", "bytes=3-");
    HttpResponse response = httpclient.execute(httpget);
    HttpEntity entity=response.getEntity();
   
    System.out.println("content length: "+entity.getContentLength());
    System.out.println("status code:"+response.getStatusLine().getStatusCode());
   
    if(entity!=null){
        InputStream inputStream=entity.getContent();
        for(int i=inputStream.read(),j=1;i!=-1&&j<12;i=inputStream.read(),j++){
            System.out.println(j+":"+i);
        }
    }
}

取消屏蔽和屏蔽后的结果分别为：

content length: 10172
status code:200
1:137
2:80
3:78
4:71
5:13
6:10
7:26
8:10
9:0
10:0
11:0

content length: 10169
status code:206
1:71
2:13
3:10
4:26
5:10
6:0
7:0
8:0
9:13
10:73
11:72

 

说明静态资源是支持断点续传的。

那Tomcat是否支持动态二进制内容断点续传呢？还是需要自己开发实现？这个疑问等下一篇来实现。

断点续传的基本原理是，客户端在发送请求中可加入比如这样的请求头：

Range: bytes=3-

表示，要服务器发送从第四个字节开始的内容。如果服务器端支持断点续传，则返回响应的码不再是200，而是206。并且发送的内容是从第四个字节开始。

下面编写了两段代码，其中第一段，模拟正常请求，但是在读取到11个字节时停止。

代码如下：

public class HttpClientDemo {
    public static void main(String[] args) throws ClientProtocolException,
            IOException {
        receiveBinaryDemo();
    }
   
    public static void receiveBinaryDemo() throws ClientProtocolException, IOException{
        HttpClient httpclient = new DefaultHttpClient();
        HttpGet httpget = new HttpGet("http://labs.renren.com/apache-mirror//activemq/apache-activemq/5.5.0/activemq-parent-5.5.0-source-release.zip");
       //httpget.addHeader("Range", "bytes=3-");
        HttpResponse response = httpclient.execute(httpget);
        HttpEntity entity=response.getEntity();
       
        System.out.println("content length: "+entity.getContentLength());
        System.out.println("status code:"+response.getStatusLine().getStatusCode());
       
        if(entity!=null){
            InputStream inputStream=entity.getContent();
            for(int i=inputStream.read(),j=1;i!=-1&&j<12;i=inputStream.read(),j++){
                System.out.println(j+":"+i);
            }
        }
    }

 

打印出来的内容：

content length: 13683667
status code:200
1:80
2:75
3:3
4:4
5:10
6:0
7:0
8:0
9:0
10:0
11:115

 

如果把上述代码斜体字行的注释取消，相当于从第四个字节开始读取，输出结果是：

content length: 13683664
status code:206
1:4
2:10
3:0
4:0
5:0
6:0
7:0
8:115
9:152
10:124
11:62

 

说明断点续传成功。

用这个原理，还可以多线程并发下载。

http://labs.renren.com/apache-mirror//activemq/apache-activemq/5.5.0/activemq-parent-5.5.0-source-release.zip

在国内，而且比较快，文件尺寸也合适。

public class HttpClientDemo {
    public static void main(String[] args) throws ClientProtocolException,
            IOException {
        receiveBinaryDemo();
    }
   
    public static void receiveBinaryDemo() throws ClientProtocolException, IOException{
        HttpClient httpclient = new DefaultHttpClient();
        HttpGet httpget = new HttpGet("http://labs.renren.com/apache-mirror//activemq/apache-activemq/5.5.0/activemq-parent-5.5.0-source-release.zip");
        HttpResponse response = httpclient.execute(httpget);
        HttpEntity entity=response.getEntity();
       
        if(entity!=null){
            InputStream inputStream=entity.getContent();
            for(int i=inputStream.read(),j=0;i!=-1&&j<502;i=inputStream.read(),j++){
                System.out.println(i);
            }
        }
    }

这个代码没有什么实际意义，从这个链接下载502个字节。是为我后面编写的代码创建环境。

httpclient在：

http://hc.apache.org/

首先要下载分发包。然后将分发包解压缩，将lib目录下的jar文件，导入到项目中来，比如这样：

代码很简单：

public class HttpClientDemo {
    public static void main(String[] args) throws ClientProtocolException,
            IOException {
        HttpClient httpclient = new DefaultHttpClient();
        HttpGet httpget = new HttpGet("http://marshal.easymorse.com/");
        HttpResponse response = httpclient.execute(httpget);
        HttpEntity entity=response.getEntity();
       
        if(entity!=null){
            System.out.println(EntityUtils.toString(entity));
        }       
    }

打印效果：

Enumeration<NetworkInterface> enumeration= NetworkInterface.getNetworkInterfaces();
while(enumeration.hasMoreElements()){
     NetworkInterface networkInterface=enumeration.nextElement();
     System.out.println(networkInterface);
}

 

在我本机上显示：

name:en1 (en1) index: 5 addresses:
/192.168.0.172;
/fe80:0:0:0:7aca:39ff:feb5:a315%5;

name:lo0 (lo0) index: 1 addresses:
/127.0.0.1;
/fe80:0:0:0:0:0:0:1%1;
/0:0:0:0:0:0:0:1;

 

如果有多个网卡，可以用如下代码指定Socket绑定哪个网卡：

NetworkInterface networkInterface=NetworkInterface.getByName("tiwlan0");

Socket socket=new Socket();
socket.bind(new InetSocketAddress(networkInterface.getInetAddresses().nextElement(),0));
socket.connect(new InetSocketAddress("www.baidu.com", 80));

上面代码使用了网卡名为tiwlan0，然后用这个网卡的第一个ip地址绑定到socket上，使用端口为0表示，让系统来决定具体的端口号。本地端口号是无所谓的。然后连接到百度的80端口。

System.out.println(MessageFormat.format("当前时间：{0,time}", new Date()));

或者，用长整型数也可以：

System.out.println(MessageFormat.format("当前时间：{0,time}", 123456789));

得到的显示类似这样：

当前时间：10:25:44

不过，这个时间显示是带默认时区的，比如在中国，如果按照格林尼治时间是凌晨1点，会调整为上午9点，因为中国是东八区。

在特殊的场合，这种显示就不符合需求了。比如要写个播放器，里面需要显示视频播放的时长。

当然只要会java就可以写出格式化的方法。不过要注意的是，要考虑国际化/本地化的问题，如果在代码中写了本地化的文字提示，或者当前应用的文字，就不大好复用了。

这里写一个简单的代码，供有此需求的人参考：

long time = 1000 * 3600 * 25 + 1000 * 60 * 5 + 1000 * 62;
long sec = 1000;
long min = 1000 * 60;
long hour = min * 60;
System.out.println(MessageFormat.format(
        "{0,number,00}:{1,number,00}:{2,number,00}", time / hour, time
                % hour / min, time % hour % min / sec));

这里的：

{0,number,00}:{1,number,00}:{2,number,00}

是个字符串，是可以抽取出来放在国际化的资源文件里的。

考虑了一下，有两种解决思路：

• 使用JNI，java通过socket获取到流的字节数组，然后通过JNI用本地C编程转换成java可用的数据结构，比如整型数和char数组，这种办法肯定可行，但是需要开发人员会运用C编程，另外这里是Android，还要牵扯到NDK，部署起来也不灵活；
• 使用纯java解决，java将字节数组通过转换和移位等操作转换为java可用的数据，比如long和String，这种办法较好，技术跨度小，部署和移植性好。

本文最终选择了后者实现了处理。

我们碰到的struct结构类似这样：

#define STAFF_ITEM_MAX_LEN      (63)
typedef struct _STAFF_INFO_T
{   
    DWORD dwStaffID;
    TCHAR szTitle[STAFF_ITEM_MAX_LEN + 1];
    TCHAR szName[STAFF_ITEM_MAX_LEN + 1];
} STAFF_INFO, * PSTAFF_INFO;
typedef const PSTAFF

对端的c处理代码：

    STAFF_INFO stf1 = { 0 };
    STAFF_INFO stf2 = { 0 };
    stf1.dwStaffID = 0×12345678;
    _tcscpy_s(stf1.szName, STAFF_ITEM_MAX_LEN, _T("Staff Name"));
    _tcscpy_s(stf1.szTitle, STAFF_ITEM_MAX_LEN, _T("Staff Title"));
    stf2.dwStaffID = 0xABCDEF00;
    _tcscpy_s(stf2.szName, STAFF_ITEM_MAX_LEN, _T("Staff 名称"));
    _tcscpy_s(stf2.szTitle, STAFF_ITEM_MAX_LEN, _T("Staff 头衔"));
    FILE * pf = fopen("R:\\staff_sample.dat", "wb");
    if( NULL != pf )
    {
        fwrite(&stf1, 1, sizeof(stf1), pf);
        fwrite(&stf2, 1, sizeof(stf2), pf);
        fclose(pf);
    }

这里需要处理的数据类型是2种，DWORD和TCHAR。DWORD是无符号的4字节整数，TCHAR在这里确定是Unicode，即wchar（wchar_t）。

查看一下生成的文件情况，DWORD类型的0×12345678，生成的4字节情况：

TCHAR字符的字节，这里拿“头”这个字举例，2字节表示为：

针对DWORD的转换

DWORD类型如果映射到java基本型的话，只有long类型可以对应，long是8字节的有符号表示整数，DWORD是4字节表示无符号整数。其中：

• long的取值范围是2⁶³-1~-2⁶³，这里63是8位/字节*8个字节-1得来的
• DWORD就简单了，是2⁶³

因此这种转换将无法表示DWORD的最大值。

转换的原理是通过左移位运算，将4字节合并到一个long型值中，如果四字节分别是：｛0×12,0×34,0×56,0×78｝，那么先0×12转换为0×12000000，这样它需要左移3个字节长度即3*8=24位，以此类推，然后相加，即0×12000000+0×340000+0×5600+0×78，这样就得到了0×12345678。

这里需要注意，上面说的字节数组示例是为了方便理解，实际上得到的是倒排序的，即｛0×78,0×56,0×34,0×12｝。

从字节数组转long的方法：

public static long dwordBytesToLong(byte[] data) {
    return (data[3] << 8 * 3) + (data[2] << 8 * 2) + (data[1] << 8 )
            + data[0];
}

 

从long到字节数组的方法：

public static byte[] longToDword(long value){
    byte[] data=new byte[4];
   
    for(int i=0;i<data.length;i++){
        data[i]=(byte) (value>>(8*i));
    }
   
    return data;
}

针对TCHAR的转换

VC里的TCHAR转换，如果无条件转换，无论是java还是*nux c都是比较麻烦的。因为TCHAR即可以是ASCII码，也可以是宽字符比如UNICODE，在*nix c中是区分的。还在这里对端肯定传的是unicode，使问题得到简化。

这里不能直接用String的参数是byte[]数组的构造方法，因为String会认为字节数组是字符集编码得到的字节，会自动用默认字符集解码，而struct的TCHAR是c从内存中直接将unicode字符的内存复制出来，就相当于把java的String字符在内存中复制下来一样。

unicode是内存中的字符表示，字符集比如GBK、UTF-8是unicode存储时的编码，二者有区别。

因为内存中unicode是两字节表示一个字符（char），因此将两个字节合并成java中的一个char，然后char数组再转换为字符串。这里要注意，java中的unicode的表示和c内存中位置颠倒，拿上面“头”字举例，字节的16进制表示是：0×5934。

转换TCHAR到字符串的代码：

public static String wcharUnicodeBytesToString(byte[] data) {
    StringBuilder builder = new StringBuilder();

    for (int i = 0; i < data.length; i += 2) {
        if (data[i] == 0xfffffffe) {
            break;
        }
        byte[] temp = new byte[2];
        temp[0] = data[i];
        temp[1] = data[i + 1];
        builder.append(wcharUnicodeBytesToChar(temp));
    }

    return builder.toString();
}

 

private static char wcharUnicodeBytesToChar(byte[] data) {
    char c = (char) (((data[1]) << 8 ) + data[0]);
    return c;
}

将java字符串转换为TCHAR的byte数组代码：

/**
* 将java字符串转换为wchar数组
* @param value
* @param arraySize
* @return
*/
public static byte[] stringToWcharUnicodeBytes(String value,int arraySize){
    char[] valueChars=value.toCharArray();
    byte[] data=new byte[arraySize*2];
    Arrays.fill(data, (byte)0xFE);
   
    for(int i=0;i<valueChars.length && i<arraySize;i++){
        data[i*2]=(byte) valueChars[i];
        data[i*2+1]=(byte)(valueChars[i]>>8);
    }
   
    return data;
}

provider将token号、通知内容、通知形式（比如是否弹出提示窗口、是否发声等）发送给苹果的服务器（apns）。

最简单的provider实现，其实就是通过证书，和苹果服务器建立安全连接（tsl或ssl），通过认证建立连接后，向苹果服务器发送符合苹果要求的数据流。

获得证书

苹果提供两种接入方式的证书：

• developer，用于测试
• production，用于产品

如果是内部测试，使用developer方式即可。

下载证书，通过ios provisioning portal：

这要求：

• 登录的apple developer program帐号必须是级别最高的agent（这是针对企业帐号来说的，如果是个人帐号就无所谓了），agent帐号即创始帐号，否则看不到configure链接；
• 必须经过configure操作，已经enable了developer和product。

然后进入configure链接，点击download按钮即可：

处理证书

如果是编写在mac下跑的objc程序，无需对证书做处理，可跳过这一步。

如果是在java下使用，需要把打证书用的私有专用密钥和上述的支持通知的证书（注意，不是iphone developer证书）合并导出。

生成证书：

点击存储的时候，会提示生成一个文件密码：

当然可以密码为空。

之后会提示：

这里需要输入mac登录用户的密码。

文件生成。

编写发送通知的实例

如果是编写mac代码，有一个现成的项目可用：http://stefan.hafeneger.name/download/PushMeBabySource.zip

导入到xcode中，只需将：

deviceToken填写成设备的token字符串，另外，pathForResource改为上面图中的：

aps_developer_identity

另外，要把刚才获得证书步骤中下载的证书复制到xcode项目Resources目录下：

可以看到文件名和上面的pathForResource的参数一致。

之后运行程序就可以在设备上收到推送通知。

如果是用java编写，可以用第三方库，见：

http://code.google.com/p/javapns/

编写简单的发送通知代码：

import org.json.JSONException;

import javapns.back.PushNotificationManager;
import javapns.back.SSLConnectionHelper;
import javapns.data.Device;
import javapns.data.PayLoad;

public class Main {

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
         PayLoad simplePayLoad = new PayLoad();
        // Get PushNotification Instance
         PushNotificationManager pushManager = PushNotificationManager.getInstance();
         // Link iPhone’s UDID (64-char device token) to a stringName
         pushManager.addDevice("iPhone", "00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 ");
         simplePayLoad.addAlert("My alert message测试");
         simplePayLoad.addBadge(1);
         simplePayLoad.addSound("default");
         Device client = PushNotificationManager.getInstance().getDevice("iPhone");
         PushNotificationManager.getInstance().initializeConnection("gateway.sandbox.push.apple.com", 2195, "/home/ubuntu/mypush.p12", "password", SSLConnectionHelper.KEYSTORE_TYPE_PKCS12);
         PushNotificationManager.getInstance().sendNotification(client, simplePayLoad);

 

测试中文没有乱码问题。

编写比较复杂的使用示例（可以控制通知是否有提示窗口、是否有提醒声音）：

• aPayload.addBadge( 2)，显示在手机应用图标上的数字
• aPayload.addAlert("软件版本有更新")，显示提示窗口文字
• aPayload.addSound("default.wav")，指定提示声音

另外，也可以使用php的第三方实现，比如：

http://code.google.com/p/php-apns

基本原理是启动一个php服务，监控memcacheq队列，如果有消息就发送给苹果服务器。