JAVA中网络编程以及TCP通信程序

最新推荐文章于 2022-07-04 16:36:42 发布

MilkBerg

最新推荐文章于 2022-07-04 16:36:42 发布

阅读量444

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/weixin_43153854/article/details/103109406

版权

java 专栏收录该内容

42 篇文章 0 订阅

订阅专栏

一.网络编程

1.软件结构

网络编程就是在一定的协议下，实现两台计算机的通信程序。
俩种结构：
（1）C/S结构：Client/Server,客户端和服务器结构。
（2）B/S结构：Browser/Server,浏览器和服务器结构。

2.网络通信协议

网络通信协议
在这里插入图片描述
TCP/IP通信协议

3.协议分类

（1）UDP协议（无通信连接）
在这里插入图片描述
（2）TCP协议（面向连接）

4.网络编程三要素

协议，IP地址，端口号
在这里插入图片描述

二.TCP通信程序

1.概述

本地服务器地址127.0.0.1
在这里插入图片描述
服务器端：

2.Socket类

TCP通信的客户端：向服务器发送连接请求，给服务器发送数据，读取服务器回写的数据
表示客户端的类：
java.net.Socket：此类实现客户端套接字（也可以就叫“套接字”）。套接字是两台机器间通信的端点。
套接字：包含了IP地址和端口号的网络单位

构造方法：
Socket(String host, int port) 创建一个流套接字并将其连接到指定主机上的指定端口号。
参数：String host:服务器主机的名称/服务器的IP地址
int port:服务器的端口号

成员方法：
OutputStream getOutputStream() 返回此套接字的输出流。
InputStream getInputStream() 返回此套接字的输入流。
void close() 关闭此套接字。

3.TCP通信客户端代码实现

实现步骤：
1.创建一个客户端对象Socket,构造方法中绑定服务器的IP地址和端口号
2.使用Socket对象中的方法getOutputStream（）获取网络字节输出流OutputStream对象
3.使用网络字节输出流getOutputStream对象中的方法write，给服务器发送数据
4.使用Socket对象中的方法getInputStream获取网络字节输入流InputStream对象
5.使用网络字节输入流InputStream对象中的方法read,读取服务器回写的数据
6.释放资源（Socket）
注意：
1.客户端和服务器进行交互，必须使用Socket中提供的网络流，不能使用自己创建的流对象
2.当我们创建客户端对象Socket的时候，就会请求服务器和服务器经过3次握手，建立连接通路，
这时如果服务器没有启动，那么就会抛出异常
如果服务器已经启动，那么就可以进行交互

package Client;

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

    }
}

4.TCP通信服务器端代码实现

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.使用网络字节输出流getOutputStream对象中的方法write，给客户端回写数据
7.释放资源（Socket,ServerSocket）

package Server;

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.使用网络字节输出流getOutputStream对象中的方法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();
        os.write("收到，谢谢！".getBytes());
        socket.close();
        serverSocket.close();

    }

}

三.TCP通信案例

1.文件上传案例

原理
在这里插入图片描述
客户端代码实现

package demo02.FileUpload;

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

/*
   package demo02.FileUpload;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
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 TCPClient {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("c:\\1.jpg");
        Socket socket = new Socket("127.0.0.1", 8888);
        OutputStream os = socket.getOutputStream();
        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读取服务器回写的数据
        System.out.println("333333333333333333333333333333333");
        while ((len = is.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, len));
        }
        System.out.println("4444444444444444,while进入死循环打印不到");
        //8.释放资源（FileInputStream，Socket）
        fis.close();
        socket.close();
    }
}

服务器端代码实现

package demo02.FileUpload;

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

/*
    文件上传的服务器端：读取上传的文件，保存到本地，然后回传“上传成功”消息给客户端

    明确：
        数据源：客户端
        目的地：d:\\upload\\1.jpg

    实现的步骤：
        1.创建服务器ServerSocket对象，构造方法中绑定端口号
        2.使用ServerSocket对象中的方法accept方法，获取到请求的客户端对象Socket
        3.使用Socket对象中的方法getInputStream获取网络字节输入流InputStream对象
        4.判断d:\\update文件夹是否存在，不存在则创建
        5.创建一个本地字节输出流FileOutputStream对象，构造方法中绑定要输出的目的地
        6.使用网络字节输入流InputStream中的方法read,读取客户端上传的文件
        7.读取本地字节输出流FileOutputStream对象中的方法write,把读取到的文件保存到服务器的目的地
        8.使用Socket对象中的方法getOutputStream，获取网络字节输出流对象OutputStream
        9.使用网络字节输出流对象中方法write给客户端回写上传成功
        10.释放资源（ServerSocket,Socket,FileOutputStream）
 */
public class TCPServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8888);
        Socket socket = serverSocket.accept();
        InputStream is = socket.getInputStream();
        File file = new File("d:\\upload");
        if (!file.exists()) {
            file.mkdirs();
        }
        FileOutputStream fos = new FileOutputStream(file + "\\1.jpg");
        System.out.println("111111111111111111");
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = is.read(bytes))!=-1){
            fos.write(bytes,0,len);
        }
        System.out.println("2222222222222222222,while进入死循环打印不到");
        socket.getOutputStream().write("上传成功".getBytes());
        serverSocket.close();
        socket.close();
        fos.close();

    }
}

遇到的问题
（1） FileOutputStream fos = new FileOutputStream(file + "\\1.jpg");
不加\的话会缺少路径
（2）Run之后没有消息回传
因为客户端read并不读取-1写入上传文件，所以服务器read，没有读取到-1结束标记符，会一直死循环，进入阻塞状态。同理，回来客户端也没有读取到-1结束标记，进入阻塞状态。

问题分析：
在这里插入图片描述
解决方法：
解决：上传完文件，给服务器写一个结束标记
shutdownOutput()禁用此套接字的输出流。
对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接终止序列。

修改后的客户端解决代码

package demo02.FileUpload;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
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 TCPClient {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("c:\\1.jpg");
        Socket socket = new Socket("127.0.0.1", 8888);
        OutputStream os = socket.getOutputStream();
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = fis.read(bytes)) != -1) {
            // 5.使用网络字节输出流OutputStream对象中的方法write,把读取到的文件上传到服务器
            os.write(bytes, 0, len);
        }
        /*
            解决：上传完文件，给服务器写一个结束标记
            shutdownOutput()禁用此套接字的输出流。
            对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接终止序列。
         */
        socket.shutdownOutput();
        //6.使用Socket中的方法getInputStream,获取网络字节输入流InputStream对象
        InputStream is = socket.getInputStream();
        //7.使用网络字节输入流InputStream对象read读取服务器回写的数据
        System.out.println("333333333333333333333333333333333");
        while ((len = is.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, len));
        }

        System.out.println("4444444444444444,while进入死循环打印不到");
        //8.释放资源（FileInputStream，Socket）
        fis.close();
        socket.close();
    }
}

2.文件上传的优化分析

（1）自定义一个文件的命名规则

防止同名的文件被覆盖，规则：域名+毫秒值+随机数

 String fileName = "itcast" + System.currentTimeMillis() + new Random().nextInt(999999) + ".jpg";
                        FileOutputStream fos = new FileOutputStream(file + "\\" + fileName);

（2）让服务器一直处于监听状态（死循环accept方法）

有一个客户端上传文件，就保存一个文件，服务器不用关闭

while (true) {}

（3）使用多线程技术，提高程序的效率

有一个客户端上传文件，就开启一个线程，完成文件的上传

new Thread(new Runnable() {
                //完成文件的上传
                @Override
                public void run() {}

重写run方法

（4）重写run方法

重写run方法时并没有声明抛出异常，子类重写方法时也不能抛出异常，使用try catch

四.模拟B/S服务器

1.B/S案例分析

在这里插入图片描述

2.B/S服务器端代码实现

package demo04.BSTCP;

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,和系统要指定的端口号
        ServerSocket serverSocket = new ServerSocket(8080);

        /*
            浏览器解析服务器回写的html页面，页面中如果有图片，那么浏览器就会单独的开启一个线程，读取服务器的图片
            就需要让服务区一直处于监听状态，客户端请求一次，服务器就回写一次
         */
        while (true) {

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

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

                        //使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
                        InputStream is = socket.getInputStream();
                        //把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(" ");
                        //把路径前边的/去掉，进行截取
                        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();

        }

        //释放资源
//        serverSocket.close();
    }
}

MilkBerg

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JAVA中网络编程以及TCP通信程序

一.网络编程1.软件结构网络编程就是在一定的协议下，实现两台计算机的通信程序。俩种结构：（1）C/S结构：Client/Server,客户端和服务器结构。（2）B/S结构：Browser/Server,浏览器和服务器结构。2.网络通信协议网络通信协议TCP/IP通信协议3.协议分类（1）UDP协议（无通信连接）（2）TCP协议（面向连接）4.网络编程三要素协议...
复制链接

扫一扫