01 网络编程入门

1.1软件结构

C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、迅雷等软件。
B/S结构 ：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。
两种架构各有优势，但是无论哪种架构，都离不开网络的支持。网络编程，就是在一定的协议下，实现两台计算机的通信的程序。

1.2 网络通信协议

网络通信协议：通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。
TCP/IP协议： 传输控制协议/因特网互联协议( Transmission Control Protocol/Internet Protocol)，是Internet最基本、最广泛的协议。它定义了计算机如何连入因特网，以及数据如何在它们之间传输的标准。它的内部包含一系列的用于处理数据通信的协议，并采用了4层的分层模型，每一层都呼叫它的下一层所提供的协议来完成自己的需求。

上图中，TCP/IP协议中的四层分别是应用层、传输层、网络层和链路层，每层分别负责不同的通信功能。
链路层：链路层是用于定义物理传输通道，通常是对某些网络连接设备的驱动协议，例如针对光纤、网线提供的驱动。
网络层：网络层是整个TCP/IP协议的核心，它主要用于将传输的数据进行分组，将分组数据发送到目标计算机或者网络。
传输层：主要使网络程序进行通信，在进行网络通信时，可以采用TCP协议，也可以采用UDP协议。
应用层：主要负责应用程序的协议，例如HTTP协议、FTP协议等。

1.3 协议分类

通信的协议还是比较复杂的，java.net 包中包含的类和接口，它们提供低层次的通信细节。我们可以直接使用这些类和接口，来专注于网络程序开发，而不用考虑通信的细节。

java.net 包中提供了两种常见的网络协议的支持：

UDP：用户数据报协议(User Datagram Protocol)。UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。

由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。

但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议。UDP的交换过程如下图所示。

特点:数据被限制在64kb以内，超出这个范围就不能发送了。
数据报(Datagram):网络传输的基本单位
TCP：传输控制协议 (Transmission Control Protocol)。TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。

在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”。

扫描二维码关注公众号，回复： 11544213 查看本文章
- 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。
  - 第一次握手，客户端向服务器端发出连接请求，等待服务器确认。
  - 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。
  - 第三次握手，客户端再次向服务器端发送确认信息，确认连接。整个交互过程如下图所示。

在这里插入图片描述

完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛，例如下载文件、浏览网页等。

1.4 网络编程三要素

1.4.1协议

协议：计算机网络通信必须遵守的规则，

1.4.2IP地址

IP地址：指互联网协议地址（Internet Protocol Address），俗称IP。IP地址用来给一个网络中的计算机设备做唯一的编号。假如我们把“个人电脑”比作“一台电话”的话，那么“IP地址”就相当于“电话号码”。

IP地址分类

IPv4：是一个32位的二进制数，通常被分为4个字节，表示成a.b.c.d 的形式，例如192.168.65.100 。其中a、b、c、d都是0~255之间的十进制整数，那么最多可以表示42亿个。
IPv6：由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。

为了扩大地址空间，拟通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，表示成ABCD:EF01:2345:6789:ABCD:EF01:2345:6789，号称可以为全世界的每一粒沙子编上一个网址，这样就解决了网络地址资源数量不够的问题。

常用命令

查看本机IP地址，在控制台输入：

ipconfig

检查网络是否连通，在控制台输入：

ping 空格 IP地址
ping 182.61.200.6

特殊的IP地址

本机IP地址：127.0.0.1、localhost 。

1.4.3端口号

网络的通信，本质上是两个进程（应用程序）的通信。每台计算机都有很多的进程，那么在网络通信时，如何区分这些进程呢？

如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的进程（应用程序）了。

我们通过IP地址找到某一个计算机或者服务器，通过端口号找到这台计算机或者服务器上的某个应用程序

端口号：用两个字节表示的整数，它的取值范围是0~65535。其中，0 ~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。

利用协议+IP地址+端口号 三元组合，就可以标识网络中的进程了，那么进程间的通信就可以利用这个标识与其它进程进行交互。

例如我们可以通过这ip加端口号访问百度：182.61.200.6:80
常用端口号如下：

1.百度默认端口：80端口
IP方式访问：182.61.200.6:80
链接方式访问：www.baidu.com:80
2.mysql默认端口号：3306
3.Oracle默认端口号：1512
4.tomcat默认端口号：8080
注意：默认端口号可以省略不写，如果计算机中的一个应用的端口号被其
他应用占用，这个应用启动就会失败

02TCP通信程序

2.1 概述

TCP通信能实现两台计算机之间的数据交互，通信的两端，要严格区分为客户端（Client）与服务端（Server）。

两端通信时步骤：

服务端程序，需要事先启动，等待客户端的连接。
客户端主动连接服务器端，连接成功才能通信。服务端不可以主动连接客户端。

在Java中，提供了两个类用于实现TCP通信程序：

客户端：java.net.Socket 类表示。创建Socket对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信。
服务端：java.net.ServerSocket 类表示。创建ServerSocket对象，相当于开启一个服务，并等待客户端的连接。

2.2 Socket类

Socket 类：该类实现客户端套接字，套接字指的是两台设备之间通讯的端点。

套接字：包含IP地址和端口号的网络单位

2.2.1Socket构造方法

public Socket(String host, int port) :创建套接字对象并将其连接到指定主机上的指定端口号。如果指定的host是null ，则相当于指定地址为回送地址。

回送地址：回送地址(127.x.x.x) 是本机回送地址（Loopback Address），主要用于网络软件测试以及本地机进程间通信，无论什么程序，一旦使用回送地址发送数据，立即返回，不进行任何网络传输。

构造举例，代码如下：

Socket client = new Socket("127.0.0.1", 6666);

2.2.2Socket成员方法

public InputStream getInputStream() ：返回此套接字的输入流。
- 如果此Scoket具有相关联的通道，则生成的InputStream 的所有操作也关联该通道。
- 关闭生成的InputStream也将关闭相关的Socket。
public OutputStream getOutputStream() ：返回此套接字的输出流。
- 如果此Scoket具有相关联的通道，则生成的OutputStream 的所有操作也关联该通道。
- 关闭生成的OutputStream也将关闭相关的Socket。
public void close() ：关闭此套接字。
- 一旦一个socket被关闭，它不可再使用。
- 关闭此socket也将关闭相关的InputStream和OutputStream 。
public void shutdownOutput() ：禁用此套接字的输出流。
- 任何先前写出的数据将被发送，随后终止输出流。

2.3 ServerSocket类

ServerSocket类：这个类实现了服务器套接字，该对象等待通过网络的请求。

2.3.1ServerSocket构造方法

public ServerSocket(int port) ：使用该构造方法在创建ServerSocket对象时，就可以将其绑定到一个指定的端口号上，参数port就是端口号。

构造举例，代码如下：

ServerSocket server = new ServerSocket(6666);

2.3.2ServerSocket成员方法

public Socket accept() ：侦听并接受连接，返回一个新的Socket对象，用于和客户端实现通信。该方法会一直阻塞直到建立连接。

2.4 简单的TCP网络程序

2.4.1 TCP通信分析图解

【服务端】启动,创建ServerSocket对象，等待连接。
【客户端】启动,创建Socket对象，请求连接。
【服务端】接收连接,调用accept方法，并返回一个Socket对象。
【客户端】Socket对象，获取OutputStream，向服务端写出数据。
【服务端】Scoket对象，获取InputStream，读取客户端发送的数据。

到此，客户端向服务端发送数据成功。

在这里插入图片描述

自此，服务端向客户端回写数据。

【服务端】Socket对象，获取OutputStream，向客户端回写数据。
【客户端】Scoket对象，获取InputStream，解析回写数据。
【客户端】释放资源，断开连接。

2.4.2客户端向服务器发送数据，服务器收到数据之后向客户端写回信息

服务端实现步骤：

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.通过服务器对象的accept方法，来获取是哪个客户端访问了服务器
        Socket server=ss.accept();
        //3.使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
        InputStream is=server.getInputStream();
        //4.使用网络字节输入流InputStream对象中的read()方法，读取客户端发送的数据
        byte[] b=new byte[1024];
        int len=is.read(b);
        System.out.println(new String(b,0,len));
        //5.使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
        OutputStream os=server.getOutputStream();
        //6.使用网络字节输入流InputStream对象中的read()方法，读取客户端发送的数据
        os.write("这是服务器回写到数据(显示在客户端)".getBytes());
        //7.释放数据
        server.close();
        ss.close();
    }
}

客户端实现步骤：

1）创建一个客户端对象Socket，构造方法绑定服务器的IP地址和端口号
2）使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
3）使用网络字节输出流OutputStream对象中的Write()方法，给服务器发送数据
4）使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
5）使用网络字节输入流InputStream对象中的read()方法，读取服务器写回的数据
6）释放资源（Socket）

注意

客户端与服务器进行交互，必须使用Socket中提供的网络流，不能使用自己创建的流对象

客户端实现：

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

注意：

两个程序启动的时候是有顺序的，服务器端要先启动，然后在启动客户端程序，否则会报错
服务器启动之后可以通过netstat -an指令，在cmd中查看是否有这个端口

03 综合案例

3.1 文件上传案例

原理：客户端读取本地的文件，把文件上传到服务器，服务器再把上传的文件保存到服务器上的硬盘上

3.1.1文件上传分析图解

【客户端】输入流，从硬盘读取文件数据到程序中。
【客户端】输出流，写出文件数据到服务端。
【服务端】输入流，读取文件数据到服务端程序。
【服务端】输出流，写出文件数据到服务器硬盘中。
【服务端】获取输出流，回写数据。
【客户端】获取输入流，解析回写数据。

文件上传注意问题：

使用文件上传的时候，使用while循环读取本地文件时，是不会将文件结束标志-1，传递给服务器，所以上传到服务器的文件将缺少标志位，然而read方法在读取完文件内容之后，如果读取不到文件标志位将会陷入阻塞，是程序无法继续运行，为了解决这个问题，使用Socket中的public void shutdownOutput()方法，在上传完文件之后给服务器写一个结束标记。
在下面的程序中可以先不加此方法，运行查看输出，然后加上此方法再次运行查看输出，就可以看到问题所在

3.1.1.1基本实现

服务器端实现步骤
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）释放资源

服务端实现：

public class TCPServer {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器启动");
        //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:\\File\\Idea_File\\java_se\\02java_Object\\upload");
        if(!file.exists()){
            file.mkdirs();
        }
        //5）创建一个本地字节输出流FileOutputStream对象，构造方法中绑定输出的目的地
        FileOutputStream fos=new FileOutputStream(file+"\\1.jpg");
        //6）使用网络字节输入流InputStream对象中的read方法，读取客户端上传的文件
        byte[] b=new byte[1024];
        int len=0;

        System.out.println("1111111111");

        while((len=is.read(b))!=-1){
          //7）使用本地字节输出流FileOutputStream对象中的write方法将上传的文件写出到服务器的硬盘上
          fos.write(b,0,len);
        }

        System.out.println("2222222222 while陷入死循环");

        //8）使用Socket对象中的getOutputStream方法，获取网络字节输出流OutputStream对象
        OutputStream os=socket.getOutputStream();
        //9）使用网络字节输出流OutputStream对象中的write方法给客户端回写数据
        os.write("上传成功".getBytes());
        //10）释放资源
        fos.close();
        socket.close();
        server.close();
        System.out.println("服务器运行结束");
    }
}

客户端实现步骤
1）创建一个本地字节输入流FileInputStream对象，构造方法中绑定要传输的数据源（也就是要上传的文件）
2）创建一个客户端Socket对象，构造方法中绑定服务器的IP和端口号
3）使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream对象
4）使用本地本地字节输入流FileInputStream对象中的方法read(),读取本地文件
5）使用网络字节输出流OutputStream对象中的方法write，把读取到的文件上传到服务器
6）使用Socket中的方法getInputStream，获取网络字节输入流InputStream对象
7）使用网络字节输入流InputStream对象中的方法read读取回写的数据
8）释放资源（本地流和网络流）
注意：在客户端和服务器端传递的数据必须使用网络流，在读取本地数据的时候可以使用本地流

客户端实现：

/*
由于我们演示的是上传文件，上传的文件可能很大，所以要采用循环读取的方式，当文件上传成功后，服务器就给客户端回写一句话，上传成功，所以不需要创建本地输出流对象，用来向本地硬盘中写入数据

注意：在客户端和服务器端传递的数据必须使用网络流，在读取本地数据的时候可以使用本地流
* */
public class TCPClient {
    public static void main(String[] args) throws IOException {
        System.out.println("客户端启动");
        //1）创建一个本地字节输入流FileInputStream对象，构造方法中绑定要传输的数据源
        FileInputStream fis=new FileInputStream("H:\\photo\\cat.jpg");
        //2）创建一个客户端Socket对象，构造方法中绑定服务器的IP和端口号
        Socket client=new Socket("localhost",8888);
        //3）使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream对象
        OutputStream os=client.getOutputStream();
        //4）使用本地本地字节输入流FileInputStream对象中的方法read(),读取本地文件
        byte[] b=new byte[1024];
        int len=0;
        //循环读取数据
        while((len=fis.read(b))!=-1){
            //5）使用网络字节输出流OutputStream对象中的方法write，把读取到的文件上传到服务器
            os.write(b, 0, len);
        }

        /*解决：上传完文件，给服务器写一个结束标记*/
        client.shutdownOutput();

        //6）使用Socket中的方法getInputStream，获取网络字节输入流InputStream对象
        InputStream is=client.getInputStream();

        System.out.println("333333333");

        //7）使用网络字节输入流InputStream对象中的方法read读取回写的数据
        //注意由于我们不需要把从服务器写回的数据写入到硬盘，所以就不用创建本地输出流对象了
        byte[] b2=new byte[1024];
        int len2=0;
        len2=is.read(b2);
        System.out.println(new String(b2,0,len2));

        System.out.println("44444444444");

        //8）释放资源
        fis.close();
        client.close();
        System.out.println("客户端结束");
    }
}

3.1.2文件上传优化分析

文件名称写死的问题

服务端，保存文件的名称如果写死，那么最终导致服务器硬盘，只会保留一个文件，因为同名文件或被覆盖，建议使用系统时间优化，保证文件名称唯一，代码如下：

 //5）创建一个本地字节输出流FileOutputStream对象，构造方法中绑定输出的目的地
        FileOutputStream fos=new FileOutputStream(file+"\\1.jpg");

//更改为
 FileOutputStream fos=new FileOutputStream(file+"\\"+System.currentTimeMillis()+"1.jpg");

循环接收的问题

服务端，指保存一个文件就关闭了，之后的用户无法再上传，这是不符合实际的，使用循环改进，可以不断的接收不同用户的文件，代码如下：

// 每次接收新的连接,创建一个Socket
while（true）{
    Socket accept = serverSocket.accept();
    ......
}

效率问题

服务端，在接收大文件时，可能耗费几秒钟的时间，此时不能接收其他用户上传，所以，使用多线程技术优化，代码如下：

while（true）{
	//创建一个Socket对象
    Socket accept = serverSocket.accept();
    
    // 其他交给子线程处理.
    new Thread(() -> {
      	......
        InputStream bis = accept.getInputStream();
      	......
    }).start();
}

3.1.2.1优化实现（仅限服务器端）

public class TCPServer {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器启动");
        //1）创建一个服务器ServerSocket对象，指定系统端口号
        ServerSocket server=new ServerSocket(8888);
        while(true){//为了使服务器一直运行使用死循环
            //2）使用ServerSocket对象中的accept方法，获取请求客户端的Socket对象
            Socket socket=server.accept();
            
            //为了提高效率使用多线程（使用匿名内部类）
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //3）使用Socket对象中的方法getInputStream，获取网络字节流InputStream对象
                        InputStream is=socket.getInputStream();
                        //4）判断本地是否有保存上传文件的的文件夹，没有就创建一个
                        File file=new File("D:\\File\\Idea_File\\java_se\\02java_Object\\upload");
                        if(!file.exists()){
                            file.mkdirs();
                        }
                        //5）创建一个本地字节输出流FileOutputStream对象，构造方法中绑定输出的目的地
                        FileOutputStream fos=new FileOutputStream(file+"\\"+System.currentTimeMillis()+"1.jpg");
                        //6）使用网络字节输入流InputStream对象中的read方法，读取客户端上传的文件
                        byte[] b=new byte[1024];
                        int len=0;
                        while((len=is.read(b))!=-1){
                            //7）使用本地字节输出流FileOutputStream对象中的write方法将上传的文件写出到服务器的硬盘上
                            fos.write(b,0,len);
                        }
                        //8）使用Socket对象中的getOutputStream方法，获取网络字节输出流OutputStream对象
                        OutputStream os=socket.getOutputStream();
                        //9）使用网络字节输出流OutputStream对象中的write方法给客户端回写数据
                        os.write("上传成功".getBytes());
                        //10）释放资源
                        fos.close();
                        socket.close();
                    }catch (IOException e){
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

3.2 模拟B\S服务器(扩展知识点)

模拟网站服务器，使用浏览器访问自己编写的服务端程序，查看网页效果。

3.2.1案例分析

准备页面数据，web文件夹。

在IDEA中创建一个web项目，在项目中创建一个名为HelloWorld的Module，然后将页面需要的文件放到web文件夹下即可，如图：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5hp6aTfo-1588077354780)(img\复制.png)]$

我们模拟服务器端，ServerSocket类监听端口，使用浏览器访问
服务器程序中字节输入流可以读取到浏览器发来的请求信息

3.2.2案例实现

服务端实现：

//index文件路径：D:\File\Idea_File\java_se\02java_Object\helloworld\web\index.html
//浏览器访问路径为：http://localhost:8080/helloworld/web/index.html
public class TCPServer {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器启动");
        //1）创建一个服务器，并指定端口号
        ServerSocket server=new ServerSocket(8080);
        /*因为浏览器解析服务器回写的HTML页面时，如果页面中有图片，浏览器就会单独开启一个线程，
        * 读取服务器上的图片，所以我们不能让服务器启动一次就关闭，要让服务器一直处于监听状态*/
        while (true){
            //2）使用accept方法获取请求客户端对象（浏览器）
            Socket socket=server.accept();
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                        //3）获取网络字节输入流对象
                        InputStream is=socket.getInputStream();


                      /*
                        //4）使用网络字节输入流中的read方法读取客户端请求的信息
                        byte[] b=new byte[1024];
                        int len=0;
                        while((len=is.read(b))!=-1){
                            System.out.println(new String(b,0,len));
                        }
                        */


                        //根据客户端请求信息，服务器要想客户端返回文件（index.html页面）
                        //由于请求信息中包含index.html页面的路径，下面我们对路径进行提取
                        //5）把网络字节输入流转换为字符缓冲输入流
                        BufferedReader bf= new BufferedReader(new InputStreamReader(is));
                        //把请求信息的第一行读取出来
                        String str=bf.readLine();
                        System.out.println(str);
                        //6）对缓冲区字符串进行切割，使用String对象的split方法
                        //使用空格符字符串进行切割
                        String[] arr=str.split(" ");
                        //7）使用String对象的subString方法获取切割好字符串中的关键信息（文件路径）
                        //把字符串数组中的第二个字符串完整的读取出来
                        String filePath=arr[1].substring(1);
                        System.out.println(filePath);
                        //8）服务器创建一个本地字节输入流根据获取到的文件路径读取HTML文件
                        FileInputStream fis=new FileInputStream(filePath);
                        //9）获取网络字节输出流
                        OutputStream os=socket.getOutputStream();

                        //写入Http协议响应头，固定写法，\r为空行，\n为换行
                        os.write("HTTP/1.1.200 OK\r\n".getBytes());
                        os.write("Content-type:text/html\r\n".getBytes());
                        //必须写入空行否则浏览器不解析
                        os.write("\r\n".getBytes());

                        //10）把服务器的HTML文件回写到客户端
                        byte[] b2=new byte[1024];
                        int len2=0;
                        while((len2=fis.read(b2))!=-1){
                            os.write(b2,0,len2);
                        }
                        //11）释放资源
                        fis.close();
                        socket.close();
                        }catch (IOException e){
                            e.printStackTrace();
                        }
                    }
                }).start();
        }
    }
}

3.2.3访问链接的知识补充

当你的服务器项目启动后，访问项目的链接形式为：
协议+域名+端口号+虚拟目录+参数列表+锚
例如：
http://localhost:8080/helloworld/web/index.html
协议：http
域名(也叫IP)：localhost
端口号：8080
虚拟目录（项目名开始）：helloworld/web/index.html
参数列表：此处没有，做表单提交的时候会遇到，参数为前台向后台提交的数据

17—JAVA（进阶）—网络编程

目录

01 网络编程入门

1.1软件结构

1.2 网络通信协议

1.3 协议分类

1.4 网络编程三要素

1.4.1协议

1.4.2IP地址

1.4.3端口号

02TCP通信程序

2.1 概述

2.2 Socket类

2.2.1Socket构造方法

2.2.2Socket成员方法

2.3 ServerSocket类

2.3.1ServerSocket构造方法

2.3.2ServerSocket成员方法

2.4 简单的TCP网络程序

2.4.1 TCP通信分析图解

2.4.2客户端向服务器发送数据，服务器收到数据之后向客户端写回信息

03 综合案例

3.1 文件上传案例

3.1.1文件上传分析图解

文件上传注意问题：

3.1.1.1基本实现

3.1.2文件上传优化分析

3.1.2.1优化实现（仅限服务器端）

3.2 模拟B\S服务器(扩展知识点)

3.2.1案例分析

3.2.2案例实现

3.2.3访问链接的知识补充

猜你喜欢