lykAnd的博客

lykAnd的博客

Android App开发基础篇—Socket通信

Android App开发基础篇—Socket通信

    前言:离职闲置了半年,终于又开始上班了。重新工作的第一个项目就是Socket通信,虽然自己对Socket有一点点印象(读书的时候有过Java网络编程的课程),但是之前的工作中完全没接触过,于是,果断买了一本Android网络编程的书来开始学习。下面简单做一个学习笔记。

一、首先,看一下Socket和ServerSocket最基本的用法

1.1、在Eclipse上创建ServerSocket,代码如下:

public class Server{
    
public static void main(String[] args) {
    try {
        //获取ServerSocket实例,监听指定端口
        ServerSocket server = new ServerSocket(8033);
        System.out.println("服务端已启动,等待客户端连接...");
        //accept()方法接收客户端的Socket连接请求,返回一个
        //与客户端对应的Socket
        Socket socket = server.accept();
        System.out.println("客户端" + socket.getInetAddress() + "已连接...");
        //获取Socket的输出流
        OutputStream os = socket.getOutputStream();
        //将输出流包装成PrintStream
        PrintStream ps = new PrintStream(os);
        //向客户端输出信息
        ps.println("Hello客户端");
        //关闭输出流
        ps.close();
        //关闭Socket
        socket.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
}

1.2、编写Android客户端Socket程序,代码如下: 

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private static String TAG = "MainActivity";

    //服务端的IP地址,依据每个人的实际情况而不同,例如
    //笔者的服务端是在自己电脑上用Eclipse写的应用程序,
    //因此此处IP地址是用ipconfig(windows系统下)命令查询
    //到的电脑的IPv4地址
    private static final String IP = "192.168.1.132";
    //端口号,有效值0~65535,避免使用已被占用的端口号
    private static final int PORT = 8033;
    private String data = "this is from socket client";
    private Socket socket;
    private Button mBtnConn;
    private Button mBtnSend;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mBtnConn = (Button) findViewById(R.id.btn_connect);
        mBtnSend = (Button) findViewById(R.id.btn_send);
        mBtnConn.setOnClickListener(this);
        mBtnSend.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_connect:
                //Android上不能将网络操作写在主线程,
                //这里创建一个线程来执行Socket操作
                new ClientThread().start();
                break;
            case R.id.btn_send:
                break;
        }
    }

    //执行Socket操作的线程
    private class ClientThread extends Thread {
        @Override
        public void run() {
            super.run();
            try {
                //获取Socket实例,通过指定的端口号向指定的IP地址Server发送连接请求
                Socket socket = new Socket(IP, PORT);
                //获取Socket输入流
                InputStream is = socket.getInputStream();
                //将Socket输入流包装成BufferedReader
                BufferedReader buff = new BufferedReader(new InputStreamReader(is));
                //读取数据
                String s = buff.readLine();
                //打印信息
                Log.e(TAG, "run: 服务端:" + s);
                //关闭输入流
                buff.close();
                //关闭Socket
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

    以上便是Socket通信最基本的过程。在Eclipse上运行Server端程序,然后运行Android客户端APP,点击“连接”按钮,连接成功后,Server端直接向Client端发送信息,Client端接收到消息后通过log打印出来。通信结束后双方都关闭各自的IO流和Socket连接。这里只是一个简单的例子,但实际应用中不会这么简单,通常都需要Server端和Client端都具备接收消息和发送消息的功能。因此,接下来需要修改一下程序。

二、Socket通信Server端和Client端互发信息

2.1、在Eclipse中书写Server端代码如下:

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;

import javax.swing.JButton;
import javax.swing.JTextArea;

    public class Server implements ActionListener {

        private JButton sendButton;
        private Window window;
        private ServerSocket serverSocket;
        private JTextArea jTextArea;
        private Socket mCurrentSocket;

        public Server() {
            // 为了操作方便,这里写一个Java应用程序窗口
            window = new Window("服务端");
            // 获取一个按钮
            sendButton = window.getSendButton();
            // 给按钮设置事件监听
            sendButton.addActionListener(this);
            // 获取一个文本显示区
            jTextArea = window.getJTextArea();
            try {
                // 获取ServerSocket实例,开启端口监听
                serverSocket = new ServerSocket(8033);
                System.out.println("服务端已启动,等待客户端连接...");
                jTextArea.append("服务端已启动,等待客户端连接...\n");
                // 使用while循环实现持续监听客户端Socket连接请求
                while (true) {
                    // accept()方法接收客户端Socket连接请求,产生一个与客户端对应
                    // 的Socket
                    Socket socket = serverSocket.accept();
                    //这里用一个全局变量mCurrentSocket来记录当前正在与服务端互动的
                    //的客户端Socket,即最新连接Server端,或者最近一次向Server端发送
                    //消息的客户端Socket,服务端发送的消息会被该客户端接收
                    mCurrentSocket = socket;
                    System.out.println("客户端" + socket.getInetAddress() + "已连接...");
                    jTextArea.append("客户端:" + socket.getInetAddress() + "已连接...\n");
                    //每有一个客户端Socket接入,就开启一个线程单独监听来自该客户端的消息的输入
                    new Thread(new Runnable() {
                        @Override
                        public void run() {
                            // 当一个客户端Socket连接成功时,开启一个while循环
                            // 用于持续监听客户端的消息输入
                            while (true) {
                                if(!socket.isClosed()) {
                                    // 读取客户端发送的消息
                                    readMessage(socket);
                                }
                            }
                        }
                    }).start();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // main方法是Java程序启动的入口
        public static void main(String[] args) {
            new Server();
        }

        private void readMessage(Socket socket) {
            //记录最近一次向服务端发送消息的客户端Socket,服务端发送
            //的消息将被该客户端接收
            mCurrentSocket=socket;
            try {
                // 获取客户端Socket输入流
                InputStream is = socket.getInputStream();
                // 将输入流包装成BufferedReader
                BufferedReader buff = new BufferedReader(new InputStreamReader(is));
                // 读取数据
                String readLine = buff.readLine();
                System.out.println("来自客户端:" + readLine);
                jTextArea.append("来自客户端:" + readLine + "\n");
            } catch (IOException e) {
                e.printStackTrace();
                try {
                    socket.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        }

        @Override
        public void actionPerformed(ActionEvent arg0) {
            sendMessage();
        }

        private void sendMessage() {
            try {
                // 将Socket对应的输出流包装成PrintStream
                PrintStream ps = new PrintStream(mCurrentSocket.getOutputStream());
                // 进行普通IO操作,向客户端输出信息
                ps.println("Hello客户端");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

2.2、Android客户端代码如下:

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private static String TAG = "MainActivity";
    private static final String IP = "192.168.1.132";
    private static final int PORT = 8033;
    private String data = "this is from socket client";
    private Button mBtnConn;
    private Button mBtnSend;
    private TextView mMessageTv;
    private Socket mSocket;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mMessageTv = (TextView) findViewById(R.id.message_tv);
        mBtnConn = (Button) findViewById(R.id.btn_connect);
        mBtnSend = (Button) findViewById(R.id.btn_send);
        mBtnConn.setOnClickListener(this);
        mBtnSend.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_connect:
                //Android上不能将网络操作写在主线程,
                //这里创建一个线程来执行Socket操作
                new ConnectThread().start();
                break;
            case R.id.btn_send:
                new SendDataThread().start();
                break;
        }
    }

    //执行Socket连接操作的线程
    private class ConnectThread extends Thread {
        @Override
        public void run() {
            super.run();
            try {
                //获取Socket实例,通过指定的端口号向指定的IP地址Server发送连接请求
                mSocket = new Socket(IP, PORT);
                if (mSocket != null) {
                    //获取Socket输入流
                    InputStream is = mSocket.getInputStream();
                    //将Socket输入流包装成BufferedReader
                    BufferedReader buff = new BufferedReader(new InputStreamReader(is));
                    //连接成功以后,开启一个while循环来持续监听服务端的消息输入
                    while (true) {
                        final String s = buff.readLine();
                        //将获取到的信息显示在TextView上,子线程中不能更新UI,这里直接用
                        //runOnUiThread来做
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                mMessageTv.append("来自服务端:" + s + "\n");
                            }
                        });
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private class SendDataThread extends Thread {
        @Override
        public void run() {
            super.run();
            if (mSocket != null) {
                try {
                    OutputStream os = mSocket.getOutputStream();
                    PrintStream ps = new PrintStream(os);
                    ps.println(data);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

    好了,上面的代码已经可以实现Socket服务端和客户端互相收发消息的通信 了。燃鹅,问题还没有结束。相信熟悉的同学马上就会发现了,上面的程序有问题,有BUG。那么,问题在哪里呢?很简单,我们多启动一个客户端,然后两个客户端分别与服务端互发消息,问题马上就出现 了。尝试过后发现,如果启动了两个客户端,服务端只能向其中一个客户端发送消息,而两个客户端也只有其中一个能向服务端发送消息。并且当两个客户端分别都执行了向客户端发消息的操作后,原本能向服务端发送消息的客户端再发消息时,服务端接收到的却是空数据。这里出现问题的原因,由于作者目前水平有限,暂时无法解释清楚。只是根据书本的说法,这里我们需要开启多线程。因此,下面我们继续对代码进行修改。修改的地方主要在服务端,将读取客户端消息的代码放到一个线程里面。即将上面服务端代码中的

// 当一个客户端Socket连接成功时,开启一个while循环
// 用于持续监听客户端的消息输入
while(true){
    // 读取客户端发送的消息
    readMessage(socket);
}

部分放入一个线程中去执行。修改如下:

new Thread(new Runnable() {
@Override
public void run() {
        // 当一个客户端Socket连接成功时,开启一个while循环
        // 用于持续监听客户端的消息输入
        while (true) {
        // 读取客户端发送的消息
        readMessage(socket);
        }
     }
}).start();

    好了,现在服务端可以同时跟多个客户端正常通信了。然而,现在的程序虽然可以运行,也能实现功能,达到效果,但是还是存在一些问题的。这也是本人目前水平的局限,这里就暂且把问题留下,当做今后学习的方向之一。

最后贴上程序中用到的用于创建Java应用程序窗口的Window类

import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextArea;
import javax.swing.JTextField;

    public class Window extends JFrame {

        /**
         * 窗口类 定义客户端和服务器端的窗口
         */
        private static final long serialVersionUID = 2L;
        private String windowName;
        private JFrame myWindow;
        private JTextArea area;
        private JTextField field;
        private JButton btnSend;
        private JButton btnSendAll;

        public Window(String windowName) {
            this.windowName = windowName;
            myWindow = new JFrame(windowName);
            myWindow.setLayout(new FlowLayout());
            myWindow.setSize(new Dimension(500, 300));
            // 不能改变窗口大小
            myWindow.setResizable(false);

            area = new JTextArea();
            field = new JTextField();
            btnSend = new JButton("Send");
            btnSendAll = new JButton("Send To All");

            // 设置field的大小
            field.setPreferredSize(new Dimension(300, 30));
            myWindow.add(field);
            myWindow.add(btnSend);
            myWindow.add(btnSendAll);
            myWindow.add(area);
            // 改变area的大小
            area.setPreferredSize(new Dimension(470, 210));
            area.setBackground(Color.PINK);
            area.setEditable(false);
            // 设置窗口显示在电脑屏幕的某区域
            myWindow.setLocation(400, 200);

            myWindow.setVisible(true);
            // 点击关闭按钮时触发该方法
            closeMyWindow();
        }

        /**
         * 方法名:closeMyWindow()
         *
         * @param
         * @return 功能:当用户点击关闭按钮时,退出并且关闭该窗口
         */
        private void closeMyWindow() {
            myWindow.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        }

        /**
         * 方法名:getFieldText()
         *
         * @param
         * @return string 功能:获取窗口的TextField中的字符串
         */
        public String getFieldText() {
            return field.getText().toString();
        }

        /**
         * 方法名:getSendButton()
         *
         * @param
         * @return JButton 功能:获得该窗口中的按钮
         */
        public JButton getSendButton() {
            return btnSend;
        }

        /**
         * 方法名:getSendAllButton()
         *
         * @param
         * @return JButton 功能:获得该窗口中的按钮
         */
        public JButton getSendAllButton() {
            return btnSendAll;
        }

        /**
         * 方法名:getJTextArea()
         *
         * @param
         * @return JTextArea 功能:返回窗口中的JTextArea
         */
        public JTextArea getJTextArea() {
            return area;
        }

        /**
         * 方法名:getTextField()
         *
         * @param
         * @return JTextField 功能:获得窗口中的textfield
         */
        public JTextField getTextField() {
            return field;
        }
    }

    后记:Android 开发中的Socket通信主要用到了Java API中java.net中的两个类Socket和ServerSocket,分别用来表示Socket连接的客户端和服务端。Socket通信的过程大致可描述为:(1)Server端运行一个SocketServer程序,监听设备上指定的端口;(2)Client端通过指定的Server端的IP地址和端口号,向Server端发起连接请求;(3)Server端向Client发回Accept(接收)消息,Socket连接建立;(4)Server端和Client端开始通信。



阅读更多
版权声明:本文为博主原创文章,转载请注明。 https://blog.csdn.net/lyklykkk/article/details/73732390
个人分类: Android
想对作者说点什么? 我来说一句

Android NDK tcp例子

2014年10月21日 731KB 下载

Android App的签名打包

2014年07月31日 13KB 下载

没有更多推荐了,返回首页

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭