学习记录——进阶版11

@学习记录

开始学习Java

遵从同学的指导，从Java se开始学习

黑马的JavaSE零基础入门【网络编程】

第一章 网络编程入门

1.1 软件结构

22-02 软件结构

1.2 网络通信协议

22-03 网络通信协议

1.3 协议分类

22-04 网络通信协议分类

1.4 网络编程三要素

协议
IP地址
端口号

22-05 IP地址

22-06 端口号

第二章 TCP通信程序

2.1 概述

22-08 TCP通信概述

2.2 Socket类

构造方法
成员方法

2.3 ServerSocket类

构造方法
成员方法

2.4 简单的TCP网络程序

TCP通信分析图解
客户端向服务器发送数据
服务器向客户端回写数据

22-10 TCP通信的服务器代码实现

package day_11Net.demo01TCP;

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

/*
TCP通信的服务器端：接收客户端的请求，读取客户端发送的数据，给客户端回写数据
表示服务器端的类：
    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.释放资源（Socket，ServerSocket）

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

package day_11Net.demo01TCP;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/*
TCP通信的客户端：向服务器发送连接请求，给服务器发送数据，读取服务器回写的数据
表示客户端的类：
    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对象中的方法write，给服务器发送数据
    4.使用Socket对象中的方法getInputStream获取网络字节输入流InputStream对象
    5.使用网络字节输入流InputStream对象中的方法read，读取服务器回写的数据
    6.释放资源（Socket）

注意：
    1.客户端和服务器端进行交互，必须使用Socket中提供的网络流，不能使用自己创建的流对象
    2.当我们创建客户端对象Socket时，就会去请求服务器和服务器经过3次握手建立连接通路
        这时如果服务器没有启动，就会抛出异常ConnectException
        如果服务器已经启动，就可以进行交互
 */
public class TCPClient {
    
    
    public static void main(String[] args) throws IOException {
    
    
        // 1.创建一个客户端对象Socket，构造方法绑定服务器的IP地址和端口号
        Socket socket = new Socket("127.0.0.1", 8888);
        // 2.使用Socket对象中的方法getOutputStream获取网络字节输出流OutputStream对象
        OutputStream os = socket.getOutputStream();
        // 3.使用网络字节输出流OutputStream对象中的方法write，给服务器发送数据
        os.write("你好服务器！".getBytes());
        // 4.使用Socket对象中的方法getInputStream获取网络字节输入流InputStream对象
        InputStream is = socket.getInputStream();
        // 5.使用网络字节输入流InputStream对象中的方法read，读取服务器回写的数据
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        System.out.println(new String(bytes,0,len));
        // 6.释放资源（Socket）
        socket.close();
    }
}

第三章 综合案例

3.1 文件上传案例

文件上传分析图解
基本实现
文件上传优化分析
优化实现
信息回写分析图解
回写实现

22-11 综合案例-文件上传的原理

22-14 综合案例-文件上传阻塞问题

package day_11Net.demo02FileUpload;

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

/*
文件上传案例的服务器端：读取客户端上传的文件，保存到服务器的硬盘，给客户端回写数据

实现步骤：
    1.创建一个服务器端对象ServerSocket，构造方法指定服务器的端口号
    2.使用ServerSocket对象中的方法accept获取到请求的客户端对象Socket
    3.使用Socket对象中的方法getInputStream获取网络字节输入流InputStream对象
    4.判断文件夹是否存在，不存在则创建
    5.创建一个本地字节输出流FileOutputStream对象，构造方法中传递存储文件的地址
    6.使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
    7.使用本地字节输出流FileOutputStream对象中的方法write，保存到服务器的硬盘
    8.使用Socket对象中的方法getOutputStream获取网络字节输出流OutputStream对象
    9.使用网络字节输出流OutputStream对象中的方法write，给客户端回写数据
    10.释放资源（FileOutputStream，Socket,ServerSocket）

 */
public class TCPServer {
    
    
    public static void main(String[] args) throws IOException {
    
    
        // 1.创建一个服务器端对象ServerSocket，构造方法指定服务器的端口号
        ServerSocket server = new ServerSocket(8888);
        // 2.使用ServerSocket对象中的方法accept获取到请求的客户端对象Socket
        Socket socket = server.accept();
        // 3.使用Socket对象中的方法getInputStream获取网络字节输入流InputStream对象
        InputStream is = socket.getInputStream();
        // 4.判断文件夹是否存在，不存在则创建
        File file = new File("d:\\TCP");
        if (!file.exists()) {
    
    
            file.mkdir();
        }
        // 5.创建一个本地字节输出流FileOutputStream对象，构造方法中传递存储文件的地址
        FileOutputStream fos = new FileOutputStream(file + "\\tu.jpg");
        // 6.使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = is.read(bytes)) != -1) {
    
    
            // 7.使用本地字节输出流FileOutputStream对象中的方法write，保存到服务器的硬盘
            fos.write(bytes,0,len);
        }
        // 8.使用Socket对象中的方法getOutputStream获取网络字节输出流OutputStream对象
        OutputStream os = socket.getOutputStream();
        // 9.使用网络字节输出流OutputStream对象中的方法write，给客户端回写数据
        os.write("上传完毕".getBytes());
        // 10.释放资源（FileOutputStream，Socket,ServerSocket）
        fos.close();
        socket.close();
        server.close();
    }
}

package day_11Net.demo02FileUpload;


import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/*
文件上传案例的客户端：读取本地文件，上传到服务器，读取服务器回写的数据

实现步骤：
    1.创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
    2.创建一个客户端对象Socket，构造方法绑定服务器的IP地址和端口号
    3.使用Socket对象中的方法getOutputStream获取网络字节输出流OutputStream对象
    4.使用本地字节输入流FileInputStream对象中的方法read，读取本地文件
    5.使用网络字节输出流OutputStream对象中的方法write，给服务器发送数据
    6.使用Socket对象中的方法getInputStream获取网络字节输入流InputStream对象
    7.使用网络字节输入流InputStream对象中的方法read，读取服务器回写的数据
    8.释放资源（FileInputStream，Socket）
 */
public class TCPClient {
    
    
    public static void main(String[] args) throws IOException {
    
    
        // 1.创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("tu.jpg");
        // 2.创建一个客户端对象Socket，构造方法绑定服务器的IP地址和端口号
        Socket socket = new Socket("127.0.0.1",8888);
        // 3.使用Socket对象中的方法getOutputStream获取网络字节输出流OutputStream对象
        OutputStream os = socket.getOutputStream();
        // 4.使用本地字节输入流FileInputStream对象中的方法read，读取本地文件
        byte[] bytes = new byte[1024];
        int len = 0 ;
        while ((len = fis.read(bytes)) != -1) {
    
    
            // 5.使用网络字节输出流OutputStream对象中的方法write，给服务器发送数据
            os.write(bytes,0,len);
        }
        // 上传完文件，给服务器写一个结束标记
        socket.shutdownOutput();
        // 6.使用Socket对象中的方法getInputStream获取网络字节输入流InputStream对象
        InputStream is = socket.getInputStream();
        // 7.使用网络字节输入流InputStream对象中的方法read，读取服务器回写的数据
        while ((len = is.read(bytes)) != -1) {
    
    
            System.out.println(new String(bytes,0,len));
        }
        // 8.释放资源（FileInputStream，Socket）
        fis.close();
        socket.close();

    }

}

22-15 综合案例-文件上传案例优化（文件命名&循环接收&多线程提高效率）

package day_11Net.demo03FileUpload;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;
import java.util.concurrent.ThreadPoolExecutor;

/*
文件上传案例的服务器端：读取客户端上传的文件，保存到服务器的硬盘，给客户端回写数据

实现步骤：
    1.创建一个服务器端对象ServerSocket，构造方法指定服务器的端口号
    2.使用ServerSocket对象中的方法accept获取到请求的客户端对象Socket
    3.使用Socket对象中的方法getInputStream获取网络字节输入流InputStream对象
    4.判断文件夹是否存在，不存在则创建
    5.创建一个本地字节输出流FileOutputStream对象，构造方法中传递存储文件的地址
    6.使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
    7.使用本地字节输出流FileOutputStream对象中的方法write，保存到服务器的硬盘
    8.使用Socket对象中的方法getOutputStream获取网络字节输出流OutputStream对象
    9.使用网络字节输出流OutputStream对象中的方法write，给客户端回写数据
    10.释放资源（FileOutputStream，Socket,ServerSocket）

 */
public class TCPServer {
    
    
    public static void main(String[] args) throws IOException {
    
    
        // 1.创建一个服务器端对象ServerSocket，构造方法指定服务器的端口号
        ServerSocket server = new ServerSocket(8888);
        // 2.使用ServerSocket对象中的方法accept获取到请求的客户端对象Socket
        // 让服务器一直处于监听状态（死循环accept方法），有客户上传文件，就保存文件
        while (true) {
    
    
            Socket socket = server.accept();
            // 使用多线程技术提高程序的效率,有一个客户上传文件，就开启一个线程，完成文件的上传
            new Thread(new Runnable() {
    
    
                // 完成文件的上传
                @Override
                public void run() {
    
     // 由于接口中的run方法没有抛出异常，因此这里也不能抛出异常，使用try catch
                    try {
    
    
                        // 3.使用Socket对象中的方法getInputStream获取网络字节输入流InputStream对象
                        InputStream is = socket.getInputStream();
                        // 4.判断文件夹是否存在，不存在则创建
                        File file = new File("d:\\TCP");
                        if (!file.exists()) {
    
    
                            file.mkdir();
                        }
                        // 自定义一个命名的规则，防止同名的文件被覆盖
                        // 规则：域名+毫秒值+随机数
                        String fileName = "itcast" + System.currentTimeMillis() + new Random().nextInt(10) + ".jpg";
                        // 5.创建一个本地字节输出流FileOutputStream对象，构造方法中传递存储文件的地址
//                      FileOutputStream fos = new FileOutputStream(file + "\\tu.jpg");
                        FileOutputStream fos = new FileOutputStream(file + "\\" + fileName);
                        // 6.使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
                        byte[] bytes = new byte[1024];
                        int len = 0;
                        while ((len = is.read(bytes)) != -1) {
    
    
                            // 7.使用本地字节输出流FileOutputStream对象中的方法write，保存到服务器的硬盘
                            fos.write(bytes,0,len);
                        }
                        // 8.使用Socket对象中的方法getOutputStream获取网络字节输出流OutputStream对象
                        OutputStream os = socket.getOutputStream();
                        // 9.使用网络字节输出流OutputStream对象中的方法write，给客户端回写数据
                        os.write("上传完毕".getBytes());

                    } catch (IOException e) {
    
    
                        System.out.println(e);
                    }
                }
            }).start();

        }
        // 10.服务器就不用关闭了
//        fos.close();
//        socket.close();
//        server.close();
    }
}

3.2 模拟B\S服务器

案例分析
案例实现
访问效果

22-16 模拟B\S服务器分析

22-17 模拟B\S服务器代码实现

package day_11Net.demo04BSTCP;

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

/*
创建BS版本的TCP服务器
 */
public class TCPServer {
    
    
    public static void main(String[] args) throws IOException {
    
    
        // 创建一个服务器
        ServerSocket server = new ServerSocket(8080);
        // 获取客户端对象（浏览器）
        Socket socket = server.accept();
        // 获取网络字节输入流对象
        InputStream is = socket.getInputStream();
        // 读取客户请求信息
//        int len = 0;
//        byte[] bytes = new byte[1024];
//        while((len = is.read(bytes)) != -1) {
    
    
//            System.out.println(new String(bytes,0,len));
//        }
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        // 把客户端请求信息的第一行读取出来
        String line = br.readLine();
        // 把读取的进行切割
        String[] arr = line.split(" ");
        String htmlpath = arr[1].substring(1);
        // 创建本地字节输入流，构造方法中绑定要读取的html路径
        FileInputStream fis = new FileInputStream(htmlpath);
        OutputStream os = socket.getOutputStream();
        // 写入HTTP协议响应头，固定写法
        os.write("HTTP/1.1 200 OK\r\n".getBytes());
        os.write("Content-Type:text/html\r\n".getBytes());
        // 必须写入空行，否则浏览器不解析
        os.write("\r\n".getBytes());
        // 复制文件
        int len = 0;
        byte[] bytes = new byte[1024];
        while((len = fis.read(bytes)) != -1) {
    
    
            System.out.println(new String(bytes,0,len));
        }
        fis.close();
        socket.close();
        server.close();
    }
}

package day_11Net.demo04BSTCP;

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

/*
创建BS版本的TCP服务器
 */
public class TCPServerThread {
    
    
    public static void main(String[] args) throws IOException {
    
    
        // 创建一个服务器
        ServerSocket server = new ServerSocket(8080);
        // 浏览器解析服务器回写的html页面，如果页面中有图片，那么浏览器就会单独开启一个线程，读取服务器的图片
        // 让服务器一直处于监听状态，客户端请求一次，服务器回写一次
        while (true) {
    
    
            // 获取客户端对象（浏览器）
            Socket socket = server.accept();
            new Thread(new Runnable() {
    
    
                @Override
                public void run() {
    
    
                    try {
    
    
                        // 获取网络字节输入流对象
                        InputStream is = socket.getInputStream();
                        // 读取客户请求信息
//                      int len = 0;
//                      byte[] bytes = new byte[1024];
//                      while((len = is.read(bytes)) != -1) {
    
    
//                          System.out.println(new String(bytes,0,len));
//                      }
                        BufferedReader br = new BufferedReader(new InputStreamReader(is));
                        // 把客户端请求信息的第一行读取出来
                        String line = br.readLine();
                        // 把读取的进行切割
                        String[] arr = line.split(" ");
                        String htmlpath = arr[1].substring(1);
                        // 创建本地字节输入流，构造方法中绑定要读取的html路径
                        FileInputStream fis = new FileInputStream(htmlpath);
                        OutputStream os = socket.getOutputStream();
                        // 写入HTTP协议响应头，固定写法
                        os.write("HTTP/1.1 200 OK\r\n".getBytes());
                        os.write("Content-Type:text/html\r\n".getBytes());
                        // 必须写入空行，否则浏览器不解析
                        os.write("\r\n".getBytes());
                        // 复制文件
                        int len = 0;
                        byte[] bytes = new byte[1024];
                        while((len = fis.read(bytes)) != -1) {
    
    
                            System.out.println(new String(bytes,0,len));
                        }
//                        fis.close();
//                        socket.close();
//                        server.close();

                    } catch (IOException e) {
    
    
                        System.out.println(e);
                    }
                }
            }).start();
        }
    }
}