java Socket简单用法 && Android使用socket使底层和framework通信

          Socket通常也称做”套接字“，用于描述IP地址和端口，废话不多说，它就是网络通信过程中端点的抽象表示。值得一提的是，Java在包java.net中提供了两个类Socket和ServerSocket，分别用来表示双向连接的客户端和服务端。这是两个封装得非常好的类，使用起来很方便！

         下面将首先创建一个SocketServer的类作为服务端如下，该服务端实现了多线程机制，可以在特定端口处监听多个客户请求，一旦有客户请求，Server总是会创建一个服务纯种来服务新来的客户，而自己继续监听。程序中accept()是一个阻塞函数，所谓阻塞性方法就是说该方法被调用后将等待客户的请求，直到有一个客户启动并请求连接到相同的端口，然后accept()返回一个对应于客户的Socket。这时，客户方和服务方都建立了用于通信的Socket，接下来就是由各个Socket分别打开各自的输入、输出流。

（1）服务器端SocketServer类

import java.io.*;
import java.net.*;

public class SocketServer {
	ServerSocket sever;
    
    public SocketServer(int port){
        try{
            sever = new ServerSocket(port);
        }catch(IOException e){
            e.printStackTrace();
        }
    }
    
    public void beginListen(){
        while(true){
            try{
                final Socket socket = sever.accept();
                
                new Thread(new Runnable(){
                    public void run(){
                        BufferedReader in;
                        try{
                            in = new BufferedReader(new InputStreamReader(socket.getInputStream(),"UTF-8"));
                            PrintWriter out = new PrintWriter(socket.getOutputStream());
                            while (!socket.isClosed()){
                                String str;
                                str = in.readLine();
                                out.println("Hello!world!! " + str);
                                out.flush();
                                if (str == null || str.equals("end"))
                                    break;
                                System.out.println(str);
                            }
                            socket.close();
                        }catch(IOException e){
                            e.printStackTrace();
                        }
                    }
                }).start();
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }
}

      服务器端测试代码执行

public class TestSocketServer {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        SocketServer server = new SocketServer(12345);
        server.beginListen();
	}
}

（2）客户端SocketClient类

import java.io.*;
import java.net.*;

public class SocketClient {
static Socket client;
    
    public SocketClient(String site, int port){
        try{
            client = new Socket(site,port);
            System.out.println("Client is created! site:"+site+" port:"+port);
        }catch (UnknownHostException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
    
    public String sendMsg(String msg){
        try{
            BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
            PrintWriter out = new PrintWriter(client.getOutputStream());
            out.println(msg);
            out.flush();
            return in.readLine();
        }catch(IOException e){
            e.printStackTrace();
        }
        return "";
    }
    public void closeSocket(){
        try{
            client.close();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

      客户端测试代码执行

public class TestSocketClient {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SocketClient client = new SocketClient("127.0.0.1",12345);
        System.out.println(client.sendMsg("nimei1"));
        client.closeSocket();
        
        SocketClient client1 = new SocketClient("127.0.0.1",12345);
        System.out.println(client1.sendMsg("nimei1111"));
        client1.closeSocket();
        
        SocketClient client11 = new SocketClient("127.0.0.1",12345);
        System.out.println(client11.sendMsg("nimei11111111"));
        client11.closeSocket();
        
        SocketClient client111 = new SocketClient("127.0.0.1",12345);
        System.out.println(client111.sendMsg("nimei11111111111111111"));
        client111.closeSocket();
	}
}

（3）单机上执行结果 

       服务器端只需执行一次，执行多次会提示：java.net.BindException: Address already in use: JVM_Bind。执行客户端时，会在控制台显示如下信息

Client is created! site:127.0.0.1 port:12345
Hello!world!! nimei1
Client is created! site:127.0.0.1 port:12345
Hello!world!! nimei1111
Client is created! site:127.0.0.1 port:12345
Hello!world!! nimei11111111
Client is created! site:127.0.0.1 port:12345
Hello!world!! nimei11111111111111111

参考原文：http://www.cnblogs.com/harrisonpc/archive/2011/03/31/2001565.html

参考原文：http://my.oschina.net/hes/blog/158404

========================================================================================================

 （1）一般的native和framework的通信是通过jni，但是这一般只是framework调用native，native如果有消息要怎样通知上层呢？
        这里介绍一种使用socket通信的方法可以使native和framework自由通信，具体实现如下：由于android是基于linux的，所以linux的代码会在java之前先执行，所以一般native端是服务器，framework端是客户端。
native层主要代码：
1.s_fdListen = android_get_control_socket(SOCKET_NAME);
2.ret = listen(s_fdListen, n);
3.s_fdCommand = accept(s_fdListen, (sockaddr *) &peeraddr, &socklen);
        如果连接没有问题就可以使用linux中的write/read来对socket进行读和写了。
  java层主要代码： 
1.LocalSocket s =null;
2.LocalSocketAddress l;
3.s = new LocalSocket();
4.l = new LocalSocketAddress(SOCKET_NAME,LocalSocketAddress.Namespace.RESERVED);
5.s.connect(l);
到此时如果socket连接没有问题，就可以像正常的读写了。当以LocalSocketAddress.Namespace.RESERVED为创建socket时的属性时，会在/dev/socket/下面创建一个socket文件。
（2）这里有必要解释一下SOCKET_NAME，它的值是一个字符串，服务端和客户端SOCKET_NAME的定义必须一致，在/dev/socket下可以找到这个字串，表明创建成功，前提是修改init.rc中来申请我们需要的socket资源。假设native层代码生成的bin是upcomm，init.rc申明
service upcomm  /system/bin/upcomm
class main
 socket upcommcommsocket stream 666 system system
user root
oneshot
这里的oneshot必须有，没有的话，你的server很可能起不来。一个实际的源码例子http://blog.csdn.net/goleftgoright/article/details/7406292

参考原文：http://www.linuxidc.com/Linux/2011-03/33473.htm