网络编程IP/UDP

JAVA不会写

于 2023-12-17 18:23:52 发布

阅读量705

点赞数 16

文章标签：网络服务器运维

本文链接：https://blog.csdn.net/Jack_GXx/article/details/135046162

版权

1.网络通信

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

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

java.net包下提供了一系列的类或接口，供程序员使用，完成网络通信

2.网络

概念：两台或多台设备通过一定物理设备连接起来构成了网络

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

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

2）城域网：覆盖范围很大，可以覆盖一个城市

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

3.ip地址

1）概念：用于唯一表示网络中的每台计算机/主机

2）查看ip地址：ipconfig

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

4) 每个十进制数的范围 0-255

5) ip地址的组成=网络地址+主机地址，比如：192.183.32.42

6) iIPv6是互联网工程任务组设计的用于代替IPV4的下一代Ip协议，其地址数量号称可以为全世界的每一粒啥子编上一个地址

7）由于Ipv3最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的使用，不仅能解决网络地址资源数量问题，而且也解决了多种接入设备连接互联网的障碍

ipv4地址分类

域名：

举例：百度主机ip：110.242.68.3

百度域名：www.baidu.com

好处：为了方便记忆，解决了记Ip的困难

概念：将ip地址映射成域名，这里怎么映射上，HTTP协议

端口号：

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

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

3. 0-1024已经被占用，比如ssh12,ftp21,smtp25，不能在继续使用这些端口号

4.常见的网络端口号：sqlserver:1433 tomcat:8080 mysql:3306

网络通信协议：

网络通信协议包含（TCP传输控制协议和 IP/因特网互联协议），又称为协议，这个协议是Internet最基本的协议，Internet国际互联网的基础，简单来说，网络通信协议就是由互联网的Ip协议和传输层的TCP

TCP和UDP

1.TCP协议：传输控制协议

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

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

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

4）在连接中可进行大数据量大传输

5）传输完毕，需释放已经建立的连接，效率较低

2.UDP协议：用户数据协议

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

2）每个数据报的大小限制在64K内，不适合传输大量数据

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

4）发送数据结束时无需释放资源，速度快

InetAddress类相关方法

1.获取本机InetAddress对象getLocalHost

2.根据指定主机名/域名获取ip地址对象getByName

3.获取InetAddress对象的主机名 getHostName

4.获取InetAddtress对象的地址 getHostAddress

package com_xx;
import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * 演示InetAddress的使用
 */
public class api {
    public static void main(String[] args) throws UnknownHostException {
        //获取本机的InetAdress对象
        InetAddress localHost =InetAddress.getLocalHost();
        System.out.println(localHost);

        //2.根据指定的主机名获取InetAdress对象
        InetAddress host1=InetAddress.getByName("LAPTOP-K1LTB3RJ");
        System.out.println("host1="+host1);


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

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

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

}

Socket

1）套接字Socket开发网络应用程序被广泛采用，以至于成为事实上的标准，通信的两端都要有Socket，是两台机器间通信的端点，网络通信其实就是Socket间的端点

2）Socket允许程序把网络连接成一个流，数据在两个Socket间通过IO传输，一般主动发起通讯的应用属于客户端，等待通信请求的为服务端

TCP网络通信编程

1.基于客户端-服务端的网络通信

2.底层使用的是TCP/IP协议

3.应用场景举例：客户端发送数据，服务端接收并显示

4.基于Socket的TCP编程

例题一（使用字节流客户端发送信息到客户端）

服务端

package Socket入门.socket;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 *
 * 服务端
 * 1.在本机的9999端口监听，等待连接
 *       细节：要求在本机没有其他服务在监听9999
 * 2.当没有客户端连接9999端口时，程序会阻塞，等待连接
 * 3，通过socket.getInputStream()读取客户端写到数据通道的数据
 *
 * 客户端
 * 1.连接服务端
 * 2.连接上后 生成Socket通过socket.getOutputStream
 * 3.通过输出流，写入数据到数据通道 显示
 */
public class SocketTPC01Server {
    public static void main(String[] args) throws IOException {
        //serverSocket 可以通过accept()返回多个Socket[多并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务器，在9999端口监听 等待连接");

        //如果有客户端连接9999端口 程序继续执行
        Socket socket = serverSocket.accept();
        System.out.println("服务器端socket="+socket.getClass());

        //3，通过socket.getInputStream()读取客户端写到数据通道的数据
        InputStream inputStream = socket.getInputStream();
        //4.io读取
        byte[] buf =new byte[1024];
        int readlen =0;
        while ((readlen =inputStream.read(buf))!=-1){
            System.out.println(new String(buf,0,readlen));
        }

        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

客户端

package Socket入门.socket;

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

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

例题二（字节流客户端发送文字并接收文字）

服务端

package Socket入门.socket.socket1;

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

/**
 * 服务端
 * 1.在本机的9999端口监听，等待连接
 *       细节  要求在本机没有其他服务在监听9999
 * 2.当没有客户端连接9999端口时，程序会阻塞，等待连接
 * 3，通过socket.getInputStream()读取客户端写到数据通道的数据
 *
 * 客户端
 * 1.连接服务端
 * 2.连接上后 生成Socket通过socket.getOutputStream
 * 3.通过输出流，写入数据到数据通道 显示
 */
@SuppressWarnings({"all"})
public class SocketTPC02Server {
    public static void main(String[] args) throws IOException {
        //serverSocket 可以通过accept()返回多个Socket[多并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务器，在9999端口监听 等待连接");

        //如果有客户端连接9999端口 程序继续执行
        Socket socket = serverSocket.accept();
        System.out.println("服务器端socket="+socket.getClass());

        //3，通过socket.getInputStream()读取客户端写到数据通道的数据
        InputStream inputStream = socket.getInputStream();
        //4.io读取
        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();
        //3.通过输出流，写入数据到数据通道 显示
        outputStream.write("hello,server".getBytes());
        socket.shutdownOutput();

        inputStream.close();
        socket.close();
        serverSocket.close();

    }

}

客户端

package Socket入门.socket.socket1;

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

/**
 *  * 客户端
 *  * 1.连接服务端
 *  * 2.连接上后 生成Socket通过socket.getOutputStream
 *  * 3.通过输出流，写入数据到数据通道 显示
 */
@SuppressWarnings({"all"})
public class SocketTCP02Client {
    public static void main(String[] args) throws IOException {
        //连接本机的9999端口  如果连接成功 换回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 Socket"+socket.getClass());
        //连接上后，生成Socket,通过socket.getOutPutStream()
        //得到和socket对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //3.通过输出流，写入数据到数据通道 显示
        outputStream.write("hello,server".getBytes());

        socket.shutdownOutput();
        InputStream inputStream = socket.getInputStream();
        //4.io读取
        byte[] buf =new byte[1024];
        int readlen =0;
        while ((readlen =inputStream.read(buf))!=-1){
            System.out.println(new String(buf,0,readlen));
        }

        //4.关闭流对象 和socket 必须关闭
        outputStream.close();
        socket.close();
        System.out.println("客户端退出");


    }

}

例题三（使用字符流客户端发送文字信息，并接收到文字信息）

服务端

package Socket入门.socket.socket2;

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

/**
 *使用字符流
 * 服务端
 * 1.在本机的9999端口监听，等待连接
 *       细节  要求在本机没有其他服务在监听9999
 * 2.当没有客户端连接9999端口时，程序会阻塞，等待连接
 * 3，通过socket.getInputStream()读取客户端写到数据通道的数据
 *
 * 客户端
 * 1.连接服务端
 * 2.连接上后 生成Socket通过socket.getOutputStream
 * 3.通过输出流，写入数据到数据通道 显示
 */
@SuppressWarnings({"all"})
public class SocketTPC03Server {
    public static void main(String[] args) throws IOException {
        //serverSocket 可以通过accept()返回多个Socket[多并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务器，在9999端口监听 等待连接");

        //如果有客户端连接9999端口 程序继续执行
        Socket socket = serverSocket.accept();
        System.out.println("服务器端socket="+socket.getClass());

        //3，通过socket.getInputStream()读取客户端写到数据通道的数据
        InputStream inputStream = socket.getInputStream();
        //4.io读取 使用字符流  使用转换流将inputStream转换成bufferedreader
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s=bufferedReader.readLine();
        System.out.println(s);

        OutputStream outputStream = socket.getOutputStream();
        //3.通过输出流，写入数据到数据通道 显示
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello , client  字符流");
        bufferedWriter.newLine();
        bufferedWriter.flush();//需要手动刷新

        socket.shutdownOutput();

        bufferedReader.close();
        bufferedWriter.close();
        socket.close();
        serverSocket.close();

    }

}

客户端

package Socket入门.socket.socket2;

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

/**
 *  * 客户端  使用字符流
 *  * 1.连接服务端
 *  * 2.连接上后 生成Socket通过socket.getOutputStream
 *  * 3.通过输出流，写入数据到数据通道 显示
 */
@SuppressWarnings({"all"})
public class SocketTPC03Client {
    public static void main(String[] args) throws IOException {
        //连接本机的9999端口  如果连接成功 换回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 Socket"+socket.getClass());
        //连接上后，生成Socket,通过socket.getOutPutStream()
        //得到和socket对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //3.通过输出流，写入数据到数据通道 显示
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello,server 字符流");
        bufferedWriter.newLine();//插入一个换行符 表示写入内容的结束  注意要求对方使用readline()来读
        bufferedWriter.flush();//如果使用的字符流 需要手动刷新否则数据不会写入数据通道

        socket.shutdownOutput();
        InputStream inputStream = socket.getInputStream();
        //4.io读取 字符流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s =bufferedReader.readLine();
        System.out.println(s);
        System.out.println("客户端退出");
        //4.关闭流对象 和socket 必须关闭
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
    }
}

例题四（服务端接收到一张照片，返回文字信息）

文件上传的客户端

package Socket入门.socket.socket2;

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

/**
 *  * 客户端  使用字符流
 *  * 1.连接服务端
 *  * 2.连接上后 生成Socket通过socket.getOutputStream
 *  * 3.通过输出流，写入数据到数据通道 显示
 */
@SuppressWarnings({"all"})
public class SocketTPC03Client {
    public static void main(String[] args) throws IOException {
        //连接本机的9999端口  如果连接成功 换回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 Socket"+socket.getClass());
        //连接上后，生成Socket,通过socket.getOutPutStream()
        //得到和socket对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //3.通过输出流，写入数据到数据通道 显示
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello,server 字符流");
        bufferedWriter.newLine();//插入一个换行符 表示写入内容的结束  注意要求对方使用readline()来读
        bufferedWriter.flush();//如果使用的字符流 需要手动刷新否则数据不会写入数据通道

        socket.shutdownOutput();
        InputStream inputStream = socket.getInputStream();
        //4.io读取 字符流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s =bufferedReader.readLine();
        System.out.println(s);
        System.out.println("客户端退出");
        //4.关闭流对象 和socket 必须关闭
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
    }
}

文字上传的服务端

package upload;

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 {
        //1.连接到服务端  得到Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 6666);
        //2.创建读取磁盘文件的输入流
        String FilePath ="e:\\hello\\美女.jpg";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(FilePath));

        //3.把文件读到字节数组中   使用方法 Stream.Utils  可以将文件的内容传入到byte[]中
        //这里的bytes就是filePath返回的字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);

        //4.通过socket获取到输出流，将bytes数据发送给服务端
        BufferedOutputStream bos= new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);//将文件转换成数组 并写到数据通道里面
        bis.close();
        socket.shutdownOutput();//设置写入数据到结束标记

        //======接受从服务端返回来的信息
        InputStream inputStream = socket.getInputStream();
        //使用StreamUtils 的方法，直接将inputStream读取到的内容转成字符串
        String s = StreamUtils.streamToString(inputStream);
        System.out.println(s);

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

    }
}

StreamUtils流

package upload;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
/**
 * 此类用于演示关于流的读写方法
 */
public class StreamUtils {
	/**
	 * 功能：将输入流转换成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);	
		}
		byte[] array = bos.toByteArray();
		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){ //当读取到 null时，就表示结束
			builder.append(line+"\r\n");
		}
		return builder.toString();
	}
}

netstat指令

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

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

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

说明：

1）Listening 表示某个端口在监听

2）如果有一个外币程序连接到该接口，就会显示一条连接信息

3）可以输入ctrl + c 退出指定

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

UDP网络通信编程

1.类DatagramSocket和DatagramPacket[数据报|数据报]实现了基于UDP协议网络程序、

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

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

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

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

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

UDP编程流程

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

2.建立发送端，接收端（没有客户端和服务端）

3.发送数据前，建立数据包/报 DatagramPacket对象

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

5.关闭DatagramSocket

接收端

package com.udp;
import java.io.IOException;
import java.net.*;

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

        //4.可以把packet进行拆包 取出数据  并显示
        byte[] data = packet.getData();
        int length = packet.getLength();

       String s = new String(data,0,length);
        System.out.println(s);
        //发送数据包
        byte []a ="ok".getBytes();
        DatagramPacket packet1 = new DatagramPacket(a, a.length, InetAddress.getByName("192.168.164.211"), 9998);
        socket.send(packet1);
        //关闭资源
        socket.close();
        System.out.println("A端退出");
    }
}

发送端

package com.udp;

import java.io.IOException;
import java.net.*;

/**
 * 发送端B
 */
public class UDPSenterB {
    public static void main(String[] args) throws IOException {

        //首先我们要创建 DatagramSocket 对象 准备在9998端口发送数据
        //这里的发送端口不能和接收端口的端口号相同
        DatagramSocket socket = new DatagramSocket(9998);

        //2.降需要发送的数据  封装到DatagramPacket数据报中
        //本机可以使用InetAddress.getHostAddress
       byte[] data= "hello 明天吃火锅".getBytes();
       //封装到DatagramPacket对象 data 内容 字节数组，data.length,主机Ip ,端口号
       DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.164.211"), 9999);

       socket.send(packet);

       //接收数据包
       byte []data1=new byte[1024];
        DatagramPacket packet1 = new DatagramPacket(data1, data1.length);
        System.out.println("B在等待A的回信");
        socket.receive(packet1);

        //拆包
        byte[] data2 = packet1.getData();
        int length = packet1.getLength();
        String s1 =new String(data2,0,length);
        System.out.println(s1);

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