Java 网络编程（大全）

缺乏、安全感 2023-09-27 10:13 116阅读 0赞

## 前言必读 ##

> [读者手册（必读）\_云边的快乐猫的博客-CSDN博客][-CSDN]

**一、1网络通信的基本模式分为两种**

**1.CS模式**（Client---客户端，Server---服务端）

客户端是需要程序员去开发的，例如日常使用的各种的APP，服务端就是服务器。

例子：端游，依赖特定的PC端才能玩。

**2.BS模式**（Browser---浏览器，Server---服务端）---重点学习

服务端是需要程序员去开发的。浏览器就是我们日常使用的浏览器去访问各种网站，只要有浏览器就可以访问，不依赖特定的PC端，在任意设备上都可以访问网站服务器 。

例子：网页小游戏，联网浏览器就可以玩。

**一、2 请分析C/S和B/S架构相比的各自的优缺点？**

**1.CS（客户端--服务器结构）**

**优点 ：**技术成熟，交互性强，网络通信量低，响应数据快。将任务分到了两端，降低了系统的开销。客户端要处理大多数的业务逻辑和UI展示。他是胖客户端。

**缺点：**更新太快，要求用户有相同的操作系统，如果有不同的操作系统还要开发不同的版本，对于计算机电脑的配置要求也高

**2。BS（浏览器-服务器结构）**

**优点：**主要事务在服务端实现。分布性强、维护方便、开发简单

共享性强、总体成本低，对客户端的电脑配置要求较低

**缺点：**数据安全性问题，对服务器要求高。数据传输速度较慢，软件的个性化明显降低，难以实现传统模式下的特殊功能要求，他是瘦客户端，大量的数据的传输都要通过服务器与浏览器进行交互，通信开销大，难以实现复杂的应用构造

**二、实现网络编程的三种要素**

IP地址可以理解为具体哪个计算机，端口理解计算机上的程序（一个程序一个端口），协议理解为电脑通过什么方式和外界交互

**要素一：IP地址：**设备在网络中的地址，是唯一的标识

**详解：**

**（1）**常见的IP分类为：

**IPv4（**32比特4字节）和**IPv6**（128位16个字节）--称号--可以标记地球上的每一粒沙子。

**（2）**IP地址的取经之路：

计算机：我要去找百度获取数据。

DNS服务器：发过来我看看哪个网址域名啊，给你指路具体的ip地址

计算机：知道了这个ip地址，我就可以去找具体要访问的服务器了

服务器：计算机老弟你来找我了啊，那我把你要的数据发给你吧。

**（3）**公网地址和私有地址（局域网使用）

192.168开头的就是常见的私有地址

**（4）**获取IP地址的代码

要去实现这个IP地址的获取就要用到 **InetAddress**方法

代码例子：

package bao;
    
    import java.net.InetAddress;
    
    public class Test {
        public static void main(String[] args) throws Exception {
            //1.获取本机地址ip对象
            InetAddress ip1 = InetAddress.getLocalHost();
            System.out.println(ip1.getHostName());//获取主机名字
            System.out.println(ip1.getHostAddress());//获取ip地址
            //2.获取域名ip对象
            InetAddress ip2 = InetAddress.getByName("www.baidu.com");
            System.out.println(ip2.getHostName());//获取域名
            System.out.println(ip2.getHostAddress());//获取域名的ip地址
            //3.获取公网对象
            InetAddress ip3 = InetAddress.getByName("112.80.248.76");
            System.out.println(ip3.getHostName());//获取公网名字
            System.out.println(ip3.getHostAddress());//获取公网ip地址
            //判断网络是否能连接通信 ping 5s之前测试是否能通过
            System.out.println(ip3.isReachable(5000));//通过会返回true
        }
    }

运行结果：

> 涉及到个人隐私就不放到这里来了，可以自己运行试试看

**=========================================================================**

**要素二：端口：**应用程序在设备中的唯一标识

一个主机设备中，端口号是唯一的

**（1）**端口号：一个程序一个端口号，被规定为16位的二进制，范围是0~65535

**（2）**周知端口：0~1023，被预先定义的知名应用占用。（例如：HTTP占用80端口，FTP占用21端口）

**（3）**注册端口：1024~49151，分配给用户进程或某些程序（例如：Tomcat占用8080端口）

**（4）**动态端口：49152~65535，不固定分配到某种进程，动态分配

**=========================================================================**

**要素三：协议：**数据在网络中的传输协议，最常见的有UDP和TCP（重点）

![75c92cc8900e43279d5c853cc48368e3.png][]

**（1）TCP协议：**（安全，有连接确认可靠）

使用TCP协议，双方必须先建立连接，它是一种**面向连接**的**可靠通信**协议，传输前，要建立三次握手方式建立连接确认。连接和发送数据都需要确认。传输完成后，还需要释放已连接的通信，通信效率相对比较低。

使用场景：对安全需求较高的文件下载、金融数据通信等。

三次握手连接：

客户端：在吗？

服务端：在

客户端：上号

四次握手断开连接：

客户端：不玩了

服务端：好吧

服务端：下次什么时候玩？

客户端：有空再玩

**例子：**

一收一发

发送端（客户端）

package bao;
    
    import java.io.IOException;
    import java.io.OutputStream;
    import java.io.PrintStream;
    import java.net.Socket;
    
    //发送端
    public class Test {
        public static void main(String[] args) throws IOException {
            System.out.println("==============客户端启动===============");
            //1.创建发送通信管道
            Socket socket = new Socket("127.0.0.1",7777);//参数一：服务端地址 参数二：服务端端口
            //2.从scoket管道中获得一个字节输出流,负责发送数据
            OutputStream os = socket.getOutputStream();
            //3.字节流升级成打印流
            PrintStream ps = new PrintStream(os);
            //4.发送消息
            ps.println("大哥，我来了");
            ps.flush();//刷新
        }
    }

接收端 （服务端）

package bao;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    //服务端
    public class Test1 {
        public static void main(String[] args) throws IOException {
            System.out.println("========服务端启动============");
            //1.创建接收管道，注册端口
            ServerSocket serverSocket = new ServerSocket(7777);//参数一：定义服务端口
            //2.等待管道连接
            Socket accept = serverSocket.accept();
            //3.从管道中获取一个字节输入流
            InputStream is = accept.getInputStream();
            //4.字节流升级生缓冲输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            //5.按照行读取消息会更好
            String a;
            if ((a = br.readLine())!=null){
                System.out.println(accept.getRemoteSocketAddress()+"说了："+a);
            }
        }
    }

运行结果：

> /127.0.0.1:60316说了：大哥，我来了

> ==============客户端启动===============

多收多发

发送端（客户端）

package bao;
    
    import java.io.*;
    import java.net.InetAddress;
    import java.net.Socket;
    import java.util.Scanner;
    
    
    public class kehu {
        public static void main(String[] args) throws Exception {
            System.out.println("客户端启动");
            //1.创建与服务端连接的管道
            Socket s = new Socket(InetAddress.getLocalHost(), 9966);
            //2.创建一个线程负责客户端的消息读取
            new ClientReaderThread(s).start();
            //3.创建一个字节输入流管道
            OutputStream o = s.getOutputStream();
            PrintStream p = new PrintStream(o);//升级流
            //4.客户端输入数据
            Scanner sc = new Scanner(System.in);
            while (true){
                System.out.println("请输入：");
                String s1 = sc.nextLine();
                p.println(s1);//发送数据出去
                p.flush();//刷新流
            }
        }
    }
    class ClientReaderThread extends Thread{
        private Socket socket;
        public ClientReaderThread(Socket socket){
            this.socket = socket;
        }
            @Override
            public void run(){
                try {
                    //把字节输入流包装成字符输入流
                    InputStream i = socket.getInputStream();
                    BufferedReader b = new BufferedReader(new InputStreamReader(i));
                    String s1;
                    while (true){
                        if ((s1=b.readLine())!=null){
                            System.out.println("收到了消息"+s1);
                        }
                    }
                } catch (IOException e) {
                    System.out.println("服务器把你提出群聊");
                }
            }
        }

接收端 （服务端）

package bao;
    
    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.ArrayList;
    import java.util.List;
    
    public class fuwu {
        //1.定义一个静态变量储存全部管道
        public static List<Socket> all_Sockets = new ArrayList<>();
        public static void main(String[] args) throws IOException {
            System.out.println("服务端启动成功");
            //2.服务端口注册
            ServerSocket ss = new ServerSocket(9966);
            //3.管道死循环设置
            while (true){
                Socket s = ss.accept();
                System.out.println(s.getRemoteSocketAddress()+"上线了");
                all_Sockets.add(s);
                new fuwuThread(s).start();
            }
        }
    }
    class fuwuThread extends Thread{
        private Socket socket;
        public fuwuThread(Socket socket){
            this.socket=socket;
        }
        @Override
        public void run(){
            try {
                InputStream i = socket.getInputStream();
                BufferedReader b = new BufferedReader(new InputStreamReader(i));
                String s1;
                while ((s1=b.readLine())!=null){
                    System.out.println(socket.getRemoteSocketAddress()+"说"+s1);
                    sendMessage(s1);
                }
            } catch (IOException e) {
                System.out.println(socket.getRemoteSocketAddress()+"离线了");
                fuwu.all_Sockets.remove(socket);
            }
        }
        private void sendMessage (String s1) throws IOException {
            for (Socket s:fuwu.all_Sockets){
                OutputStream o = s.getOutputStream();
                PrintStream p = new PrintStream(o);
                p.println(s1);
                p.flush();
            }
        }
    }

运行结果：

> 服务端启动成功  
> /192.168.78.1:56384上线了  
> /192.168.78.1:56384说大哥  
> /192.168.78.1:56389上线了  
> /192.168.78.1:56389说小弟  
> /192.168.78.1:56384说  
> /192.168.78.1:56384说大哥11

> 客户端启动  
> 请输入：  
> 大哥  
> 请输入：  
> 收到了消息大哥  
> 收到了消息小弟
> 
> 大哥11  
> 请输入：  
> 请输入：  
> 收到了消息  
> 收到了消息大哥11

> 客户端启动  
> 请输入：  
> 小弟  
> 请输入：  
> 收到了消息小弟  
> 收到了消息  
> 收到了消息大哥11

**=========================================================================**

**TCP和UDP的分界线**

**=========================================================================**

**（2）UDP协议：**（速度快，无连接，不可靠）

不需要建立连接（因为把数据源IP、目的地IP、端口封装成数据包），每个数据包在64KB内，只管发，不管对方有没有接到确认什么的。

**优点：**可以广播发送，发送数据结束时无需释放资源，开销小，速度快。

**使用场景：**语言通话、视频通话等。

ps：这个就是一股脑的什么都封装一起，直接往外抛就什么都不管了，当然快了。

**例子：**

一收一发

发送端（客户端）

package bao;
    
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    
    public class Test {
        public static void main(String[] args) throws Exception {
            //一、发送端(测试时候先启动接收再发送端)
            //1.创建发送端对象，发送端自带默认端口号（人）
            System.out.println("========客户端启动============");
            DatagramSocket socket1 = new DatagramSocket();//不定义就默认端口
    
            //2.创建一个要发送的数据容器（容器里面有数据）
            byte[] a ="我是水".getBytes();
            //3.创建一个数据包对象把容器装起来
            DatagramPacket packet1 = new DatagramPacket(a,a.length, InetAddress.getLocalHost(),8899);//数据，大小，服务端的IP，服务端的端口
            //4.发送出去
            socket1.send(packet1);
            //5.关闭资源,避免资源浪费
           socket1.close();
        }
    }

接收端 （服务端）

package bao;
    
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    
    public class Test1 {
        public static void main(String[] args) throws Exception {
            //二、接收端(测试时候先启动接收再发送端)
            //1.创建接收端对象，注册端口（人）
            System.out.println("=========接收端启动===============");
            DatagramSocket socket2 = new DatagramSocket(8899);
    
            //2.创建一个要接收的数据容器（等待接收数据）
            byte[]b =new byte[1024*64];
            //3.把容器数据打包
            DatagramPacket packet2 = new DatagramPacket(b,b.length);
            //4.等待接收数据
            socket2.receive(packet2);
            //5.读取多少倒出多少
            int len = packet2.getLength();
            String rs = new String(b,0,len);
            System.out.println("接收到了数据了"+rs);
    
            //6.关闭资源,避免资源浪费
            socket2.close();
        }
    }
    //额外知识点,获取对方端口和ip地址
    //String ip = packet2.getAddress().toString();
    //System.out.println("对方IP地址为"+ip);
    
    //int port = packet2.getPort();
    //System.out.println("对方端口位置"+port);

运行结果：

> ========客户端启动============

> =========接收端启动===============  
> 接收到了数据了我是水

多收多发

思想：把一收一发代码拿来改进就好了

发送端：把主要发送的代码写入死循环并写一个键盘输入代码，只有用户输入exit才能退出循环。

接收端：把等待接收的封装包开始写入死循环里面，然后再把释放资源的代码注释掉才能一直接收

发送端（客户端）

package bao;
    
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    import java.util.Scanner;
    //发送端
    public class Test {
        public static void main(String[] args) throws Exception {
            //一、1.创建发送端对象，发送端自带默认端口号（人）
            DatagramSocket socket1 = new DatagramSocket();//不定义就默认端口
            System.out.println("========客户端启动============");
            //二.6创建键盘录入
            Scanner sc = new Scanner(System.in);
            while (true) {//二、5.死循环把代码封起来（多收多发步骤）
                //二、6.接收键盘录入
                System.out.println("请输入：");
                String msg = sc.nextLine();
    
                //二、7.设置exit退出
                if ("exit".equals(msg)){
                    System.out.println("离线成功");
                    socket1.close();//释放资源
                    break;
                }
    
                //2.创建一个要发送的数据容器（容器里面有数据）
                byte[] a =msg.getBytes();
                //3.创建一个数据包对象把容器装起来
                DatagramPacket packet1 = new DatagramPacket(a,a.length, InetAddress.getLocalHost(),8899);//数据，大小，服务端的IP，服务端的端口
                //4.发送出去
                socket1.send(packet1);
            }
        }
    }

接收端 （服务端）

package bao;
    
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    //二、接收端
    public class Test1 {
        public static void main(String[] args) throws Exception {
            //1.创建接收端对象，注册端口（人）
            System.out.println("=========接收端启动===============");
            DatagramSocket socket2 = new DatagramSocket(8899);
    
            //2.创建一个要接收的数据容器（等待接收数据）
            byte[]b =new byte[1024*64];
            //3.把容器数据打包
            DatagramPacket packet2 = new DatagramPacket(b,b.length);
            while (true) {//二、6.把封装代码写入死循环并删掉释放资源的代码（多收多发步骤）
                //4.等待接收数据
                socket2.receive(packet2);
                //5.读取多少倒出多少
                int len = packet2.getLength();
                String rs = new String(b,0,len);
                System.out.println("接收到了来自："+packet2.getAddress()+"对方端口是："+packet2.getPort()+rs);
            }
        }
    }
    //额外知识点,获取对方端口和ip地址
    //String ip = packet2.getAddress().toString();
    //System.out.println("对方IP地址为"+ip);
    
    //int port = packet2.getPort();
    //System.out.println("对方端口位置"+port);

运行结果：

> ========客户端启动============  
> 请输入：  
> 你在吗  
> 请输入：  
> 在干嘛  
> 请输入：

> =========接收端启动===============  
> 接收到了来自：（隐私不展示）对方端口是：（隐私不展示）你在吗  
> 接收到了来自：（隐私不展示）对方端口是：（隐私不展示）在干嘛

多开客户端 步骤

一台主机中可以创建很多个客户端给接收端发消息

1.在客户端的页面右上角点击

![e2a51f7fbde24d589e94af694b2b0b26.png][]

2.找到**Allow multiple instances**勾选完成

![e28b39f4376a43e89f76dff28d4a6b75.png][] 广播（当前主机和所在网络中的所有主机通信）

步骤：（前提在同一网段内）

发送端的参数地址指定为255.255.255.255,并且指定端口：例如6666

接收端的参数端口只要匹配成功就可以了，例如：6666

例子：

发送端

//修改前
    
     //3.创建一个数据包对象把容器装起来
    DatagramPacket packet1 = new DatagramPacket(a,a.length, InetAddress.getLocalHost(),8899);//数据，大小，服务端的IP，服务端的端口
    
    //修改后
    
     //3.创建一个数据包对象把容器装起来
    DatagramPacket packet1 = new DatagramPacket(a,a.length, InetAddress.getByName("255.255.255.255"),6666);//数据，大小，服务端的IP，服务端的端口

接收端

//修改前
            //1.创建接收端对象，注册端口（人）
    System.out.println("=========接收端启动===============");
    DatagramSocket socket2 = new DatagramSocket(8899);
    
    //修改后
            //1.创建接收端对象，注册端口（人）
    System.out.println("=========接收端启动===============");
    DatagramSocket socket2 = new DatagramSocket(6666);

组播 （当前主机和所在网络中的一组主机通信）

发送端和接收端都要用MulticastSocket绑定同一个IP地址和绑定同一个端口

范围：224.0.0.0~~~~239.255.255.255

发送端

//修改前
                //3.创建一个数据包对象把容器装起来
    DatagramPacket packet1 = new DatagramPacket(a,a.length, InetAddress.getByName("255.255.255.255"),6666);//数据，大小，服务端的IP，服务端的端口
    
    //修改后
                //3.创建一个数据包对象把容器装起来
    DatagramPacket packet1 = new DatagramPacket(a,a.length, InetAddress.getByName("224.0.1.1"),6666);//数据，大小，服务端的IP，服务端的端口

接收端

//修改前
    
             //1.创建接收端对象，注册端口（人）
    System.out.println("=========接收端启动===============");
    DatagramSocket socket2 = new DatagramSocket(6666);
    
    //修改后
            //1.创建接收端对象，注册端口（人）
    System.out.println("=========接收端启动===============");
    MulticastSocket socket2 = new MulticastSocket(6666);
    //绑定组播IP(JDK开始过时的API)
    socket2.joinGroup(InetAddress.getByName("224.0.1.1"));

[-CSDN]: https://blog.csdn.net/m0_52861000/article/details/128148568?spm=1001.2014.3001.5501
[75c92cc8900e43279d5c853cc48368e3.png]: https://img-blog.csdnimg.cn/75c92cc8900e43279d5c853cc48368e3.png
[e2a51f7fbde24d589e94af694b2b0b26.png]: https://img-blog.csdnimg.cn/e2a51f7fbde24d589e94af694b2b0b26.png
[e28b39f4376a43e89f76dff28d4a6b75.png]: https://img-blog.csdnimg.cn/e28b39f4376a43e89f76dff28d4a6b75.png