Demonstração cliente / servidor de comunicação Android TCP Socket (com código-fonte do APP)

Este artigo explica principalmente a implementação do cliente de comunicação Android TCP Socket (cliente) e servidor (servidor) Demo (com código-fonte), preste atenção ao método readLine () de BufferedReader [((line = br.readLine ())! = null)] O problema de bloqueio e o processamento de conversão dos dados do projeto do hardware de encaixe no hexadecimal && byte && int.

Tai Hang

Recentemente, houve um projeto que precisava usar comunicação TCP Socket e encontrou um grande fosso, então fiz esta demonstração.
Ao ler o fluxo de entrada do soquete, muitos códigos escreverão dessa maneira e geralmente não há problema, mas o método readLine () será bloqueado quando não puder ler a alimentação de linha e o retorno de carro!
String line = null;
while ((line = br.readLine ())! = Null) {
}
readLine () é uma função de bloqueio, você pode clicar para ver o código-fonte, apenas quando encontrar alimentação de linha ou retorno de carro (' \ n ',' \ r 'correspondendo a hexadecimal é 0D 0A) retornará e alguns módulos retornarão dados para você sem esses dois terminadores, portanto, isso causa bloqueio e o programa não pode continuar. Nesse caso, se o lado do módulo deseja modificar e adicionar um terminador, não há problema. Se for inconveniente alterar o módulo, este método não pode ser usado e o método de escrita deve ser alterado.

Ferramentas de depuração

Para depuração em tempo real, podemos usar algumas ferramentas do lado do PC, como assistentes de depuração TCP e ferramentas de teste TCP. Existem muitos usuários, e a operação também é tola. Preencha o IP e a porta e, em seguida, estabeleça ou conecte .

Demonstração de demonstração e implementação

Pare de falar bobagem, vá direto para o tópico de hoje, vamos dar uma olhada em como usar o protocolo TCP / IP no Android para se comunicar com o Servidor usando Socket!

1. Permissão

 <uses-permission android:name="android.permission.INTERNET"/>

Em segundo lugar, a implementação do servidor, em termos simples, leva 3 etapas

1. Crie um ServerSocket, monitore a porta e espere o Socket do cliente se conectar
2. Obtenha a mensagem do cliente do Socket
3. Envie uma mensagem ao cliente através do Socket.

O código principal é o seguinte

class ServerSocketThread extends Thread {

    @Override
    public void run() {
        try {  
           // 创建ServerSocket  
           ServerSocket serverSocket = new ServerSocket(9999);  
           System.out.println("--开启服务器，监听端口 9999--");  

           // 监听端口，等待客户端连接  
           while (true) {  
               System.out.println("--等待客户端连接--");  
               Socket socket = serverSocket.accept(); //等待客户端连接  
               System.out.println("得到客户端连接：" + socket);  

               startReader(socket);  
           }  

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

   /**  
    * 从参数的Socket里获取消息 
    */  
   private static void startReader(final Socket mSocket) {  
       new Thread(){  
           @Override  
           public void run() {  
               try {  
                   // 获取读取流  
                   BufferedReader in = new BufferedReader(new InputStreamReader(mSocket.getInputStream(),"utf-8"))
                   String line="";
                   while ((line = in.readLine()) != null) {// 读取数据  
                       System.out.println("*等待客户端输入*");  
                       System.out.println("获取到客户端的信息：" + line);
                    }
               } catch (IOException e) {  
                   e.printStackTrace();  
               }  
           }  
       }.start();  
   } 

 //通过socket来给客户端发送消息
 private void serverSendMessage(String mServerSendMessage) {
     new Thread() {
         @Override
         public void run() {
             PrintWriter out;
             try {
                 out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(mSocket.getOutputStream())), true);
                 out.println(mServerSendMessage);
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }.start();
  }

Três, implementação do lado do cliente, semelhante ao processo do lado do servidor

1. Estabeleça uma conexão Socket com o servidor
2. Obtenha fluxos de entrada e saída
3. Receba / envie mensagens

//与服务器建立连接
Socket mClientSocket = new Socket(mClientIp, mClientPort);

//从socket获取输入输出流
BufferedReader mClientIn = new BufferedReader(new InputStreamReader(mClientSocket.getInputStream()));
PrintWriter mClientOut = new PrintWriter(new BufferedWriter(new OutputStreamWriter(mClientSocket.getOutputStream())), true);

//监听服务端下发的消息
String clientReceiverMessage;
if ((clientReceiverMessage = mClientIn.readLine()) != null) {
    if (mOnConnectListener != null) {
        mOnConnectListener.onMessage(clientReceiverMessage);
    }
} 

//给服务端发消息
mClientOut.println(mClientSendMessage);

Interface do listener do pacote de código

No processo de desenvolvimento real, geralmente encapsulamos o Socket e, em seguida, configuramos a interface do Listener externamente, lidamos com a lógica de negócios em outros módulos e alguns precisam lidar com várias conexões e comunicações de soquete.

Exemplo de implementação de código do lado do servidor

public class TcpServer {

    private static final String TAG = "TcpServer";

    private static TcpServer mTcpServer = new TcpServer();
    private OnListener mOnListener;
    private ServerSocketThread mServerSocketThread;

    public static TcpServer getInstance() {
        return mTcpServer;
    }

    public void setOnListener(OnListener onListener) {
        mOnListener = onListener;
    }

    public interface OnListener {
        void onStart();

        void onNewClient(String serverIp, String clientIp, int count);

        void onError(Throwable e, String message);

        void onMessage(String ip, String message);

        void onAutoReplyMessage(String ip, String message);

        void onClientDisConnect(String ip);

        void onConnectTimeOut(String ip);
    }

    public void setPort(int port) {
        mServerPort = port;
    }

    ………………………………
    ………………………………
    ………………………………
}

Processamento de envio e recebimento hexadecimal

O protocolo de comunicação do projeto de hardware docking pode usar hexadecimal, portanto os dados devem ser convertidos na string \ byte \ int hexadecimal, mas a essência da parte de comunicação é a mesma, o código é o seguinte

  //十六进制 发送
  try {
      //byte[] msg = {(byte) 0xaa,(byte) 0xbb,(byte) 0x0d,(byte) 0x0a};
      byte[] msg = IntByteStringHexUtil.hexStrToByteArray("AABB0D0A");
      OutputStream socketWriter = socket.getOutputStream();

      socketWriter.write(msg);
  } catch (IOException e) {
      e.printStackTrace();
  }

  //十六进制 接收
  InputStream socketReader = socket.getInputStream();
  byte buf[] = new byte[1024];
  int len = socketReader.read(buf);

  byte data[] = new byte[len];
  System.arraycopy(buf, 0, data, 0, len);

  logClient(len+","+IntByteStringHexUtil.byteArrayToHexStr(data));

Endereço de download da fonte de demonstração

O código-fonte também é colocado no CSDN, você pode aprender com ele se precisar

===> Exemplo de comunicação do Android TCP Socket Código fonte de demonstração Apk download