TCP网络编程（Socket通讯）

TCP 网路编程：　

　　1、TCP 三次握手：

　　　　第一次握手，客户端向服务器端发出连接请求，等待服务器确认。

　　　　第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。

　　　　第三次握手，客户端再次向服务器端发送确认信息，确认连接。

 

　　2、TCP的通讯步骤：

　　　　服务器先启动

　　　　服务器不会主动请求客户端

　　　　必须使用客户端请求服务器端

　　　　客户端和服务器端会建立一个逻辑连接

　　　　而这个链接包含一个对象

　　　　这个对象就是IO对象

　　　　客户端和服务端就可以使用

　　　　IO对象进行通信

　　　　通信的数据不仅仅是字符

　　　　所以IO对象是字节流对象。

 

　　3、服务端要做：

 

　　　　1、多个客户端同时和服务器进行交互，服务器必须明确和那个客户端进行交互

　　　 　　在服务端有一个方法，叫accept，用来获取到请求的客户端对象。

　　　

　　　　　accept方法的返回值是Socket

 

　　　　2、多个客户端同时和服务端进行交互，就需要进行多个IO流对象。

　　　 　　而服务端没有IO流，服务端可以获取到请求的客户端对象的Socket

　　     　　使用每一个客户端Socket中提供的IO流和客户端进行交互。

　　

　　　　3、服务端使用客户端的字节输入流读取用户端发送的数据

　　　  　　服务端使用客户端的字节输出流给客户端回写数据。

 

　　　　简单记：服务端使用客户端的流和客户端交互。

 

　　4、Socket通讯代码实现；

 

　　　　TCPServer代码：

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 serverSocket=new ServerSocket(8888);
        //2.使用ServerSocket对象中的方法accept,获取到请求的客户端对象Socket
        Socket socket= serverSocket.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();
        serverSocket.close();
    }
}

　　TCPClient代码：

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: Connection refused: connect
            如果服务器已经启动,那么就可以进行交互了
 */
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();
    }
}

　　　　步骤：先开启服务端，在开启客户端。

　　　　服务端结果：收到，谢谢

　　　　客户端结果：你好服务器

　　　5、TCP通讯的文件上传案例

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

　　　　步骤：

　　　　1、客户端使用本地字节输入流，读取要上传的文件

　　　　2、客户端使用网络字节输出流，把读取到的文件上传到服务器

　　　　3、服务器使用网络字节输入流，读取客户端上传的文件

　　　　4、服务器使用本地字节输出流，把从客户端读取到的文件，保存到服务器硬盘上。

　　　　5、服务器使用网路字节输出流，给客户端回写“上传成功”

　　　　6、客户端使用网络字节输入流，读取服务器回写的数据

　　　　7、释放资源

　　注意：

　　　　客户端，服务器和本地硬盘进行读写，需要使用自己创建的字节流对象（本地流）

　　　　客户端和服务器之间的读写，必须使用Socket中提供的字节流对象（网络流）

　　代码实现：

　　客户端代码：

import java.io.*;
import java.net.Socket;
 
/*
    文件上传案例的客户端:读取本地文件,上传到服务器,读取服务器回写的数据
 
    明确:
        数据源:c:\\1.jpg
        目的地:服务器
 
    实现步骤:
        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 FileUpLoadClint {
    public static void main(String[] args) throws IOException {
        //1.创建一个本地字节输入流FileInputStream对象,构造方法中绑定要读取的数据源
        FileInputStream fis=new FileInputStream("D:\\video\\1\\123.png");
        //2.创建一个客户端Socket对象,构造方法中绑定服务器的IP地址和端口号
        Socket socket=new Socket("127.0.0.1",8888);
        //3.使用Socket中的方法getOutputStream,获取网络字节输出流OutputStream对象
        OutputStream os=socket.getOutputStream();
        //4.使用本地字节输入流FileInputStream对象中的方法read,读取本地文件,存入 bytes
        int len=0;
        byte[] bytes=new byte[1024];
        while ((len=fis.read(bytes))!=-1){
            //5.使用网络字节输出流OutputStream对象中的方法write,把读取到的文件上传到服务器
            os.write(bytes,0,len);
        }
        // 6.使用Socket中的方法getInputStream,获取网络字节输入流InputStream对象
        InputStream is=socket.getInputStream();
        //7.使用网络字节输入流InputStream对象中的方法read读取服务回写的数据,存入 bytes
        while ((len=is.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }
        //8.释放资源(FileInputStream,Socket)
        is.close();
        os.close();
        fis.close();
 
    }
}

　　服务端代码：

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
 
/*
    文件上传案例服务器端:读取客户端上传的文件,保存到服务器的硬盘,给客户端回写"上传成功"
 
    明确:
        数据源:客户端上传的文件
        目的地:服务器的硬盘 d:\\upload\\1.jpg
 
    实现步骤:
        1.创建一个服务器ServerSocket对象,和系统要指定的端口号
        2.使用ServerSocket对象中的方法accept,获取到请求的客户端Socket对象
        3.使用Socket对象中的方法getInputStream,获取到网络字节输入流InputStream对象
        4.判断D:\\video\\2文件夹是否存在,不存在则创建
        5.创建一个本地字节输出流FileOutputStream对象,构造方法中绑定要输出的目的地
        6.使用网络字节输入流InputStream对象中的方法read,读取客户端上传的文件
        7.使用本地字节输出流FileOutputStream对象中的方法write,把读取到的文件保存到服务器的硬盘上
        8.使用Socket对象中的方法getOutputStream,获取到网络字节输出流OutputStream对象
        9.使用网络字节输出流OutputStream对象中的方法write,给客户端回写"上传成功"
        10.释放资源(FileOutputStream,Socket,ServerSocket)
 */
public class FileUpLoadServer {
    public static void main(String[] args) throws IOException {
        // 1.创建一个服务器ServerSocket对象,和系统要指定的端口号
        ServerSocket serverSocket=new ServerSocket(8888);
        // 2.使用ServerSocket对象中的方法accept,获取到请求的客户端Socket对象
        Socket socket=serverSocket.accept();
        //3.使用Socket对象中的方法getInputStream,获取到网络字节输入流InputStream对象
        InputStream is=socket.getInputStream();
        //4.判断d:\\upload文件夹是否存在,不存在则创建
        File file =new File("D:\\video\\2");
        if(file.exists()){
            file.mkdirs();
        }
 
        //5.创建一个本地字节输出流FileOutputStream对象,构造方法中绑定要输出的目的地
        FileOutputStream fos=new FileOutputStream(file+"\\321.png");
        //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对象
        OutputStream os=socket.getOutputStream();
        //9.使用网络字节输出流OutputStream对象中的方法write,给客户端回写"上传成功"
        os.write("上传成功".getBytes());
        //10.释放资源(FileOutputStream,Socket,ServerSocket)
        is.close();
        os.close();
        fos.close();
    }
}

　　结果图片虽然上传成功，但代码并没有结束运行：

　　这是为什么那？

　　　　因为：客户端的   fis.read(bytes)  读取本地文件，结束的标记是读取到 -1 ，

　　　　而while循环是不会读取到 -1 ，也不会把结束标志写给服务器端。

　　　　服务端也就永远读取不到文件的结束标志。

　　解决方案：上传完文件，给服务端写一个结束标识 void shutdownOutput() 禁用此套接字输出流。

　　　　　对于 TCP 套接字，任何以前写入的数据都将被发送，而且后跟 TCP 的正常连接终止序列（结束标志）

　　代码修改：

import java.io.*;
import java.net.Socket;
 
/*
    文件上传案例的客户端:读取本地文件,上传到服务器,读取服务器回写的数据
 
    明确:
        数据源:c:\\1.jpg
        目的地:服务器
 
    实现步骤:
        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 FileUpLoadClint {
    public static void main(String[] args) throws IOException {
        //1.创建一个本地字节输入流FileInputStream对象,构造方法中绑定要读取的数据源
        FileInputStream fis=new FileInputStream("D:\\video\\1\\1.jpg");
        //2.创建一个客户端Socket对象,构造方法中绑定服务器的IP地址和端口号
        Socket socket=new Socket("127.0.0.1",8888);
        //3.使用Socket中的方法getOutputStream,获取网络字节输出流OutputStream对象
        OutputStream os=socket.getOutputStream();
        //4.使用本地字节输入流FileInputStream对象中的方法read,读取本地文件,存入 bytes
        int len=0;
        byte[] bytes=new byte[1024];
        while ((len=fis.read(bytes))!=-1){
            //5.使用网络字节输出流OutputStream对象中的方法write,把读取到的文件上传到服务器
            os.write(bytes,0,len);
        }
        /*
            解决：上传完文件，给服务端写一个结束标识
            void shutdownOutput() 禁用此套接字输出流。
            对于 TCP 套接字，任何以前写入的数据都将被发送，而且后跟 TCP 的正常连接终止序列（结束标志）
         */
        socket.shutdownOutput();
        // 6.使用Socket中的方法getInputStream,获取网络字节输入流InputStream对象
        InputStream is=socket.getInputStream();
        //7.使用网络字节输入流InputStream对象中的方法read读取服务回写的数据,存入 bytes
        while ((len=is.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }
        //8.释放资源(FileInputStream,Socket)
        is.close();
        os.close();
        fis.close();
 
    }
}

　　图片上传成功，代码也停止了运行，工作台结果输出：上传成功。

　　代码优化改造：服务器一直开启可以不断的接收上传的文件，且不会覆盖同名文件，

　　　　　　　　　且为了提高多人上传文件的效率，我们为服务端开启了多线程。

　　服务端代码：

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;
 
/*
    文件上传案例服务器端:读取客户端上传的文件,保存到服务器的硬盘,给客户端回写"上传成功"
 
    明确:
        数据源:客户端上传的文件
        目的地:服务器的硬盘 d:\\upload\\1.jpg
 
    实现步骤:
        1.创建一个服务器ServerSocket对象,和系统要指定的端口号
        2.使用ServerSocket对象中的方法accept,获取到请求的客户端Socket对象
        3.使用Socket对象中的方法getInputStream,获取到网络字节输入流InputStream对象
        4.判断D:\\video\\2文件夹是否存在,不存在则创建
        5.创建一个本地字节输出流FileOutputStream对象,构造方法中绑定要输出的目的地
        6.使用网络字节输入流InputStream对象中的方法read,读取客户端上传的文件
        7.使用本地字节输出流FileOutputStream对象中的方法write,把读取到的文件保存到服务器的硬盘上
        8.使用Socket对象中的方法getOutputStream,获取到网络字节输出流OutputStream对象
        9.使用网络字节输出流OutputStream对象中的方法write,给客户端回写"上传成功"
        10.释放资源(FileOutputStream,Socket,ServerSocket)
 */
public class FileUpLoadServer {
    public static void main(String[] args) throws IOException {
        // 1.创建一个服务器ServerSocket对象,和系统要指定的端口号
        ServerSocket serverSocket=new ServerSocket(8888);
        while (true){
            // 2.使用ServerSocket对象中的方法accept,获取到请求的客户端Socket对象
            Socket socket=serverSocket.accept();
             /*
                使用多线程技术,提高程序的效率
                有一个客户端上传文件,就开启一个线程,完成文件的上传
             */
            new Thread(new Runnable() {
            //完成文件的上传
            @Override
            public void run() {
                try {
                    //3.使用Socket对象中的方法getInputStream,获取到网络字节输入流InputStream对象
                    InputStream is=socket.getInputStream();
                    //4.判断d:\\upload文件夹是否存在,不存在则创建
                    File file =new File("D:\\video\\2");
                    if(file.exists()){
                        file.mkdirs();
                    }
                    String fileName="Not_Copy"+System.currentTimeMillis()+new Random().nextInt(9999)+".jpg";
 
                    //5.创建一个本地字节输出流FileOutputStream对象,构造方法中绑定要输出的目的地
                    FileOutputStream fos=new FileOutputStream(file+"\\"+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对象
                    OutputStream os=socket.getOutputStream();
                    //9.使用网络字节输出流OutputStream对象中的方法write,给客户端回写"上传成功"
                    os.write("上传成功".getBytes());
                    //10.释放资源(FileOutputStream,Socket,ServerSocket)
 
                    is.close();
                    os.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
        //fos.close(); 服务器不用关闭一直开启
    }
}

　　开启服务端后，多次运行客户端，结果：

　　6、模拟  浏览器/服务器   访问模式

　　项目文件结构：

　　　　后端代码：

import    java.io.*;
import    java.net.Socket;
import    java.net.ServerSocket;
 
public class TCPServer {
    public static void main(String[] args) 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 /simulationBS/web/index.html HTTP/1.1
                        String line = br.readLine();
                        System.out.println(line);
                        //把读取的信息进行切割,只要中间部分 /simulationBS/web/index.html
                        String[] arr = line.split(" ");
                        //把路径前边的/去掉,进行截取 simulationBS/web/index.html
                        String htmlpath = arr[1].substring(1);
                        System.out.println(htmlpath);
                        //创建一个本地字节输入流,构造方法中绑定要读取的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();
    }
}

　　浏览器访问：http://127.0.0.1:8080/src/web/index.html

　　结果：

 TCP与UDP异同：

　　1、TCP保证数据正确性，UDP可能丢包，

　　　　TCP保证数据顺序，UDP不保证。

　　　　也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;

　　　　UDP尽最大努力交付，即不保证可靠交付Tcp通过校验和，重传控制，序号标识，

　　　　滑动窗口、确认应答实现可靠传输。如丢包时的重发控制，

　　　　还可以对次序乱掉的分包进行顺序控制。

　　3、UDP是无连接的，即发送数据之前不需要建立连接；

　　　　UDP具有较好的实时性，工作效率比TCP高，适用于对高速传输和实时性有较高的通信或广播通信。

　　4、每一条TCP连接只能是点到点的，对系统资源要求较多

　　　　UDP支持一对一，一对多，多对一和多对多的交互通信，对系统资源要求较少。

　　 5、UDP数据被限制在6KB以内，超出这个范围就不能发送了。