Android TCP通信(二)

原创 2016年05月31日 16:54:39

在Android TCP通信(一)中我们自己写了一个简易的服务器,以及在android 客户端程序发送消息给那个服务器。

如果客户端发送的消息需要异步响应,又该怎么处理呢?

这里我参考了 别人的代码,做了一个改进。

服务端

package com.cmcc.iot;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SocketServerThreadPool {
    private static final int PORT = 12345;
    private List<Socket> mList = new ArrayList<Socket>();
    private ServerSocket server = null;
    private ExecutorService mExecutorService = null; // thread pool

    public static void main(String[] args) {
        new SocketServerThreadPool();
    }

    public SocketServerThreadPool() {
        try {
            server = new ServerSocket(PORT);
            mExecutorService = Executors.newCachedThreadPool(); // create a
                                                                // thread pool
            System.out.println("服务器已启动...");
            Socket client = null;
            while (true) {
                client = server.accept();
                // 把客户端放入客户端集合中
                mList.add(client);
                mExecutorService.execute(new Service(client)); // start a new
                                                                // thread to
                                                                // handle the
                                                                // connection
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    class Service implements Runnable {
        private Socket socket;
        private BufferedReader in = null;
        private String msg = "";

        public Service(Socket socket) {
            this.socket = socket;
            try {
                in = new BufferedReader(new InputStreamReader(
                        socket.getInputStream()));
                // 客户端只要一连到服务器,便向客户端发送下面的信息。
                msg = "服务器地址:" + this.socket.getInetAddress() + "come toal:"
                        + mList.size() + "(服务器发送)";
                this.sendmsg();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

        /**
         * 循环遍历客户端集合,给每个客户端都发送信息。
         */
        public void sendmsg() {
            System.out.println(msg);
            int num = mList.size();
            for (int index = 0; index < num; index++) {
                Socket mSocket = mList.get(index);
                PrintWriter pout = null;
                try {
                    pout = new PrintWriter(new BufferedWriter(
                            new OutputStreamWriter(mSocket.getOutputStream())),
                            true);
                    pout.println(msg);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        public void run() {
            try {
                while(true ) {
                    if((msg = in .readLine())!= null) {
                        //当客户端发送的信息为:exit时,关闭连接
                        if(msg .equals("exit" )) {
                            System.out.println("ssssssss" );
                            mList.remove( socket);
                            in.close();
                            msg = "user:" + socket.getInetAddress()
                                + "exit total:" + mList.size();
                            socket.close();
                            this.sendmsg();
                            break;
                            //接收客户端发过来的信息 msg,然后发送给客户端。
                        } else {
                            msg = socket.getInetAddress() + ":" + msg +"(服务器发送)" ;
                            this.sendmsg();
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }


        }
    }
}

客户端

package com.lq.mypractice.activity;

import android.app.Activity;
import android.os.AsyncTask;
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 com.lq.mypractice.R;
import com.lq.mypractice.util.LogFactory;
import com.lq.mypractice.util.LogUtils;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;

public class SocketDemoActivity extends Activity {
    private TextView tv_msg = null;
    private EditText ed_msg = null;
    private Button btn_send = null;
    // private Button btn_login = null;
    private static final String HOST = "192.168.205.46";
    private static final int PORT = 12345;
    private Socket socket = null;
    private BufferedReader in = null;
    private PrintWriter out = null;
    private String content = "";
    //接收线程发送过来信息,并用TextView显示
    public Handler mHandler = new Handler() {
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            tv_msg.setText(content);
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_socket_asyn);

        tv_msg = (TextView) findViewById(R.id.textview);
        ed_msg = (EditText) findViewById(R.id.edittext01);
        btn_send = (Button) findViewById(R.id.button02);

        //发送任务
        new SoketTask().execute();

        btn_send.setOnClickListener(new Button.OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                String msg = ed_msg.getText().toString();
                if (socket.isConnected()) {
                    if (!socket.isOutputShutdown()) {
                        out.println(msg);
                    }
                }
            }
        });


        //接收任务
        new ReceiveTask().execute();
    }

    private class ReceiveTask extends AsyncTask<Void, Integer, Integer> {
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
        }

        @Override
        protected Integer doInBackground(Void... params) {
            //启动线程,接收服务器发送过来的数据
            try {
                while (true) {
                    if (!socket.isClosed()) {
                        if (socket.isConnected()) {
                            if (!socket.isInputShutdown()) {
                                if ((content = in.readLine()) != null) {
                                    LogFactory.i("lengqi", content);
                                    content += "\n";
                                    mHandler.sendMessage(mHandler.obtainMessage());
                                } else {

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

            return null;
        }


    }

    private class SoketTask extends AsyncTask<Void, Integer, Integer> {
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
        }

        @Override
        protected Integer doInBackground(Void... params) {
            try {
                socket = new Socket(HOST, PORT);
                in = new BufferedReader(new InputStreamReader(socket
                        .getInputStream()));
                out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
                        socket.getOutputStream())), true);
            } catch (IOException ex) {
                ex.printStackTrace();
                LogUtils.i("login exception" + ex.getMessage());
            }

            return null;
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
        }
    }


}

注意客户端发送和接收都要写到异步任务里面,不能放到主线程里面操作。

针对有异步响应的,可以写一个监听,回调结果。

参考

http://www.cnblogs.com/devinzhang/archive/2012/10/04/2711763.html

【Android Socket专题】: TCP通信客户端app的demo的实现

UDP Client客户端  http://blog.csdn.net/shankezh/article/details/50731287 UDP Server服务器 http://blog.csd...
  • shankezh
  • shankezh
  • 2017年04月25日 19:14
  • 4333

Android利用Socket(TCP)通信实现即时聊天

TCP 是传输控制协议的缩写,它保障了两个应用程序之间的可靠通信。通常用于互联网协议,被称 TCP / IP。java中的TCP通信都是通过Socket来进行的。Socket 编程 Socket是应...
  • chengliang0315
  • chengliang0315
  • 2017年01月08日 00:53
  • 6918

Android TCP socket通信

转载请注明出处:http://blog.csdn.net/vnanyesheshou/article/details/74896575 之前做过的一个局域网内TCP通信、聊天的demo,周日整理了一下...
  • VNanyesheshou
  • VNanyesheshou
  • 2017年07月09日 23:19
  • 3858

Android网络编程TCP、UDP(一)

一、TCP与UDP简介TCP和UDP都属于TCP/IP参考模型中传输层的协议,且都是基于网际互联层IP协议。一位大神作了一个很形象的比喻:TCP和UDP使用IP协议从一个网络传送数据包到另一个网络。把...
  • a10615
  • a10615
  • 2016年09月01日 02:21
  • 4888

Android TCP通信的简单实例以及常见问题[超时/主线程阻塞]

个人偏好从简洁的实例入手,最后再进行深入的理论学习。 理论什么的先放一边,把程序跑起来再说。只有跑起来了,才会有动力去继续往下学,参透整个代码的运行机制。 附带一个android TCP实例,并对一...
  • Shenpibaipao
  • Shenpibaipao
  • 2017年04月14日 21:10
  • 2771

Android中基于TCP协议的网络通信之使用Socket进行通信

TCP协议被称为一种端到端的协议。这是因为它为两台计算机的连接起到了重要作用:当一台计算机需要与另一台计算机进行接连时,TCP协议会他们之间建立一个连接:用于发送和接收数据的虚拟链路。...
  • u013761665
  • u013761665
  • 2014年08月31日 12:44
  • 3126

PC 与 Android 的adb同步通信(一)

公司只能上csdn,作为中转站传资料。原文地址http://www.yidin.net/discuz/forum.php?mod=viewthread&tid=172&extra=page%3D1 ...
  • FANCHUANLIN2000
  • FANCHUANLIN2000
  • 2015年01月03日 14:56
  • 1979

基于Java的TCP Socket通信详解(计算机端/Android手机端)

TCP Socket通信是一种比较常用的基于连接的网络通信方式。本文通过Java实现TCP Socket通信,并将其用于计算机端、Android手机端,同时做到代码规范化,实现代码最大化复用。 本...
  • jzj1993
  • jzj1993
  • 2015年02月28日 14:48
  • 2584

Android_TCP/IP开发——聊天室模型(客户端与服务器进行通信)

 TCP/IP 是Transmission Control Protocol/Intemet Protocol的简写,中文译名为传输控制协议/因特网互联协议,又叫网络通信协议,这个协议是Inte...
  • yan8024
  • yan8024
  • 2015年06月12日 17:41
  • 1084

《TCP/IP详解卷2:实现》笔记--TCP的输入

当收到的数据报的协议字段指明这是一个TCP报文段时,ipintr(通过协议协议转换表中的pr_input函数)会调用tcp_input 进行处理,tcp_inut在软件中断一级执行。 函数非常长,我们...
  • TODD911
  • TODD911
  • 2015年01月06日 22:45
  • 1767
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Android TCP通信(二)
举报原因:
原因补充:

(最多只允许输入30个字)