android Socket 和 ServerSocket简单实现

Alex老夫子

已于 2022-09-24 18:28:21 修改

阅读量1.6k

点赞数 1

分类专栏： Android 文章标签： android java 单例模式 ServerSocket Socket

于 2022-09-24 18:17:04 首次发布

本文链接：https://blog.csdn.net/msn465780/article/details/127028800

版权

Android 专栏收录该内容

145 篇文章

订阅专栏

直接上代码：

客户端：

package com.example.myapplication.util;

import android.os.SystemClock;
import android.text.TextUtils;
import android.util.Log;
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;

/**
 * 客户端Socket工具类
 */
public class SocketUtil {

    private PrintWriter mPrintWriter;
    /**
     * 是否关闭连接
     */
    private boolean isFinishing;
    private Socket socket = null;

    private static volatile SocketUtil socketUtil;

    /**
     * socketUtil 单例模式 - 双重校验锁
      */
    public static SocketUtil getInstance() {
        if (socketUtil == null) {
            synchronized (SocketUtil.class) {
                if (socketUtil == null) {
                    socketUtil = new SocketUtil();
                }
            }
        }
        return socketUtil;
    }

    /**
     * 开启连接
     */
    public void connect() {
        while (socket == null){
            try {
                // 设置服务器相同的ip和端口 8080
                socket = new Socket("192.168.0.104",8080);
                mPrintWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
                        socket.getOutputStream())),true);
            } catch (IOException exception){
                Log.d("Alex", "连接服务异常: " + exception.toString());
                SystemClock.sleep(1000);
            } catch (Exception exception) {
                exception.printStackTrace();
                Log.d("Alex", "接收消息异常: " + exception.toString());
            }
        }
        try {
            // 用于接收服务端的消息
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            while(!isFinishing){
                final String msg = br.readLine();
                if (msg != null){
                    Log.d("Alex", "接收到消息：" + msg);
                }
            }
            mPrintWriter.close();
            br.close();
            socket.close();
            Log.d("Alex", "关闭连接：");
        } catch (IOException exception){
            exception.printStackTrace();
            Log.d("Alex", "接收消息异常: " + exception.toString());
        } catch (Exception exception) {
            exception.printStackTrace();
            Log.d("Alex", "接收消息异常: " + exception.toString());
        }
    }

    /**
     * 关闭连接
     */
    public void close() {
        isFinishing = true;
    }

    /**
     * 向服务端发送消息
     * @param msg 消息
     */
    public void sendMessage(String msg) {
        if (!TextUtils.isEmpty(msg) && mPrintWriter != null) {
            mPrintWriter.println(msg);
        }
    }



}

服务端：

package com.example.myapplication.util;

import android.text.TextUtils;
import android.util.Log;
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;

/**
 * 服务端Socket工具类
 */
public class ServerSocketUtil {

    private static volatile ServerSocketUtil serverSocketUtil;
    private PrintWriter mPrintWriter;

    /**
     * ServerSocketUtil 单例模式 - 双重校验锁
     */
    public static ServerSocketUtil getInstance() {
        if (serverSocketUtil == null) {
            synchronized (ServerSocketUtil.class) {
                if (serverSocketUtil == null) {
                    serverSocketUtil = new ServerSocketUtil();
                }
            }
        }
        return serverSocketUtil;
    }

    /**
     * 初始化服务
     */
    public void init() {
        try {
            //服务器对象，定义一个端口
            ServerSocket server = new ServerSocket(8080);
            //客户端对象
            Socket socket = null;
            boolean flag = true;
            while (flag) {
                Log.d("Alex", "等待客户端请求......");
                // 这里是阻塞方法，接收下一个客户端Socket对象
                socket = server.accept();
                //接受客户端传来的字符串
                Log.d("Alex", "新客户端连接......");
                try {
                    mPrintWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
                            socket.getOutputStream())),true);
                } catch (IOException e) {
                    e.printStackTrace();
                }

                try {
                    //负责读取从客户端发送过来的字符串
                    BufferedReader buff = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
                    boolean clientFlag = true;
                    while (clientFlag) {
                        try {
                            char[] charArray = new char[16];
                            int size = buff.read(charArray);
                            if (size > -1) {
                                Log.d("Alex", "read size : " + size);
                                String openStatus = new String(charArray);
                                Log.d("Alex", "read content : " + openStatus);
                                if (openStatus.contains("健身")) {
                                    Log.d("Alex", "健身");
                                } else if (openStatus.contains("跑步")) {
                                    Log.d("Alex", "跑步");
                                } else {
                                    break;
                                }
                            } else {
                                clientFlag = false;
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                            clientFlag = false;
                            Log.d("Alex", "数据读取异常......");
                            Log.d("Alex", e.toString());
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    Log.d("Alex", "输入流组装异常......");
                    Log.d("Alex", e.toString());
                } finally {
                    socket.close();
                }
            }
            server.close();
            Log.d("Alex", "服务器已经关闭.........");
        } catch (Exception e) {
            e.printStackTrace();
            Log.d("Alex", "客户端连接异常......");
            Log.d("Alex", e.toString());

        }
    }

    /**
     * 向客服端发送消息
     * @param msg 消息
     */
    public void sendMessage(String msg) {
        if (!TextUtils.isEmpty(msg) && mPrintWriter != null) {
            mPrintWriter.println(msg);
        }
    }

}

由于需要操作流，所以都要在子线程中使用，如下：

客户端：

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        new Thread(new Runnable() {
            @Override
            public void run() {
                SocketUtil.getInstance().connect();
            }
        }).start();
    }

服务端：

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        new Thread(new Runnable() {
            @Override
            public void run() {
                ServerSocketUtil.getInstance().init();
            }
        }).start();
    }

这样简单的代码就可以实现长链接和收发消息，客户端和服务端可以互相发送消息。

注意：

一般情况下手机运行客户端代码，服务器运行服务端代码，

but，客户端和服务端是相对而言的，代码可以互相使用，比如手机运行服务端代码，服务器运行客户端代码；

手机端什么网络权限啥的，该加的一定不要忘了。

好了，又可以愉快玩耍了。