Socket 网络通信

Socket 网络通信

1.OSI (Open System Interconnect Reference Model)(开放系统互联参考模型)

从下低到高 ：物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。

2.TCP/IP

TCP/IP 是一个协议族，里边包括很多协议，TCP，IP知识两个很重要的协议。

TCP(Transmission Control Protocol,传输控制协议) 是面向连接的协议，在收发数据时，都需要与对面建立连接，TCP协议能够确保数据在传输过程中不会遗失。它的缺点是过程复杂，消耗的资源更多。

UDP(User Datagram Protocol)用户数据报协议，相比TCP就是无需建立连接，结构简单，无法保证正确性，容易丢包。

3.Socket 实现网络通信

Socket（套接字），用来描述IP地址和端口，是通信链的句柄，应用程序可以通过Socket向网络发送请求或者应答网络请求。Socket是支持TCP/IP协议的网络通信的基本操作单元。

3.1 实现服务端和客户端连接

服务端：

    // 1.创建服务端 Socket 并绑定端口
    ServerSocket serverSocket=new ServerSocket(6666);
    String ip=InetAddress.getLocalHost().getHostAddress();

    S.println("~ ~ ~ 服务端已开启。 IP:"+ip);

    // 2.调用 accept() 方法，等待客户连接
    Socket socket=serverSocket.accept();

    // 3.获取输入流
    InputStream inputStream = socket.getInputStream();
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));

    //4. 不断读取客户端信息
    String info;
    while ((info=bufferedReader.readLine())!=null){
        S.println(info);
    }

    socket.shutdownInput(); //关闭输入流
    socket.close();//关闭连接

客户端：

private void acceptServer() throws IOException {

    // 1.创建客户端Socket,指定服务器地址和端口
    Socket socket=new Socket(IP,PORT);
    // 2.获取输出流
    OutputStream outputStream=socket.getOutputStream();
    String string = "Tiger connect to server.";
    // 3.向输出流中写入数据
    outputStream.write(string.getBytes());
    outputStream.flush(); // *** 强制发送缓冲区数据 ***

    socket.shutdownOutput(); //关闭输出流
    socket.close();//关闭连接
}

3.2 多个客户端之间通信

实际上是所有客户端都向服务端发送消息，然后服务端再将消息返回给所有客户端。

服务端：

public class Server {

    private static final int PORT = 6666; //端口
    private List<Socket> list = new ArrayList<>(); //存储所有客户端
    private ServerSocket serverSocket = null;
    private ExecutorService myExecutorService = null; //线程池

    public static void main(String[] args) throws IOException {

        new Server(); //在构造函数中开启服务端
    }

    public Server() throws IOException {

        // 1.创建Socket 服务并指定端口
        serverSocket = new ServerSocket(PORT);
        // 2.创建线程池
        myExecutorService = Executors.newCachedThreadPool();
        S.println("Server is running...");
        // 3.不断地等待客户端连接，当有客户端连接后，添加到Socket集合，开启新的线程到线程池中
        Socket client = null;
        while (true) {
            client = serverSocket.accept();
            list.add(client);
            myExecutorService.execute(new Service(client));
        }
    }

    class Service implements Runnable {

        private Socket socket;
        private BufferedReader br;
        private String msg;

        public Service(Socket socket) throws IOException {
            this.socket = socket;

            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            msg = "User:" + socket.getInetAddress().getHostAddress() + " ~ join the chat group. The amount of online:" + list.size();
            this.sendMessage();
        }

        @Override
        public void run() {

            try {
                // 不断接受客户端发来的消息，直到客户端退出， “bye”
                while (true) {
                if ((msg = br.readLine()) != null) {
                        if (msg.equals("bye")) { //客户端退出

                            S.println(" ~~~ ~~~ ~~~ ~~~ ");
                            list.remove(socket);
                            socket.close();
                            msg = "User:" + socket.getInetAddress() + " exit. The amount of online:" + list.size();
                            this.sendMessage();
                            break; // *** 退出循环 ***
                        } else { //客户端发送消息
                            msg = socket.getInetAddress() + " say:" + msg;
                            this.sendMessage();
                        }
                    }
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        //为连接上服务端的每个客户端发送消息
        public void sendMessage() throws IOException {

            S.println(msg);
            //向每个客户端发送消息
            for (Socket socketClient : list) {
                try {
                    PrintWriter pout = new PrintWriter(new BufferedWriter(
                            new OutputStreamWriter(socketClient.getOutputStream(),"UTF-8")),true);
                    pout.println(msg);
                }catch (IOException e) {e.printStackTrace();}
            }
        }
    }
}

客户端：

public class MainActivity extends AppCompatActivity implements Runnable {

    private final String IP = "10.0.2.2"; //IP
    private final int PORT = 6666; //端口
    private EditText etMessage;
    private TextView tvMessage;

    private Socket socket;
    private BufferedReader br;
    private OutputStream outputStream;
    private String msg;

    private PrintWriter pw;
    private boolean bIsClosed = false; //是否退出

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

        //Init controls
        etMessage = (EditText) findViewById(R.id.et_Message);
        tvMessage = (TextView) findViewById(R.id.tv_Message);

        connectToServer();
        new Thread(MainActivity.this).start();
    }

    //连接到服务端
    private void connectToServer() {

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // 1.创建客户端Socket,指定服务器地址和端口
                    socket = new Socket(IP, PORT);
                    // 2.获取输入流
                    br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                    // 3.获取输出流
                    outputStream = socket.getOutputStream();
                    pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)), true);

                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }).start();
    }

    public void onClick(View view) throws IOException {

        //Send message
        msg = etMessage.getText().toString();
        sendMessage();
    }

    public void sendMessage(){

        //Socket 已经连接，并且输出流没有关闭
        if (socket.isConnected() && !socket.isOutputShutdown()) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    if (bIsClosed)
                        pw.println("bye");
                    else
                        pw.println(msg);
                }
            }).start();
        }
    }

    @Override
    public void run() {

        try {
            //不断地从输入流中读取数据
            while (true) {
                //Socket已经连接
                if (socket != null) {
                    if ((msg = br.readLine()) != null) {

                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                tvMessage.setText(tvMessage.getText().toString() + msg + "\n");
                            }
                        });
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onDestroy() {

        bIsClosed = true;
        sendMessage();
        super.onDestroy();
    }
}

3.3 Socket 上传文件

服务端：

    // 1.创建服务端 Socket 并绑定端口
    ServerSocket serverSocket=new ServerSocket(8888);
    S.println("~~~ Server is running，waiting for client  ~~~");
    // 2.调用 accept() 方法，等待客户连接
    Socket socket=serverSocket.accept();
    // 3.获取输入流
    InputStream inputStream = socket.getInputStream();
    // 4.获取文件名称
    String fileName="";
    int len2;
    while ((len2=inputStream.read())!=-1){
        if(len2=='\t')
            break;
        else
            fileName+=String.valueOf ((char)(len2));
    }
    // 5.创建文件，用来存储用户上传数据
    FileOutputStream outputStream=new FileOutputStream(fileName,true);
    // 6.将用户上传文件保存到本地
    int len;
    byte[] buffer=new byte[1024];
    while ((len=inputStream.read(buffer,0,buffer.length))!=-1){
        outputStream.write(buffer,0,len);
    }
    outputStream.close();
    inputStream.close();
    socket.shutdownInput(); //关闭输入流
    socket.close();//关闭连接

客户端：

    new AsyncTask<Void, Integer, Void>() {
        @Override
        protected Void doInBackground(Void... params) {
            try {
                //1.创建Socket对象并获取输出流
                Socket socket = new Socket(IP, PORT);
                OutputStream outputStream = socket.getOutputStream();
                // 2.写入文件名称，最后使用 \t 分割
                outputStream.write("Video5.mp4\t".getBytes());
                // 3.读取文件内容
                InputStream inputStream=getResources().openRawResource(R.raw.video);
                // 4.上传文件
                int len;
                byte[] buffer = new byte[1024];
                while ((len = inputStream.read(buffer, 0, buffer.length)) != -1) {

                    outputStream.write(buffer, 0, len);
                    outputStream.flush();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
        @Override
        protected void onPostExecute(Void aVoid) {
            Toast.makeText(UDPActivity.this, "Upload successfully.", Toast.LENGTH_SHORT).show();
        }
    }.execute();

3.4UPD 通信

服务端：

   //1.创建服务端 DatagramSocket 指定端口
   DatagramSocket socket=new DatagramSocket(8888);
   //2.创建数据报，用于接受客户端发送的数据
   byte[] data=new byte[1024]; //指定接受数据包的大小
   DatagramPacket packet=new DatagramPacket(data,data.length);
   //3.接受客户端发送的数据
   S.println("~~~ Server is running，waiting for client  ~~~");
   while (true){
       socket.receive(packet);
       //4.读取数据
       String info=new String(data,0,data.length);
       S.println("Client:"+ info);
       if(socket.isClosed())
       {
           S.println("Client has been exit.");
           break;
       }
   }
   socket.close(); //关闭 Socket

客户端：

    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                //1.获取 InetAddress 对象，指定IP
                InetAddress address = InetAddress.getByName(IP);
                //2.要发送的信息
                byte[] data = "Test".getBytes();
                //3.创建 DatagramSocket，用来发送数据
                DatagramSocket socket = new DatagramSocket();
                //4.创建 DatagramPacket，用来存储要发送的数据，并指定目标IP和端口
                DatagramPacket packet = new DatagramPacket(data, data.length, address, PORT);
                //5.发送消息到服务端
                socket.send(packet);
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }).start();

3.5UPD 发送文件

服务端：

   //1.创建服务端 DatagramSocket 指定端口
   DatagramSocket socket=new DatagramSocket(8888);
   S.println("~~~ Server is running，waiting for client  ~~~");
   //2.创建文件，用来存储用户上传数据
   File file=new File("Video.mp4");
   FileOutputStream outputStream=new FileOutputStream("Video.mp4",true);
   //3.不断接受客户端发送的数据
   while (true){
       //4.创建数据报，用于接受客户端发送的数据
       byte[] buffer=new byte[1024]; //指定接受数据包的大小
       DatagramPacket packet=new DatagramPacket(buffer,buffer.length);
       socket.receive(packet);
       //5.将数据写入文件
       outputStream.write(buffer,0,packet.getLength());
       if(socket.isClosed())
           break;
   }
   outputStream.close();
   socket.close(); //关闭 Socket

客户端：

    new AsyncTask<Void, Integer, Void>() {
        @Override
        protected Void doInBackground(Void... params) {
            try {
                //1.创建Socket对象并获取输出流
                Socket socket = new Socket(IP, PORT);
                OutputStream outputStream = socket.getOutputStream();
                // 2.写入文件名称，最后使用 \t 分割
                outputStream.write("Video5.mp4\t".getBytes());
                // 3.读取文件内容
                InputStream inputStream=getResources().openRawResource(R.raw.video);
                // 4.上传文件
                int len;
                byte[] buffer = new byte[1024];
                while ((len = inputStream.read(buffer, 0, buffer.length)) != -1) {
                    outputStream.write(buffer, 0, len);
                    outputStream.flush();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
        @Override
        protected void onPostExecute(Void aVoid) {
            Toast.makeText(UDPActivity.this, "Upload successfully.", Toast.LENGTH_SHORT).show();
        }
    }.execute();

学习自：http://www.runoob.com/w3cnote/android-tutorial-socket-intro.html