android开发之socket传递

最新推荐文章于 2023-09-07 20:10:00 发布
最新推荐文章于 2023-09-07 20:10:00 发布
阅读量632 收藏
点赞数
分类专栏： android开发常用功能

client:

[java]  view plain copy
  1. package com.SocketClient;    
  2.   
  3. import java.io.BufferedReader;  
  4. import java.io.InputStreamReader;  
  5. import java.io.PrintWriter;  
  6. import java.net.Socket;  
  7.   
  8. import android.app.Activity;  
  9. import android.app.AlertDialog;  
  10. import android.content.DialogInterface;  
  11. import android.os.Bundle;  
  12. import android.os.Handler;  
  13. import android.os.Message;  
  14. import android.util.Log;  
  15. import android.view.KeyEvent;  
  16. import android.view.View;  
  17. import android.view.View.OnClickListener;  
  18. import android.widget.Button;  
  19. import android.widget.EditText;  
  20.   
  21. public class SocketClient extends Activity {  
  22.     /** Called when the activity is first created. */  
  23.     private final String        DEBUG_TAG   = "Activity";  
  24.     private  String ipaddress;  
  25.     private  int port ; //服务器IP、端口   
  26.     private Thread mThread = null;  
  27.     private Socket              mSocket     = null;  
  28.     private Button              mButton_In  = null;  
  29.     private Button              mButton_Send= null;  
  30.     private EditText            mEditText01     = null;  
  31.     private EditText            mEditText02     = null;  
  32.     private BufferedReader      mBufferedReader = null;  
  33.     private EditText            mPortEdit       =null;  
  34.     private EditText            mIpEdit         =null;  
  35.     private PrintWriter mPrintWriter = null;  
  36.     private  String mStrMSG = "";  
  37.     boolean connected;  
  38.     @Override  
  39.     public void onCreate(Bundle savedInstanceState) {  
  40.         super.onCreate(savedInstanceState);  
  41.         setContentView(R.layout.main);  
  42.         mButton_In = (Button)findViewById(R.id.Button_In);  
  43.         mButton_Send = (Button)findViewById(R.id.Button_Send);  
  44.         mEditText01=(EditText)findViewById(R.id.EditText01);  
  45.         mEditText02=(EditText)findViewById(R.id.EditText02);  
  46.         mPortEdit=(EditText)findViewById(R.id.PortEdit);  
  47.         mIpEdit=(EditText)findViewById(R.id.IpEdit);  
  48.         mButton_In.setOnClickListener(new OnClickListener()  
  49.         {  
  50.             public void onClick(View v)  
  51.             {  
  52.                 if(!connected)  
  53.                 {  
  54.                     ipaddress=mIpEdit.getText().toString();  
  55.                     port=Integer.parseInt(mPortEdit.getText().toString());  
  56.                     try   
  57.                     {  
  58.                         mSocket = new Socket(ipaddress, port);      //连接服务器  
  59.                         mBufferedReader = new BufferedReader(new InputStreamReader(mSocket.getInputStream()));//取得输入、输出流  
  60.                         mPrintWriter=new PrintWriter(mSocket.getOutputStream(), true);     
  61.                         mIpEdit.setEnabled(false);  
  62.                         mPortEdit.setEnabled(false);  
  63.                         mButton_In.setText("disConnect");  
  64.                         connected=true;  
  65.                         mEditText02.setEnabled(connected);  
  66.                         mButton_Send.setEnabled(connected);  
  67.                     }  
  68.                     catch (Exception e)   
  69.                     {  
  70.                         new AlertDialog.Builder(SocketClient.this)  
  71.                         .setTitle("ERROR!")  
  72.                         .setMessage(e.toString())  
  73.                         .setPositiveButton  
  74.                         (  
  75.                             "确定",  
  76.                             new DialogInterface.OnClickListener()  
  77.                             {  
  78.                                 public void onClick(DialogInterface dialoginterface,int i)  
  79.                                 {  
  80.                                     mIpEdit.setText("");  
  81.                                     mPortEdit.setText("");  
  82.                                 }  
  83.                             }  
  84.                         )  
  85.                         .show();      
  86.                         Log.e(DEBUG_TAG, e.toString());  
  87.                     }  
  88.                 }  
  89.                 else  
  90.                 {  
  91.                     connected=false;  
  92.                     mEditText02.setText("");  
  93.                     mButton_In.setText("Connect");  
  94.                     mPrintWriter.print("exit"+"\n");  
  95.                     mPrintWriter.flush();  
  96.                     mIpEdit.setEnabled(true);  
  97.                     mPortEdit.setEnabled(true);  
  98.                     mEditText02.setEnabled(connected);  
  99.                     mButton_Send.setEnabled(connected);  
  100.                 }  
  101.             }  
  102.         });  
  103.           
  104.         mButton_Send.setOnClickListener(new OnClickListener()  
  105.         {  
  106.             public void onClick(View v)  
  107.             {  
  108.                 String str = mEditText02.getText().toString() + "\n";//取得编辑框中我们输入的内容  
  109.                 mEditText02.setText("");  
  110.                 try   
  111.                 {     
  112.                     mPrintWriter.print(str);//发送给服务器  
  113.                     mPrintWriter.flush();     
  114.                 }  
  115.                 catch (Exception e)   
  116.                 {  
  117.                     Log.e(DEBUG_TAG, e.toString());  
  118.                 }  
  119.             }  
  120.         });  
  121.         mThread = new Thread(mRunnable);  
  122.         mThread.start();  
  123.     }  
  124.     private Runnable mRunnable= new Runnable()   
  125.     {  
  126.         public void run()  
  127.         {  
  128.             while (true)  
  129.             {  
  130.                 try  
  131.                 {  
  132.                     if ( (mStrMSG = mBufferedReader.readLine()) != null )  
  133.                     {  
  134.                         mStrMSG+="\n";//消息换行  
  135.                         mHandler.sendMessage(mHandler.obtainMessage());// 发送消息  
  136.                     }     
  137.                 }  
  138.                 catch (Exception e)  
  139.                 {  
  140.                     Log.e(DEBUG_TAG, e.toString());  
  141.                 }  
  142.             }  
  143.         }  
  144.     };  
  145.       
  146.     Handler mHandler= new Handler()   
  147.     {                                         
  148.           public void handleMessage(Message msg)                                          
  149.           {                                           
  150.               super.handleMessage(msg);                                               
  151.               try                               // 刷新                 
  152.               {   
  153.                   mEditText01.append(mStrMSG);//将聊天记录添加进来     
  154.               }                                           
  155.               catch (Exception e)                                             
  156.               {                                                                                   
  157.                   Log.e(DEBUG_TAG, e.toString());                                             
  158.               }                                       
  159.           }                                   
  160.      };  
  161.      public boolean onKeyDown(int keyCode,KeyEvent event)  
  162.      {  
  163.          if(keyCode==KeyEvent.KEYCODE_BACK)  
  164.          {  
  165.                 String str="exit"+"\n";  
  166.                 try   
  167.                 {     
  168.                     mPrintWriter.print(str);//发送给服务器  
  169.                     mPrintWriter.flush();     
  170.                 }  
  171.                 catch (Exception e)   
  172.                 {  
  173.                     Log.e(DEBUG_TAG, e.toString());  
  174.                 }  
  175.                 this.finish();  
  176.          }  
  177.          return true;  
  178.      }  
  179. }  


 

server:

[java]  view plain copy
  1. import java.io.BufferedReader;  
  2. import java.io.IOException;  
  3. import java.io.InputStreamReader;  
  4. import java.io.PrintWriter;  
  5. import java.net.ServerSocket;  
  6. import java.net.Socket;  
  7. import java.util.ArrayList;  
  8. import java.util.List;  
  9. import java.util.concurrent.ExecutorService;  
  10. import java.util.concurrent.Executors;  
  11.   
  12. public class Server  
  13. {  
  14.     private static final int SERVERPORT = 8888; //服务器端口  
  15.     private static List<Socket> mClientList = new ArrayList<Socket>(); //客户端连接  
  16.     private ExecutorService mExecutorService;  //线程池  
  17.     private ServerSocket mServerSocket;  //ServerSocket对象  
  18.     public static void main(String[] args)  
  19.     {  
  20.         new Server();  
  21.     }  
  22.     public Server()  
  23.     {  
  24.         try  
  25.         {  
  26.             mServerSocket = new ServerSocket(SERVERPORT);//设置服务器端口  
  27.             mExecutorService = Executors.newCachedThreadPool();//创建一个线程池  
  28.             System.out.println("start...");  
  29.             Socket client = null;           //用来临时保存客户端连接的Socket对象  
  30.             while (true)  
  31.             {  
  32.                 client = mServerSocket.accept(); //接收客户连接并添加到list中  
  33.                 mClientList.add(client);  
  34.                 mExecutorService.execute(new ThreadServer(client));//开启一个客户端线程  
  35.             }  
  36.         }  
  37.         catch (IOException e)  
  38.         {  
  39.             e.printStackTrace();  
  40.         }  
  41.     }     
  42.     //每个客户端单独开启一个线程  
  43.     static class ThreadServer implements Runnable  
  44.     {  
  45.         private Socket          mSocket;  
  46.         private BufferedReader  mBufferedReader;  
  47.         private PrintWriter     mPrintWriter;  
  48.         private String          mStrMSG;  
  49.   
  50.         public ThreadServer(Socket socket) throws IOException  
  51.         {  
  52.             this.mSocket = socket;  
  53.             mBufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
  54.             mStrMSG = "user:"+this.mSocket.getInetAddress()+" come total:" + mClientList.size();  
  55.             sendMessage();  
  56.         }  
  57.         public void run()  
  58.         {  
  59.             //try  
  60.             //{  
  61.                 try {  
  62.                     while ((mStrMSG = mBufferedReader.readLine()) != null)  
  63.                     {  
  64.                         if (mStrMSG.trim().equals("exit"))//当一个客户端退出时  
  65.                         {  
  66.                             mClientList.remove(mSocket);  
  67.                             mBufferedReader.close();  
  68.                             mPrintWriter.close();  
  69.                             mStrMSG = "user:"+this.mSocket.getInetAddress()+" exit total:" + mClientList.size();  
  70.                             mSocket.close();  
  71.                             sendMessage();  
  72.                             break;  
  73.                         }  
  74.                         else  
  75.                         {  
  76.                             mStrMSG = mSocket.getInetAddress() + ":" + mStrMSG;  
  77.                             sendMessage();  
  78.                         }  
  79.                     }  
  80.                 } catch (IOException e) {  
  81.                     // TODO Auto-generated catch block  
  82.                     e.printStackTrace();  
  83.                 }  
  84.         //  }  
  85.         }  
  86.         /** 
  87.          *  发送消息给所有客户端 
  88.          */  
  89.         private void sendMessage() throws IOException  
  90.         {  
  91.             System.out.println(mStrMSG);  
  92.             for (Socket client : mClientList)  
  93.             {  
  94.                 mPrintWriter = new PrintWriter(client.getOutputStream(), true);  
  95.                 mPrintWriter.println(mStrMSG);  
  96.             }  
  97.         }  
  98.     }  
  99. }  
落花飞花
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android实现基于socket的聊天
01-06
1. 实时消息传递：通过Socket不断监听输入流，一旦接收到新消息，就触发UI更新，展示给用户。 2. 发送消息：用户输入消息后，通过Socket的输出流向服务器发送，服务器再广播给其他连接的客户端。 四、本地消息存储 ...
关于Android中Activity之间socket传递的问题
shaomingshan的博客
04-13 4105
众所周知，一个Android程序如果需要和服务器建立socket通信的话，在每个activity中都新建socket与服务器连接是非常不便的，那么我们就需要在各个activity之间传递socket，这样只需要和服务器建立一次连接就可以了。下面博主将自己学习的过程和走过的弯路分享出来供大家参考。 一、通过Intent传递类对象 首先声明，该方法是不能实现socket传递的，下面会介绍原因
安卓实现多个activity使用同一个socket通信
最新发布
m0_61973119的博客
09-07 200
多个activity页面调用。
字节数组和javaBean的相互转换
tm7796的专栏
03-26 2186
近期由于物联网的发展，IOT设备对接，成为每个公司必不可少的事情。硬件方面都是采用的MQTT和服务端通讯，这里我们不讲MQTT，因为网上的资料很多，我们来点干货：如何把MQTT的通讯数组（字节数组）转换成我们熟悉的javaBean。 首先做一下简单的介绍一下。java的数组类型占的字节长度。 byte占一个字节 short占两个字节 int占4四个字节 long占8个字节 以上4个类...
Android平台TCP网络转发实现方案（redsocks+iptables+socks5）
bgylde的博客
03-06 7540
android平台redSocks+ipTable+socks5实现tcp的转发 要求android系统有root权限，可以执行程序，修改iptable。参考url： https://blog.csdn.net/yeshennet/article/details/79397651 一、redsocks编译 1. libevent编译 redsocks依赖于libevnet，需要首先...
Android使用Socket(Tcp/Udp)协议进行数据传输(传输大文件)
刘桂林
10-29 3864
先揭晓一下前面天的抽奖活动中奖人员：恭喜这位同学中奖，麻烦你在微信公众号留言你的收货地址，或者加入QQ群：417046685 来找我也行。同时，知识星球的活动还在继续，现...
Android NDK中socket的用法以及注意事项分析
09-05
在Android开发中，有时我们需要利用Native层来处理网络通信，这时Android NDK就派上了用场。本文将详细解析在Android NDK环境中如何使用socket进行数据传输，以及需要注意的关键点。 1. **创建socket并绑定IP和端口...
android socket跨进程通讯demo
09-06
然而，相比于Socket，Messenger更适合于简单的消息传递，而不是大量数据的交换。在某些场景下，如需要进行复杂的数据交互或需要保持长连接时，使用Socket更为合适。 **总结** "android socket跨进程通讯demo"展示了...
android socket 服务器端
05-24
在实际应用中，可能会通过Socket传递控制指令，例如亮度、颜色等参数，然后由服务器端解析并执行相应的操作。 总之，Android Socket服务器端开发涉及到Java网络编程、多线程、权限管理等多个方面，对于实现设备间的...
Android开发艺术探索
03-02
2.4.6 使用Socket ／ 103 2.5 Binder连接池 ／ 112 2.6 选用合适的IPC方式 ／ 121 第3章 View的事件体系 ／ 122 3.1 View基础知识 ／ 122 3.1.1 什么是View ／ 123 3.1.2 View的位置参数 ／ 123 3.1.3 Motion...
安卓进程间传递对象
07-25
安卓 使用Serialable 和Parcelable两种方法. 实现如何在进程间传递对象的方法 详情见我博客. http://blog.csdn.net/sanjay_f
android socket实时传输到服务端
09-16
android 实时传输摄像头内容到服务器,服务器支持查看
android进程间socket传递Ashmem的文件描述符
05-12
android传递大文件的话，第一想到的就是匿名共享内存了，但是进程间怎么共享匿名共享内存的。试想进程A创建匿名共享内存，进程B怎么得共享内存读出数据？熬得凌晨2点多写个demo，备忘和分享！
socket 中使用byte数组或者是字符流传输数据
sundancer_lilong的博客
02-22 6447
1、使用byte数组传输 client： public static void test(){ Socket socket = null; BufferedReader br = null; PrintWriter pw = null; try { // 客户端socket指定服务器的地址和端口号 socket = new Socket("127.0.0.1", 7890); S
Java Socket 如何接收byte和String
Android唐浮的专栏
05-05 4628
Java Socket 如何接收byte和String 一、发送byte[]与String 我们平时是怎么发送byte和String的呢？举例代码： String str = "hello world"+ "\n"; byte[] bytes = 图片字节流; // 获取socket输出流 OutputStream out = socket.getOutputStream(); // 发送字符串 ...
android进程间传递文件描述符原理
lyf's blog
02-15 3777
linux打开文件过程 android binder传递文件描述符在linux中，进程打开一个文件，返回一个整数的文件描述符，然后就可以在这个文件描述符上对该文件进行操作。那么文件描述符和文件到底是什么关系？进程使用的是虚拟地址，不同进程间是地址隔离的，如何在两个进程中传递文件描述符，然后指向同一文件(binder传递文件描述符)？linux打开文件过程下图是linux内核中打开文件的结构体之间的关
Android开发——本机Tomcat搭建服务器，客户端socket网络连接不上问题以及D-LINK端口转发设置
牧之
05-24 3659
我是用自己的电脑搭建服务器，首先问题是我们需要在路由器上端口映射，外网才能访问到自己的电脑，如何端口映射可以看看这篇文章： http://blog.csdn.net/zhoubin1992/article/details/45917775 一、D-LINK端口转发设置 我的是D-link如图： 名称写你客户端的名称。 IP地址：路由器给本机分配的IP地址，一般以192.168
Android应用socket即时通讯的实现
热门推荐
执迷的博客
09-14 1万+
一、服务器 思路： 首先创建服务器，用一个死循环等候若干个客户端的连接。一旦有客户端连接，就把客户端添加到集合当中，并且启动一个新的线程来保持长连接，监控客户端发来的信息。一旦接收到有客户端发来的信息，就进行包装后遍历集合，把包装好的信息发送给每一个客户端。 代码如下： [java] view plain copy /** 
深入探索：Android开发艺术与优化实践
"《Android开发艺术探索》是一本深入讲解Android应用开发的专业书籍，涵盖了Activity生命周期、IPC机制、View事件体系和工作原理等多个关键知识点。本书旨在帮助开发者提升Android开发技能，通过理论、源码分析与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值