Java-网络编程

Neo丶

已于 2023-03-20 19:39:43 修改

阅读量1.1k

点赞数

文章标签：网络 java 学习

于 2022-09-20 18:00:40 首次发布

本文链接：https://blog.csdn.net/Ego_Ekko/article/details/126923956

版权

网络通信

1）两台及以上设备之间通过网络实现数据传输；

2）将数据通过网络从一台设备传送到另一台设备；

3）java.net包下提供了一系列的类或者接口使用来实现网络通信。

网络

1）两台或者多台设备通过一定物理设备连接起来构成了网络；

2）根据覆盖范围不同分为：局域网、城域网、广域网。

IP地址

1）用于唯一标识网络中的每台计算机/主机；

2）查看本机ip：ipconfig；

3）IPv4地址的表示方式：点分十进制：0.0.0.0~255.255.255.255；

①IPv4地址分为A、B、C、D、E五类。A类从0.0.0.0到127.255.255.255；B类从128.0.0.0到191.255.255.255；C类从192.0.0.0到223.255.255.255；D类从224.0.0.0到239.255.255.255；E类从240.0.0.0到247.255.255.255；

4）每个十进制数的范围：0~255;

5）ip地址的组成：网络地址+主机地址；

6）IPv6是互联网工程任务组设计的用于替代IPv4的下一代协议；

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

域名

1）例如www.baidu.com

2）将ip地址映射成域名，方便记忆，HTTP协议

端口号

1）用于表示计算机上某个特定的网络程序；

2）表示形式：以整数形式，端口范围0~65535（（2^16） -1）

3）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最基本的协议，由网络层的IP协议和传输层的TCP协议组成。

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

TCP和UDP

★TCP协议：传输控制协议

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

2）传输前，采用“三次握手”的方式，具备很强的可靠性；

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

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

5）传输完毕后需释放已建立的链接，效率较低。

★UDP协议：

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

2）每个数据包的大小限制在64K以内；

3）无需链接，是不可靠的；

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

InetAddress类

1）获取本机InetAddress对象getLocalHost；

2）根据指定本机名/域名获取ip地址对象getByName；

3）获取InetAddress对象的主机名getHostName；

4）获取InetAddress对象的地址getHostAddress。

package com.pero;

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

/**
 * @author Pero
 * @version 1.0
 */
public class InetAddress_ {
    public static void main(String[] args) throws UnknownHostException {

        //获取本机InetAddress对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);  //DESKTOP-KHU9144/192.168.0.105

        //根据主机名获取InetAddress
        InetAddress byName = InetAddress.getByName("www.baidu.com");
        System.out.println(byName);     //www.baidu.com/220.181.38.149

        //获取InetAddress对象的主机名getHostName
        String hostName = byName.getHostName();
        System.out.println(hostName);   //www.baidu.com

        //获取InetAddress对象的地址getHostAddress。
        String hostAddress = byName.getHostAddress();
        System.out.println(hostAddress);    //220.181.38.150
    }
}

Socket类(TCP编程，UDP编程)

1）套接字（Socket）开发网络应用程序被广泛采用，以至于成为事实上的标准；

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

3）网络通信其实就是Socket间的通信；

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

5）一般主动发起通信的应用程序属于客户端，等待通信请求（监听）的为服务器端。

socket.getOutputStream();

socket.getInputStream();

TCP网络通信编程

1）基于客户端—服务端的网络通信；

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

3）客户端发送数据，服务端接收并显示控制台；

4）基于Socket的TCP编程。

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

Server	↔	Client
SeverSocket(int port) ⬇ Socket accept()	↔	Socket(InetAddress address,int port)
InputStream Socket.getInputStream() OutputStream Socket.getOutputStream()	← →	OutputStream Socket.getOutputStream() InputStream Socket.getInputStream()
Socket.close()		Socket.close()

字节流传输

服务器端代码

package com.pero.net_;

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

/**
 * 编写一个服务器端和一个客户端
 * 服务器端在9999端口监听
 * 客户端连接到服务器端，发送"hello，server"然后退出
 * 服务器端接收到客户端发送的信息，输出，并推出
 *
 * @author Pero
 * @version 1.0
 */

public class SocketServer_ {
    public static void main(String[] args) throws IOException {
        //监听
        //调用ServerSocket构造器填入端口号（端口号必须是没有被占用的，否则报错）创建对象对象，
        //serverSocket可以通过accept()方法创建有多个socket，
        // 多个客户端连接服务器的并发，服务器端可以监听多个端口
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务器9999端口监听，等待连接...");

        //等待连接
        //当没有客户端连接9999端口时，程序会阻塞，等待连接
        //如果有客户端连接，则会返回Socket对象，程序继续运行
        Socket socket = serverSocket.accept();     //这里阻塞
        System.out.println("客户端连接到9999端口，程序运行" + socket.getClass());

        //连接成功后
        //获取socket对象的输入流
        InputStream inputStream = socket.getInputStream();
        //设置缓冲，读取数据
        byte[] bytes = new byte[1024];
        int length = 0;
        while ((length = inputStream.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, length));
        }

        //返回发送收到
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("receive,over".getBytes());
        //设置写入结束标记
        socket.shutdownOutput();

        //关闭流、socket和serverSocket
        inputStream.close();
        outputStream.close();
        socket.close();
        serverSocket.close();
    }
}

客户端代码

package com.pero.net_;

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

/**
 * 编写一个服务器端和一个客户端
 * 服务器端在9999端口监听
 * 客户端连接到服务器端，发送"hello，server"然后退出
 * 服务器端接收到客户端发送的信息，输出，并推出
 *
 * @author Pero
 * @version 1.0
 */
public class SocketClient_ {
    public static void main(String[] args) throws IOException {

        //连接服务器端（ip,端口）
        //调用Socket构造器（目标主机的InetAddress对象，端口号）来连接目标主机端口
        //如果连接成功则返回socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端与服务器端连接成功" + socket.getClass());

        //获取socket对象的输出流
        OutputStream outputStream = socket.getOutputStream();
        //将信息写入流中
        outputStream.write("hello,server".getBytes());
        //设置写入结束标记
        socket.shutdownOutput();

        //获取socket输入流
        InputStream inputStream = socket.getInputStream();
        //设置缓冲，读取数据
        byte[] bytes = new byte[1024];
        int readLength = 0;
        while ((readLength = inputStream.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, readLength));
        }

        //关闭流对象和socket对象
        outputStream.close();
        inputStream.close();
        socket.close();

        System.out.println("客户端退出");
    }
}

字符流传输

服务器端代码

package com.pero.net_;

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

/**
 * 编写一个服务端，一个客户端
 * 服务端在9999端口监听
 * 客户端连接到服务器端，发送"hello,server"，并接收服务端回发的"hello,client"在退出
 * 服务端接收到客户端发送的信息，输出，并发送"hello,client"再退出
 *
 * @author Pero
 * @version 1.0
 */
public class SocketServerChar_ {
    public static void main(String[] args) throws IOException {

        //创建服务器9999端口serverSocket对象
        ServerSocket serverSocket = new ServerSocket(9999);

        //获取socket
        //如果连接成功返回socket
        Socket socket = serverSocket.accept();
        System.out.println("客户端与服务端口连接成功");

        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(
                new InputStreamReader(inputStream, "utf8"));
        String s = bufferedReader.readLine();
        System.out.println(s);
        //必须以readLine()作为读，否则无法读取换行无法结束接收
        //socket.shutdownInput();

        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(
                new OutputStreamWriter(outputStream, "utf8"));
        bufferedWriter.write("hello,client(字符流)");
        bufferedWriter.newLine();
        bufferedWriter.flush();
        //socket.shutdownOutput();

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

客户端代码

package com.pero.net_;

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

/**
 * 编写一个服务端，一个客户端
 * 服务端在9999端口监听
 * 客户端连接到服务器端，发送"hello,server"，并接收服务端回发的"hello,client"在退出
 * 服务端接收到客户端发送的信息，输出，并发送"hello,client"再退出
 *
 * @author Pero
 * @version 1.0
 */
public class SocketClientChar_ {
    public static void main(String[] args) throws IOException {

        //建立与服务器连接的socket传输口
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(
                new OutputStreamWriter(outputStream, "utf8"));
        bufferedWriter.write("hello,server(字符流)");
        bufferedWriter.newLine(); //接收方必须以readLine()作为读取结束标记，否则无法读取换行，无法结束接收
        //必须手动刷新，否则数据无法写入通道
        bufferedWriter.flush();
        //如果以writer.newLine()作为写入结束标记，则接收方必须以readLine()作为读取结束标记，否则无法读取
        //socket.shutdownOutput();

        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(
                new InputStreamReader(inputStream, "utf8"));
        String s= bufferedReader.readLine();
        System.out.println(s);
        //socket.shutdownInput();


        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        System.out.println("客户端退出");
    }
}

文件传输

服务器端代码

package com.pero.net_;

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

/**
 * @author Pero
 * @version 1.0
 */
public class TCPFileUploadServer {
    public static void main(String[] args) throws Exception {

        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端口8888监听中...");
        Socket socket = serverSocket.accept();
        System.out.println("客户端连接服务端成功！");

        //读取数据
        InputStream inputStream = socket.getInputStream();
        BufferedInputStream bis = new BufferedInputStream(inputStream);
        byte[] bytes = StreamUtils.StreamToByteArray(bis);
        String filePath = "src\\4.jpeg";
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(filePath));
        bos.write(bytes);
        bos.close();

        //回复"收到图片"
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(
                new OutputStreamWriter(outputStream, "utf8"));
        bufferedWriter.write("收到图片");
        bufferedWriter.flush();
        //bufferedWriter.newLine(); //与flush二选一
        socket.shutdownOutput();

        //关闭资源
        bufferedWriter.close();
        bis.close();    //先开后关
        socket.close();
        serverSocket.close();
    }
}

客户端代码

package com.pero.net_;

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

/**
 * @author Pero
 * @version 1.0
 */
public class TCPFileUploadClient {
    public static void main(String[] args) throws Exception {
        //获取与服务端链接的插口
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        //将本地文件输入到磁盘中
        String filePath = "C:\\Users\\Pero\\Desktop\\4.jpeg";
        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream(filePath));
        byte[] bytes = StreamUtils.StreamToByteArray(bis);
        //文件传输给服务端
        OutputStream outputStream = socket.getOutputStream();
        BufferedOutputStream bos = new BufferedOutputStream(outputStream);
        bos.write(bytes);
        bis.close();
        socket.shutdownOutput();    //输出数据结束

        //读取服务器回复
        InputStream inputStream = socket.getInputStream();
        String s = StreamUtils.StreamToString(inputStream);
        System.out.println(s);

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

工具类代码

package com.pero.net_;

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

/**
 * @author Pero
 * @version 1.0
 */
public class StreamUtils {

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

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

netstat指令

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

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

3）在dos控制台下执行。

说明：

①Listening表示某个端口在监听；

②如果有一个外部程序（客户端）连接到该端口，会显示连接信息；

③输入ctrl+c推出指令。

UDP网络通信编程

1）类DatagramSocket【数据报套接字】和DatagramPacket【数据报】实现了基于UDP协议网络程序；

2）UDP数据报通过数据报套接字DatagramSocket发送和接收，系统不保证UDP数据包一定能够安全到达目的地，也不能确定什么时间可以抵达；

3）DatagramPacket对象封装了UDP数据报，在数据报中报含了发送端的IP地址和端口号以及接收端的IP地址和端口号；

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

说明：

①没有明确的服务端和客户端，演变成数据的发送端和接收端；

②接收数据和发送数据都是通过DatagramSocket对象完成；

③将数据封装到DatagramPacket对象/装包；

④当接收到DatagramPacket对象，需要进行拆包取出数据；

⑤DatagramSocket可以指定在哪个端口接收数据。

基本流程：

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

2）建立发送端，接收端；

3）建立数据包；

4）调用DatagramSocket的发送、接收方法；

5）关闭DatagramSocket 。

代码测试

接收端A

package com.pero.net_;

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

/**
 * 编写一个接收端A，一个发送端B
 * 接收端A在9999端口等待接收数据
 * 发送端B向接收端A发送数据"hello，明天吃火锅"
 * 接收端A收到发送端B发送的数据，回复"好的，明天见“再退出
 * 发送端接收回复的数据，再退出
 * 
 * @author Pero
 * @version 1.0
 */
public class UDPReceiverA {
    public static void main(String[] args) throws IOException {
        //创建接收端/发送端，并指定端口9999
        DatagramSocket datagramSocket = new DatagramSocket(9999);
        //数据包最大64KB
        byte[] bytes = new byte[64*1024];   //1024个字节等于1KB
        //创建数据报
        DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length);
        //调用接收方法，将接收到的数据填充到datagramPacket中
        //当有数据包发送到9999端口时，就会接收到数据，
        System.out.println("接收端等待接收数据");
        datagramSocket.receive(datagramPacket);// 如果没有数据包发送到9999端口时，程序会在这里阻塞
        //拆包，提取数据
        int length = datagramPacket.getLength();    //实际接收数据长度
        byte[] data = datagramPacket.getData();     //接收到的数据
        String s = new String(data, 0, length);
        System.out.println(s);

        //发送回复消息
        byte[] bytes1 = "好的，明天见".getBytes();
        DatagramPacket datagramPacket1 = new DatagramPacket(
                bytes1, bytes1.length, InetAddress.getByName("192.168.0.105"), 9998);
        datagramSocket.send(datagramPacket1);

        //关闭资源
        datagramSocket.close();
        System.out.println("接收端A退出");
    }
}

发送端B

package com.pero.net_;

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

/**
 * 编写一个接收端A，一个发送端B
 * 接收端A在9999端口等待接收数据
 * 发送端B向接收端A发送数据"hello，明天吃火锅"
 * 接收端A收到发送端B发送的数据，回复"好的，明天见“再退出
 * 发送端接收回复的数据，再退出
 *
 * @author Pero
 * @version 1.0
 */
public class UDPSenderB {
    public static void main(String[] args) throws IOException {

        //创建发送端/接收端，并指定端口
        DatagramSocket datagramSocket = new DatagramSocket(9998);

        //将发送数据封装到DatagramPacket中
        byte[] bytes = "hello,明天吃火锅".getBytes();
        //封装到DatagramPacket的内容有bytes数据内容,bytes.length数据长度
        //InetAddress.getByName(目标主机IPv4地址),端口号
        DatagramPacket datagramPacket = new DatagramPacket(
                bytes, bytes.length, InetAddress.getByName("192.168.0.105"), 9999);
        //发送数据报
        datagramSocket.send(datagramPacket);

        //接收回复数据
        byte[] bytes1 = new byte[64*1024];
        DatagramPacket datagramPacket1 = new DatagramPacket(bytes1, bytes.length);
        datagramSocket.receive(datagramPacket1);
        //先获取数据长度，在获取数据
        int length = datagramPacket1.getLength();
        byte[] data = datagramPacket1.getData();
        String s = new String(data, 0, length);
        System.out.println(s);

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