023Java基础之网络编程

最新推荐文章于 2023-07-27 20:27:54 发布

曳空@竹

最新推荐文章于 2023-07-27 20:27:54 发布

阅读量519

点赞数 1

分类专栏： java基础文章标签： java 后端

本文链接：https://blog.csdn.net/qq_44835120/article/details/123288659

版权

java基础专栏收录该内容

29 篇文章 1 订阅

订阅专栏

1、网络的相关概念

1.1、网络通信

概念两台设备之间通过网络实现数据传输
网络通信将数据通过网络从一台设备传输到另外一台设备
java.net包下提供了一系列的类和接口，供程序员使用，完成网络通信

1.2、网络

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

1.3、ip地址

概念用来表示网络中的唯一一台计算机

2、 InetAddress 类

2.1、相关方法

（1）getLocalHost() 获取本机InteAddress对象
（2）getByName()根据指定主机名/域名获取ip地址对象
（3）getHostName() 获取InetAddress对象的主机名
（4）getHostAddress()获取InetAddress对象的地址

package com.francis.api;

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

/**
 * @author Francis
 * @create 2022-03-05 6:06
 */
public class InetAddress_ {
    public static void main(String[] args) throws UnknownHostException {
        //获取本机 InetAddress 对象 getLocalHost
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);
        //根据指定主机名/域名获取 ip 地址对象 getByName
        InetAddress host2 = InetAddress.getByName("Francis");
        System.out.println(host2);
        InetAddress host3 = InetAddress.getByName("www.baidu.com");
        System.out.println(host3);
        //获取 InetAddress 对象的主机名 getHostName
        String host3Name = host3.getHostName();
        System.out.println(host3Name);
        //获取InetAddress 对象的地址 getHostAddress
        String host3Address = host3.getHostAddress();
        System.out.println(host3Address);
    }
}

在这里插入图片描述

3、Socket

3.1、基本介绍

（1）套接字（Socket）开发网络应用程序被广泛应用，以至于称为事实上的标准
（2）通信的两端都要有Socket,是两台机器通信的断点
（3）Socket允许把网络连接当成一个流，数据在两个Socket间通过IO传输
（4）一般主动发起通信的一端称为客户端，等待通信请求的一端称为服务端
在这里插入图片描述

4、TCP 网络通信编程

4.1、基本介绍

（1）基于客户端-服务端的网络通信
（2）底层使用的是TCP/IP协议
（3）基于TCP的socket编程
在这里插入图片描述

4.2、应用案例 1(使用字节流)

（1）编写一个服务端、一个客户端
（2）服务器在9999端口监听
（3）客户端连接到服务器，发送“hello server”，然后退出
（4）服务端接受到客户端发送的消息，输出并退出

package com.francis.socket;

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


/**
 * @author Francis
 * @create 2022-03-05 6:47
 */
public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端在9999端口监听，等待连接");
        //当没有客户端连接9999端口时，程序会阻塞，等待连接
        //如果有客户端连接则会返回一个socket对象
        Socket socket = serverSocket.accept();
        System.out.println("服务端 socket=" + socket.getClass());
        InputStream inputStream = socket.getInputStream();
        byte[] buff = new byte[1024];
        int readLen = 0;
        String content = "";
        while ((readLen = inputStream.read(buff)) != -1) {
            System.out.println(new String(buff, 0, readLen));
            content += new String(buff, 0, readLen);
        }
        System.out.println(content);
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

package com.francis.socket;

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

/**
 * @author Francis
 * @create 2022-03-05 6:47
 */
public class Client {
    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());
        outputStream.close();
        socket.close();
    }
}

4.3、应用案例 2(使用字节流)

（1）编写一个服务端、一个客户端
（2）服务器在9999端口监听
（3）客户端连接到服务器，发送“hello server”，并接收服务器发回的“hello client”，然后退出
（4）服务端接受到客户端发送的消息，输出，并向客户端发送“hello client” ，然后退出

package com.francis.socket;

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

/**
 * @author Francis
 * @create 2022-03-05 8:17
 */
public class SocketTCP02Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务器端正在监听9999端口");
        Socket socket = serverSocket.accept();
        InputStream inputStream = socket.getInputStream();
        byte[] buff = new byte[1024];
        int readLen = 0;
        while((readLen = inputStream.read(buff))!=-1){
            System.out.println(new String(buff,0,readLen));
        }
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello client".getBytes());
        // 设置结束标记,这里如果socket断开了，也可以取到结束标记的作用
        socket.shutdownOutput();
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

package com.francis.socket;

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

/**
 * @author Francis
 * @create 2022-03-05 8:17
 */
public class SocketTCP02Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLoopbackAddress(), 9999);
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello server" .getBytes());
        // 设置结束标记
        socket.shutdownOutput();
        InputStream inputStream = socket.getInputStream();
        byte[] buff = new byte[1024];
        int readLen = 0;
        while((readLen = inputStream.read(buff))!=-1){
            System.out.println(new String(buff,0,readLen));
        }
        inputStream.close();
        outputStream.close();
        socket.close();
    }
}

4.4、应用案例 3(使用字符流)

（1）编写一个服务端、一个客户端
（2）服务器在9999端口监听
（3）客户端连接到服务器，发送“hello server 字符流”，并接收服务器发回的“hello client”，然后退出
（4）服务端接受到客户端发送的消息，输出，并向客户端发送“hello client 字符流” ，然后退出

package com.francis.socket;

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

/**
 * @author Francis
 * @create 2022-03-05 9:24
 */
public class SocketTCP03Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在 9999 端口监听，等待连接..");
        Socket socket = serverSocket.accept();
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello client 字符流");
       //插入一个换行符，表示写入的内容结束, 注意，要求对方使用 readLine()!!!!
        bufferedWriter.newLine();
        // 如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
        bufferedWriter.flush();
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        serverSocket.close();
    }
}

package com.francis.socket;

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

/**
 * @author Francis
 * @create 2022-03-05 9:24
 */
public class SocketTCP03Client {
    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();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello server 字符流");
        //插入结束标识，注意，newLine要求对方使用readLine的方式读取
        bufferedWriter.newLine();
        //刷新缓存通道
        bufferedWriter.flush();
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);
        inputStream.close();
        outputStream.close();
        socket.close();

    }
}

4.5、复制图片

（1）编写一个服务端和客户端
（2）服务端监听8888端口
（3）服务器端接收到客户端发送的图片，保存到src下，发送“收到图片”再退出

package com.francis.socket.upload_picture;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.Socket;

/**
 * @author Francis
 * @create 2022-03-05 10:13
 */
public class TCPFileUploadClient {
    public static void main(String[] args) throws Exception {
//客户端连接服务端 8888，得到 Socket 对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        //创建读取磁盘文件的输入流
        String filePath = "f:\\1.jpg";
        //String filePath="e:\\abc.mp4";
        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();
//=====接收从服务端回复的消息=====
        InputStream inputStream = socket.getInputStream(); //使用 StreamUtils
        // 的方法，直接将 inputStream 读取到的内容 转成字符串
        String s = StreamUtils.streamToString(inputStream);
        System.out.println(s);
//关闭相关的流
        inputStream.close();
        bos.close();
        socket.close();
    }
}

package com.francis.socket.upload_picture;

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

/**
 * @author Francis
 * @create 2022-03-05 10:13
 */
public class TCPFileUploadServer {
    public static void main(String[] args) throws Exception {
//1. 服务端在本机监听 8888 端口
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端在 8888 端口监听....");
        //2. 等待连接
        Socket socket = serverSocket.accept();
//3. 读取客户端发送的数据
// 通过 Socket 得到输入流
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //4. 将得到 bytes 数组，写入到指定的路径，就得到一个文件了
        String destFilePath = "f:\\111.jpg";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
        bos.write(bytes);
        bos.close();
// 向客户端回复 "收到图片"
// 通过 socket 获取到输出流(字符)
        BufferedWriter writer =
                new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        writer.write("收到图片");
        writer.flush();//把内容刷新到数据通道 socket.shutdownOutput();//设置写入结束标记
//关闭其他资源
        writer.close();
        bis.close();
        socket.close();
        serverSocket.close();
    }
}

package com.francis.socket.upload_picture;

import com.sun.org.apache.bcel.internal.generic.NEW;

import java.io.*;

/**
 * @author Francis
 * @create 2022-03-05 10:14
 */
public class StreamUtils {
    public static byte[] streamToByteArray(InputStream is) throws IOException, 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
     *  @throwsException
     */
    public static String streamToString(InputStream is) throws IOException, 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();

    }
}

4.6、netstat指令

（1）netstat -an可以查看当前主机的网络情况，包括端口监听情况和网络连接情况
（2）netstat -an | more 可以分页显示

5、UDP 网络通信编程

5.1、基本介绍

（1）类DatagramSocket和DatagramPacket实现了基于UDP网络协议程序
（2）UDP数据报通过数据报套接字DatagramSocket发送和接收，系统不保证数据报一定能够安全的送达目的地，也不确定什么时候可以送达
（3）DatagramPacket对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的ip地址和端口号
（4）UDP协议中每个数据报都给出了完整的地址信息，因此无需建立发送方和接接收方的连接
在这里插入图片描述

5.2、基本流程

在这里插入图片描述

5.3、UDP应用案例

package com.francis.socket.upload_picture.udp;

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

/**
 * 接收端
 * @author Francis
 * @create 2022-03-05 15:19
 */
public class UDPReceiverA {
    public static void main(String[] args) throws IOException {
        //1. 创建一个DatagramSocket 对象，准备在 9999 接收数据
        DatagramSocket socket = new DatagramSocket(9999);
        //2. 构建一个DatagramPacket 对象，准备接收数据
        //  UDP 协议的数据包最大 64k
        byte[] buf = new byte[64*1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);
        //3. 调用接收方法, 将通过网络传输的 DatagramPacket 对象填充到 packet 对象
        //提示: 当有数据包发送到 本机的 9999 端口时，就会接收到数据
        // 如果没有数据包发送到 本机的 9999 端口, 就会阻塞等待.
        System.out.println("接收端 A 等待接收数据..");
        socket.receive(packet);
        //4. 可以把 packet 进行拆包，取出数据，并显示.
        int length = packet.getLength();
        //实际接收到的数据字节长度
        byte[] data = packet.getData();
        //接收到数据
        String s = new String(data, 0, length);
        System.out.println(s);
        //===回复信息给 B 端
        // 将需要发送的数据，封装到 DatagramPacket 对象
        data = "好的, 明天见".getBytes();
        //说明: 封装的 DatagramPacket 对象 data 内容字节数组 ,data.length, 主机(IP), 端口
        packet = new DatagramPacket(data, data.length, InetAddress.getByName(
                "192.168.5.1"), 9998);
        //发送
        socket.send(packet);
        //5. 关闭资源
        socket.close();
        System.out.println("A 端退出...");
    }

}

package com.francis.socket.upload_picture.udp;

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

/**
 * 发送端
 *
 * @author Francis
 * @create 2022-03-05 15:19
 */
public class UDPSenderB {
    public static void main(String[] args) throws IOException {
        //1.创建 DatagramSocket 对象，准备在 9998 端口 接收数据
        DatagramSocket socket = new DatagramSocket(9998);
        //2. 将需要发送的数据，封装到 DatagramPacket 对象
        byte[] data = "hello 明天吃火锅~".getBytes();
        //说明: 封装的 DatagramPacket 对象 data 内容字节数组 ,data.length, 主机(IP), 端口
        DatagramPacket packet = new DatagramPacket(data, data.length,
                InetAddress.getByName("192.168.5.1"), 9999);
        socket.send(packet);
        //3. === 接收从 A 端回复的信息
// (1) 构建一个 DatagramPacket 对象，准备接收数据
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        //(2) 调用// 接收方法, 将通过网络传输的 DatagramPacket 对象 // 填充到 packet 对象
        // 本机的 9998 端口时，就会接收到数据 // 如果没有数据包发送到 本机的 9998 端口, 就会阻塞等待.
        socket.receive(packet);
//(3) 可以把 packet 进行拆包，取出数据，并显示.
        int length = packet.getLength();//实际接收到的数据字节长度
        data = packet.getData();//接收到数据
        String s = new String(data, 0, length);
        System.out.println(s);
//关闭资源
        socket.close();
        System.out.println("B 端退出");
    }

}

曳空@竹

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
023Java基础之网络编程

1、网络的相关概念1.1、网络通信概念两台设备之间通过网络实现数据传输网络通信将数据通过网络从一台设备传输到另外一台设备java.net包下提供了一系列的类和接口，供程序员使用，完成网络通信1.2、网络概念两台或多台设备之间通过一定物理设备连接起来构成网络1.3、ip地址概念用来表示网络中的唯一一台计算机2、 InetAddress 类2.1、相关方法（1）getLocalHost() 获取本机InteAddress对象（2）getByName()根据指定主机名/域名获取ip地址
复制链接

扫一扫