zoukankan html css js c++ java

TCP通信程序

2.1 概述

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

客户端（Client）与服务端（Server）其实都是一台计算机，配置存在差异而已

比如：

自己电脑通过浏览器访问淘宝网站，自己的电脑就是客服端打开淘宝访问淘宝就是访问淘宝的服务器端

自己电脑上安装游戏LOL,自己的电脑就是客服端，输入用户名和密码就会连接服务器，打完游戏数据就会上传服务器端，下次登录数据还会存在

两端通信时步骤：

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

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

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

2.2 Socket类（客户端）

TCP通信的客户端：向服务器发送请求，给服务器发送数据，读取服务器回写的数据

表示客户端的类：

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

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

构造方法

Sockrt(String host,int port ) 创建一个流套接字并将其连接到指定主机上的指定端口号

参数

String host：服务器主机的名称/服务器的IP地址
int port：服务器的端口号

成员方法

OutputStream getOutputStream() 返回此套接字的输出流

InputStream getInputStream() 返回此套接字的输入流

void close() 关闭此套接字

实现步骤

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

注意

客户端和服务器端进行交互，必须使用Socket中提供的网络流，不能使用自己创建的流对象
当我们创建客户端对象Socket的时候，就会去请求服务器和服务器进行3次握手建立连接通路
1. 这时候如果服务器没有启动，那么就会抛出异常
2. 如果服务器启动，就可以进行正常的交互

2.3 ServerSocket类

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

TCP通信的服务器端：接收客户端的请求，读取客户端发送的数据，给客户端回写数据

表示服务器的类

java.net.ServerSocket：此类实现服务器的套接字

构造方法

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

服务器端必须明确的一件事，必须知道是哪个客户端请求的服务器

所以可以使用accept方法获取到请求的客户端对象Socket

成员方法

Socket accept() 侦听并接受此套接字的连接

服务器的实现步骤

创建服务器ServerSocket对象和系统要指定的端口号
使用ServerSocket对象中的方法accept，获取到请求的客户端对象Socket
使用Socket对象中的方法getInputStream() 获取网络字节输入流InputStream对象
使用网络字节输入流InputStream对象中的方法read，读取客户端发送的数据
使用Socket对象中的方法getOutputStream() 获取网络字节输入流OuputStream对象
使用网络字节输出流OutputStream对象中的方法write，给客户端回写数据
释放资源（socket，severSocket）

示例代码

客户端

public static void main(String[] args){
    //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();

}

服务器端

 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.使用网络字节输入流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();
    }
}

第三章综合案例

3.1 文件上传案例

TCP通信的文件上传案例

原理

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

步骤

客户端使用本地的字节输入流，读取要上传的文件。
客户端换使用网络字节输出流，把读取到的文建上传到服务器
服务器使用网络字节输入流，读取客户端上传的文件
服务器使用本地字节输出流，把读取到的文件，保存到服务器的硬盘上
服务器使用网络字节输出流，给客户端回复上“传成功”
客户端使用网络字节输入流，读取服务器回写的数据
释放资源

注意

客户端和服务器和本地硬盘进行读写，需要使用自己创建的字节流对象（本地流）
客户端和服务器之间进行读写，必须使用Socket中提供的字节流对象（网络流）

文件上传的原理，就是文件的复制

明确

数据源
数据目的地

文件上传分析图解

3.2 文件上传案例客户端

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

明确

数据源：c:Test1.jpg
目的地：服务器

实现步骤

创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream对象
使用本地字节输入流FileInputStream对象中的方法read，读取本地文件
使用字节网络输出流OutputStream对象中的方法write，把读取的文件上传到服务器
使用Socket中的方法getInputStream，获取网络字节输入流InputStream对象
使用网络字节输入流InputStream对象中的方法read读取服务器回写的数据
释放资源（getInputStream，socket）

示例代码

public static void main(String[] args) throws IOException {
        // 1. 创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("c:\Test\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，读取本地文件
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = fis.read())!=-1){
            // * 5. 使用字节网络输出流OutputStream对象中的方法write，把读取的文件上传到服务器
            os.write(bytes,0,len);
        }
        // * 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. 释放资源（getInputStream，socket）
        fis.close();
        socket.close();

    }

3.3 文件上传案例服务器端

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

明确

数据源：客户端上传的文件
目的地：服务器的硬盘 d:Testupload1.jpg

实现步骤

创建一个服务器ServerSocket对象，和系统要指定的端口号
使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象
使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
判断d:Testupload1.jpg文件夹是否存在，不存在则创建
创建一个本地字节输出流FileOutputStream对象，构造方法中绑定要输出的目的地
使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
使用本地字节输出流FileOutputStream对象中的方法write，把读取到的数据保存到服务器的硬盘上
使用Socket对象中的方法getOutputStream，获取到网络字节输出流OutputStream对象
使用网络字节输出流OutputStream对象中的方法write，给客户端回写“上传成功”
释放资源（FileOutputStream，socket，serversocket）

示例代码

public static void main(String[] args) throws IOException {
        // 1. 创建一个服务器ServerSocket对象，和系统要指定的端口号
        ServerSocket server = new ServerSocket(888);
        // 2. 使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象
        Socket socket = server.accept();
        // 3. 使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
        InputStream is = socket.getInputStream();
        // 4. 判断d:\Test\upload\1.jpg文件夹是否存在，不存在则创建
        File file = new File("d:\Test\upload\1.jpg");
        if (!file.exists()){
            file.mkdirs();
        }
        // 5. 创建一个本地字节输出流FileOutputStream对象，构造方法中绑定要输出的目的地
        FileOutputStream fos = new FileOutputStream(file+"1.jpg");
        // 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();
        server.close();
    }

文件上传优化分析

文件名称写死的问题

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

FileOutputStream fis = new FileOutputStream(System.currentTimeMillis()+".jpg") // 文件名称
BufferedOutputStream bos = new BufferedOutputStream(fis);

循环接收的问题

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

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

效率问题

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

while（true）{
    Socket accept = serverSocket.accept();
    // accept 交给子线程处理.
    new Thread(() -> {
      	......
        InputStream bis = accept.getInputStream();
      	......
    }).start();
}

优化实现

public class FileUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器 启动.....  ");
        // 1. 创建服务端ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
      	// 2. 循环接收,建立连接
        while (true) {
            Socket accept = serverSocket.accept();
          	/* 
          	3. socket对象交给子线程处理,进行读写操作
               Runnable接口中,只有一个run方法,使用lambda表达式简化格式
            */
            new Thread(() -> {
                try (
                    //3.1 获取输入流对象
                    BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                    //3.2 创建输出流对象, 保存到本地 .
                    FileOutputStream fis = new FileOutputStream(System.currentTimeMillis() + ".jpg");
                    BufferedOutputStream bos = new BufferedOutputStream(fis);) {
                    // 3.3 读写数据
                    byte[] b = new byte[1024 * 8];
                    int len;
                    while ((len = bis.read(b)) != -1) {
                      bos.write(b, 0, len);
                    }
                    //4. 关闭 资源
                    bos.close();
                    bis.close();
                    accept.close();
                    System.out.println("文件上传已保存");
                } catch (IOException e) {
                  	e.printStackTrace();
                }
            }).start();
        }
    }
}

信息回写分析图解

前四步与基本文件上传一致.

【服务端】获取输出流，回写数据。
【客户端】获取输入流，解析回写数据。

回写实现

public class FileUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器 启动.....  ");
        // 1. 创建服务端ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
        // 2. 循环接收,建立连接
        while (true) {
            Socket accept = serverSocket.accept();
          	/*
          	3. socket对象交给子线程处理,进行读写操作
               Runnable接口中,只有一个run方法,使用lambda表达式简化格式
            */
            new Thread(() -> {
                try (
                    //3.1 获取输入流对象
                    BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                    //3.2 创建输出流对象, 保存到本地 .
                    FileOutputStream fis = new FileOutputStream(System.currentTimeMillis() + ".jpg");
                    BufferedOutputStream bos = new BufferedOutputStream(fis);
                ) {
                    // 3.3 读写数据
                    byte[] b = new byte[1024 * 8];
                    int len;
                    while ((len = bis.read(b)) != -1) {
                        bos.write(b, 0, len);
                    }

                    // 4.=======信息回写===========================
                    System.out.println("back ........");
                    OutputStream out = accept.getOutputStream();
                    out.write("上传成功".getBytes());
                    out.close();
                    //================================

                    //5. 关闭 资源
                    bos.close();
                    bis.close();
                    accept.close();
                    System.out.println("文件上传已保存");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

客户端实现：

public class FileUpload_Client {
    public static void main(String[] args) throws IOException {
        // 1.创建流对象
        // 1.1 创建输入流,读取本地文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.jpg"));
        // 1.2 创建输出流,写到服务端
        Socket socket = new Socket("localhost", 6666);
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());

        //2.写出数据.
        byte[] b  = new byte[1024 * 8 ];
        int len ;
        while (( len  = bis.read(b))!=-1) {
            bos.write(b, 0, len);
        }
      	// 关闭输出流,通知服务端,写出数据完毕
        socket.shutdownOutput();
        System.out.println("文件发送完毕");
        // 3. =====解析回写============
        InputStream in = socket.getInputStream();
        byte[] back = new byte[20];
        in.read(back);
        System.out.println(new String(back));
        in.close();
        // ============================

        // 4.释放资源
        socket.close();
        bis.close();
    }
}

3.2 模拟BS服务器(扩展知识点)

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

案例分析

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

复制到我们Module中，比如复制到day08中

我们模拟服务器端，ServerSocket类监听端口，使用浏览器访问

public static void main(String[] args) throws IOException {
    	ServerSocket server = new ServerSocket(8000);
    	Socket socket = server.accept();
    	InputStream in = socket.getInputStream();
   	    byte[] bytes = new byte[1024];
    	int len = in.read(bytes);
    	System.out.println(new String(bytes,0,len));
    	socket.close();
    	server.close();
}

服务器程序中字节输入流可以读取到浏览器发来的请求信息

GET/web/index.html HTTP/1.1是浏览器的请求消息。/web/index.html为浏览器想要请求的服务器端的资源,使用字符串切割方式获取到请求的资源。

//转换流,读取浏览器请求第一行
BufferedReader readWb = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String requst = readWb.readLine();
//取出请求资源的路径
String[] strArr = requst.split(" ");
//去掉web前面的/
String path = strArr[1].substring(1);
System.out.println(path);

案例实现

服务端实现：

public class SerDemo {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端  启动 , 等待连接 .... ");
        // 创建ServerSocket 对象
        ServerSocket server = new ServerSocket(8888);
        Socket socket = server.accept();
        // 转换流读取浏览器的请求消息
        BufferedReader readWb = new
        BufferedReader(new InputStreamReader(socket.getInputStream()));
        String requst = readWb.readLine();
        // 取出请求资源的路径
        String[] strArr = requst.split(" ");
        // 去掉web前面的/
        String path = strArr[1].substring(1);
        // 读取客户端请求的资源文件
        FileInputStream fis = new FileInputStream(path);
        byte[] bytes= new byte[1024];
        int len = 0 ;
        // 字节输出流,将文件写会客户端
        OutputStream out = socket.getOutputStream();
        // 写入HTTP协议响应头,固定写法
        out.write("HTTP/1.1 200 OK
".getBytes());
        out.write("Content-Type:text/html
".getBytes());
        // 必须要写入空行,否则浏览器不解析
        out.write("
".getBytes());
        while((len = fis.read(bytes))!=-1){
            out.write(bytes,0,len);
        }
        fis.close();
        out.close();
        readWb.close();	
        socket.close();
        server.close();
    }
}

访问效果

火狐

小贴士：不同的浏览器，内核不一样，解析效果有可能不一样。

发现浏览器中出现很多的叉子,说明浏览器没有读取到图片信息导致。

浏览器工作原理是遇到图片会开启一个线程进行单独的访问,因此在服务器端加入线程技术。

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(8888);
        while(true){
            Socket socket = server.accept();
            new Thread(new Web(socket)).start();
        }
    }
    static class Web implements Runnable{
        private Socket socket;

        public Web(Socket socket){
            this.socket=socket;
        }

        public void run() {
            try{
                //转换流,读取浏览器请求第一行
                BufferedReader readWb = new
                        BufferedReader(new InputStreamReader(socket.getInputStream()));
                String requst = readWb.readLine();
                //取出请求资源的路径
                String[] strArr = requst.split(" ");
                System.out.println(Arrays.toString(strArr));
                String path = strArr[1].substring(1);
                System.out.println(path);

                FileInputStream fis = new FileInputStream(path);
                System.out.println(fis);
                byte[] bytes= new byte[1024];
                int len = 0 ;
                //向浏览器 回写数据
                OutputStream out = socket.getOutputStream();
                out.write("HTTP/1.1 200 OK
".getBytes());
                out.write("Content-Type:text/html
".getBytes());
                out.write("
".getBytes());
                while((len = fis.read(bytes))!=-1){
                    out.write(bytes,0,len);
                }
                fis.close();
                out.close();
                readWb.close();
                socket.close();
            }catch(Exception ex){

            }
        }
    }

}

访问效果：

查看全文

相关阅读:
图
 快排
 排序算法
 运算符
 二叉树
 递归
 队列
 栈（没写完）
绘制双坐标轴的图形3-不同的plot类型
 绘制双坐标轴的图形2-不同的plot类型

原文地址：https://www.cnblogs.com/anke-z/p/12726629.html

TCP通信程序

TCP通信程序

2.1 概述

2.2 Socket类 （客户端）

构造方法

成员方法

实现步骤

注意

2.3 ServerSocket类

构造方法

成员方法

服务器的实现步骤

示例代码

客户端

服务器端

第三章 综合案例

3.1 文件上传案例

原理

步骤

注意

明确

文件上传分析图解

3.2 文件上传案例 客户端

明确

实现步骤

示例代码

3.3 文件上传案例 服务器端

明确

实现步骤

示例代码

文件上传优化分析

优化实现

信息回写分析图解

回写实现

3.2 模拟BS服务器(扩展知识点)

案例分析

案例实现

访问效果

2.2 Socket类（客户端）

第三章综合案例

3.2 文件上传案例客户端

3.3 文件上传案例服务器端