手机与PC的网络协议

网络 通信技术 网络管理
现在我们用一台电脑做服务器,一部手机做客户端,来实现手机与电脑之间的通信啦。首先,异曲同工,在手机上建立客户端与在电脑上是差不多的。

现在我们用一台电脑做服务器,一部手机做客户端,来实现手机与电脑之间的通信啦。首先,异曲同工,在手机上建立客户端与在电脑上是差不多的,首先我们现在电脑上面建立服务器如下:

  1. package 手机与PC端通信;   
  2.    
  3. import java.io.IOException;   
  4.    
  5.    
  6.    
  7.    
  8. import java.net.ServerSocket;   
  9. import java.net.Socket;   
  10.    
  11.    
  12.    
  13. public class Server {   
  14.        
  15.     public void setup(int port){   
  16.            
  17.             try {   
  18.                 //创建服务器   
  19.                 ServerSocket host=new ServerSocket(port);   
  20.                 System.out.println("通信端口"+port+"成功开启");   
  21.                 while(true){   
  22.                     //等待客户端访问   
  23.                     Socket socket=host.accept();   
  24.                     System.out.println("有人访问了");   
  25.                     //把跟客户端交流的事情交给线程处理   
  26.                     ServerThread st = new ServerThread(socket);   
  27.                     //开启线程                     
  28.                     st.start();   
  29.    
  30.                 }   
  31.             } catch (IOException e) {   
  32.                 // TODO Auto-generated catch block   
  33.                 e.printStackTrace();   
  34.             }   
  35.                
  36.            
  37.     }   
  38.     public static void main(String[] args){   
  39.         //传入端口号   
  40.         new Server().setup(8888);   
  41.     }   
  42.    
  43. }   

接下来建立线程来处理socket得到的输入流以及输出流:

  1. package 手机与PC端通信;   
  2.    
  3. import java.io.DataInputStream;   
  4.    
  5. import java.io.DataOutputStream;   
  6. import java.io.IOException;   
  7. import java.io.InputStream;   
  8. import java.io.OutputStream;   
  9. import java.net.Socket;   
  10.    
  11. public class ServerThread extends Thread {   
  12.     private Socket socket;   
  13.     private DataOutputStream  dos;   
  14.     public ServerThread(Socket socket){   
  15.         this.socket=socket;   
  16.     }   
  17.        
  18.    
  19.     public void run(){   
  20.         //得到网络连接socket得到的输出输入流   
  21.         try {   
  22.             //输入流   
  23.             InputStream input=socket.getInputStream();   
  24.                
  25.             DataInputStream dis=new DataInputStream(input);   
  26.             //得到客户端的输出流   
  27.             dos=new DataOutputStream(socket.getOutputStream());   
  28.             //读取客户端发到服务端的字节   
  29.             while(true){   
  30.                    int msgType=dis.readInt();   
  31.                    
  32.                     int len=dis.readInt();   
  33.                     byte[] bytes=new byte[len];   
  34.                     dis.readFully(bytes);   
  35.                     String content=new String(bytes,"GB2312");   
  36.                     System.out.println("客户端说:"+content);   
  37.                        
  38.                        
  39.                         //这里是发到客户端的   
  40.                         String replyString = "服务器收到了("+content+")";   
  41.                         bytes = replyString.getBytes("GB2312");   
  42.                            
  43.                         //写进是文字  1   
  44.                         dos.writeInt(1);   
  45.                         //输出流写进字节长度   
  46.                         dos.writeInt(bytes.length);   
  47.                         //写进字节   
  48.                         dos.write(bytes);   
  49.                         //刷新   
  50.                         dos.flush();   
  51.                     }   
  52.                    
  53.                
  54.                
  55.                
  56.         } catch (IOException e) {   
  57.             // TODO Auto-generated catch block   
  58.             e.printStackTrace();   
  59.         }   
  60.     }   
  61.    
  62. }   

这些内容在上节中都已经讲过,这里不做过多阐述

接下来就是重点内容啦,就是在Android中建立客户端,这里我们要使用带安卓插件的eclipse来编写

首先处理界面,我大概定义了一个textview来显示聊天内容,editText来进行输入框的角色,再者就是一个发送按钮,这样一个简单的聊天界面就已经完成了,如下,简洁的小界面,读者们可以自行美化界面哈:

(***记得绑定发送按钮到指定函数哦

***记得绑定发送按钮到指定函数哦。#p#

接下来就是在MainActivity中开始动工了,动工之前,讲一个非常重要的函数Handler,我们知道,在UI界面主线程中,我们肯定要获取到输入框输入的文字来发送到服务器上,Android里面的线程是不能直接访问Ui组件的,例如:在另一个线程调用textView。setText(“23232”);在编译的时候是没有问题的,但是在运行时就会报错,所以这时候就要用到handler的函数,我们在这里可以理解为一个中介,子线程将信息绑定在handler上,handler将信息更新到主函数UI上,里面会用到callBack函数,具体代码里讲,万事俱备,只差将网络权限添加到你的手机上了,在AndroidMainfest.xml文件中,在

android:minSdkVersion="8"

android:targetSdkVersion="18" />后面添加网络允许代码,就是下面这一句

接下来,就是UI界面MainActivity.java代码如下:

  1. import android.os.Bundle;   
  2. import android.os.Handler;   
  3. import android.os.Message;   
  4. import android.app.Activity;   
  5. import android.util.Log;   
  6. import android.view.Menu;   
  7. import android.view.View;   
  8. import android.view.View.OnClickListener;   
  9. import android.widget.Button;   
  10. import android.widget.EditText;   
  11. import android.widget.TextView;   
  12. import android.widget.Toast;   
  13.    
  14. public class MainActivity extends Activity {   
  15.     //聊天区域   
  16.     private TextView textMsgLog;   
  17.     //客户端处理线程   
  18.     private ClientThread clientThread;   
  19.     protected void onCreate(Bundle savedInstanceState) {   
  20.         super.onCreate(savedInstanceState);   
  21.         setContentView(R.layout.activity_main);   
  22.         Button btnSend=(Button)findViewById(R.id.btnSend);   
  23.         //聊天显示界面   
  24.         textMsgLog=(TextView)findViewById(R.id.textMsgLog);   
  25.         Log.i("test""oooooooooooooo11111");   
  26.         //创建Handler对象,介于主线程和子线程一个代理,子线程ClientThread将要传递的数据通过   
  27.         //Handler传递给主进程UI,数据在UI上更新   
  28.         Handler.Callback callback=new Handler.Callback(){   
  29.             public boolean handleMessage(Message msg){   
  30.                    
  31.                     //   
  32.                     textMsgLog.append("服务器:" + msg.obj.toString() +   
  33.                     "\n");   
  34.                    
  35.                 return true;   
  36.             }   
  37.                
  38.         };   
  39.            
  40.            
  41.         Handler handler=new Handler(callback);   
  42.         clientThread =new ClientThread(handler);   
  43.         clientThread.start();   
  44.            
  45.            
  46.     }   
  47.     //将文本输入框的发送给服务器   
  48.     public void send(View v){   
  49.            
  50.         //得到输入框   
  51.         EditText editInput = (EditText)findViewById(R.id.editInput);   
  52.         //得到输入框中文字   
  53.         String msg = editInput.getText().toString();   
  54.         //调用,写到服务器上,返回成功   
  55.         boolean result = clientThread.sendText(msg);   
  56.         textMsgLog.append("我:"+msg+"\n");   
  57.         if(result){   
  58.         textMsgLog.append("我:"+msg+"\n");   
  59.         editInput.setText("");   
  60.         } else {   
  61.         Toast.makeText(this"发送失败", Toast.LENGTH_LONG).show();   
  62.         }   
  63.            
  64.     }   
  65.            
  66.        
  67.    
  68.     @Override   
  69.     public boolean onCreateOptionsMenu(Menu menu) {   
  70.         // Inflate the menu; this adds items to the action bar if it is present.   
  71.         getMenuInflater().inflate(R.menu.main, menu);   
  72.         return true;   
  73.     }   
  74.    
  75. }   

#p#和客户端线程,也就是刚才说的子线程代码:

  1. ackage com.example.eetalk;   
  2.    
  3. import java.io.DataInputStream;   
  4. import java.io.DataOutputStream;   
  5. import java.io.IOException;   
  6. import java.net.Socket;   
  7. import java.net.UnknownHostException;   
  8.    
  9. import android.os.Handler;   
  10. import android.os.Message;   
  11.    
  12. public class ClientThread extends Thread {   
  13.     private Handler handler;   
  14.     private DataOutputStream dos;   
  15.     private DataInputStream dis;   
  16.     private Socket socket;   
  17.    
  18.     public ClientThread(Handler handler) {   
  19.         this.handler = handler;   
  20.     }   
  21.    
  22.     public void run() {   
  23.         try {   
  24.             connect();   
  25.             dos.writeInt(1);   
  26.             dos.writeInt(5);   
  27.             dos.write("hello".getBytes());   
  28.             while (true) {   
  29.                 //读取服务器发过来的数据   
  30.                 int msgType = dis.readInt();   
  31.                 //   
  32.                 System.out.println("121");   
  33.                     //   
  34.                     int len = dis.readInt();   
  35.                     //   
  36.                     byte[] bytes = new byte[len];   
  37.                     dis.readFully(bytes);   
  38.                     //   
  39.                     String content = new String(bytes, "GB2312");   
  40.                     Message msg = new Message();   
  41.                     msg.what = 1;   
  42.                     //   
  43.                     msg.obj = content;   
  44.                     //   
  45.                     handler.sendMessage(msg);   
  46.                    
  47.             }   
  48.         } catch (IOException e) {   
  49.             e.printStackTrace();   
  50.         } finally {   
  51.             //close();   
  52.         }   
  53.    
  54.     }   
  55.    
  56.     private void connect() throws UnknownHostException, IOException {   
  57.         //   
  58.         socket = new Socket("172.27.35.3"8888);   
  59.         //   
  60.         dis = new DataInputStream(socket.getInputStream());   
  61.            
  62.         dos = new DataOutputStream(socket.getOutputStream());   
  63.    
  64.     }   
  65.    
  66.     private void close() {   
  67.         if (dis != null) {   
  68.             try {   
  69.                 dis.close();   
  70.             } catch (IOException e) {   
  71.             }   
  72.         }   
  73.         if (dos != null) {   
  74.             try {   
  75.                 dos.close();   
  76.             } catch (IOException e) {   
  77.             }   
  78.         }   
  79.         if (socket != null) {   
  80.             try {   
  81.                 socket.close();   
  82.             } catch (IOException e) {   
  83.             }   
  84.         }   
  85.     }   
  86.     //发送到服务器的   
  87.     public boolean sendText(String content){   
  88.         try {   
  89.         //   
  90.         byte[] bytes = content.getBytes("GB2312");   
  91.         //   
  92.         dos.writeInt(1);   
  93.         //   
  94.         dos.writeInt(bytes.length);   
  95.         //   
  96.         dos.write(bytes);   
  97.         dos.flush();   
  98.         return true;   
  99.         } catch (IOException e) {   
  100.         e.printStackTrace();   
  101.         }   
  102.         return false;   
  103.         }   
  104. }   

记住你的手机和你的电脑一定要在同一个局域网,这里可以看出手机的客户端做法与电脑是差不多的,上面手机客户端连接的ip地址是你的电脑连入的ipv4地址,可以在cmd命令里恰如ipconfig来搜寻。

做到这里,将你的app下载到手机,打开服务器,打开手机的应用程序,就可以聊天了,记住打开网络

美美聊天了:

这是服务器

 

 

这是手机客户端

 

 

 

 

做到这里,就可以和手机互发图片和文字啦,这是小编下期的实现目标 。

责任编辑:林琳 来源: ITeye-博客
相关推荐

2020-04-23 09:11:09

网络协议网络设备网络

2011-11-10 09:43:14

ZigBee协议栈网络层

2019-10-09 08:41:49

XA2PC3PC

2016-11-16 15:36:09

2016-11-16 08:47:01

2010-01-21 11:33:29

GoogleChrome OS

2019-11-08 10:00:09

Windows手机应用程序

2019-03-29 10:31:53

2013-08-01 10:01:02

网络协议TCP协议UDP协议

2020-04-20 21:22:50

网络设备网络协议计算机网络

2014-06-13 13:47:31

UDP

2011-08-24 10:31:01

网络协议SLIPPPP

2010-07-05 10:38:49

网络层次协议

2010-09-09 15:25:35

网络协议

2013-04-08 10:12:04

Android手机通过

2012-03-14 10:04:49

手机浏览器海豚浏览器

2018-02-09 15:23:35

PC游戏手游Moonlight

2019-08-01 14:00:21

2012-10-19 09:38:56

Ubuntu 12.1

2010-06-17 18:00:40

网络通讯协议
点赞
收藏

51CTO技术栈公众号