网络编程-TCP

一、网络基本介绍

1.1 软件结构

* C/S结构：全称Client/Server结构，是指客户端和服务器结构，常见程序有QQ、迅雷、百度网盘等。
* B/S结构：全称Browser/Server结构，是指浏览器和服务器结构，常见浏览器有谷歌、火狐等。

1.2 协议分类

UDP

* 用户数据报协议(User Datagram Protocol)。
	UDP是无连接通信协议，即在传输数据时，数据的发送端和接收端不建立逻辑连接。
	简单来说，当一台计算机向另一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样，接收端在接收数据时也不会对接收结果产生太大影响。

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

* 但是在使用UDP协议传输数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议。

* 特点：数据被限制在64kb以内，超出这个范围就不能发送了

TCP

- 传输控制协议。TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。
- 在TCP连接中心必须要明确客户端与服务器端，由客户端向服务器端发出连接请求，每次连接的创建都需要经过“三次握手”。
- 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。
    - 第一次握手：客户端向服务器端发出连接请求，等待服务器确认。
    - 第二次握手：服务器端向客户端回送一个响应，通知客户端收到了连接请求。
    - 第三次握手：客户端再次向服务器端发送信息，确认连接。
完成三次握手，连接建立后，客户端和服务器就可以进行数据传输了，由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛，例如下载文件、浏览网页等。

1.3 网络编程三要素：协议、IP地址、端口号

* 协议：计算机网络通信必须遵循的规则。
* IP地址
	- IP地址：指互联网协议地址，俗称IP。IP地址用来给一个网络中的计算机设备做唯一的编号。假如我们把“个人电脑”比作 “一台电话”的话，那么“IP地址”就相当于“电话号码”。
	- IP地址分类:
		- IPv4：是一个32位的二进制数，通常被分为4个字节，表示成a.b.c.d的形式，例如：192.168.0.125
		- IPv6：采用128位地址长度，每16个字节一组，分成8组十六进制数，表示成ABCD:EF01:2345:6789:ABCD:EF01:2345:6789，号称可以为全世界的每一粒沙子编上一个网址，这样就解决了网络地址资源数量不够的问题。

	- 查看本机IP地址，在控制台输入：ipconfig
	- 检查网络是否连通，在控制台输入：
		ping 空格 IP地址
		ping 220.181.57.21 
	* 特殊的IP地址：
	 - 本机IP地址：127.0.0.1 、localhost

• 端口号
  

二、TCP通信协议

2.1 TCP通信分析图解

1. 【服务端】启动，创建ServerSocket对象，等待连接。
2. 【客户端】启动，创建Socket对象，请求连接。
3. 【服务端】接收连接,调用accept方法，并返回一个Socket对象。
4. 【客户端】Socket对象，获取OutputStream，向服务端写出数据。
5. 【服务端】Scoket对象，获取InputStream，读取客户端发送的数据。
   到此，客户端向服务端发送数据成功。
   
   自此，服务端向客户端回写数据。
6. 【服务端】Socket对象，获取OutputStream，向客户端回写数据。
7. 【客户端】Scoket对象，获取InputStream，解析回写数据。
8. 【客户端】释放资源，断开连接。

2.1 TCP通信的客户端代码实现

* 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对象中getO的方法OutputStream()获取网络字节输出流OutputStream对象
     3. 使用网络字节输出流OutputStream对象中的方法write，给服务器发送数据
     4. 使用Socket对象中的方法getInputStream()获取网络字节输入流对象
     5. 使用网络字节输入流InputStream对象中的方法read，读取服务器回写的对象
     6. 释放资源(Socket)
    
     
* 注意：
     1. 客户端和服务器端进行交互，必须使用Socket中提供的网络流，不能使用字节创建的流对象
     2. 当我们创建客户端对象Socket的时候，就会请求服务器经过3次握手建立连接通路
         这时如果服务器没有启动，那么就会抛出异常
         如果服务器已经启动，那么就可以进行交互了

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

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 outputStream = socket.getOutputStream();        //3. 使用网络字节输出流OutputStream对象中的方法write，给服务器发送数据
        outputStream.write("你好服务器".getBytes());

        //4. 使用Socket对象中的方法getInputStream()获取网络字节输入流对象
        //5. 使用网络字节输入流InputStream对象中的方法read，读取服务器回写的对象

        //6. 释放资源(Socket)
        socket.close();
    }
}

2.2 TCP通信的服务器端实现

* TCP通信的服务器端：接收客户端的请求，读取客户端发送的数据，给客户回写数据
* 表示服务器的类：
    java.net.ServerSocket:此类实现服务器套接字。

* 构造方法：
    ServerSocket(int port)创建绑定到特定端口的服务器套接字。

* 服务器端必须明确一件事情，必须得知道是哪个客户端请求的服务器
  所以可以使用accept方法获取到请求的客户端对象Socket
  
* 成员方法：
    Socket accept() 侦听并接受到此套接字的连接。

* 服务器的实现步骤：
	1. 创建服务器ServerSocket对象和系统要指定的端口号
	2. 使用ServerSocket对象中的方法accept，获取到请求的客户端对象Socket
	3. 使用Socket对象中的方法getInputStream()获取网络字节输入流对象
	4. 使用网络字节输入流InputStream对象中的方法read，读取客户端发送的数据
	5. 使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
	6. 使用网络字节输出流OutputStream对象中的方法write，给客户端回写数据
	7. 释放资源(Socket,ServerSocket)

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

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 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();
        server.close();
    }

2.3 TCP通信的文件上传案例

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

* 明确：
    数据源: c:\\1.jpg
    目的地：服务器
* 实现步骤:
    1. 创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
    2. 创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
    3. 使用Socket中的方法getOutputStream，获取网络中字节输入流OutputStream对象
    4. 使用本地字节输入流FileInputStream，获取网络字节输入流OutputStream对象
    5. 使用网络字节输出流OutputStream对象中的方法writer，把读取到的文件上传到服务器
    6. 使用Socket中的方法getOutputStream,获取网络字节输入流InputStream对象
    7. 使用网络字节输入流InputStream对象中的方法read读取服务器会写的数据
    8. 释放资源(FileInputStream, Socket)

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

public class TCPClient {
    public static void main(String[] args) throws IOException {
        //1，创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("C:\\Users\\32189\\Desktop\\考研资料\\a\\a.jpg");
        //2. 创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
        Socket socket = new Socket("127.0.0.1",8888);
        //3. 使用Socket中的方法getOutputStream，获取网络中字节输入流OutputStream对象
        OutputStream os = socket.getOutputStream();
        //4. 使用本地字节输入流FileInputStream，获取网络字节输入流OutputStream对象
        int len = 0;
        byte[] bytes = new byte[1024];
        while((len = fis.read(bytes)) != -1){
            //5. 使用网络字节输出流OutputStream对象中的方法writer，把读取到的文件上传到服务器
            os.write(bytes,0,len);
        }
        //6. 使用Socket中的方法getOutputStream,获取网络字节输入流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();
    }
}

* TCP通信的服务器端：接收客户端的请求，读取客户端发送的数据，给客户回写数据
* 表示服务器的类：
    java.net.ServerSocket:此类实现服务器套接字。

* 构造方法：
    ServerSocket(int port)创建绑定到特定端口的服务器套接字。

* 服务器端必须明确一件事情，必须得知道是哪个客户端请求的服务器
   所以可以使用accept方法获取到请求的客户端对象Socket
   
* 成员方法：
    Socket accept() 侦听并接受到此套接字的连接。

* 服务器的实现步骤：
    1. 创建服务器ServerSocket对象和系统要指定的端口号
    2. 使用ServerSocket对象中的方法accept，获取到请求的客户端对象Socket
    3. 使用Socket对象中的方法getInputStream()获取网络字节输入流对象
    4. 使用网络字节输入流InputStream对象中的方法read，读取客户端发送的数据
    5. 使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
    6. 使用网络字节输出流OutputStream对象中的方法write，给客户端回写数据
    7. 释放资源(Socket,ServerSocket)

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

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 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();
        server.close();
    }
}

2.4 bug ：服务器不发送“上传成功”

解决方案：在客户端的第一个while循环之后写：socket.sutdownOutput();

2.5 文件上传案例的优化：避免把上传文件名写死，以便上传多个文件

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

* 明确：
     数据源：客户端上传的文件
     目的地：服务器的硬盘 C:\\Users\\32189\\Desktop\\考研资料\\upload\\1.jpg
     
* 实现步骤：
     1. 创建一个服务器ServerSocket对象，和系统要指定的端口号
     2. 使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象
     3. 使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
     4. 判断C:\\Users\\32189\\Desktop\\考研资料\\upload文件夹是否存在，不存在则创建
     5. 创建一个本地输出流FileOutputStream对象，构造方法中绑定要输出的目的地
     6. 使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
     7. 使用本地字节输入流FileOutputStream对象中的方法write，把读取到的文件保存到服务器的硬盘上
     8. 使用Socket对象中的方法getOutputStream，获取到网络字节输出流OutputStream对象
     9. 使用网络字节输出流OutputStream对象中的write，给客户端回写“上传成功”
     10.释放资源(FileOutputStream, Socket, ServerSocket)

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;

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() {
                    try{
                        //3. 使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
                        InputStream is = socket.getInputStream();
                        //4. 判断C:\\Users\\32189\\Desktop\\考研资料\\upload文件夹是否存在，不存在则创建
                        File file = new File("C:\\Users\\32189\\Desktop\\\\考研资料\\upload");
                        if (!file.exists()) {
                            file.mkdirs();
                        }

                    /*
                        自定义一个文件的命名规则，防止同名的文件被覆盖掉
                        规则：域名+毫秒值+随机数
                     */
                        String fileName = "itcast" + System.currentTimeMillis() + new Random().nextInt(999999999) + ".jpg";

                        //5. 创建一个本地输出流FileOutputStream对象，构造方法中绑定要输出的目的地
                        //FileOutputStream fos = new FileOutputStream(file + "\\1.jpg");
                        FileOutputStream fos = new FileOutputStream(file + "\\1" + fileName);
                        //6. 使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
                        int len = 0;
                        byte[] bytes = new byte[1024];
                        while ((len = is.read(bytes)) != -1) {
                            //7. 使用本地字节输入流FileOutputStream对象中的方法write，把读取到的文件保存到服务器的硬盘上
                            fos.write(bytes, 0, len);
                        }
                        //8. 使用Socket对象中的方法getOutputStream，获取到网络字节输出流OutputStream对象
                        //9. 使用网络字节输出流OutputStream对象中的write，给客户端回写“上传成功”
                        socket.getOutputStream().write("上传成功".getBytes());
                        //10.释放资源(FileOutputStream, Socket, ServerSocket)
                        fos.close();
                        socket.close();
                    }catch(IOException e){
                        System.out.println(e);
                    }
                }
            }).start();
        }
        //服务器就不用关闭
        //server.close();
    }
}

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

* 明确：
     数据源: c:\\1.jpg
     目的地：服务器
* 实现步骤:
     1，创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
     2. 创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
     3. 使用Socket中的方法getOutputStream，获取网络中字节输入流OutputStream对象
     4. 使用本地字节输入流FileInputStream，获取网络字节输入流OutputStream对象
     5. 使用网络字节输出流OutputStream对象中的方法writer，把读取到的文件上传到服务器
     6. 使用Socket中的方法getOutputStream,获取网络字节输入流InputStream对象
     7. 使用网络字节输入流InputStream对象中的方法read读取服务器会写的数据
     8. 释放资源(FileInputStream, Socket)

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

public class TCPClient {
    public static void main(String[] args) throws IOException {
        //1，创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("C:\\Users\\32189\\Desktop\\考研资料\\a\\a.jpg");
        //2. 创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号


        Socket socket = new Socket("127.0.0.1",8888);
        //3. 使用Socket中的方法getOutputStream，获取网络中字节输入流OutputStream对象
        OutputStream os = socket.getOutputStream();
        //4. 使用本地字节输入流FileInputStream，获取网络字节输入流OutputStream对象
        int len = 0;
        byte[] bytes = new byte[1024];
        while((len = fis.read(bytes))!= -1){
            //5. 使用网络字节输出流OutputStream对象中的方法writer，把读取到的文件上传到服务器
            os.write(bytes,0,len);
        }

        /*
            解决：上传完文件，给服务器写一个结束标记
            void shutdownOutput() 禁用此套接字的输出流。
            对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接中止序列
         */
        socket.shutdownOutput();

        //6. 使用Socket中的方法getOutputStream,获取网络字节输入流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();
    }
}

模拟BS服务器

BS模式案例

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

/*
    创建BS版本TCP服务器
 */
public class TCPServer {
    public static void main() throws IOException {
        //创建一个服务器ServerSocket，和系统要指定的端口号
        ServerSocket server = new ServerSocket(8080);
        /*
            浏览器解析服务器回写的html页面，页面中如果有图片，那么浏览器就会单独的开启一个线程，读取服务器的图片
            我们就得让服务器一直处于监听状态，客户端请求一次，服务器就回写一次
            */
        while (true) {

            //使用accept方法获取到请求的客户端对象(浏览器)
            Socket socket = server.accept();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {

                        //使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
                        InputStream is = socket.getInputStream();
                        //使用网络字节输入流InputStream对象中的方法read读取客户端的请求信息
                   /* byte[] bytes = new byte[1024];
                    int len = 0;
                    while ((len = is.read(bytes)) != -1) {
                        System.out.println(new String(bytes,0,len));
                    }*/

                        //把is网络字节输入流对象，转换为字符输入流
                        BufferedReader br = new BufferedReader(new InputStreamReader(is));
                        //把客户端请求信息的第一行读取出来 GET /11_Net/web/index.html HTTP/1.1
                        String line = br.readLine();
                        String[] arr = line.split(" ");
                        //把路径前面的/去掉，进行截取 /11_Net/web/index.html
                        String htmlpath = arr[1].substring(1);

                        //创建一个本地字节输入流，构造方法中绑定要读取的html路径
                        FileInputStream fis = new FileInputStream(htmlpath);
                        //使用Socket中的方法getOutputStream获取网络字节输出流OutputStream对象
                        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());

                        //一读一写复制文件，把服务器读取的html文件回写到客户端
                        int len = 0;
                        byte[] bytes = new byte[1024];
                        while ((len = fis.read(bytes)) != -1) {
                            os.write(bytes, 0, len);
                        }
                        //释放资源
                        fis.close();
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();


        }
        //无需释放服务器
        //server.close();
    }
}