• 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 + "
    ");
                                }
                            });
                        }
                    }
                }
            } 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=='	')
                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.写入文件名称,最后使用 	 分割
                    outputStream.write("Video5.mp4	".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.写入文件名称,最后使用 	 分割
                    outputStream.write("Video5.mp4	".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

  • 相关阅读:
    AtCoder Grand Contest 013 C:Ants on a Circle
    AtCoder Grand Contest 010 C:Cleaning
    055 列表推导式
    054 三元表达式
    05 Python爬虫之信息标记与提取方法
    053 迭代器
    052 装饰器
    051 闭包函数
    04 Python爬虫之Beautiful Soup库
    03 Python爬虫之Requests网络爬取实战
  • 原文地址:https://www.cnblogs.com/-Tiger/p/8708443.html
Copyright © 2020-2023  润新知