Android 用socket实现客户端发送消息，服务端显示消息

最新推荐文章于 2024-04-06 02:47:15 发布
最新推荐文章于 2024-04-06 02:47:15 发布
阅读量1.8k 收藏 1
点赞数 1
分类专栏： Android socket 文章标签： android socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jiang1989M/article/details/52388665
版权

1.  服务端代码


package com.ziona.socket_service;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.Enumeration;

import android.os.Bundle;
import android.app.Activity;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends Activity {

    TextView info, infoip, msg;
    String message = "";
    ServerSocket serverSocket;
    private DataInputStream dataInputStream;
    Button clear_message;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        info = (TextView) findViewById(R.id.info);
        infoip = (TextView) findViewById(R.id.infoip);
        msg = (TextView) findViewById(R.id.msg);
        clear_message = (Button) findViewById(R.id.clear_message);
        clear_message.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                message= "";
                msg.setText("");
            }
        });

        infoip.setText(getIpAddress());

        Thread socketServerThread = new Thread(new SocketServerThread());
        socketServerThread.start();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        if (serverSocket != null) {
            try {
                serverSocket.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }


        if (dataInputStream != null){
            try {
                dataInputStream.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    private class SocketServerThread extends Thread {
        DataInputStream dataInputStream = null;
        static final int SocketServerPORT = 8080;
        int count = 0;

        @Override
        public void run() {
            try {
                serverSocket = new ServerSocket(SocketServerPORT);


                MainActivity.this.runOnUiThread(new Runnable() {

                    @Override
                    public void run() {
                        info.setText("端口号 : "
                                + serverSocket.getLocalPort());
                    }
                });

                while (true) {
                    Socket socket = serverSocket.accept();

                    dataInputStream = new DataInputStream(socket.getInputStream());
                    String clientMessage = dataInputStream.readUTF();
                    count++;
                    message += "# "  + " from " + ":"  + clientMessage + "\n";

                    MainActivity.this.runOnUiThread(new Runnable() {

                        @Override
                        public void run() {
                            msg.setText(message);
                        }
                    });

                    SocketServerReplyThread socketServerReplyThread = new SocketServerReplyThread(
                            socket, count);
                    socketServerReplyThread.run();

                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

    private class SocketServerReplyThread extends Thread {

        private Socket hostThreadSocket;
        int cnt;

        SocketServerReplyThread(Socket socket, int c) {
            hostThreadSocket = socket;
            cnt = c;
        }

        @Override
        public void run() {
            OutputStream outputStream;
            String msgReply = " 您好! 服务台马上给您处理! " ;

            try {
                outputStream = hostThreadSocket.getOutputStream();
                PrintStream printStream = new PrintStream(outputStream);
                printStream.print(msgReply);
                printStream.close();

                message += " "  +"\n";

                MainActivity.this.runOnUiThread(new Runnable() {

                    @Override
                    public void run() {
                        msg.setText(message);
                    }
                });

            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                message += "Something wrong! " + e.toString() + "\n";
            }

            MainActivity.this.runOnUiThread(new Runnable() {

                @Override
                public void run() {
                    msg.setText(message);
                }
            });
        }

    }

    private String getIpAddress() {
        String ip = "";
        try {
            Enumeration<NetworkInterface> enumNetworkInterfaces = NetworkInterface
                    .getNetworkInterfaces();
            while (enumNetworkInterfaces.hasMoreElements()) {
                NetworkInterface networkInterface = enumNetworkInterfaces
                        .nextElement();
                Enumeration<InetAddress> enumInetAddress = networkInterface
                        .getInetAddresses();
                while (enumInetAddress.hasMoreElements()) {
                    InetAddress inetAddress = enumInetAddress.nextElement();

                    if (inetAddress.isSiteLocalAddress()) {
                        ip += "本机IP地址 : "
                                + inetAddress.getHostAddress() + "\n";
                    }

                }

            }

        } catch (SocketException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            ip += "Something Wrong! " + e.toString() + "\n";
        }

        return ip;
    }
}




<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".MainActivity" >

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:autoLink="web"
        android:text="消息中心"
        android:textSize="26dp"
        android:textStyle="bold" />

    <TextView
        android:id="@+id/info"
        android:layout_gravity="center_horizontal"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
    <TextView
        android:id="@+id/infoip"
        android:layout_gravity="center_horizontal"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
    <Button
        android:id="@+id/clear_message"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="20dp"
        android:text="清理消息"/>

    <ScrollView
        android:layout_gravity="center_horizontal"
        android:layout_width="match_parent"
        android:layout_height="match_parent" >
        <TextView
            android:id="@+id/msg"
            android:textSize="18dp"
            android:layout_gravity="center_horizontal"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content" />
    </ScrollView>

</LinearLayout>






//客户端

package com.example.admin.android_client;

package com.example.admin.android_client;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import java.net.UnknownHostException;

import android.os.AsyncTask;
import android.os.Bundle;
import android.app.Activity;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends Activity {

    private static final String TAG = "MainActivity";
    TextView textResponse;
    EditText editTextAddress, editTextPort;
    Button buttonConnect, buttonClear,clear_house,call_service;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        editTextAddress = (EditText)findViewById(R.id.address);
        editTextPort = (EditText)findViewById(R.id.port);
        buttonClear = (Button)findViewById(R.id.clear);
        textResponse = (TextView)findViewById(R.id.response);

        clear_house= (Button) findViewById(R.id.clear_house);
        clear_house.setOnClickListener(buttonClear_houseConnectOnClickListener);

        buttonConnect = (Button)findViewById(R.id.connect);
        buttonConnect.setOnClickListener(buttonConnectOnClickListener);

        call_service= (Button) findViewById(R.id.call_service);
        call_service.setOnClickListener(buttonCall_serviceConnectOnClickListener);

        buttonClear.setOnClickListener(new OnClickListener(){

            @Override
            public void onClick(View v) {
                textResponse.setText("");
            }});
    }

    OnClickListener buttonConnectOnClickListener =
            new OnClickListener(){
                @Override
                public void onClick(View arg0) {
                    MyClientTask myClientTask = new MyClientTask(editTextAddress.getText().toString(), Integer.parseInt(editTextPort.getText().toString()));
                    myClientTask.execute();
                }};

    public class MyClientTask extends AsyncTask<Void, Void, Void> {

        String dstAddress;
        int dstPort;
        String response = "";

        MyClientTask(String addr, int port){
            dstAddress = addr;
            dstPort = port;
        }

        @Override
        protected Void doInBackground(Void... arg0) {
            DataOutputStream dataOutputStream = null;
            Socket socket = null;

            try {
                socket = new Socket(dstAddress, dstPort);
                dataOutputStream = new DataOutputStream(socket.getOutputStream());
                dataOutputStream.writeUTF("请勿打扰");
                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(1024);
                byte[] buffer = new byte[1024];

                int bytesRead;
                InputStream inputStream = socket.getInputStream();//获得 服务端 发来的消息

    /*
     * notice:
     * inputStream.read() will block if no data return
     */
                while ((bytesRead = inputStream.read(buffer)) != -1){
                    byteArrayOutputStream.write(buffer, 0, bytesRead);
                    response += byteArrayOutputStream.toString("UTF-8");
                    Log.e(TAG,"-------------response = "+response);
                }

            } catch (UnknownHostException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                response = "UnknownHostException: " + e.toString();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                response = "IOException: " + e.toString();
            }finally{
                if(socket != null){
                    try {
                        socket.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

                if (dataOutputStream != null){
                    try {
                        dataOutputStream.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
            return null;
        }

        @Override
        protected void onPostExecute(Void result) {
            textResponse.setText(response);
            super.onPostExecute(result);
        }

    }

    //清理房间-----------------------------------------------------------------------
    OnClickListener buttonClear_houseConnectOnClickListener =
            new OnClickListener(){
                @Override
                public void onClick(View arg0) {
                    MyClientTask_Clear_house myClientTask_Clear_house = new MyClientTask_Clear_house(editTextAddress.getText().toString(), Integer.parseInt(editTextPort.getText().toString()));
                    myClientTask_Clear_house.execute();
                }};

    public class MyClientTask_Clear_house extends AsyncTask<Void, Void, Void> {

        String dstAddress;
        int dstPort;
        String response = "前台回应 :";

        MyClientTask_Clear_house(String addr, int port){
            dstAddress = addr;
            dstPort = port;
        }

        @Override
        protected Void doInBackground(Void... arg0) {
            DataOutputStream dataOutputStream = null;
            Socket socket = null;

            try {
                socket = new Socket(dstAddress, dstPort);
                dataOutputStream = new DataOutputStream(socket.getOutputStream());
                dataOutputStream.writeUTF("清理房间");
                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(1024);
                byte[] buffer = new byte[1024];

                int bytesRead;
                InputStream inputStream = socket.getInputStream();//获得 服务端 发来的消息

    /*
     * notice:
     * inputStream.read() will block if no data return
     */
                while ((bytesRead = inputStream.read(buffer)) != -1){
                    Log.e(TAG,"-------------bytesRead = "+bytesRead);
                    byteArrayOutputStream.write(buffer, 0, bytesRead);
                    response += byteArrayOutputStream.toString("UTF-8");//这个response 是回应与服务端 连接成功，将消息打印在 自己这边，但这个消息没有发送给服务端
                    Log.e(TAG,"-------------response = "+response);
                }
            } catch (UnknownHostException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                response = "UnknownHostException: " + e.toString();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                response = "IOException: " + e.toString();
            }finally{
                if(socket != null){
                    try {
                        socket.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                if (dataOutputStream != null){
                    try {
                        dataOutputStream.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
            return null;
        }

        @Override
        protected void onPostExecute(Void result) {
            textResponse.setText(response);
            super.onPostExecute(result);
        }

    }
//呼叫服务-------------------------------------------------------------------------------
OnClickListener buttonCall_serviceConnectOnClickListener =
        new OnClickListener(){
            @Override
            public void onClick(View arg0) {
                MyClientTask_Call_service myClientTask_Call_service = new MyClientTask_Call_service(editTextAddress.getText().toString(), Integer.parseInt(editTextPort.getText().toString()));
                myClientTask_Call_service.execute();
            }};

    public class MyClientTask_Call_service extends AsyncTask<Void, Void, Void> {

        String dstAddress;
        int dstPort;
        String response = "前台回应 :";

        MyClientTask_Call_service(String addr, int port){
            dstAddress = addr;
            dstPort = port;
        }

        @Override
        protected Void doInBackground(Void... arg0) {
            DataOutputStream dataOutputStream = null;
            Socket socket = null;

            try {
                socket = new Socket(dstAddress, dstPort);
                dataOutputStream = new DataOutputStream(socket.getOutputStream());
                dataOutputStream.writeUTF("呼叫服务");
                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(1024);
                byte[] buffer = new byte[1024];

                int bytesRead;
                InputStream inputStream = socket.getInputStream();//获得 服务端 发来的消息

    /*
     * notice:
     * inputStream.read() will block if no data return
     */
                while ((bytesRead = inputStream.read(buffer)) != -1){
                    Log.e(TAG,"-------------bytesRead = "+bytesRead);
                    byteArrayOutputStream.write(buffer, 0, bytesRead);
                    response += byteArrayOutputStream.toString("UTF-8");
                    Log.e(TAG,"-------------response = "+response);
                }
            } catch (UnknownHostException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                response = "UnknownHostException: " + e.toString();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                response = "IOException: " + e.toString();
            }finally{
                if(socket != null){
                    try {
                        socket.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                if (dataOutputStream != null){
                    try {
                        dataOutputStream.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
            return null;
        }

        @Override
        protected void onPostExecute(Void result) {
            textResponse.setText(response);
            super.onPostExecute(result);
        }

    }

}


<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:orientation="vertical"
    tools:context=".MainActivity" >

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:autoLink="web"
        android:text="客户端"
        android:textStyle="bold" />
    <EditText
        android:id="@+id/address"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="dstAddress" />
    <EditText
        android:id="@+id/port"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="dstPort" />
    <Button
        android:id="@+id/connect"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="请勿打扰..."/>
    <Button
        android:id="@+id/clear_house"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="清理房间..."/>
    <Button
        android:id="@+id/call_service"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="呼叫服务..."/>
    <Button
        android:id="@+id/clear"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Clear"/>
    <TextView
        android:id="@+id/response"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

</LinearLayout>










Jiang1989M
关注
专栏目录
android 实现socket服务端,Android socket实现原理详解 服务端和客户端如何搭建
weixin_33642922的博客
05-26 2274
本文实例为大家分享了Android socket的实现原理，供大家参考，具体内容如下Socket套接字是网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字。socket实现的原理机制：1、通信的两端都有Socket2、网络通信其实就是Socket间的通信3、数据在两个Socket间通过IO传输建立Socket(客户端)和ServerSocket(服务器端)建立连接后，通...
android，socket服务端和客户端实现2端发送和接收消息
08-22
本资源使用了java语音编写，利用传输二进制的方式发送数据和二进制解析数据，实现了客户端给服务器端发送消息，服务器端解析数据，服务器端发送消息给客服端，客户端解析数据。
android通过Service实现消息推送（客户端+服务器）
11-21
模拟android客户端通过Service，每隔一段时间向系统发送一个请求，已获取重要的，实时更新的消息
android socket用TCP方式，client端怎么监听服务器发送来的数据
10-18 1101
http://www.myexception.cn/android/1172505.html         请问一下android socket用TCP方式，Client 端如何监听服务器发送来的数据？ 我客户端的发送部分线程的代码如下： Runnable SendThread = new Runnable() {     public void run() {         t
3、客户端给服务端发消息和服务端主动推送消息
xyphf的博客
08-17 4507
index.html &lt;!-- 客户端 --&gt; &lt;!DOCTYPE html&gt; &lt;html lang="en"&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;meta name="viewport" content="width=de
Android简单实现Socket通信，客户端连接服务器后，服务器向客户端发送文字数据
大事龙
12-29 2565
案例实现的是简单的Socket通信，当客户端（Android客户端）连接到指定服务器以后，服务器向客户端发送一句话文字信息（你可以拓展其它的了）先看一下服务端程序的实现吧Server.javaimport java.io.IOException;import java.io.Ou
Android Socket使用详解，学习Binder前必须要了解的知识点
最新发布
2401_84149836的博客
04-06 691
即套接字，是一个对 TCP / IP协议进行封装 的编程调用接口（API）即通过Socket，我们才能在Andorid平台上通过TCP/IP协议进行开发Socket不是一种协议，而是一个编程调用接口（API），属于传输层（主要解决数据如何在网络中传输）成对出现，一对套接字：Socket ={(IP地址1:PORT端口号)，(IP地址2:PORT端口号)}
Android socket实现原理详解 服务端和客户端如何搭建
01-04
本文实例为大家分享了Android socket的实现原理，供大家参考，具体内容如下 Socket套接字 是网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字。 socket实现的原理机制： 1、通信的...
Android socket通信聊天，客户端+服务端
06-25
本文将深入探讨如何在Android中实现基于Socket的客户端和服务端通信，以构建一个简单的聊天应用。 首先，让我们理解Socket的基本概念。Socket是网络通信中的一个编程接口，它允许两台计算机通过网络进行数据交换。...
EasySocket:一个轻量级的Android端Socket框架，可快速实现客户端和服务端之间的TCP长连接通讯，兼容于各种消息协议，框架的特色之一是可以实现Socket的消息回调功能
05-10
EasySocket README内容将不再更新，请到博客阅读最新的框架说明！ 博客地址： EasySocket的初衷是希望使Socket...3、消息结构使用的协议为：包头+包体，其中包体存储要发送的消息实体，而包头则存储消息的长度、类型
WebSocket安卓客户端实现详解(三)–服务端主动通知
08-06
WebSocket安卓客户端实现详解(三)–服务端主动通知
Android socket连接 并接受消息发送消息 处理返回消息
baidu_25769725的博客
07-05 995
private Myhandler myhandler = new Myhandler(this); private SocketConnectorThread connectorThread; private SZdialogadpter sZdialogadpter; Button connect; TextView text; @Override public void onClick(View v) { switch (v...
Android中使用AsyncTask对socket连接client端的封装
情怀中的释然~
05-17 881
/** * 作者：guoyzh * 时间：2019/5/15 11:02 * 功能：处理socket的工具类 */ public class SocketUtils { private Socket socket; private static final SocketUtils ourInstance = new SocketUtils(); static So...
android socket 回调,Android使用socket.io的connect事件没有回调
weixin_28812943的博客
05-27 494
踩坑缘由：最近项目上用到了即时性的需求，首先就想到了socket，服务端的node.js用的是socket.io，所以我就在github上找到了一个开源的socket.io项目，https://github.com/socketio/socket.io-client-java，集成使用方式可以上去阅读下代码。下面说说使用过程中遇到的问题：Socket mSocket= IO.socket(url)...
android用socket向服务器发送和接收消息 【转自网易闯京城的博客】
mobei1983的博客
05-24 2742
本文是一个demo，模拟一个android客户端可以持续的向socket服务器发送和从socket服务器接收消息。 先上效果图： 手机上的图：    我们可以看到  手机上的消息可以发送到服务器上，服务器上的消息手机上也可以接收并显示出来。关于这个服务器端的下载地址还是要看前面的博客。java Socket从服务器连续取消息 下面上代码：先是布局文件xml<?
Android-Socket连接（客户端发消息给服务端）
jie212的博客
08-08 5195
准备工作 一台手机作服务端，一台手机作客户端，两部手机连接同一个wifi 服务端 布局 MainActivity 客户端 布局 MainActivity
Android Socket 轻松建立连接和发送消息
热门推荐
钟铭
02-04 2万+
1.建立Socket连接         1) Socket 实现了TCP/IP协议，可以连接到网络上的上脑，并收发数据         2) ServerSocket 用于服务端，可以监听服务端口，等待客户端连接，连接后可以生成用于传输数据的Socket         3) 创建服务端             ServerSocket serverSocket = ne
Android Socket编程：简单同步服务端与客户端示例
"该资源提供了一个简单的Android平台上基于Socket通信的示例，旨在帮助初学者理解如何在Android环境中实现客户端和服务端的同步通信。通过TCP协议进行数据传输，使用Socket编程来建立连接，并且示例中包含服务端的...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值