[转帖]Socket 通信原理(Android客户端和服务器以TCP&&UDP方式互通)_Android, Python及开发编程讨论区_Weblogic技术|Tuxedo技术|中间件技术|Oracle论坛|JAVA论坛|Linux/Unix技术|hadoop论坛_联动北方技术论坛  
网站首页 | 关于我们 | 服务中心 | 经验交流 | 公司荣誉 | 成功案例 | 合作伙伴 | 联系我们 |
联动北方-国内领先的云技术服务提供商
»  游客             当前位置:  论坛首页 »  自由讨论区 »  Android, Python及开发编程讨论区 »
总帖数
1
每页帖数
101/1页1
返回列表
0
发起投票  发起投票 发新帖子
查看: 3396 | 回复: 0   主题: [转帖]Socket 通信原理(Android客户端和服务器以TCP&&UDP方式互通)        下一篇 
huizai
注册用户
等级:少校
经验:933
发帖:83
精华:0
注册:2013-6-18
状态:离线
发送短消息息给huizai 加好友    发送短消息息给huizai 发消息
发表于: IP:您无权察看 2013-6-26 10:16:09 | [全部帖] [楼主帖] 楼主

ZERO、前言

有关通信原理内容是在网上或百科整理得到,代码部分为本人所写,如果不当,还望指教。

一、Socket通信简介 

Android与服务器的通信方式主要有两种,一是Http通信,一是Socket通信。两者的最大差异在于,http连接使用的是“请求—响应方式”,即在请求时建立连接通道,当客户端向服务器发送请求后,服务器端才能向客户端返回数据。而Socket通信则是在双方建立起连接后就可以直接进行数据的传输,在连接时可实现信息的主动推送,而不需要每次由客户端想服务器发送请求。 那么,什么是socket?Socket又称套接字,在程序内部提供了与外界通信的端口,即端口通信。通过建立socket连接,可为通信双方的数据传输传提供通道。socket的主要特点有数据丢失率低,使用简单且易于移植。

1.1什么是Socket Socket
是一种抽象层,应用程序通过它来发送和接收数据,使用Socket可以将应用程序添加到网络中,与处于同一网络中的其他应用程序进行通信。简单来说,Socket提供了程序内部与外界通信的端口并为通信双方的提供了数据传输通道。

    1.2Socket的分类
 根据不同的的底层协议,Socket的实现是多样化的。本指南中只介绍TCP/IP协议族的内容,在这个协议族当中主要的Socket类型为流套接字(streamsocket)和数据报套接字(datagramsocket)。流套接字将TCP作为其端对端协议,提供了一个可信赖的字节流服务。数据报套接字使用UDP协议,提供数据打包发送服务。 下面,我们来认识一下这两种Socket类型的基本实现模型。

二、Socket 基本通信模型

北京联动北方科技有限公司

三、Socket基本实现原理

    3.1基于TCP协议的Socket 
服务器端首先声明一个ServerSocket对象并且指定端口号,然后调用Serversocket的accept()方法接收客户端的数据。accept()方法在没有数据进行接收的处于堵塞状态。(Socketsocket=serversocket.accept()),一旦接收到数据,通过inputstream读取接收的数据。
  客户端创建一个Socket对象,指定服务器端的ip地址和端口号(Socketsocket=newSocket("172.168.10.108",8080);),通过inputstream读取数据,获取服务器发出的数据(OutputStreamoutputstream=socket.getOutputStream()),最后将要发送的数据写入到outputstream即可进行TCP协议的socket数据传输。
3.2基于UDP协议的数据传输 
服务器端首先创建一个DatagramSocket对象,并且指点监听的端口。接下来创建一个空的DatagramSocket对象用于接收数据(bytedata[]=newbyte[1024;]DatagramSocketpacket=newDatagramSocket(data,data.length)),使用DatagramSocket的receive方法接收客户端发送的数据,receive()与serversocket的accepet()类似,在没有数据进行接收的处于堵塞状态。
客户端也创建个DatagramSocket对象,并且指点监听的端口。接下来创建一个InetAddress对象,这个对象类似与一个网络的发送地址(InetAddressserveraddress=InetAddress.getByName("172.168.1.120")).定义要发送的一个字符串,创建一个DatagramPacket对象,并制定要讲这个数据报包发送到网络的那个地址以及端口号,最后使用DatagramSocket的对象的send()发送数据。*(Stringstr="hello";bytedata[]=str.getByte();DatagramPacketpacket=new DatagramPacket(data,data.length,serveraddress,4567);socket.send(packet);)

四、android 实现socket简单通信

前言:添加权限

[java]view plaincopyprint?

  1. <!--允许应用程序改变网络状态-->    
  2. <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>    
  3. <!--允许应用程序改变WIFI连接状态-->    
  4. <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>    
  5. <!--允许应用程序访问有关的网络信息-->    
  6. <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>    
  7. <!--允许应用程序访问WIFI网卡的网络信息-->    
  8. <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>    
  9. <!--允许应用程序完全使用网络-->    
  10. <uses-permission android:name="android.permission.INTERNET"/>    

<!--允许应用程序改变网络状态-->
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>

<!--允许应用程序改变WIFI连接状态-->
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>

<!--允许应用程序访问有关的网络信息-->
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>

<!--允许应用程序访问WIFI网卡的网络信息-->
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>

<!--允许应用程序完全使用网络-->
<uses-permission android:name="android.permission.INTERNET"/>

;

4.1使用TCP协议通信

android端实现:

[java]view plaincopyprint?

  1.  protected void connectServerWithTCPSocket() { 
  2.       
  3.        Socket socket; 
  4.        try {// 创建一个Socket对象,并指定服务端的IP及端口号 
  5.              socket = new Socket("192.168.1.32", 1989); 
  6.              // 创建一个InputStream用户读取要发送的文件。 
  7.              InputStream inputStream = new FileInputStream("e://a.txt"); 
  8.              // 获取Socket的OutputStream对象用于发送数据。 
  9.              OutputStream outputStream = socket.getOutputStream(); 
  10.              // 创建一个byte类型的buffer字节数组,用于存放读取的本地文件 
  11.              byte buffer[] = new byte[4 * 1024]; 
  12.              int temp = 0; 
  13.              // 循环读取文件 
  14.              while ((temp = inputStream.read(buffer)) != -1) { 
  15.                    // 把数据写入到OuputStream对象中 
  16.                    outputStream.write(buffer, 0, temp); 
  17.              } 
  18.              // 发送读取的数据到服务端 
  19.              outputStream.flush(); 
  20.             
  21.              /** 或创建一个报文,使用BufferedWriter写入,看你的需求 **/ 
  22.             // String socketData = "[2143213;21343fjks;213]"; 
  23.             // BufferedWriter writer = new BufferedWriter(new OutputStreamWriter( 
  24.             // socket.getOutputStream())); 
  25.             // writer.write(socketData.replace("\n", " ") + "\n"); 
  26.             // writer.flush(); 
  27.              /************************************************/ 
  28.        } catch (UnknownHostException e) { 
  29.              e.printStackTrace(); 
  30.        } catch (IOException e) { 
  31.              e.printStackTrace(); 
  32.        } 
  33.       
  34.  } 


protected void connectServerWithTCPSocket() {

       Socket socket;
       try {// 创建一个Socket对象,并指定服务端的IP及端口号
             socket = new Socket("192.168.1.32", 1989);
             // 创建一个InputStream用户读取要发送的文件。
             InputStream inputStream = new FileInputStream("e://a.txt");
             // 获取Socket的OutputStream对象用于发送数据。
             OutputStream outputStream = socket.getOutputStream();
             // 创建一个byte类型的buffer字节数组,用于存放读取的本地文件
             byte buffer[] = new byte[4 * 1024];
             int temp = 0;
             // 循环读取文件
             while ((temp = inputStream.read(buffer)) != -1) {
                   // 把数据写入到OuputStream对象中
                   outputStream.write(buffer, 0, temp);
             }
             // 发送读取的数据到服务端
             outputStream.flush();

             /** 或创建一个报文,使用BufferedWriter写入,看你的需求 **/
            // String socketData = "[2143213;21343fjks;213]";
            // BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(
            // socket.getOutputStream()));
            // writer.write(socketData.replace("\n", " ") + "\n");
            // writer.flush();
             /************************************************/
       } catch (UnknownHostException e) {
       e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}

}

;

服务器端简单实现:

[java]

  1. public void ServerReceviedByTcp() { 
  2.        // 声明一个ServerSocket对象 
  3.        ServerSocket serverSocket = null; 
  4.        try { 
  5.              // 创建一个ServerSocket对象,并让这个Socket在1989端口监听 
  6.              serverSocket = new ServerSocket(1989); 
  7.              // 调用ServerSocket的accept()方法,接受客户端所发送的请求, 
  8.              // 如果客户端没有发送数据,那么该线程就停滞不继续 
  9.              Socket socket = serverSocket.accept(); 
  10.              // 从Socket当中得到InputStream对象 
  11.              InputStream inputStream = socket.getInputStream(); 
  12.              byte buffer[] = new byte[1024 * 4]; 
  13.              int temp = 0; 
  14.              // 从InputStream当中读取客户端所发送的数据 
  15.              while ((temp = inputStream.read(buffer)) != -1) { 
  16.                    System.out.println(new String(buffer, 0, temp)); 
  17.              } 
  18.              serverSocket.close(); 
  19.        } catch (IOException e) { 
  20.              e.printStackTrace(); 
  21.        } 


public void ServerReceviedByTcp() {
       // 声明一个ServerSocket对象
       ServerSocket serverSocket = null;
       try {
             // 创建一个ServerSocket对象,并让这个Socket在1989端口监听
             serverSocket = new ServerSocket(1989);
             // 调用ServerSocket的accept()方法,接受客户端所发送的请求,
             // 如果客户端没有发送数据,那么该线程就停滞不继续
             Socket socket = serverSocket.accept();
             // 从Socket当中得到InputStream对象
             InputStream inputStream = socket.getInputStream();
             byte buffer[] = new byte[1024 * 4];
             int temp = 0;
             // 从InputStream当中读取客户端所发送的数据
             while ((temp = inputStream.read(buffer)) != -1) {
                   System.out.println(new String(buffer, 0, temp));
             }
             serverSocket.close();
       } catch (IOException e) {
       e.printStackTrace();
}
}

;

4.2使用UDP协议通信

客户端发送数据实现:

[java]

  1. protected void connectServerWithUDPSocket() { 
  2.       
  3.        DatagramSocket socket; 
  4.        try { 
  5.              //创建DatagramSocket对象并指定一个端口号,注意,如果客户端需要接收服务器的返回数据, 
  6.              //还需要使用这个端口号来receive,所以一定要记住 
  7.              socket = new DatagramSocket(1985); 
  8.              //使用InetAddress(Inet4Address).getByName把IP地址转换为网络地址 
  9.              InetAddress serverAddress = InetAddress.getByName("192.168.1.32"); 
  10.              //Inet4Address serverAddress = (Inet4Address) Inet4Address.getByName("192.168.1.32"); 
  11.              String str = "[2143213;21343fjks;213]";//设置要发送的报文 
  12.              byte data[] = str.getBytes();//把字符串str字符串转换为字节数组 
  13.              //创建一个DatagramPacket对象,用于发送数据。 
  14.              //参数一:要发送的数据 参数二:数据的长度 参数三:服务端的网络地址 参数四:服务器端端口号 
  15.              DatagramPacket packet = new DatagramPacket(data, data.length ,serverAddress ,10025); 
  16.              socket.send(packet);//把数据发送到服务端。 
  17.        } catch (SocketException e) { 
  18.              e.printStackTrace(); 
  19.        } catch (UnknownHostException e) { 
  20.              e.printStackTrace(); 
  21.        } catch (IOException e) { 
  22.              e.printStackTrace(); 
  23.        } 


protected void connectServerWithUDPSocket() {

       DatagramSocket socket;
       try {
             //创建DatagramSocket对象并指定一个端口号,注意,如果客户端需要接收服务器的返回数据,
             //还需要使用这个端口号来receive,所以一定要记住
             socket = new DatagramSocket(1985);
             //使用InetAddress(Inet4Address).getByName把IP地址转换为网络地址
             InetAddress serverAddress = InetAddress.getByName("192.168.1.32");
             //Inet4Address serverAddress = (Inet4Address) Inet4Address.getByName("192.168.1.32");
             String str = "[2143213;21343fjks;213]";//设置要发送的报文
             byte data[] = str.getBytes();//把字符串str字符串转换为字节数组
             //创建一个DatagramPacket对象,用于发送数据。
             //参数一:要发送的数据 参数二:数据的长度 参数三:服务端的网络地址 参数四:服务器端端口号
             DatagramPacket packet = new DatagramPacket(data, data.length ,serverAddress ,10025);
             socket.send(packet);//把数据发送到服务端。
       } catch (SocketException e) {
       e.printStackTrace();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
       e.printStackTrace();
}
}

;

客户端接收服务器返回的数据:

[java]

  1. public void ReceiveServerSocketData() { 
  2.        DatagramSocket socket; 
  3.        try { 
  4.              //实例化的端口号要和发送时的socket一致,否则收不到data 
  5.              socket = new DatagramSocket(1985); 
  6.              byte data[] = new byte[4 * 1024]; 
  7.              //参数一:要接受的data 参数二:data的长度 
  8.              DatagramPacket packet = new DatagramPacket(data, data.length); 
  9.              socket.receive(packet); 
  10.              //把接收到的data转换为String字符串 
  11.              String result = new String(packet.getData(), packet.getOffset(), 
  12.              packet.getLength()); 
  13.              socket.close();//不使用了记得要关闭 
  14.              System.out.println("the number of reveived Socket is :" + flag 
  15.              + "udpData:" + result); 
  16.        } catch (SocketException e) { 
  17.              e.printStackTrace(); 
  18.        } catch (IOException e) { 
  19.              e.printStackTrace(); 
  20.        } 


public void ReceiveServerSocketData() {
       DatagramSocket socket;
       try {
             //实例化的端口号要和发送时的socket一致,否则收不到data
             socket = new DatagramSocket(1985);
             byte data[] = new byte[4 * 1024];
             //参数一:要接受的data 参数二:data的长度
             DatagramPacket packet = new DatagramPacket(data, data.length);
             socket.receive(packet);
             //把接收到的data转换为String字符串
             String result = new String(packet.getData(), packet.getOffset(),
             packet.getLength());
             socket.close();//不使用了记得要关闭
             System.out.println("the number of reveived Socket is :" + flag
             + "udpData:" + result);
       } catch (SocketException e) {
       e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

;

服务器接收客户端实现:

[java]

  1. public void ServerReceviedByUdp(){ 
  2.        //创建一个DatagramSocket对象,并指定监听端口。(UDP使用DatagramSocket) 
  3.        DatagramSocket socket; 
  4.        try { 
  5.              socket = new DatagramSocket(10025); 
  6.              //创建一个byte类型的数组,用于存放接收到得数据 
  7.              byte data[] = new byte[4*1024]; 
  8.              //创建一个DatagramPacket对象,并指定DatagramPacket对象的大小 
  9.              DatagramPacket packet = new DatagramPacket(data,data.length); 
  10.              //读取接收到得数据 
  11.              socket.receive(packet); 
  12.              //把客户端发送的数据转换为字符串。 
  13.              //使用三个参数的String方法。参数一:数据包 参数二:起始位置 参数三:数据包长 
  14.              String result = new String(packet.getData(),packet.getOffset() ,packet.getLength()); 
  15.        } catch (SocketException e) { 
  16.              e.printStackTrace(); 
  17.        } catch (IOException e) { 
  18.              e.printStackTrace(); 
  19.        } 


public void ServerReceviedByUdp(){
       //创建一个DatagramSocket对象,并指定监听端口。(UDP使用DatagramSocket)
       DatagramSocket socket;
       try {
             socket = new DatagramSocket(10025);
             //创建一个byte类型的数组,用于存放接收到得数据
             byte data[] = new byte[4*1024];
             //创建一个DatagramPacket对象,并指定DatagramPacket对象的大小
             DatagramPacket packet = new DatagramPacket(data,data.length);
             //读取接收到得数据
             socket.receive(packet);
             //把客户端发送的数据转换为字符串。
             //使用三个参数的String方法。参数一:数据包 参数二:起始位置 参数三:数据包长
             String result = new String(packet.getData(),packet.getOffset() ,packet.getLength());
       } catch (SocketException e) {
       e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

;

五、总结:

使用UDP方式android端和服务器端接收可以看出,其实android端和服务器端的发送和接收大庭相径,只要端口号正确了,相互通信就没有问题,TCP使用的是流的方式发送,UDP是以包的形式发送。

demo地址:http://download.csdn.net/detail/mad1989/5626975




赞(0)    操作        顶端 
总帖数
1
每页帖数
101/1页1
返回列表
发新帖子
请输入验证码: 点击刷新验证码
您需要登录后才可以回帖 登录 | 注册
技术讨论