[java基础] 网络编程: 域名.InetAddress类.TCP/IP

本文主要是介绍[java基础] 网络编程: 域名.InetAddress类.TCP/IP，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

网络的相关概念

网络通信

网络

ip地址

概念:用于唯一标识网络中的每台计算和41主机
查看ip地址:ipconfig
ip地址的表示形式:点分十进制 xx.xx.xx.xx
每一个十进制数的范围:0~255
ip地址的组成=网络地址+主机地址，比如:192.168.16.69
IPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号称可以为全世界的每一粒沙子编上一个地址。
由于IPv4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的使用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联网的障碍

ipv4地址分类

域名

www.baidu.cam
好处:为了方便记忆，解决记ip的困难
概念:将!p地址映射成域名，这里怎么映射上，HTTP协议

端口号

概念:用于标识计算机上某个特定的网络程序
表示形式:以整数形式，端口范围0-65535 [2个字节表示端口0~2^16-1]
0~1024已经被占用，比如ssh 22,ftp 21,smtp 25,http 80
4.常见的网络程序端口号:

tomcat:8080
mysql:3306
oracle:1521
sqlserver:1433

网络通信协议

TCP/IP(Transmission Control Protocol/Internet Protocol)的简写,中文译名为:传输控制协议/因特网互联协议,又叫网络通讯协议,这个协议是Internet最基本的协议,Internet国际互联网络的基础,简单地说,就是由网络层的IP协议和传输层的TCP协议组成的.

TCP和UDP

TCP协议:传输控制协议

使用TCP协议前，须先建立TCP连接，形成传输数据通道
传输前,采用"三次握手"方式，是可靠的
TCP协议进行通信的两个应用进程:客户端、服务端
在连接中可进行大数据量的传输
传输完毕，需释放已建立的连接，效率低
UDP协议:用户数据协议
将数据、源、目的封装成数据包，不需要建立连接
每个数据报的大小限制在64k内，不适合传输大量数据
因无需连接，故是不可靠的
发送数据结束时无需释放资源(因为不是面向连接的),速度快

InetAddress类

Socket

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

TCP 网络通信编程

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

补充

当客户端连接到服务器后,实际上客户端也是通过一个端口和服务端进行通讯的,这个端口是TCP/IP来分配的,是不确定的,是随机的
程序验证+netstat

案例一

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

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:25
 * @Version
 * 服务端
 */
public class Server {
    public static void main(String[] args) throws IOException {
        //在(默认)本机的指定端口建立服务端插座
        //注意:serverSocket监听9999的前提是没有其他服务在监听9999
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端,在9999端口监听,并等待连接..");

        //等待连接插入-->若没有连接,程序阻塞-->若连接成功,返回Socket对象,程序继续
        //注意:该方法可返回多个Socket对象->多个客户端连接服务器的并发
        Socket socket = serverSocket.accept();

        //net包下Socket类型
        System.out.println("服务端 socket="+socket.getClass());

        //通过网络连接构造输入流:读取
        InputStream inputStream = socket.getInputStream();

        byte[] buf = new byte[1024];
        int length;
        while ((length = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, length));
        }

        //关闭流,连接,端口插座(插孔有限)以节约资源
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:25
 * @Version
 * 客户端，发送 "hello, server" 给服务端
 */
public class Client {
    public static void main(String[] args) throws IOException {
        //客户端连接到服务端(本机的9999端口)的插座-->若连接成功,返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        //与服务端的连接类型一致
        System.out.println("客户端socket="+socket.getClass());

        //通过网络连接构造输出流:写入
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,sever".getBytes());

        //关闭流,连接
        outputStream.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

案例二

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

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:57
 * @Version
 * 服务端:接收客户端发送的消息-->并发送"hello,client"
 */
public class Server {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //在(默认)本机的指定端口建立服务端插座
        //注意:serverSocket监听9999的前提是没有其他服务在监听9999
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端,在9999端口监听,并等待连接..");

        //等待连接插入-->若没有连接,程序阻塞-->若连接成功,返回Socket对象,程序继续
        //注意:该方法可返回多个Socket对象->多个客户端连接服务器的并发
        Socket socket = serverSocket.accept();

        //net包下Socket类型
        System.out.println("服务端 socket="+socket.getClass()+"已连接");

        //通过网络连接构造输入流:读取
        InputStream inputStream = socket.getInputStream();

        byte[] buf = new byte[1024];
        int length;
        while ((length = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, length));
        }

        //读取后的 写入到数据通道
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,client".getBytes());

        //设置(输出)结束标记
        socket.shutdownOutput();//若写入后没有再传输可以不设置标记

        //关闭流,连接,端口插座(插孔有限)以节约资源
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();

    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:56
 * @Version
 * 客户端:连接服务端-->发送"hello,server"-->接收服务端回发的"hello,client"-->退出
 */
public class Client {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //客户端连接到服务端(本机的9999端口)的插座-->若连接成功,返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        //与服务端的连接类型一致
        System.out.println("客户端socket="+socket.getClass()+"已连接");

        //通过网络连接构造输出流:写入
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,sever".getBytes());

        //设置(输出)结束标记(先写后读不可省略,否则两端都阻塞在数据的传输上)
//        socket.shutdownOutput();

        //写入后的 读取数据
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int length;
        while ((length = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, length));
        }

        //关闭流,连接
        inputStream.close();
        outputStream.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

案例三

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

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:57
 * @Version 字符流方式
 * 服务端:接收客户端发送的消息-->并发送"hello,client"
 */
public class Server {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //在(默认)本机的指定端口建立服务端插座
        //注意:serverSocket监听9999的前提是没有其他服务在监听9999
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端,在9999端口监听,并等待连接..");

        //等待连接插入-->若没有连接,程序阻塞-->若连接成功,返回Socket对象,程序继续
        //注意:该方法可返回多个Socket对象->多个客户端连接服务器的并发
        Socket socket = serverSocket.accept();

        //net包下Socket类型
        System.out.println("服务端 socket="+socket.getClass()+"已连接");

        //通过网络连接构造输入流:读取
        InputStream inputStream = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));

        System.out.println(br.readLine());

        //读取后的 写入到数据通道
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
        bw.write("hello,client 字符流");


        //设置(输出)结束标记
//      bw.newLine();//若写入后没有再传输可以不设置标记


        //关闭流,连接,端口插座(插孔有限)以节约资源
        bw.close();//写入
        br.close();
        socket.close();
        serverSocket.close();

    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:56
 * @Version 字符流方式
 * 客户端:连接服务端-->发送"hello,server"-->接收服务端回发的"hello,client"-->退出
 */
public class Client {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //客户端连接到服务端(本机的9999端口)的插座-->若连接成功,返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        //与服务端的连接类型一致
        System.out.println("客户端socket="+socket.getClass()+"已连接");

        //通过网络连接构造输出流:写入
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
        bw.write("hello,server 字符流");


        //设置(输出)结束标记(先写后读不可省略,否则两端都阻塞在数据的传输上)
        bw.newLine();//对应的另一端必须使用readLine!!!
        bw.flush();//刷新以写入

        //写入后的 读取数据
        InputStream inputStream = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));

        System.out.println(br.readLine());

        //关闭流,连接
        br.close();
        bw.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

案例四(上传文件)

编写一个服务端，和一个客户端
服务器端在8 888端口监听
客户端连接到服务端，发送一张图片e://q i e. p n g
服务器端接收到客户端发送的图片，保存到src下，发送”收到图片”
客户端接收到服务端发送的”收到图片”，再退出
该程序要求使用StreamUtils.java,我们直接使用

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();
		
	}

}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-19:58
 * @Version 服务端
 * 接收客户端发送的文件-->保存到系统文件目录下-->发送"收到图片"后退出
 */
public class Server {
    public static void main(String[] args) throws Exception {
        //创建字节输出流-->上传到本地
        String filePath = "chapter21\\src\\Copy.wmv";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));

        //服务端监听本机端口
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端,监听8888端口,等待连接...");

        //等待连接
        Socket socket = serverSocket.accept();

        //连接后创建数据通道的输入流/输出流
        InputStream inputStream = socket.getInputStream();
        OutputStream outputStream = socket.getOutputStream();

        /*byte[] buf = new byte[1024];
        int length;
        //从数据通道的输入流读取到图片数据
        while ((length = inputStream.read(buf)) != -1) {
            //通过字节输出流将数据写入到指定目录下的文件
            bos.write(buf,0,length);
        }*/

        //不使用缓冲数组的先读后写(简化了循环读写)
        byte[] bytes = StreamUtils.streamToByteArray(inputStream);
        bos.write(bytes);

        //从数据通道的输出流写入文本数据
        outputStream.write("收到图片".getBytes());

        //关闭资源
        outputStream.close();
        inputStream.close();
        bos.close();
        socket.close();
        serverSocket.close();
    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-19:58
 * @Version 客户端
 * 连接到服务端-->发送磁盘里的文件-->接收到"收到图片"后退出
 */
public class Client {
    public static void main(String[] args) throws Exception {
        //创建字节输入流-->从磁盘读取到内存
        String filePath = "f:\\io\\bufferedCopy.wmv";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));

        //连接到服务端
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);

        //创建数据通道的输出流/输入流
        OutputStream outputStream = socket.getOutputStream();
        InputStream inputStream = socket.getInputStream();


        /*byte[] buf = new byte[1024];
        int length;
        //通过字节输入流从磁盘读取到图片数据
        while ((length = bis.read(buf)) != -1) {
            //通过数据通道的输出流写入图片数据
            outputStream.write(buf,0,length);
        }*/

        //简化版先读后写
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        outputStream.write(bytes);

        //设置传输结束标记
        socket.shutdownOutput();

        /*byte[] bytes = new byte[1024];
        int len;
        //通过数据通道的输入流读取文本数据
        while ((len = inputStream.read(bytes))!=-1) {
            System.out.println(new String(bytes,0,len));
        }*/

        //简化版循环读取打印
        String string = StreamUtils.streamToString(inputStream);
        System.out.println(string);

        //关闭资源
        inputStream.close();
        outputStream.close();
        bis.close();
        socket.close();
    }
}

案例五(下载文件)

编写客户端程序和服务器端程序
客户端可以输入一个音乐文件名，比如高山流水，服务端收到音乐名后，可以给客户端返回这个音乐文件，如果服务器没有这个文件，返回一个默认的音乐即可.
客户端收到文件后，保存到本地e:\
提示:该程序可以使用StreamUtils.java
本质:其实就是指定下载文件的应用

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();
		
	}

}

public class Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端,监听9999端口,等待连接...");
        Socket socket = serverSocket.accept();

        //接收文件名
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String musicName = br.readLine();
        System.out.println("客户端点歌:"+musicName);

        String srcPath = "";
        if (musicName.equals("高山流水")) {
            srcPath = "chapter21\\src\\高山流水.mp3";
        } else {
            srcPath="chapter21\\src\\无名.mp3";
        }

        //提取文件数据到数组
        FileInputStream fileInputStream = new FileInputStream(srcPath);
        byte[] data = StreamUtils.streamToByteArray(fileInputStream);

        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(data);

        bos.close();
        fileInputStream.close();
        br.close();
        socket.close();
        serverSocket.close();

    }
}

public class Client {
    public static void main(String[] args) throws Exception {
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入下载的音乐名");
        String music = sc.next();
        bw.write(music);
        bw.newLine();
        bw.flush();

        InputStream inputStream = socket.getInputStream();
        byte[] data = StreamUtils.streamToByteArray(inputStream);

        String destPath = "";
        if (music.equals("高山流水")) {
            destPath = "f:\\io\\高山流水.mp3";
        } else {
            destPath = "f:\\io\\zxk.mp3";
        }
        FileOutputStream fos = new FileOutputStream(destPath);
        fos.write(data);

        fos.close();
        inputStream.close();
        bw.close();
        socket.close();
        System.out.println("客户端退出");
    }
}

netstat指令

补充:

netstat -anb指令:

查看监听端口的应用:

必须在管理员身份下运行控制台输入指令

UDP 网络通信编程

介绍

类DatagramSocket和DatagramPacket[数据报/数据包]实现了基于UDP协议网络程序。
UDP数据报通过数据报套接字DatagramSacket发送和接收,系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。
DatagramPacket对象封装了UDP数据报，在数据报中包含了发送端的IP地址端口号以及接收端的IP地址和端口号。
UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接

基本流程

核心的两个类/对象DatagrarnSocket与DatagramPacket
建立发送端，接收端(没有服务端和客户端概念)
发送数据前，建立数据报 DatagramPacket对象
调用DatagramSocket的发送、接收方法
关闭DatagramSocket

案例

编写一个接收端A，和一个发送端B
接收端A在9999端口等待接收数据(receive)
发送端B向接收端A发送数据”hello，明天吃火锅~”
接收端A接收到发送端B发送的数据，回复"好的，明天见"，再退出
发送端接收回复的数据，再退出

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-06-0:53
 * @Version 接收端A
 */
public class UDPReceiverA {
    public static void main(String[] args) throws IOException {
        //创建DatagramSocket对象-->在指定端口接收
        DatagramSocket socket = new DatagramSocket(9999);

        //创建DatagramPacket对象-->准备接收数据报
        byte[] bytes = new byte[1024];//接收数组
        DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
        System.out.println("端口A,监听9999端口,等待接收...");
        //调用 接收方法, 将通过网络传输的 DatagramPacket 对象,填充到 packet对象
        socket.receive(packet);
        //拆包显示
        int length = packet.getLength();
        byte[] data = packet.getData();
        String s = new String(data, 0, length);
        System.out.println(s);

        //创建待发送数据报,并指明接收端的地址和端口
        byte[] buf = "好的明天见".getBytes();
        packet = new DatagramPacket(buf, buf.length,
                InetAddress.getByName("192.168.200.1"), 9998);
        socket.send(packet);

        socket.close();
        System.out.println("A端退出");
    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-06-0:53
 * @Version 发送端B
 */
public class UDPSenderB {
    public static void main(String[] args) throws IOException {
        //创建DatagramSocket对象-->在指定端口接收
        DatagramSocket socket = new DatagramSocket(9998);

        //待发送数据封装到数据报
        byte[] data = "hello,明天吃火锅~".getBytes();
        //待发报中指明接收地址和端口
        DatagramPacket packet = new DatagramPacket(data, data.length,
                InetAddress.getByName("192.168.200.1"), 9999);
        socket.send(packet);

        //创建数据报准备接收
        byte[] bytes = new byte[1024];
        packet = new DatagramPacket(bytes, bytes.length);
        System.out.println("端口B,监听9998端口,等待接收...");
        //调用接收方法填充数据报
        socket.receive(packet);
        //拆包显示
        int length = packet.getLength();//实际接收的数据字节长度
        byte[] buf = packet.getData();//接收到的数据
        String s = new String(buf, 0, length);
        System.out.println(s);


        socket.close();
        System.out.println("B端退出");
    }
}

这篇关于[java基础] 网络编程: 域名.InetAddress类.TCP/IP的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

[java基础] 网络编程: 域名.InetAddress类.TCP/IP

网络的相关概念

网络通信

网络

ip地址

域名

网络通信协议

TCP和UDP

InetAddress类

相关方法

Socket

TCP 网络通信编程

补充

案例一

案例二

案例三

案例四(上传文件)

案例五(下载文件)

netstat指令

UDP 网络通信编程

介绍

基本流程

案例

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯