Android Socket的使用到简单封装（一）

在我们使用okHttp等网络框架去请求网络时，都是我们Android客户端主动发起一次请求，然后服务器返回相应的数据给我们客户端去使用，即经常说起的一次请求一次响应，和Servlet一样。这样的请求都是基于HTTP协议去实现的，在HTTP模式下，只能是客户端主动去请求数据，服务端才会给你返回你想要的数据，也就是说，服务端只能是你要了我才能给。我们主动久了，总会希望服务端也主动一点，给我们主动发一点数据。试想一下，和妹子一起么么哒的时候，妹子在你耳边轻轻的娇嗔：“我要，我要，我要给你，我就要给你嘛！”，是不是超级刺激？为了解决妹子的需求，我们肯定要使上九牛二虎之力，把妹子整的服服帖帖的，一阵巫山云雨，不可描述之后，妹子娇红着脸，把脑袋埋在你的胸口，宛如一只小绵羊。emmmmm，舒服了。基于TCP协议的Socket就是为了帮助我们解决这种需求的。它能让你和妹子相互的“要”，相互的“给”，还能超级持久哦。

下面就简单的在代码里介绍一下Socket长连接的使用，栗子要实现的效果是：安卓客户端给服务端发送一个消息，服务端收到消息后立马给我返回一个消息。

看图说话：我代表客户端，媳妇儿代表服务端
[图片上传中...(image-810b3b-1532078403207-0)]

S80720-17021934.jpg

具体实现：
下面是MainActivity的布局文件：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <Button
        android:id="@+id/bt_sendData"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="发送数据"
        android:layout_alignParentTop="true"/>

    <LinearLayout
        android:id="@+id/ll_content"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_below="@+id/bt_sendData"
        android:layout_marginTop="20dp"
        android:orientation="vertical"></LinearLayout>

</RelativeLayout>

接着继续看MainActivity的代码：
1.首先调用doConnect()方法建立服务器连接，由于网络请求要写在子线程中，所以这里新建了一个线程，在子线程中建立连接。在这个连接中使用了我本机的ip地址（用手机测试时，手机需连接wifi，和电脑处于同一个局域网中），以及6666端口，设置了5秒的响应超时。

private void doConnect() {
        //子线程请求网络
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Socket socket = new Socket();
                    //建立Socket连接，需要服务端IP地址和端口号
                    socket.connect(new InetSocketAddress("192.168.1.188", 6666), 5 * 1000);
                    //通过Socket实例获取输入输出流，作为和服务器交换数据的通道
                    bis = new BufferedInputStream(socket.getInputStream());
                    bos = new BufferedOutputStream(socket.getOutputStream());

                    readThread = new ReadThread();
                    readThread.start();

                    Log.i("Socket","socket连接成功");
                } catch (Exception e) {
                    e.printStackTrace();
                    Log.i("Socket","socket连接失败");
                }
            }
        }).start();
    }

2.新建子线程WriteThread，负责向服务器发送数据， showText()是显示客服端与服务端通讯数据的方法。

//启动一个线程，在子线程中发送数据给服务端
   private class WriteRead extends Thread{
       @Override
       public void run() {
           try {
               String iSay = "我说：媳妇儿媳妇儿，你还行吗？";
               bos.write(iSay.getBytes());
               //记得一定要flush一下
               bos.flush();
               showText(FROM_CLIENT, iSay);
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   }

3.客服端通过WriteRead 向服务端发送数据后，我们肯定就是要去建立一个测试的服务端去接收数据。
新建Java类SocketServer，需要注意的是，这个类的位置需要与与包名平级，即放在As的Java目录下。
代码中的端口号需要与Android中设置的端口号一样，即6666。
在连接建立后立马创建了一个服务端的ReadThread去读取信息，读取到信息后，又立马使用bos给客户端回写了一条消息。这时，我们就需要在客户端去创建接受消息的方法了。

public class SocketServer {

    private static BufferedOutputStream bos;
    private static BufferedInputStream bis;
    private static ReadThread readThread;

    public static void main(String args[]){
        try{
            //通过accept方法获取socket实例，只有在程序获得到一个socket实例后，程序才会继续向下执行，否则会一直阻塞在accept方法
            ServerSocket  serverSocket = new ServerSocket(6666);
            Socket socket = serverSocket.accept();
            //通过Socket实例获取输入输出流，作为和服务器交换数据的通道
            bis = new BufferedInputStream(socket.getInputStream());
            bos = new BufferedOutputStream(socket.getOutputStream());

            readThread = new ReadThread();
            readThread.start();
        }catch (Exception e){
            e.printStackTrace();
            System.out.print("完了完了，我GG了");
        }
    }
    //启动一个线程，一直读取从客户端发送过来的消息
    private static class ReadThread extends Thread{
        @Override
        public void run() {
            while (true){
                byte[] data = new byte[1024];
                int size = 0;
                try {
                    //收到客服端发送的消息后，返回一个消息给客户端
                    while((size = bis.read(data)) != -1){
                        String str = new String(data,0,size);
                        System.out.print("老公对我说:"+str);
                        bos.write("媳妇儿说：死鬼！我还要，不够嘛。".getBytes());
                        bos.flush();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                    System.out.print("完了完了，我GG了");
                }
            }
        }
    }

4.回到MainActivity去创建接收服务端返回消息的方法：即客户端的ReadThread，同样的也需要启动一个线程，因为不管是使用bis去读取数据，还是使用bos去读取数据，都是需要去操作网络的，而我们Android中只能在子线程操作网络。
读取到数据后，使用Handler将信息传递回主线程显示

//启动一个线程，一直读取从服务端发送过来的消息
    private class ReadThread extends Thread {
        @Override
        public void run() {
            while (true) {
                byte[] data = new byte[1024];
                int size = 0;
                try {
                    //收到客服端发送的消息后，返回一个消息给客户端
                    while((size = bis.read(data)) != -1) {
                        String str = new String(data, 0, size);
                        Message msg = new Message();
                        msg.obj = new String(str);
                        mHandler.sendMessage(msg);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

5.下面是MainActivity中所有的代码：

public class MainActivity extends AppCompatActivity {

    private Button bt_sendData;
    private LinearLayout ll_content;
    private BufferedOutputStream bos;
    private BufferedInputStream bis;
    private ReadThread readThread;
    private WriteRead writeRead;
    private int FROM_CLIENT = 0;
    private int FROM_SERVER = 1;

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

    private void initView() {
        bt_sendData = (Button) findViewById(R.id.bt_sendData);
        ll_content = (LinearLayout) findViewById(R.id.ll_content);

        bt_sendData.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                writeRead = new WriteRead();
                writeRead.start();
            }
        });
    }

    private void doConnect() {
        //子线程请求网络
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Socket socket = new Socket();
                    //建立Socket连接，需要服务端IP地址和端口号
                    socket.connect(new InetSocketAddress("192.168.1.188", 6666), 5 * 1000);
                    //通过Socket实例获取输入输出流，作为和服务器交换数据的通道
                    bis = new BufferedInputStream(socket.getInputStream());
                    bos = new BufferedOutputStream(socket.getOutputStream());

                    readThread = new ReadThread();
                    readThread.start();

                    Log.i("Socket","socket连接成功");
                } catch (Exception e) {
                    e.printStackTrace();
                    Log.i("Socket","socket连接失败");
                }
            }
        }).start();
    }

    //启动一个线程，一直读取从服务端发送过来的消息
    private class ReadThread extends Thread {
        @Override
        public void run() {
            while (true) {
                byte[] data = new byte[1024];
                int size = 0;
                try {
                    //收到客服端发送的消息后，返回一个消息给客户端
                    while((size = bis.read(data)) != -1) {
                        String str = new String(data, 0, size);
                        Message msg = new Message();
                        msg.obj = new String(str);
                        mHandler.sendMessage(msg);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //启动一个线程，在子线程中发送数据给服务端
    private class WriteRead extends Thread{
        @Override
        public void run() {
            try {
                String iSay = "我说：媳妇儿媳妇儿，你还行吗？";
                bos.write(iSay.getBytes());
                //记得一定要flush一下
                bos.flush();
                showText(FROM_CLIENT, iSay);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            String xifuerSay = msg.obj.toString();
            showText(FROM_SERVER, xifuerSay);
        }
    };

    //显示客户端与服务端之间的对话
    private void showText(final int type,final  String text) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                TextView tv = new TextView(MainActivity.this);
                tv.setText(text);
                tv.setTextSize(TypedValue.COMPLEX_UNIT_SP, 20);
                tv.setLayoutParams(new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT));
                if (type == FROM_CLIENT) {
                    tv.setTextColor(Color.parseColor("#000000"));
                } else if (type == FROM_SERVER) {
                    tv.setTextColor(Color.parseColor("#ff0000"));
                }
                ll_content.addView(tv);
            }
        });
    }
}

6.主程序就是一个MainActivity和一个SocketServer类，测试的时候首先需要在As中启动服务端SocketServer，然后再启动我们的APP程序。
7.这个程序有很多的不足，比如粗暴的创建线程，退出App后重新进入点击按钮，就收不到服务端返回的消息了。下篇文章将在服务中结合线程池去解决这些问题。