开发者社区> 迅雷老曾> 正文

Java4Android之socket网络通信基础

简介:
+关注继续查看

本节主要介绍Socket编程,发现Java里面的socket编程和C语言的还是有一些不一样,比如TCP socket ,在Java中区分了serverSocket。不过原理都一样,在流程处理上也非常相似,所以,理解起来并不难。我们会先从基础说起,从如何建立socket连接,到如何实现一个合理的设计例如在android中,我们发送一条消息,然后监听一个回复,如何做到不卡死UI,本文将会由浅入深的为大家呈现一个相对完整的android socket编程。

在进入Java 的socket编程之前,我们从原理上切入,然后提及相应的代码说明。

Socket可以说是一种针对网络的抽象,应用通过它可以来针对网络读写数据。就像通过一个文件的file handler就可以都写数据到存储设备上一样。根据TCP协议和UDP协议的不同,在网络编程方面就有面向两个协议的不同socket,一个是面向字节流的一个是面向报文的


TCP

  TCP主要是面向连接的协议,它包含有建立和拆除连接,保证数据流的顺序和正确性等功能。每次对TCP中间的数据操作相当于对一个数据流进行访问。它最典型的特征就是那三次握手的建立连接过程。TCP的连接建立和撤销过程如下图:

tcp

Server端

Server端所要做的事情主要是建立一个通信的端点,然后等待客户端发送的请求。典型的处理步骤如下:
1. 构建一个ServerSocket实例,指定本地的端口。这个socket就是用来监听指定端口的连接请求的。
2.重复如下几个步骤:
a. 调用socket的accept()方法来获得下面客户端的连接请求。通过accept()方法返回的socket实例,建立了一个和客户端的新连接。
b.通过这个返回的socket实例获取InputStream和OutputStream,可以通过这两个stream来分别读和写数据。
c.结束的时候调用socket实例的close()方法关闭socket连接。
 

单线程版本


这个流程的典型示例代码如下:

//1. 构造ServerSocket实例,指定服务端口。
ServerSocket servSock = new ServerSocket(servPort);


while(true)
{
	   // 2.调用accept方法,建立和客户端的连接
           Socket clntSock = servSock.accept();
           SocketAddress clientAddress =    
                clntSock.getRemoteSocketAddress();
           System.out.println("Handling client at " + clientAddress);

	    // 3. 获取连接的InputStream,OutputStream来进行数据读写
            InputStream in = clntSock.getInputStream();
            OutputStream out = clntSock.getOutputStream();

            while((recvMsgSize = in.read(receiveBuf)) != -1)
            {
                out.write(receiveBuf, 0, recvMsgSize);
            }   
	    // 4.操作结束,关闭socket.
            clntSock.close();
}  

多线程版本

上述是单线程版本的服务器流程,也可是是多线程的。大体代码如下:

try   
{ file://建立服务器    
 ServerSocket server = new ServerSocket(9998);    
 int i=1;    
 for(;;)    
 {    
<span style="white-space:pre">	</span>Socket incoming = server.accept();    
<span style="white-space:pre">	</span>new ServerThread(incoming,i).start();    //开启线程来处理客户端的请求
<span style="white-space:pre">	</span>i++;    
 }    
}catch (IOException ex){ ex.printStackTrace(); }   

Client端

客户端的请求过程稍微有点不一样:
1.构建Socket实例,通过指定的远程服务器地址和端口来建立连接。
2.通过Socket实例包含的InputStream和OutputStream来进行数据的读写。
3.操作结束后调用socket实例的close方法,关闭。
示例代码如下;

// 1.根据指定的server地址和端口,建立socket连接。
Socket socket = new Socket(server, servPort);

// 2. 根据socket实例获取InputStream, OutputStream进行数据读写。
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();
out.write(data);

//3.操作结束,关闭socket.
socket.close();


上述代码就是一个完整的客户端/服务器结构的socket通信代码。



不卡死UI的socket设计

但是,在android中的socket通信中,我们可以想象一下这样的场景。我在EditText里面输入了一句“你好”,然后我按发送Button按钮,就把消息发送给了远端的服务器,然后服务器给我回了一个“你好,欢迎您!”。我们发送完第一条信息的时候,我们要阻塞在那里等服务器的话,会发生什么?我们 UI是不是会卡死?所以,很明显,这样的设计是不合理的。

客户端


MyClientActivity.java文件,主要是定义了一个继承自Thread类的用于接收数据的类,覆写了其中的run()方法,在这个函数里面接收数据,接收到数据后就通过Handler发送消息,收到消息后在UI线程里更新接收到的数据。完整的内容如下:
package com.nan.client;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.Socket;
import java.net.UnknownHostException;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;


public class MyClientActivity extends Activity 
{
    private EditText mEditText = null;
    private Button connectButton = null;
    private Button sendButton = null;
    private TextView mTextView = null;
    
    private Socket clientSocket = null;
    private OutputStream outStream = null;
    
    private Handler mHandler = null;
    
    private ReceiveThread mReceiveThread = null;
    private boolean stop = true;
    
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) 
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        mEditText = (EditText)this.findViewById(R.id.edittext);
        mTextView = (TextView)this.findViewById(R.id.retextview);
        connectButton = (Button)this.findViewById(R.id.connectbutton);
        sendButton = (Button)this.findViewById(R.id.sendbutton);
        sendButton.setEnabled(false);      
        
        //连接按钮监听
        connectButton.setOnClickListener(new View.OnClickListener() 
        {
            
            @Override
            public void onClick(View v) 
            {
                // TODO Auto-generated method stub
                try 
                {
                    //实例化对象并连接到服务器
                    clientSocket = new Socket("113.114.170.246",8888);
                } 
                catch (UnknownHostException e) 
                {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } 
                catch (IOException e) 
                {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
                displayToast("连接成功!");                        
                //连接按钮使能
                connectButton.setEnabled(false);
                //发送按钮使能
                sendButton.setEnabled(true);
                
                mReceiveThread = new ReceiveThread(clientSocket);
                stop = false;
                //开启线程
                mReceiveThread.start();
            }
        });
        
        //发送数据按钮监听
        sendButton.setOnClickListener(new View.OnClickListener() 
        {
            
            @Override
            public void onClick(View v) 
            {
                // TODO Auto-generated method stub
                byte[] msgBuffer = null;
                //获得EditTex的内容
                String text = mEditText.getText().toString();
                try {
                    //字符编码转换
                    msgBuffer = text.getBytes("GB2312");
                } catch (UnsupportedEncodingException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
                            
                
                try {
                    //获得Socket的输出流
                    outStream = clientSocket.getOutputStream();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }                                                    
                
                
                try {
                    //发送数据
                    outStream.write(msgBuffer);
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                //清空内容
                mEditText.setText("");
                displayToast("发送成功!");
            }
        });
              
        //消息处理
        mHandler = new Handler()
        {
            @Override
            public void handleMessage(Message msg)
            {
                //显示接收到的内容
                mTextView.setText((msg.obj).toString());
            }
        };
        
    }
    
    //显示Toast函数
    private void displayToast(String s)
    {
        Toast.makeText(this, s, Toast.LENGTH_SHORT).show();
    }
    
    
    private class ReceiveThread extends Thread
    {
        private InputStream inStream = null;
        
        private byte[] buf;  
        private String str = null;
        
        ReceiveThread(Socket s)
        {
            try {
                //获得输入流
                this.inStream = s.getInputStream();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }      
        
        @Override
        public void run()
        {
            while(!stop)
            {
                this.buf = new byte[512];
                
                try {
                    //读取输入数据(阻塞)
                    this.inStream.read(this.buf);
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } 
                
                //字符编码转换
                try {
                    this.str = new String(this.buf, "GB2312").trim();
                } catch (UnsupportedEncodingException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
                Message msg = new Message();
                msg.obj = this.str;
                //发送消息
                mHandler.sendMessage(msg);
                
            }
        }
        
        
    }
    
    @Override
    public void onDestroy()
    {
        super.onDestroy();
        
        if(mReceiveThread != null)
        {
            stop = true;
            mReceiveThread.interrupt();
        }
    }
     
}

服务端

MyServerActivity.java文件,定义了两个Thread子类,一个用于监听客户端的连接,一个用于接收数据,其他地方与MyClientActivity.java差不多。完整的内容如下:
package com.nan.server;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.ServerSocket;
import java.net.Socket;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;


public class MyServerActivity extends Activity 
{
    private TextView ipTextView = null;
    private EditText mEditText = null;
    private Button sendButton = null;
    private TextView mTextView = null;
    
    private OutputStream outStream = null;
    private Socket clientSocket = null;
    private ServerSocket mServerSocket = null;
    
    private Handler mHandler = null;
    
    private AcceptThread mAcceptThread = null;
    private ReceiveThread mReceiveThread = null;
    private boolean stop = true;
    
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) 
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        ipTextView = (TextView)this.findViewById(R.id.iptextview);
        mEditText = (EditText)this.findViewById(R.id.sedittext);
        sendButton = (Button)this.findViewById(R.id.sendbutton);
        sendButton.setEnabled(false);
        mTextView = (TextView)this.findViewById(R.id.textview);
        
        //发送数据按钮监听
        sendButton.setOnClickListener(new View.OnClickListener() 
        {
            
            @Override
            public void onClick(View v) 
            {
                // TODO Auto-generated method stub
                byte[] msgBuffer = null;
                //获得EditTex的内容
                String text = mEditText.getText().toString();
                try {
                    //字符编码转换
                    msgBuffer = text.getBytes("GB2312");
                } catch (UnsupportedEncodingException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
                            
                
                try {
                    //获得Socket的输出流
                    outStream = clientSocket.getOutputStream();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }                                                    
                
                
                try {
                    //发送数据
                    outStream.write(msgBuffer);
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                //清空内容
                mEditText.setText("");
                displayToast("发送成功!");
                
            }
        });
        //消息处理
        mHandler = new Handler()
        {
            @Override
            public void handleMessage(Message msg)
            {
                switch(msg.what)
                {
                    case 0:
                    {
                        //显示客户端IP
                        ipTextView.setText((msg.obj).toString());
                        //使能发送按钮
                        sendButton.setEnabled(true);
                        break;
                    }
                    case 1:
                    {
                        //显示接收到的数据
                        mTextView.setText((msg.obj).toString());
                        break;
                    }                 
                }                                           
                
            }
        };
        
        
        mAcceptThread = new AcceptThread();
        //开启监听线程
        mAcceptThread.start();
              
    }
    
    //显示Toast函数
    private void displayToast(String s)
    {
        Toast.makeText(this, s, Toast.LENGTH_SHORT).show();
    }
    
    
    private class AcceptThread extends Thread
    {
        @Override
        public void run()
        {
            try {
                //实例化ServerSocket对象并设置端口号为8888
                mServerSocket = new ServerSocket(8888);
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            while(1)
{
            try {
                //等待客户端的连接(阻塞)
                clientSocket = mServerSocket.accept();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
            mReceiveThread = new ReceiveThread(clientSocket);
            stop = false;
            //开启接收线程
            mReceiveThread.start();
            
            Message msg = new Message();
            msg.what = 0;
            //获取客户端IP
            msg.obj = clientSocket.getInetAddress().getHostAddress();
            //发送消息
            mHandler.sendMessage(msg);
  }
        }
        
    }
    
    
    private class ReceiveThread extends Thread
    {
        private InputStream mInputStream = null;
        private byte[] buf ;  
        private String str = null;
        
        ReceiveThread(Socket s)
        {
            try {
                //获得输入流
                this.mInputStream = s.getInputStream();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
        @Override
        public void run()
        {
            while(!stop)
            {
                this.buf = new byte[512];
                
                //读取输入的数据(阻塞读)
                try {
                    this.mInputStream.read(buf);
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
                
                //字符编码转换
                try {
                    this.str = new String(this.buf, "GB2312").trim();
                } catch (UnsupportedEncodingException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
                Message msg = new Message();
                msg.what = 1;        
                msg.obj = this.str;
                //发送消息
                mHandler.sendMessage(msg);
                
            }
        }
    }
    
      
    @Override
    public void onDestroy()
    {
        super.onDestroy();
        
        if(mReceiveThread != null)
        {
            stop = true;
            mReceiveThread.interrupt();
        }
    }
    
    
}
上述代码就是实现了真实环境下android的socket通信。

UDP

UDP和TCP有两个典型的区别,一个就是它不需要建立连接,另外就是它在每次收发的报文都保留了消息的边界。

server端

因为UDP协议不需要建立连接,它的过程如下:
1. 构造DatagramSocket实例,指定本地端口。
2. 通过DatagramSocket实例的receive方法接收DatagramPacket.DatagramPacket中间就包含了通信的内容。
3. 通过DatagramSocket的send和receive方法来收和发DatagramPacket.
典型的交互流程代码如下:
// 1. 构建DatagramSocket实例,指定本地端口。
DatagramSocket socket = new DatagramSocket(servPort);

// 2. 构建需要收发的DatagramPacket报文
DatagramPacket packet = new DatagramPacket(new byte[ECHOMAX], ECHOMAX);

while(true)
{
	// 3. 收报文
	socket.receive(packet);
	System.out.println("Handling client at " + packet.getAddress().getHostAddress()
	    + " on port " + packet.getPort());
	// 4. 发报文
	socket.send(packet);
	packet.setLength(ECHOMAX);
}

client端

UDP客户端的步骤也比较简单,主要包括下面3步:
1. 构造DatagramSocket实例。
2.通过DatagramSocket实例的send和receive方法发送DatagramPacket报文。
3.结束后,调用DatagramSocket的close方法关闭。
因为和TCP不同,UDP发送报文的时候可以在同一个本地端口随意发送给不同的服务器,一般不需要在UDP的DatagramSocket的构造函数中指定目的服务器的地址。
另外,UDP客户端还有一个重要的不同就是,TCP客户端发送echo连接消息之后会在调用read方法的时候进入阻塞状态,而UDP这样却不行。因为UDP中间是可以允许报文丢失的。如果报文丢失了,进程一直在阻塞或者挂起的状态,则进程会永远没法往下走了。所以会一般设置一个setSoTimeout方法,指定在多久的时间内没有收到报文就放弃。也可以通过指定一个数字,循环指定的次数来读取报文,读到就返回,否则就放弃。
 
一个典型的UDP Client代码示例如下:

// 1. 构造UDP DatagramSocket对象
DatagramSocket socket = new DatagramSocket();

// 2。指定timeout时间,防止进入无限等待状态
socket.setSoTimeout(TIMEOUT);

// 3. 构造收发的报文对象
DatagramPacket sendPacket = new DatagramPacket(bytesToSend,
    bytesToSend.length, serverAddress, servPort);
DatagramPacket receivePacket =
    new DatagramPacket(new byte[bytesToSend.length], bytesToSend.length);

// 4.指定尝试的次数
int tries = 0;
boolean receivedResponse = false;
 do
{
	socket.send(sendPacket);
	try
	{
		socket.receive(receivePacket);
 
		if(!receivePacket.getAddress().equals(serverAddress))
		{
			throw new IOException("Received packet from an unknown source");
		}
		receivedResponse = true;
	}
	catch(InterruptedIOException e)
	{
		tries += 1;
		System.out.println("Timed out, " + (MAXTRIES - tries) + "");
	}
}while((!receivedResponse) && (tries < MAXTRIES));

// 根据是否接收到报文进行反馈
if(receivedResponse)
{
	System.out.println("Received: " + new String(receivePacket.getData()));
}
else
{
	System.out.println("No response -- giving up.");
}

// 5. 关闭socket
socket.close();

这次的socket编程就说道这里,里面参考和引用转载了不少别人的东西,mark一下。

Reference:

http://shmilyaw-hotmail-com.iteye.com/blog/1556187

http://www.cnblogs.com/lknlfy/archive/2012/03/04/2379628.html




版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
使用OpenApi弹性释放和设置云服务器ECS释放
云服务器ECS的一个重要特性就是按需创建资源。您可以在业务高峰期按需弹性的自定义规则进行资源创建,在完成业务计算的时候释放资源。本篇将提供几个Tips帮助您更加容易和自动化的完成云服务器的释放和弹性设置。
18435 0
Android Java 框架基础[知识点汇总]
学习android的过程中,把整个框架的基础结构牢记很重要,特此摘录了一些这个框架的一些基础知识,在使用的过程中按照这个框架学习,事半功倍。 开发过程中参考JDK的文档和android的sdk文档可以清楚遇到的很多问题,遇到问题是现在这两个文档中一般都能找到原因(安装sdk的文档参考http://www.
895 0
Android网络通信 Get方法使用
在使用之前,要确认通信环境已经配好了,HttpClient所需要的包也已经导入了,具体的可以见我前一篇博客 在使用HttpClient的时候,可以使用的方法包括 Get方法、Post方法、Put方法、Delete方法等,这些都是HttpClient.jar给我做好了的,我们使用的时候只需要调用就可以了。 首先,从Get方法的使用开始讲起。 Get方法,顾名思义,是从网络获取数据,在使
883 0
搜狗地图2016-Android-社招笔试题(包含Java基础部分)
下面是搜狗地图的社招笔试题,由于条件有限,全是手机拍的,请将就着看。另请忽略上面的答案,不一定准确。 大伙可在下方讨论答案,上方答案仅供参考,不一定准确。 $(function () { $('pre.
1068 0
【Android 逆向】Android 逆向通用工具开发 ( 网络模块开发 | SOCKET 网络套接字初始化 | 读取远程端 “Android 模拟器“ 信息 | 向远程端写出数据 )
【Android 逆向】Android 逆向通用工具开发 ( 网络模块开发 | SOCKET 网络套接字初始化 | 读取远程端 “Android 模拟器“ 信息 | 向远程端写出数据 )
16 0
+关注
199
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
OceanBase 入门到实战教程
立即下载
阿里云图数据库GDB,加速开启“图智”未来.ppt
立即下载
实时数仓Hologres技术实战一本通2.0版(下)
立即下载