网络通信--＞TCP

1、TCP通信
面向连接的通信，客户端和服务器端必须经过3次握手，建立逻辑连接，才能通信（安全）

1.1 通信的步骤
服务器端先启动，服务器端不会主动请求客户端，必须使用客户端请求服务器端，客户端和服务器端建立逻辑连接，而这个连接中包含一个IO对象，客户端和服务器端就可以使用IO对象进行通信，通信的数据不仅仅是字符，所以IO对象是一个字节流对象

服务器端必须明确两件事情：
1. 多个客户端同时和服务器端进行交互，服务器必须明确和哪个客户端进行的交互，在服务器端有一个方法accept，可以获取到请求的客户端对象
2. 多个客户端同时和服务器端进行交互，就需要使用多个IO流对象，但服务器端是没有IO流的，服务器可以获取到请求的客户端对象Socket，使用每个客户端Socket中提供的IO流和客户端进行交互，简单来说就是服务器使用客户端的流和客户端进行交互

1.2 客户端套接字 Socket类
java.net.Socket：
此类实现客户端套接字（也可以就叫“套接字”）。套接字是两台机器间通信的端点。
套接字：包含了IP地址和端口号的网络单位
构造方法：
Socket(String host, int port)：创建一个流套接字并将其连接到指定主机上的指定端口号。
参数：
String host：服务器主机名称/服务器IP地址
int port：服务器的端口号
成员方法：
OutputStream getOutputStream()：返回此套接字的输出流。
InputStream getInputStream()：返回此套接字的输入流。
void close()：关闭此套接字。
客户端实现步骤：
1. 创建一个客户端对象Socket，构造方法中绑定服务器的IP地址和端口号
2. 使用Socket对象中的方法getOUtputStream获取网络字节输出流OutputStream对象
3. 使用网络字节输出流OutputStream对象中的方法writer，给服务器发送数据
4. 使用Socket对象中的方法getInputStream获取网络字节输入流InputStream对象
5. 使用网络字节输入流InputStream对象中的方法read，读取服务器回写的数据
6. 释放资源
注意：
1. 客户端和服务器端进行交互，必须使用Socket中提供的网络流，不能使用自己创建的流对象
2. 当创建客户端对象Socket的时候，就会去请求服务器和服务器经过3次握手建立连接通路，这时如果服务器没有启动，就会抛出异常，如果已经启动，则可以正常交互。
代码示例：

    public static void main(String[] args) throws IOException {
        // 创建客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
        Socket socket = new Socket("localhost", 7788);
        // 使用Socket中的方法getOutputStream获取网络字节输出流OutputStream对象
        OutputStream os = socket.getOutputStream();
        // 使用网络字节流OutputStream中的方法write给服务器发送数据
        os.write("给服务器发送数据".getBytes());
        // 使用Socket中的方法getInputStream获取网络字节输入流对象InputStream
        InputStream is = socket.getInputStream();
        // 使用网络字节流InputStream中的方法read，读取服务器回写的数据
        byte[] b = new byte[1024];
        int len = is.read(b);
        System.out.println(new String(b, 0, len));
        // 释放资源
        socket.close();
    }

1.3 服务器端套接字 ServerSocket
java.net.ServerSocket：此类实现服务器套接字
作用：接收客户端的请求，读取客户端发送的数据，给客户端回写数据
构造方法：
ServerSocket(int port)：创建绑定到特定端口的服务器套接字
服务器要知道是哪个客户端请求的服务器，可以使用accept方法获取到请求的客户端对象Socket
成员方法：
Socket accept()：侦听并接受到此套接字的连接。
服务器实现步骤：
1. 创建服务器ServerSocket对象和系统要指定的端口号
2. 使用ServerSocket中的方法accept，获取到请求的客户端对象Socket
3. 使用Socket对象中的方法getInputStream获取网络字节输入流对象InputStream对象
4. 使用网络字节输入流InputStream中的方法read，读取客户端发送的数据
5. 使用Socket对象中的方法getOutputStream获取网络字节输出流对象OutputStream对象
6. 使用网络字节输入流OutputStream中的方法write，给客户端回写数据
7. 释放资源
代码示例：

    public static void main(String[] args) throws IOException {
        // 创建服务器ServerSocket对象和系统要指定的端口号
        ServerSocket server = new ServerSocket(7788);
        // 使用ServerSocket中的方法accept，获取到请求的客户端对象Socket
        Socket socket = server.accept();
        // 使用Socket对象中的方法getInputStream获取网络字节输入流对象InputStream对象
        InputStream is = socket.getInputStream();
        // 使用网络字节输入流InputStream中的方法read，读取客户端发送的数据
        byte[] b = new byte[1024];
        int len = is.read(b);
        System.out.println(new String(b, 0, len));
        // 使用Socket对象中的方法getOutputStream获取网络字节输出流对象OutputStream对象
        OutputStream os = socket.getOutputStream();
        // 使用网络字节输入流OutputStream中的方法write，给客户端回写数据
        os.write("服务器给客户端回写数据".getBytes());
        // 释放资源
        socket.close();
        server.close();

    }

注意：
字节输出流InputStream中的方法read，在输入数据可用、检测到文件末尾或者抛出异常前，此方法一直阻塞。客户端读取不到-1，则也写入不到服务器端，服务器端读取客户端发送数据的时候读不到-1（结束标记），则进入阻塞状态，死循环等待结束标记；服务器端发送数据也一直处于阻塞状态，客户端接收服务器端数据也处于阻塞状态。
解决方法：
可以使用Socket类中的方法shutdownOutput在上传完文件，给服务器写一个结束标记，禁用此套接字的输出流
文件上传案例：

	// 基础版
	// 客户端
    public static void main(String[] args) throws IOException {
        // 创建本地输入流FileInputStream,构造方法中绑定读取文件的目的地
        FileInputStream fis = new FileInputStream(new File("/Users/xxx/Downloads/a.mp4"));
        // 创建客户端套接字并绑定服务器Ip和端口
        Socket socket = new Socket("localhost", 6688);
        // 使用Socket中的方法getOutputStream获取网络字节输出流OutputStream对象
        OutputStream os = socket.getOutputStream();
        // 读取本地文件并使用网络字节输出流OutputStream对象中的方法write把文件发送给服务器
        int len = 0;
        byte[] b = new byte[1024];
        while ((len = fis.read(b)) != -1) {
            os.write(b, 0, len);
        }
        // 上传完文件，给服务器写一个结束标记
        socket.shutdownOutput(); // shutdownOutput禁用此套接字的输出流
        // 使用Socket中的方法getOutputStream获取网络字节输入流InputStream对象
        InputStream is = socket.getInputStream();
        //使用网络字节输入流InputStream对象中的方法读取服务器回写的数据
        while ((len = is.read(b)) != -1) {
            System.out.println(new String(b, 0, len));
        }
        // 释放资源
        fis.close();
        socket.close();
    }
    // 服务器
        public static void main(String[] args) throws IOException {
        // 创建服务器端套接字对象，并绑定客户端的端口
        ServerSocket server = new ServerSocket(6688);
        // 使用ServerSocket中的方法accept获取客户端的套接字对象
        Socket socket = server.accept();
        // 使用Socket中的方法getInputStream获取网络字节输出流InputStream对象
        InputStream is = socket.getInputStream();
        // 判断路径是否存在，不存在则创建
        File file = new File("./upload");
        if (!file.exists()){
            file.mkdirs();
        }
        // 创建本地文件输出流对象，把客户端发送的文件保存在硬盘中
        FileOutputStream fos = new FileOutputStream(file + "/dy.mp4");
        // 使用InputStream中的方法read读取客户端发送的文件
        int len = 0;
        byte[] b = new byte[1024];
        while ((len = is.read(b)) != -1) {
            fos.write(b, 0, len);
        }
        // 使用Socket中的方法getOutputStream获取网络字节输出流OutputStream对象
        OutputStream os = socket.getOutputStream();
        // 使用OutputStream中的方法write给客户端回写数据
        os.write("文件上传成功".getBytes());
        // 释放资源
        socket.close();
        server.close();
        fos.close();
    }

	// 优化版
	// 客户端
	    public static void main(String[] args) throws IOException {
        // 创建本地文件输入流对象并绑定读取文件的目的地
        FileInputStream fis = new FileInputStream(new File(".//a.mp4"));
        // 创建客户端套接字对象并绑定服务器地址及端口
        Socket socket = new Socket("localhost", 7788);
        // 使用Socket中的方法getOutputStream获取网络字节输出流对象
        OutputStream os = socket.getOutputStream();
        // 使用网络字节输出流OutputStream中的方法write将数据发送给服务端
        byte[] b = new byte[1024];
        int len = 0;
        while ((len = fis.read(b)) != -1) {
            os.write(b, 0, len);
        }
        // 发送完数据后，给服务器写一个结束标记
        socket.shutdownOutput();
        // 使用Socket中的方法getInputStream获取网络字节输入流对象InputStream
        InputStream is = socket.getInputStream();
        // 使用网络字节输入流对象InputStream中的方法read获取服务器回写的数据
        while ((len = is.read(b)) != -1) {
            System.out.println(new String(b, 0, len));
        }
        // 释放资源
        fis.close();
        socket.close();
    }
	// 服务器端
    public static void main(String[] args) throws IOException {
        // 创建服务器端套接字对象并绑定端口
        ServerSocket server = new ServerSocket(7788);
        // 创建服务器存储文件对象并绑定存储的目的地
        File file = new File("d:\\upload");
        // 判断目录是否存在，不存在则新建
        if (!file.exists()) {
            boolean mk = file.mkdirs();
            if (mk) {
                System.out.println("新建文件夹成功");
            }
        }
        while (true) {
            // 监听客户端请求并获取客户端套接字对象socket
            Socket socket = server.accept();
            String fileName = file + "\\" + System.currentTimeMillis() + new Random().nextInt(999) + ".mp4";
            // 多线程处理
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try(FileOutputStream fos = new FileOutputStream(fileName)/* 创建服务器本地文件输出流对象并绑定存储的目的地*/) {
                        // 使用socket中的方法getInputStream获取网络字节输入流InputStream对象
                        InputStream is = socket.getInputStream();
                        // 使用socket中的方法getOutputStream获取网络字节输出流OutputStream对象
                        OutputStream os = socket.getOutputStream();
                        // 读取并存储数据
                        byte[] b = new byte[1024];
                        int len = 0;
                        while ((len = is.read(b)) != -1) {
                            fos.write(b, 0, len);
                        }
                        os.write("文件上传成功".getBytes());
                    } catch (IOException e) {
                        e.printStackTrace();
                    } finally {
                        // 释放资源
                        try {
                            socket.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();

        }
    }