devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java网络编程 ---- TCP 网络通信编程_java tcp通信编程

作者：小小林熬夜学编程 | 2024-04-08 07:07:20

赞

踩

java tcp通信编程

视频：【零基础 快速学Java】韩顺平 零基础30天学会Java

文章目录

1. Socket

  1. 套接字(Socket)开发网络应用程序被广泛采用，以至于成为事实上的标准。
  2. 通信的两端都要有Socket，是两台机器间通信的端点
  3. 网络通信其实就是Socket间的通信。
  4. Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。
  5. 一般主动发起通信的应用程序属客户端,等待通信请求的为服务端

请添加图片描述

2. TCP 网络通信编程

  1. 基于客户端服务端的网络通信
  2. 底层使用的是TCP/IP协议
  3. 应用场景举例:客户端发送数据，服务端接受并显示控制台
  4. 基于Socket的TCP编程

请添加图片描述

3. 应用案例 1(使用字节流)

  1. 编写一个服务器端,和一个客户端
  2. 服务器端在9999端口监听
  3. 客户端连接到服务器端,发送"hello, server"，然后退出
  4. 服务器端接收到客户端发送的信息，输出,并退出

SocketTCP01Server.java

package java学习.网络编程.TCP;

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

public class SocketTCP01Server {
    public static void main(String[] args) throws IOException {
//        编写一个服务器端
//        服务器端在9999端口监听
//        在本机 的 9999 端口监听, 等待连接
//        要求在本机没有其它服务在监听 9999
//        这个 ServerSocket 可以通过 accept() 返回多个 Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println( "服务端，在9999端口监听，等待连接..." );
//        当没有客户端连接 9999 端口时，程序会 阻塞, 等待连接
//        如果有客户端连接，则会返回 Socket 对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println( "服务端 socket=" + socket.getClass() );
//        服务器端接收到客户端发送的信息，输出,并退出
//        通过 socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
        InputStream inputStream = socket.getInputStream();
//        IO 读取
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ( (readLen=inputStream.read(buf))!=-1 ) {
            //根据读取到的实际长度，显示内容.
            System.out.println( new String(buf, 0, readLen) );
        }
//        关闭流和 socket
        inputStream.close();
        socket.close();
        serverSocket.close();

    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

SocketTCP01Client.java

package java学习.网络编程.TCP;

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

public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
//        连接服务端 (ip , 端口）
//        连接本机的 9999 端口, 如果连接成功，返回 Socket 对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println( "客户端 socket=" + socket.getClass() );
//        连接上后，生成 Socket, 通过 socket.getOutputStream()
//        得到 和 socket 对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
//        通过输出流，写入数据到 数据通道
        outputStream.write("hello server".getBytes());
//        关闭流对象和 socket, 必须关闭
        outputStream.close();
        socket.close();
        System.out.println( "客户端退出" );
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

请添加图片描述
请添加图片描述

4. 应用案例 2(使用字节流)

  1. 编写一个服务端,和一个客户端
  2. 服务器端在9999端口监听
  3. 客户端连接到服务端,发送"hello, server"，并接收服务器端回发的"hello,client",再退出
  4. 服务器端接收到客户端发送的信息,输出,并发送"hello, client",再退出

SocketTCP02Server

package java学习.网络编程.TCP;

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

public class SocketTCP02Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println( "服务端在9999端口监听..." );
        Socket socket = serverSocket.accept();
        System.out.println( "服务端 socket=" + socket.getClass() );
//        输入流，读取
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ( (readLen=inputStream.read(buf))!=-1 ) {
            System.out.println( new String(buf, 0, readLen) );
        }
//        输出流，输出
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write( "hello client".getBytes() );
//        输出结束标志
        socket.shutdownOutput();
//        关闭流
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

SocketTCP02Client

package java学习.网络编程.TCP;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class SocketTCP02Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println( "客户端 socket=" + socket.getClass() );
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello server".getBytes());
//        输出结束标志
        socket.shutdownOutput();
        InputStream inputStream = socket.getInputStream();
        int readLen = 0;
        byte[] buf = new byte[1024];
        while ( (readLen=inputStream.read(buf))!=-1 ) {
            System.out.println( new String(buf, 0, readLen) );
        }
        inputStream.close();
        outputStream.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

请添加图片描述
请添加图片描述

5. 应用案例 3(使用字符流)

  1. 编写一个服务端,和一个客户端
  2. 服务端在9999端口监听
  3. 客户端连接到服务端，发送"hello, server",并接收服务端回发的"hello,client",，再退出
  4. 服务端接收到客户端发送的信息，输出，并发送"hello, client"。再退出

SocketTCP03Server

package java学习.网络编程.TCP;

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

public class SocketTCP03Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println( "服务端在9999端口监听" );
        Socket accept = serverSocket.accept();
        InputStream inputStream = accept.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);
//        输出
        OutputStream outputStream = accept.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello client 字符流");
//        插入一个换行符，表示回复内容的结束
        bufferedWriter.newLine();
        bufferedWriter.flush();
//        关闭
        bufferedWriter.close();
        bufferedReader.close();
        accept.close();
        serverSocket.close();
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

SocketTCP03Client

package java学习.网络编程.TCP;

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

public class SocketTCP03Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello server 字符流");
//        插入一个换行符，表示写入的内容结束, 注意，要求对方使用 readLine()!!!!
        bufferedWriter.newLine();
        bufferedWriter.flush();
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String line = bufferedReader.readLine();
        System.out.println(line);
//        关闭
        bufferedReader.close();
        bufferedWriter.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

请添加图片描述
请添加图片描述

6. 应用案例 4 文件上传

  1. 编写一个服务端,和一个客户端

  2. 服务器端在8888端口监听

  3. 客户端连接到服务端，发送一张图片 e:\bg.jpg
    请添加图片描述

  4. 服务器端接收到客户端发送的图片，保存到src下,发送"收到图片”再退出

  5. 客户端接收到服务端发送的“收到图片”，再退出

  6. 该程序要求使用StreamUtils.java,我们直接使用

    
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * 此类用于演示关于流的读写方法
 *
 */
public class StreamUtils {
	/**
	 * 功能：将输入流转换成byte[]， 即可以把文件的内容读入到byte[]
	 * @param is
	 * @return
	 * @throws Exception
	 */
	public static byte[] streamToByteArray(InputStream is) throws Exception{
		ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
		byte[] b = new byte[1024];//字节数组
		int len;
		while((len=is.read(b))!=-1){//循环读取
			bos.write(b, 0, len);//把读取到的数据，写入bos	
		}
		byte[] array = bos.toByteArray();//然后将bos 转成字节数组
		bos.close();
		return array;
	}
	/**
	 * 功能：将InputStream转换成String
	 * @param is
	 * @return
	 * @throws Exception
	 */
	
	public static String streamToString(InputStream is) throws Exception{
		BufferedReader reader = new BufferedReader(new InputStreamReader(is));
		StringBuilder builder= new StringBuilder();
		String line;
		while((line=reader.readLine())!=null){
			builder.append(line+"\r\n");
		}
		return builder.toString();
		
	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49

在这里插入图片描述

TCPFileUploadServer.java
TCPFileUploadClient.java

6.1 创建服务器

package java学习.网络编程.TCP;

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

public class TCPFileUploadServer {
    public static void main(String[] args) throws IOException {
//        服务器在8888端口监听
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务器在8888端口监听");
//        等待连接
        Socket socket = serverSocket.accept();
        System.out.println( "服务端 socket=" + socket.getClass() );
        
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

6.2 客户端读取文件上传文件

package java学习.网络编程.TCP;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class TCPFileUploadClient {
    public static void main(String[] args) throws Exception {
//        连接服务端的8888端口
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
//        文件的路径
        String filePath = "e:\\bg.jpg";
//        输入流,读取图片
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
//        调用StreamUtils.streamToByteArray读取图片，获取二进制数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);
//        通过 socket 获取到输出流, 将 bytes 数据发送给服务端
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);//将文件对应的字节数组的内容，写入到数据通道
        socket.shutdownOutput();//设置写入数据的结束标记
        
//        关闭流
        bos.close();
        bis.close();
        socket.close();
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

6.3 服务端读取流中的文件存放在src下

package java学习.网络编程.TCP;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPFileUploadServer {
    public static void main(String[] args) throws Exception {
//        服务器在8888端口监听
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务器在8888端口监听");
//        等待连接
        Socket socket = serverSocket.accept();
        System.out.println( "服务端 socket=" + socket.getClass() );
//        输入流，读取流中数据
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
//        调用StreamUtils.streamToByteArray将输入流中的数据读到数组中
        byte[] bytes = StreamUtils.streamToByteArray(bis);
//        将得到 bytes 数组，写入到指定的路径，就得到一个文件了
//        路径
        String filePath = "src\\bg.jpg";
//        输出流
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
        bos.write(bytes);

//        关闭
        bos.close();
        bis.close();
        socket.close();
        serverSocket.close();
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

请添加图片描述
请添加图片描述
请添加图片描述

6.4 服务端回复信息

package java学习.网络编程.TCP;

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

public class TCPFileUploadServer {
    public static void main(String[] args) throws Exception {
//        服务器在8888端口监听
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务器在8888端口监听");
//        等待连接
        Socket socket = serverSocket.accept();
        System.out.println( "服务端 socket=" + socket.getClass() );
//        输入流，读取流中数据
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
//        调用StreamUtils.streamToByteArray将输入流中的数据读到数组中
        byte[] bytes = StreamUtils.streamToByteArray(bis);
//        将得到 bytes 数组，写入到指定的路径，就得到一个文件了
//        路径
        String filePath = "src\\bg.jpg";
//        输出流
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
        bos.write(bytes);


//        回复信息
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write("收到图片");
        bw.flush();//把内容刷新到数据通道
//        客户端以字节流读取信息，可以设置如下结束标记
        socket.shutdownOutput();//设置写入结束标记

//        关闭
        bw.close();
        bos.close();
        bis.close();
        socket.close();
        serverSocket.close();
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

6.5 服务端接收回复信息

package java学习.网络编程.TCP;

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

public class TCPFileUploadClient {
    public static void main(String[] args) throws Exception {
//        连接服务端的8888端口
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
//        文件的路径
        String filePath = "e:\\bg.jpg";
//        输入流,读取图片
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
//        调用StreamUtils.streamToByteArray读取图片，获取二进制数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);
//        通过 socket 获取到输出流, 将 bytes 数据发送给服务端
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);//将文件对应的字节数组的内容，写入到数据通道
        socket.shutdownOutput();//设置写入数据的结束标记


//        接收服务端回复的信息
        InputStream inputStream = socket.getInputStream();
//        使用 StreamUtils 的方法，直接将 inputStream 读取到的内容 转成字符串
        String s = StreamUtils.streamToString(inputStream);
        System.out.println(s);
//        关闭流
        inputStream.close();
        bos.close();
        bis.close();
        socket.close();
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

效果

请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述

7. netstat 指令

  1. netstat -an 可以查看当前主机网络情况，包括端口监听情况和网络连接情况
  2. netstat -an | more可以分页显示 空格下一页
  3. 要求在dos控制台下执行 win+r

说明:
(1) Listening表示某个端口在监听
(2)如果有一个外部程序(客户端)连接到该端口，就会显示一条连接信息.
(3)可以输入ctrl +c退出指令

netstat -an

  • 1
netstat -an | more

  • 1

请添加图片描述
请添加图片描述

netstat -anb

  • 1

可以查看哪些应用在监听端口(要用管理员的身份打开命令窗口)
请添加图片描述

8. TCP 网络通讯不为人知的秘密

当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的，这个端口是TCP/IP来分配的，是不确定的，是随机的.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/383741
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号