Java - 网络编程

OLDERHARD

于 2024-08-07 21:33:33 发布

阅读量808

点赞数 11

文章标签： java 网络开发语言

本文链接：https://blog.csdn.net/m0_74403543/article/details/140982188

版权

一、网络基础(网络的相关概念)
网络通信：
1.概念：两台设备之间通过网络实现数据传输
2.网络通信：将数据通过网络从一台设备传输到另一台设备
3.java.net包下提供了一系列的类或接口，供程序员使用，完成网络通信

网络：
1.概念：两台或多台设备通过一定物理设备连接起来构成了网络
2.根据网络的覆盖范围不同，对网络进行分类：
局域网：覆盖范围最小，仅仅覆盖一个教室或一个机房
城域网：覆盖范围较大，可以覆盖一个城市
广域网：覆盖范围最大，可以覆盖全国，甚至全球，万维网是广域网的代表

ip地址
1.概念：用于唯一标识网络中的每台计算机
2.查看ip地址：ipconfig。
3.ip地址的表示形式：点分十进制 xx.xx.xx.xx(IPv4)
4.每一个十进制数的范围：0~255(IPv4)
5.ip地址的组成=网络地址+主机地址，比如：192.168.16.69(IPv4)
6.IPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号称为全世界的每一粒沙子编上一个地址。
7.IPv4是4个字节(32位)用十进制表示，IPv6是16个字节(128位)用16进制表示。由于IPv4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的使用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联网的障碍。
8.127.0.0.1表示本机地址。
9.IPv4地址分类：A,B,C,D,E

域名：
1.www.baibu.com
2.好处：为了方便记忆，解决记ip的困难
3.概念：将ip地址映射成域名

端口号：
1.概念：用于监听计算机上某个特定的网络程序
2.表示形式：以整数形式，范围0~65535 (2个字节)
3. 0~1024已经被占用，比如：ssh:22、ftp:21、http:80、smtp:25
4.常见的网络程序端口号：
tomcat:8080、mysql:3306、oracle:1521、sqlserver:1433

网络通信协议
网络通信协议可以理解为通过网络传输数据的组织形式。即双方进行传输数据，得按照一定的组织形式也就是一定的规则，当对方接收的时候，才能正确读取数据信息，也才能按照相应的规则，响应你要的数据信息。(个人理解)
用户数据在传输的时候，会通过多层协议，进行包装(Appl,TCP,IP,以太网)。到达对方的时候，就是包装好的数据(以太网帧)，之后再根据协议，逐渐拆包，得到用户数据。
TCP/IP模型：应用层，传输层(TCP)，网络层(IP)，物理+数据链路层
协议(tcp/ip)
中文译名为传输控制协议，网络通讯协议，这个协议是Internet最基本的协议，Internet国际互联网络的基础。简单地说，就是由网络层的IP协议和传输层的TCP协议组成的。

TCP和UDP
TCP协议(传输控制协议)：
1.使用TCP协议前，须先建立TCP连接，形成传输数据通道
2.传输前，采用”三次握手“，是可靠的
3.TCP协议进行通信的两个应用进程：客户端、服务端
4.在连接中可进行大数据量的传输
5.传输完毕，需释放已建立的连接，效率低

UDP协议(用户数据协议)：
1.将数据、源、目的封装成数据包，不需要建立连接
2.每个数据包的大小限制在64K内
3.因无需连接，所以是不可靠的
4.发送数据结束时无需释放资源(因为不是面向连接的)，速度快

二、InetAddress类
InetAddress 是 Java 中用于表示 IP 地址的类。它封装了 IP 地址（包括 IPv4 和 IPv6）以及可能的主机名。这个类提供了一些方法来获取 IP 地址和主机名之间的映射。
作用：通过这个类可以获取本机的信息(主机名/IP),通过域名获取远程服务器的IP。
相关方法
getLocalHost       //获取本机的InetAddress对象
getByName       //根据指定主机名/域名获取对应InetAddress对象
getHostName   //获取InetAddress对象的主机名
getHostAddress   //获取InetAddress对象的地址

public class info {
    public static void main(String[] args) throws UnknownHostException {

        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost); //LAPTOP-74LRE27/127.0.0.1
//        System.out.println(InetAddress.getByName("LAPTOP-74LRE27"));
        System.out.println(localHost.getHostName());//主机名
        System.out.println(localHost.getHostAddress());//IP

        InetAddress byName = InetAddress.getByName("www.baidu.com");
        System.out.println(byName);
        System.out.println(byName.getHostName());//域名
        System.out.println(byName.getHostAddress());//ip
    }
}

三、Socket编程
1.Socket开发网络应用程序被广泛应用，以至于成为事实上的标准。
2.通信的双端都要有 Socket，Socket 是两台机器间通信的端点。
3.网络通信其实就是 Socket 间的通信。
4.Socket 允许程序把网络连接当成一个流，数据在两个 Socket 间通过IO传输。
5.一般主动发起通信的应用程序属客户端，等待通信请求的为服务端
6.当我们需要通讯时(读写数据，会用到socket的两个方法：
socket.getOutputStream() //得到这个对应的输出流，用这个输出流往外写东西；
socket.getInputStream() //得到这个对应的输入流，用这个输入流读东西；
7.Socket 编程有两种编程方式，
TCP编程，可靠
UDP编程，不可靠

四、TCP编程(TCP网络通信编程)
1.基于客户端——服务端的网络通信
2.底层使用的是TCP/IP协议
3.应用场景举例：客户端发送数据，服务端接收并显示在控制台
4.基于 Socket的TCP编程
5.netstat指令
netstat -an ，可以查看当前主机网络情况，包括端口监听情况和网络连接情况
netstat -an | more ，可以分页显示
要求在 dos 控制台下执行
6.当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的，这个端口是TCP/IP 来分配的，是不确定的，是随机的。

应用案例1(使用字节流)
1.编写一个服务器端程序，和一个客户端程序；
2.服务器端在9999端口监听；
3.客户端连接到服务器端，发送"hello server"，然后退出；
4.服务器端接收到客户端发送的信息，输出，并退出；
思路：
服务端：在本机的9999端口监听，等待连接；当没有客户端连接9999端口时，程序会阻塞，等待连接；连接成功后，通过socket.getIntputStream()，读取客户端写入到数据通道的数据，显示。
客户端：连接服务端(IP，端口)；连接上后，会生成 Socket；通过socket.getOutputStream()这个输出流，写入数据到数据通道。

public class server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999); //监视端口9999
        System.out.println("本机端口9999正在监视....");
        Socket accept = serverSocket.accept();  //等待连接，连接成功后才能继续程序
        System.out.println("连接成功");
        InputStream inputStream = accept.getInputStream();  //读取数据通道的数据
        int len=0;
        byte[] bytes = new byte[1024];
        while ((len=inputStream.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }

        inputStream.close();    //关闭
        accept.close();
        serverSocket.close();
    }
}

public class user {
    public static void main(String[] args) throws IOException {
        //连接服务端，连接成功后，会返回 socket 对象，之后用socket的getOutputStream，写入到数据通道，等待服务端处理。
        Socket socket = new Socket(InetAddress.getLocalHost(),9999);
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello server".getBytes());
        socket.shutdownOutput();    //当写完后，要设置结束标志

        outputStream.close();   //关闭
        socket.close();
    }
}

应用案例2(使用字节流)
1.编写一个服务器端程序，和一个客户端程序；
2.服务器端在9999端口监听；
3.客户端连接到服务器端，发送"hello server"，接收服务器端回发的"hello user"，然后退出；
4.服务器端接收到客户端发送的信息，输出，并发送"hello user"，再退出。

public class server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        Socket accept = serverSocket.accept();
        InputStream inputStream = accept.getInputStream();
        int len=0;
        byte[] bytes = new byte[1024];
        while ((len=inputStream.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }


        OutputStream outputStream = accept.getOutputStream();
        outputStream.write("hello user".getBytes());
        accept.shutdownOutput();
        
        
        outputStream.close();
        inputStream.close();
        accept.close();
        serverSocket.close();
    }
}

public class user {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello server".getBytes());
        socket.shutdownOutput();


        InputStream inputStream = socket.getInputStream();
        int len=0;
        byte[] bytes = new byte[1024];
        while ((len=inputStream.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }


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

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

将应用案例2使用的字节流，改为字符流，用字符流来写入和读取。

public class server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        Socket accept = serverSocket.accept();

        InputStream inputStream = accept.getInputStream();
        BufferedReader bufferedReader= new BufferedReader(new InputStreamReader(inputStream,"utf-8"));
        String read=null;
        while ((read=bufferedReader.readLine())!=null){
            System.out.println(read);
        }

        OutputStream outputStream = accept.getOutputStream();
        BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(outputStream,"utf-8"));
        bufferedWriter.write("hello user");
        bufferedWriter.newLine();
        bufferedWriter.flush();     //如果用字符流写入的话，需要手动刷新，否则数据是不会写入到数据通道的
        accept.shutdownOutput();

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

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

        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(outputStream,"utf-8"));
        bufferedWriter.write("hello server");
        bufferedWriter.newLine();
        bufferedWriter.flush();     //如果使用字符流写入的话，需要手动刷新，否则数据是不会被写入到数据通道的
        socket.shutdownOutput();

        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(inputStream,"utf-8"));
        String read=null;
        while ((read=bufferedReader.readLine())!=null){
            System.out.println(read);
        }

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

应用案例4
1.编写一个服务端，和一个客户端
2.服务器端在8888端口监听
3.客户端连接到服务端，发送一张照片 (自定义)
4.服务器端接收到客户端发送的图片，保存到一个位置，发送"success"，再退出
5.客户端接收到服务端发送的"success"，并显示，再退出
6.使用BufferedInputStream和BufferedOutputStream等

跟上面的相比，没啥特别的，但是要记住一点，Buffered这种是缓冲流，每次在最后都要刷新一下，否则会造成文件信息缺失，Socket异常。

public class server{
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8888);
        Socket accept = serverSocket.accept();
        //读取数据通道的数据，并储存
        InputStream inputStream = accept.getInputStream();
        BufferedInputStream bufferedInputStream=new BufferedInputStream(inputStream);
        String filePath="D:\\untitled1\\src\\preview.jpg";
        BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(new FileOutputStream(filePath));
        int len=0;
        byte[] bytes = new byte[1024];
        while ((len=bufferedInputStream.read(bytes))!=-1){
            bufferedOutputStream.write(bytes,0,len);
        }
        bufferedOutputStream.flush();

        //返回信息“success”
        OutputStream outputStream = accept.getOutputStream();
        BufferedOutputStream bufferedOutputStream1=new BufferedOutputStream(outputStream);
        bufferedOutputStream1.write("success".getBytes());
        bufferedOutputStream1.flush();
        accept.shutdownOutput();//结束标识

        bufferedOutputStream1.close();//关闭
        bufferedOutputStream.close();
        bufferedInputStream.close();
        accept.close();
        serverSocket.close();
    }
}

public class user{
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        //将“图片”数据，传送到数据通道
        String filePath="C:\\Users\\OLDERHARD\\Pictures\\preview.jpg";
        BufferedInputStream bufferedInputStream=new BufferedInputStream(new FileInputStream(filePath));
        OutputStream outputStream = socket.getOutputStream();
        BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(outputStream);
        int len=0;
        byte[] bytes = new byte[1024];
        while ((len=bufferedInputStream.read(bytes))!=-1){
            bufferedOutputStream.write(bytes,0,len);
        }
        bufferedOutputStream.flush();
        socket.shutdownOutput();//结束标识

        InputStream inputStream = socket.getInputStream();
        BufferedInputStream bufferedInputStream1 =new BufferedInputStream(inputStream);
        while ((len=inputStream.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }

        bufferedInputStream1.close();
        bufferedInputStream.close();
        bufferedOutputStream.close();
        socket.close();
    }
}

五、UDP网络通信编程(UDP编程)
1.类 DatagramSocket 和 DategramPacket 实现了基于 UDP 协议网络程序
2.UDP数据报通过 DatagramSocket 发送和接收，系统不保证 UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。
3.DatagramPacket 对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号
4.UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接
5基本流程：
核心的两个类/对象 DatagramSocket 与 DatagramPacket
建立发送端，接收端
建立数据报,会被装包成 DatagramPacket对象
调用DatagramSocket的发送，接收方法
关闭DatagramSocket
6.UDP说明
没有明确的服务端和客户端，演变成数据的发送端和接收端；
接收数据和发送数据时通过 DatagramSocket对象完成；
将数据封装到DatagramPacket对象，装包；
当接收到 Datagrampacket 对象，需要进行拆包，取出数据；

应用案例
1.编写一个接收端A，和一个发送端B
2.接收端A在9999端口等待接收数据(receive)
3.发送端B向接收端A发送数据"hello，明天吃火锅~"
4.接收端A接收到发送端B发送的数据，回复"好的，明天见"，再退出
5.发送端接收回复数据，再退出

/*接收端*/
public class UDPA {
    public static void main(String[] args) throws IOException {
        DatagramSocket datagramSocket = new DatagramSocket(9999);
        byte[] bytes = new byte[1024];
        DatagramPacket Packet = new DatagramPacket(bytes,bytes.length);

        datagramSocket.receive(Packet);
        int length = Packet.getLength();    //实际接收到数据报的长度
        byte[] data = Packet.getData();
        System.out.println(new String(data,0,length, StandardCharsets.UTF_8));
        
        /*充当发送端*/
        byte[] bytes1 = "好的，明天见".getBytes();
        DatagramPacket Packet1 = new DatagramPacket(bytes1, bytes1.length, InetAddress.getLocalHost(), 9998);
        datagramSocket.send(Packet1);

        datagramSocket.close(); //关闭
    }
}

/*发送端*/
public class UDPB {
    public static void main(String[] args) throws IOException {
        DatagramSocket datagramSocket = new DatagramSocket(9998);
        byte[] bytes = "hello，明天吃火锅~".getBytes();
        DatagramPacket datagramPacket = new DatagramPacket(bytes,bytes.length, InetAddress.getLocalHost(),9999);
        datagramSocket.send(datagramPacket);

        /*充当接收端*/
        byte[] bytes1 = new byte[1024];
        DatagramPacket datagramPacket1 = new DatagramPacket(bytes1,bytes1.length);
        datagramSocket.receive(datagramPacket1);

        int length = datagramPacket1.getLength();
        byte[] data1 = datagramPacket1.getData();
        String s=new String(data1,0,length, StandardCharsets.UTF_8);
        System.out.println(s);

        datagramSocket.close();//关闭
    }
}