关于socket 两台Android设备上的通信

没想到这么旧的东西还有人支持。我一开心就把源码传github上了。哈哈。然后下面的代码有两处错误。（一个是start（）写成了run（）,

另外一处的bundle没加到message里）在github中已经纠正。github是可以直接运行的。需要一台手机或者两台手机都可以。一台手机记得链接之前ip输入127.0.0.1。

哈哈哈 这个是链接 https://github.com/roofroot/SocketTest

另外compose富文本编辑持续更新中，其实做这个是想实现

富文本编辑器的传文件功能。本来是想做外网的。但是既然不能外网就打算直接用蓝牙通讯了。后面蓝牙功能写好会单独开一篇。最近还是在做ui.

 

好久没有看过socket的代码，今天想实现一个两台手机之间互传的功能，本来想用蓝牙，但是想着，蓝牙有距离限制，如果直接用网络通讯。

这样就可以远程发送了啊。于是我想起了socket。经过一上午的时间写了一个demo。然而仅仅实现了局域网的链接。从网上查资料，看了很多关于内网穿透的

文章。似乎虽然能够查询到本机的外网地址，但是其他设备并不能直接通过这个外网的ip地址访问到这个设备。其中涉及到了一个名词叫做内网穿透。由于我不是做

服务器的所以也没太看懂。大概的意思就是外网并不能直接访问内网，需要经过一些端口的映射。而即时通讯类的软件，客户端需要链接到服务器由服务器进行网络地址的映射，

交换数据，经过交换数据成功以后。两台设备链接上了，之后才可以进行点对点的通讯。（也不知道理解的对不对） 虽然说通过一些其他人开发的软件，也能在手机上进行内网穿透，

但是对我来说意义不大，毕竟我想实现的是两台设备的数据互传，而不是必须其中一台当做服务器。所以记录一下我做局域网socket通讯的简单代码吧。

没有实现具体的业务逻辑，所以整个代码非常简单。简单的说一下socket是如果进行通讯的

ScoketServer 初始化后，我们可以开启一个线程用来等待Socket客户端的链接。链接成功以后会返回一个Socket对象，我们就使用这个Socket对象收发消息

我要实现的是两台设备之间的消息互传，所以这两台设备需要一个创建SocketServer用来等待链接，另一个创建Socket连接到这个Service

下面这段代码是Socket创建并链接ServerSocket的方法。需要注意的就是所有的链接与开启输入输出流的代码都不要放主线程就可以了

public class ClientSocketUtil implements Runnable {
    public static String ip;
    public static int prot=1040;
    private Socket clientSocket;
    private  DataInputStream dataInputStream= null;
    private  DataOutputStream dataOutputStream = null;
    private Handler handler;
    public ClientSocketUtil(Handler handler){
//            new Thread(this).run();
        new Thread(this).start();
    }
    public void sendMsg(String  msg){
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Log.e("client","客户端发送消息"+msg);
                    dataOutputStream.writeUTF(msg);
                } catch (IOException e) {
                    e.printStackTrace();
                    Log.e("client","客户端发送消息出错");
                    Log.e("client",e.getMessage());
                }

            }
        }).start();

    }
    public void close(){
        if(clientSocket!=null){
            try {
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    @Override
    public void run() {
        if(clientSocket==null) {
            try {
                InetAddress serverAddr = InetAddress.getByName(ip);
                clientSocket = new Socket(ip, prot);
                if(clientSocket.isConnected()) {
                    Log.e("client","客户端链接成功");
                    dataInputStream = new DataInputStream(clientSocket.getInputStream());
                    dataOutputStream = new DataOutputStream(clientSocket.getOutputStream());
                    while (true) {
                        try {
                            if(dataInputStream!=null) {
                                String str = dataInputStream.readUTF();
                                Message message = new Message();
                                Bundle bundle = new Bundle();
                                bundle.putString("msg", str);
                                handler.sendMessage(message);
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }else{

                }
            } catch (IOException e) {
                e.printStackTrace();
                Log.e("client","链接失败");
            }

        }

    }
}

 下面这段是ServerSocket初始化并等待链接的代码，如果成功链接以后，用另一个工具类来收发消息。这个工具类的代码和上面的Socket工具类基本一致。只是Socket的对象是ServerSocket返回的。只需要这三个类的代码就可以实现最基础的局域网通讯了。由于我要实现的是互传。所以并没有考虑到多链接的场景。应该只需要每一台都执行一下

ServerSocket用来接收链接，并把所有的链接对象都保存起来就可以实现 多对多的通讯方式了。只是回复消息需要使用不同的链接对象，未免太消耗内存。所以手机端还是不适合这么搞的。互传的功能应该优化一下代码，仅接收一个链接

工具类代码

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

public class KeepSocketUtil implements Runnable {
    private Socket clientSocket;
    private static DataInputStream dataInputStream = null;
    private static DataOutputStream dataOutputStream = null;
    private Handler handler;

    public KeepSocketUtil(Socket socket, Handler handler) {

            this.handler = handler;
            this.clientSocket = socket;
            new Thread(this).run();

    }

    public void sendMsg(String msg) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    dataOutputStream.writeUTF(msg);
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }).start();

    }
    public void close(){
        if(clientSocket!=null){
            try {
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void run() {
        if(clientSocket==null){
            return;
        }
        try {
            dataInputStream = new DataInputStream(clientSocket.getInputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            dataOutputStream = new DataOutputStream(clientSocket.getOutputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }
        while (true) {
            try {
                String str = dataInputStream.readUTF();
                Log.e("msg","服务器接受消息"+str);
                Message message = new Message();
                Bundle bundle = new Bundle();
                bundle.putString("msg", str);
                message.setData(bundle);
                handler.sendMessage(message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

ServerSocket代码

import android.os.Handler;
import android.util.Log;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerSocketUtil implements Runnable{
    public static int prot=1040;
    private Socket clientSocket;
    private ServerSocket serverSocket;
    private KeepSocketUtil keepSocketUtil;

    public KeepSocketUtil getKeepSocketUtil() {
        return keepSocketUtil;
    }

    Handler handler;
    public ServerSocketUtil(Handler handler){
        this.handler=handler;
        new Thread(this).start();
    }
    public void close(){
        if(serverSocket!=null) {
            try {
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    @Override
    public void run() {
        if(serverSocket==null) {
            try {
                serverSocket = new ServerSocket(prot);
                Log.e("server","服务器启动成功");
            } catch (IOException e) {
                e.printStackTrace();
                Log.e("server","服务器启动失败"+e.getMessage());
            }
        }
        if(serverSocket!=null) {
            while (true) {

                try {
                    this.clientSocket = serverSocket.accept();
                } catch (IOException e) {
                    Log.e("server", "有客户端链接失败"+e.getMessage());
                    e.printStackTrace();
                }
                if (clientSocket != null) {
                    Log.e("server", "有客户端请求链接");
                    keepSocketUtil = new KeepSocketUtil(clientSocket, handler);
                }
            }
        }



    }
}