[网络协议] java网络通信编程

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 网络协议 -> java网络通信编程 -> 正文阅读

[网络协议]java网络通信编程

网络的相关概念

1.概念：两台设备之间通过网络实现数据传输

2.网络通信：将数据从网络从一台设备传输到另一台设备

3.java.net包下提供一系列的类或接口，供开发者使用，完成网络通信

4.根据网络覆盖范围不同，对网络进行分类：

? 局域网：覆盖范围最小，仅仅覆盖一个教室或一个机房

? 城域网：覆盖范围较大，可以覆盖一个城市

? 广域网：覆盖范围最大，可以覆盖全国，甚至全球，万维网是广域网的代表

IP地址

1.概念：用于唯一标识网络中的每台计算机

2.查看IP地址：ipconfig

3.ip地址的表现形式：点分十进制 xx.xx.xx.xx

4.每一个十进制数的范围：0-255

5.IP地址的组成=网络地址+主机地址，比如：192.168.16.69

6.ilPv6是互联网工程任务组织设计的用于替代Ipv4的下一代协议，其地址数量号称为全世界的

每一粒沙子编上一个地址，同时也解决了网络地址资源有限，也解决多种接入设备连入互联网的障碍

域名

1.www.baidu.com

2.概念：将IP地址映射成域名

3.好处就是方便记忆ip的困难

端口号

1.概念：用于标识计算机上某个特定的网络程序

2.表示形式：以整数形式，范围0-65535

3.0-1024已经被占用，比如 ssh 22，ftp21，stmp 25 http 80

4.常见的网络程序端口号：

? tomcat：8080

? mysql：3306

? oracle：1521

? sqlserver：1433

网络通信协议

TCP/IP(Transmission Control Protocol/Internet Protocol)的简写

中文译名为传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议是Internet最基本的协议，

Internet国际互联网络的基础，简单的说，就是由网络层的IP协议和传输层的Tcp协议组成的

OSI模型	TCP/IP模型	TCP/IP模型各层对应的协议
应用层	应用层	HTTP . ftp , telnet , DNS…
表示层	应用层	HTTP . ftp , telnet , DNS…
会话层	应用层	HTTP . ftp , telnet , DNS…
传输层	传输层	TCP, UDP,…
网络层	网络层	IP, ICMP, ARP
数据链路层	物理+数据链路层	Link
物理层	物理+数据链路层	Link

准确来说人和人交流(通讯):依靠语言[中文，英语，法语]

语言本身就是一种协议

数据在网络编程中数据的组织形式就是协议，回复数据也需要按照规定的协议形式

TCP协议

1.使用TCP协议前，须先建立TCP连接，形成传输数据通道

2.传输前，采用三次握手方式，是可靠的

3.TCP协议进行通信的两个应用程序：客户端，服务端

4.在连接中可以进行大数据量的传输

5.传输完毕，须释放已建立的连接，效率低

UDP协议

1.将数据，源，目的封装成数据包，不需要建立连接

2.每个数据报的大小限制在64k内

3.因无需连接，故是不可靠的

4.发送数据结束时无需释放资源（因为不是面向连接的），速度快

5.举例：厕所通知：发短信

InetAddress类相关方法

import java.net.InetAddress;
import java.net.UnknownHostException;

public class API_ {
    public static void main(String[] args) throws UnknownHostException {
        //1.获取本机的InetAddress对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);

        //2.根据主机名获取InetAddress
        InetAddress byName = InetAddress.getByName("LAPTOP-AK488A5P");
        System.out.println(byName);

        //3.根据域名返回InetAddress对象，比如www.baidu.com
        InetAddress byName1 = InetAddress.getByName("www.baidu.com");
        System.out.println(byName1);

        //4.通过InetAddress对象获取对应的地址
        String hostAddress= byName1.getHostAddress();
        System.out.println("byName1对应的IP地址=" + hostAddress);

        //5.通过InetAddress对象，获取对应的主机名或者域名
        String hostName = byName1.getHostName();
        System.out.println("byName1对应的主机名/域名 ="+hostName);
    }
}

Socket(电源插口)

1.套接字(Socket)开发网络应用程序被广泛采用，以至于称为事实上的标准

2.通信的两端都要有Socket，是两台机器通信间的端点

3.网络通信其实就是Socket之间的通信

4.Socket允许程序把网络连接当成一个流，数据在两个Socket通过IO传输

5.一般主动发起通信的应用程序是客户端，等待通信请求的为服务端

在这里插入图片描述

TCP网络通信编程

在这里插入图片描述

TCP字节流编程

客户端向服务端发起通信

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

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

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

public class SocketTCPClient {
    //编写一个客户端
    public static void main(String[] args) throws IOException {
//      1.连接服务端(IP,端口)
        //连接本机的9999端口
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket返回="+socket.getClass());
//        2.连接上后，生成Socket通过socket.getOutputStream()
        OutputStream outputStream = socket.getOutputStream();
//        3.通过输出流，写入数据到数据通道
        outputStream.write("hello,server".getBytes());
        //4.关闭流对象和socket
        outputStream.close();
        socket.close();
        System.out.println("客户端退出.....");
    }
}

服务端向客户端发起通信

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

public class SocketTCPServer {
    public static void main(String[] args) throws IOException {
        /**
          *编写一个服务端
          **/
        //思路
        //1.在本机的9999端口监听，等待连接
        //  细节：要求在本机没有其他服务器在监听9999端口
        // 细节：这个ServerSocket 可以通过accept（）返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接");
        //2.当没有客户端连接9999端口时，程序会阻塞，等待连接
        //如果有程序会连接则返回Socket对象
        Socket socket = serverSocket.accept();
        System.out.println("服务端 socket = "+socket.getClass());
        //3.通过socket.getOutputStream写入到数据通道发送到客户端
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,Client".getBytes());
        //关闭流和socket
        outputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务器向客户端发起通信");
    }
}

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

public class SocketTCPClient {
    //编写一个客户端
    public static void main(String[] args) throws IOException {
//      1.连接服务端(IP,端口)
        //连接本机的9999端口
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket返回="+socket.getClass());
        
        //读取服务端的数据
        InputStream inputStream = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int readLen= 0;
        while((readLen= inputStream.read(bytes)) != -1){
            System.out.println(new String(bytes,0,readLen));//根据读取到的实际长度，显示内容
        }

        //4.关闭流对象和socket
        inputStream.close();
        socket.close();
        System.out.println("客户端接收到服务端的信息");

TCP字符流编程

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

public class SocketTCPServer {
    public static void main(String[] args) throws IOException {
        /**
          *编写一个服务端
          **/
        //思路
        //1.在本机的9999端口监听，等待连接
        //  细节：要求在本机没有其他服务器在监听9999端口
        // 细节：这个ServerSocket 可以通过accept（）返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接");
        //2.当没有客户端连接9999端口时，程序会阻塞，等待连接
        //如果有程序会连接则返回Socket对象
        Socket socket = serverSocket.accept();
        System.out.println("服务端 socket = "+socket.getClass());
        //3.通过socket.getOutputStream写入到数据通道发送到客户端
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello,Client,字符流");
        bufferedWriter.newLine();//插入一个换行符，表示写入的内容结束
        bufferedWriter.flush();//如果使用字符流，需要手动刷新，否则数据不会写入到数据通道
        //关闭流和socket
        outputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务器向客户端发起通信");
    }
}

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

public class SocketTCPClient {
    //编写一个客户端
    public static void main(String[] args) throws IOException {
//      1.连接服务端(IP,端口)
        //连接本机的9999端口
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket返回="+socket.getClass());
        2.连接上后，生成Socket通过socket.getOutputStream()
//        OutputStream outputStream = socket.getOutputStream();
        3.通过输出流，写入数据到数据通道
//        outputStream.write("hello,server".getBytes());
        //        InputStream inputStream = socket.getInputStream();
        //读取服务端的数据
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);


        //4.关闭流对象和socket
        bufferedReader.close();
        inputStream.close();
        socket.close();
        System.out.println("客户端接收到服务端的信息");
    }
}

传送文件

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 TCPClient {
    //文件上传的客户端
    public static void main(String[] args) throws IOException {
        //客户端连接服务端8888，得到Socket
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        //创建读取磁盘文件的输入流
        String filePath = "D:\\Google\\1.png";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));

        //bytes就是filePath对应的字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);

        //通过socket获取到输出流，将bytes数据发送给服务端
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);
        bis.close();
        socket.shutdownOutput();//设置写入数据的结束标记

        //关闭相关流
        bos.close();
        socket.close();

    }
}

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 TcpServer {
    public static void main(String[] args) throws IOException {
        //1.服务端在本机监听8888端口
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端在8888端口监听");
        //2.等待连接
        Socket socket = serverSocket.accept();
        //3.读取客户端发送的数据
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //将得到bytes数组，写入到指定的路径，就得到一个文件了
        String destFilePath = "D:\\java开发\\网络通信\\src\\11.png";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
        bos.write(bytes);
        bos.close();

        //关闭其他资源
        bis.close();
        socket.close();
        serverSocket.close();


    }
}

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

public class StreamUtils {
    public static byte[] streamToByteArray(InputStream is) throws IOException {
        /**
         *封装的一个方法 
         *将输入流转换成byte[]*/
        ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
        byte[] b = new byte[1024];
        int len;
        while((len=is.read(b))!=-1){
            bos.write(b,0,len);
        }
        byte[] array = bos.toByteArray();
        bos.close();
        return array;
    }
}

netstat指令

1.netstat -an可以查看主机网络情况，包括端口监听情况和网络连接情况

2.netstat -an |more可以分页显示

3.是在dos控制台下执行win+r

? 说明：(1).Listening表示某个端口在监听

? (2).如果有一个外部程序(客户端连接)连接到该端口，就会显示一条连接信息

? (3).可以输入ctrl+c退出指令

UDP网络通信编程[了解]

基本介绍

1.类DataagramSocket和DatagramPacket实现了基于UDP协议网络程序

2.UDP数据报通过数据报套接字DatagramSocket发送和接收，系统不保证UDP数据报

? 一定能够安全送到目的地，也不确定什么时候可以抵达

3.DatagramPacket对象封装了UDP数据报，在数据报中包含了发送端的IP地址和

? 端口号以及接收端的IP地址和端口号

4.UDP协议中每个数据报都给出了完整的地址信息，因此无需建立发送方和接收方的连接

基本流程

1.核心的两个类/对象 DatagramSocket与DatagramPacket

2.建立发送端，接收端

3.建立数据包/报DatagramPacket

4.调用DatagramSocket的发送，接收方法

5.关闭DatagramSocket

在这里插入图片描述

应用案例

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UdpReceive {
    public static void main(String[] args) throws IOException {
        //1.创建一个DatagramSocket对象，准备在9999端口接收数据
        DatagramSocket socket = new DatagramSocket(9999);
        //2.构建一个DatagramPacket，准备接收数据，一个数据包最大64k
        byte[] buf = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(buf, buf.length);
        //3.调用接收方法  将通过网络传输的DatagramPacket对象
        //填充到packet对象
        //当有数据包发送到本机的9999端口时，就会接收到数据
        //如果数据包没有发送到本机的9999端口，就会阻塞等待
        System.out.println("接收端等待接收数据......");
        socket.receive(datagramPacket);

        //4.可以把packet进行拆包，取出数据，并显示
        int length = datagramPacket.getLength();//实际接收到的数据字节长度
        byte[] data = datagramPacket.getData();//接收数据
        String s = new String(data,0,length);
        System.out.println(s);

        //关闭资源
        socket.close();
        System.out.println("接口端退出");
    }
}

import java.io.IOException;
import java.net.*;
import java.nio.charset.StandardCharsets;

public class UdpSendOut {
    public static void main(String[] args) throws IOException {
        //发送端
        //创建DatagramSocket对象，准备在9998端口发送数据和接收数据
        DatagramSocket socket = new DatagramSocket(9998);
        byte[] data  = "hello 明天吃火锅-".getBytes();
        //说明：封装的DatagramPacket对象data内容字节数组，data.length,主机ip，端口
        DatagramPacket packet =
                new DatagramPacket(data, data.length, InetAddress.getLocalHost(), 9999);
        socket.send(packet);

        //关闭资源
        socket.close();
        System.out.println("发送端退出");
    }
}
SendOut {
    public static void main(String[] args) throws IOException {
        //发送端
        //创建DatagramSocket对象，准备在9998端口发送数据和接收数据
        DatagramSocket socket = new DatagramSocket(9998);
        byte[] data  = "hello 明天吃火锅-".getBytes();
        //说明：封装的DatagramPacket对象data内容字节数组，data.length,主机ip，端口
        DatagramPacket packet =
                new DatagramPacket(data, data.length, InetAddress.getLocalHost(), 9999);
        socket.send(packet);

        //关闭资源
        socket.close();
        System.out.println("发送端退出");
    }
}