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 TCP socket通信

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

QT TCP socket通信(二)

在上一节里我们使用TCP服务器发送一个字符串,然后在TCP客户端进行接收。在这一节我们重新写一个客户端程序和一个服务器程序,这次我们让客户端进行文件的发送,服务器进行文件的接收。有了上一节的基础,这一...

精选:深入理解 Docker 内部原理及网络配置

网络绝对是任何系统的核心,对于容器而言也是如此。Docker 作为目前最火的轻量级容器技术,有很多令人称道的功能,如 Docker 的镜像管理。然而,Docker的网络一直以来都比较薄弱,所以我们有必要深入了解Docker的网络知识,以满足更高的网络需求。

Android与服务器通信的方法之一(TCP)效率高安全性完善

import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.InputStreamReader; i...

Android Socket UDP,TCP通信

socket有两种通信,一种为tcp是需要建立连接,在连接的基础上去发送和接受信息,而UDP是不需要建立连接,也就在按照指定的端口发送数据。首先我们先说明下TCP通信。 我们使用不规范的写法去简单描...

Android socket通信 TCP协议

Socket通常也称做”套接字“,用于描述IP地址和端口,,它就是网络通信过程中端点的抽象表示。值得一提的是,Java在包java.net中提供了两个类Socket和ServerSocket,分别用来...

socket通信,tcp,udp通信

通过c#编写的一个简单的socket通信测试工具,可用于测试TCP、UDP通信,可实现基本的聊天和文件发送等功能 参考:http://blog.csdn.net/chwei_cson/article/...

Java_SE11-TCP通信,UDP通信

TCP通信 java.net.Socket;封装了TCP通讯,使用该类完成与服务器端的连接,并进行相应的通讯 实例化Scoket时需要传入两个参数: *服务器端的地址—通过地址找到服务端的计算机 ...

TCP通信

TCP通信JAVA中设计网络编程模式的主要有TCP和UDP两种。TCP是属于即时通信,点对点连接进行通信。UDP是通过数据包来进行通信,UDP当中就会牵扯到数据的解析和传送。在安全性能方面,TCP要略...

TCP/UDP通信

TCP通信TCP(Transmission Control Protocol 传输控制协议)是一种面向连接的、可靠的、基于字节流的传输层通信协议Socket原理socket通常称为“套接字”,用于描述...

TCP通信

TCP:全称Transmission Control Protocol ( 传输控制协议):通过三次握手完成连接,建立连接形成数据传输数据的通道,可以进行大量数据的传输,是可以可靠协议,速度相对慢。 ...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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