java网络编程

最新推荐文章于 2024-10-05 22:03:36 发布

疯狂的小鸡仔

最新推荐文章于 2024-10-05 22:03:36 发布

阅读量808

点赞数 1

文章标签：网络

本文链接：https://blog.csdn.net/m0_52896041/article/details/132367504

版权

1. 什么是网络编程?

在网络通信协议下，不同计算机上运行的程序，进行的数据传输。

应用场景:即时通信、网游对战、金融证券、国际贸易、邮件、等等

不管是什么场景，都是计算机跟计算机之间通过网络进行数据传输。

Java中可以使用java.net包下的技术轻松开发出常见的网络应用程序

BS架构（可以通过网页直接访问）

CS架构（需要用户安装APP）

BS架构的优缺点

不需要开发客户端，只需要页面+ 服务端
用户不需要下载，打开浏览器就能使用
如果应用过大，用户体验受到影响

CS架构的优缺点

画面可以做的非常精美，用户体验好
需要开发客户端，也需要开发服务端
用户需要下载和更新的时候太麻烦

CS\BS的区别

CS:客户端服务端模式需要开发客户端
BS:浏览器服务端模式不需要开发客户端
CS:适合定制专业化的办公类软件如: IDEA、网游
BS:适合移动互联网应用，可以在任何地方随时访问的系统

2. 网络编程三要素

网络编程三要素：IP、端口号、协议

IP：在网络中的地址，是唯一的标识端口号
端口号：应用程序在设备中唯一的标识。
协议：数据在网络中传输的规则，常见的协议有UDP、TCP、http、https、ftp。

2.1 IP

全称:Internet Protocol，是互联网协议地址，也称IP地址。

是分配给上网设备的数字标签
通俗理解：上网设备在网络中的地址，是唯一的

常见的IP分类：IPv4、IPv6

IPv4

全称:Internet Protocol version 4，互联网通信协议第四版

采用32位地址长度，分成4组

IPv4一共4,294,976,296个（2^32）IP不够用， 2019年11月26日全部分配完毕

所以出现了IPv6（IPv5还未发布就被淘汰）

全称:Internet Protocol version 6，互联网通信协议第六版。

采用128位地址长度，分成8组，一共有2^128个IP。

IPv4的地址分类形式
公网地址(万维网使用)和私有地址(局域网使用)。
192.168.开头的就是私有址址，范围即为192.168.0.0--192.168.255.255，专门为组织机构内部使用，以此节省IP

特殊IP地址
127.0.0.1，也可以是localhost: 是回送地址也称本地回环地址，也称本机IP，永远只会寻找当前所在本机。

假设192.168.162.100 是我电脑的IP，那么这个IP跟127.0.0.1是不一样的

往127.0.0.1发送数据，不会经过路由器

2.1.1 常见CMD命令

ipconfig:查看本机IP地址
ping:检查网络是否连通

2.1.2 InetAddress

此类表示Internet协议（IP）地址。

Inet4Address ， Inet6Address

Inet4Address:该类表示Internet协议版本4（IPv4）地址。

Inet6Address:该类表示Internet协议版本6（IPv6）地址

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

/**
 *  static InetAddress getByName(String host)   确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址
 *  String getHostName()                        获取此IP地址的主机名
 *  String getHostAddress()                     返回文本显示中的IP地址字符串
 *
 *
 */
public class MyInetAddressDemo01 {
    public static void main(String[] args) throws UnknownHostException {
        //获取InetAddress的对象
        InetAddress addresses1 = InetAddress.getByName("192.168.1.118");//IP地址
        System.out.println(addresses1); //  /192.168.1.118
        InetAddress addresses2 = InetAddress.getByName("LAPTOP-B3A26K2U");//主机名称
        System.out.println(addresses2); // LAPTOP-B3A26K2U/192.168.106.1

        String hostName = addresses1.getHostName(); //获取此IP地址的主机名
        System.out.println(hostName);//LAPTOP-B3A26K2U

        String hostAddress = addresses1.getHostAddress();//返回文本显示中的IP地址字符串
        System.out.println(hostAddress);//192.168.1.118
    }
}

2.2 端口号

应用程序在设备中唯一的标识。

端口号:由两个字节表示的整数，取值范围:0~65535

其中0~1023之间的端口号用于一些知名的网络服务或者应用
我们使用1024以上的端口号。
一个端口号只能被一个应用程序使用

2.3 协议

数据在网络中传输的规则，常见的协议有UDP、TCP、http、https、ftp。

OSI参考模型:世界互联协议标准，全球通信规范，单模型过于理想化，未能在因特网上进行广泛推广
TCP/IP参考模型(或TCP/IP协议):事实上的国际标准。

OSI参考模型	TCP/IP参考模型	TCP/IP参考模型各层对应协议	面向哪些
应用层	应用层	HTTP、FTP、Telnet、 DNS...	一把是应用程序需要关注的。如浏览器，邮箱。程序员一般在这一层开发
表示层
会话层
传输层	传输层	TCP、UDP...	选择传输使用的TCP，UDP协议
网络层	网络层	IP、ICMP、ARP...	封装自己的IP，对方的IP等信息
数据链路层	物理+数据链路层	硬件设备。 010100101010100101010..	转换成二进制利用物理设备传输
物理层	物理+数据链路层	硬件设备。 010100101010100101010..	转换成二进制利用物理设备传输

UDP协议

用户数据报协议
UDP是面向无连接通信协议。速度快，有大小限制一次最多发送64K，数据不安全，易丢失数据（面向无连接：数据直接发送，不管对方能不能收到）

TCP协议

传输控制协议
TCP协议是面向连接的通信协议。速度慢，没有大小限制，数据安全。（面向连接：确保连接成功才会发送数据）

3. UDP通信程序

发送数据：

创建发送端的DatagramSocket对象
数据打包(DatagramPacket)
发送数据
释放资源

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

public class SendMessageDemo01 {
    public static void main(String[] args) throws Exception {
        //发送数据

        //1.创建DatagramSocket对象
        //绑定端口，我们通过这个端口往外发送
        //空参：所有可用的端口中随机一个进行使用
        //有参：指定端口进行绑定
        DatagramSocket socket = new DatagramSocket();

        //2.打包数据
        String str = "123456789";
        byte[] bytes = str.getBytes();
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 6666;
        DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length, localhost, port);

        //3.发送数据
        socket.send(datagramPacket);

        //4.释放资源
        socket.close();
    }
}

接收数据：

创建接收端的DatagramSocket对象
接收打包好的数据
解析数据包
释放资源

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

public class ReceiveMessageDemo01 {
    public static void main(String[] args) throws Exception {
        //接收数据

        //1.创建DatagramSocket对象
        //绑定端口
        //绑定的端口必须和发送的端口保持一致
        DatagramSocket socket = new DatagramSocket(6666);

        //2.接收数据包
        byte[] bytes = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length);
        //该方法是阻塞的
        socket.receive(datagramPacket);

        //3.解析数据包
        byte[] data = datagramPacket.getData();
        int len = datagramPacket.getLength();
        InetAddress address = datagramPacket.getAddress();
        int port = datagramPacket.getPort();

        System.out.println("接收到数据" + new String(data, 0, len));
        System.out.println("该数据是从" + address + "这台电脑中的" + port + "这个端口发出的");

        //4.释放资源
        socket.close();
    }
}

例如：聊天室

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

public class SendMessageDemo02 {
    public static void main(String[] args) throws IOException {
        //1.创建DatagramSocket对象
        DatagramSocket socket = new DatagramSocket();

        //2.打包数据
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("输入你要说的话");
            String str = sc.nextLine();
            if ("888".equals(str)) {
                break;
            }
            byte[] bytes = str.getBytes();
            InetAddress address = InetAddress.getByName("localhost");
            int port = 6667;
            DatagramPacket dp = new DatagramPacket(bytes, bytes.length, address, port);

            //3.发送数据
            socket.send(dp);

        }
        //4.释放资源
        socket.close();
    }
}

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

public class ReceiveMessageDemo02 {
    public static void main(String[] args) throws IOException {
        //1.创建DatagramSocket对象
        DatagramSocket socket = new DatagramSocket(6667);

        //2.接收数据包
        byte[] bytes = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bytes, bytes.length);

        while (true) {
            socket.receive(dp);
            //3.解析数据包
            byte[] data = dp.getData();
            int len = dp.getLength();
            String ip = dp.getAddress().getHostAddress();
            String name = dp.getAddress().getHostName();

            //4.打印数据
            System.out.println("ip为：" + ip + ",主机名为：" + name + "发送了数据:" + new String(data, 0, len));
        }
    }
}

3.1 UDP的三种通信方式

单播、组播、广播

单播：发送端给一台电脑发送数据

组播：发送端给一组电脑发送数据

广播：发送端给局域网中所有电脑发送数据

组播地址: 224.0.0.0 ~ 239.255.255.255
其中224.0.0.0 ~ 224.0.0.255 为预留的组播地址

广播地址: 255.255.255.255

组播：一个发送端SendMessageDemo03，多个接收端ReceiveMessageDemo03

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

public class SendMessageDemo03 {
    public static void main(String[] args) throws IOException {
        //1.创建MulticastSocket对象
        MulticastSocket ms = new MulticastSocket();

        //2.打包数据
        String str = "123211";
        byte[] bytes = str.getBytes();
        InetAddress address = InetAddress.getByName("224.0.0.1");
        int port = 6668;
        DatagramPacket dp = new DatagramPacket(bytes, bytes.length, address, port);

        //3.发送数据
        ms.send(dp);
        
        //4.释放资源
        ms.close();
    }
}

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

public class ReceiveMessageDemo03 {
    public static void main(String[] args) throws IOException {
        //1.创建MulticastSocket对象
        MulticastSocket ms = new MulticastSocket(6668);

        //2.将当前主机添加到224.0.0.1的这一组中
        InetAddress address = InetAddress.getByName("224.0.0.1");
        ms.joinGroup(address);

        //3.接收数据包
        byte[] bytes = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bytes, bytes.length);
        ms.receive(dp);


        //4.解析数据包
        byte[] data = dp.getData();
        int len = dp.getLength();
        String ip = dp.getAddress().getHostAddress();
        String name = dp.getAddress().getHostName();

        //5.打印数据
        System.out.println("ip为：" + ip + ",主机名为：" + name + "发送了数据:" + new String(data, 0, len));

        ms.close();
    }

}

多个接收端都能接收到数据

如果将其中一个接收的ip改为：224.0.0.2，改的那个就接受不到数据

广播：只需要将上面聊天室的代码的localhost改为255.255.255.255

4. TCP通信程序

TCP通信协议是一种可靠的网络协议，它在通信的两端各建立一个Socket对象通信之前要保证连接已经建立
通过Socket产生I0流来进行网络通信

客户端Socket
创建客户端的Socket对象(Socket)与指定服务端连接：Socket(string host, int port)
获取输出流，写数据：Outputstream getoutputstream(）

释放资源：void close(）

服务器：ServerSocket
创建服务器端的Socket对象(ServerSocket)：ServerSocket(int port)
监听客户端连接，返回一个Socket对象：Socket accept(）
获取输入流，读数据，并把数据显示在控制台：Inputstream getInputstream()

释放资源：void close(）

例如：

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

public class Service {
    public static void main(String[] args) throws IOException {
        //创建ServerSocker对象
        ServerSocket serverSocket = new ServerSocket(6660);

        //2.监听客户端的连接
        Socket socket = serverSocket.accept();

        //3.获取输入流读取数据
        InputStream is = socket.getInputStream();
        int b;
        while ((b = is.read()) != -1) {
            System.out.println((char) b);
        }
        //4.释放资源
        socket.close();
        serverSocket.close();

    }
}

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

public class Client {
    public static void main(String[] args) throws IOException {
        //1.创建Socket对象
        Socket socket = new Socket("localhost", 6660);

        //2.获取输出流
        OutputStream os = socket.getOutputStream();
        os.write("我是客户端".getBytes());

        //3.释放资源
        os.close();
        socket.close();
    }
}

输入是乱码，不能传中文

解决：修改Service

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class Service {
    public static void main(String[] args) throws IOException {
        //创建ServerSocker对象
        ServerSocket serverSocket = new ServerSocket(6660);

        //2.监听客户端的连接
        Socket socket = serverSocket.accept();

        //3.获取输入流读取数据
        //InputStream is = socket.getInputStream();
        //InputStreamReader isr = new InputStreamReader(is);
        //提高效率
        //BufferedReader buf = new BufferedReader(isr);

        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        int b;
        while ((b = br.read()) != -1) {
            System.out.println((char) b);
        }
        //4.释放资源
        socket.close();
        serverSocket.close();
    }
}

4.1 三次握手四次挥手

三次握手为什么是三次，因为有一个反复确认的过程

综合练习1：多发多收

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

/**
 * 多发多收
 * 客户端:多次发送数据
 * 服务器: 接收多次接收数据，并打印
 */
public class Server {
    public static void main(String[] args) throws IOException {
        //1.创建对象绑定端口
        ServerSocket ss = new ServerSocket(6666);

        //2.等待客户端来连接
        Socket socket = ss.accept();

        //3.读取数据
        InputStream is = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        int b;
        while ((b = isr.read()) != -1) {
            System.out.print((char) b);
        }
        //4.释放资源
        socket.close();
        ss.close();
    }
}

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;

/**
 * 多发多收
 * 客户端:多次发送数据
 * 服务器: 接收多次接收数据，并打印
 */
public class Client {
    public static void main(String[] args) throws IOException {
        //1.创建集合
        Socket socket = new Socket("127.0.0.1", 6666);

        //2.写出数据
        Scanner sc = new Scanner(System.in);
        OutputStream os = socket.getOutputStream();

        while (true) {
            System.out.println("请输入你要写入的数据");
            String str = sc.nextLine();
            if ("888".equals(str)) {
                break;
            }
            os.write(str.getBytes());
        }
        //3.释放资源
        socket.close();
    }
}

综合练习1：接收和反馈

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

/**
 * 接收和反馈
 * 客户端:发送一条数据，接收服务端反馈的消息并打印
 * 服务器:接收数据并打印，再给客户端反馈消息
 */
public class Service {
    public static void main(String[] args) throws IOException {
        //1.创建对象绑定端口
        ServerSocket ss = new ServerSocket(6666);

        //2.等待客户端来连接

        Socket socket = ss.accept();

        //3.读取数据
        InputStream is = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        int b;
        //read方法会从连接通道中读取数据，但是，需要一个结束标记，此处的循环才会停止，否则，程序会一直停在read方法这里等待读取
        while ((b = isr.read()) != -1) {
            System.out.print((char) b);
        }
        //4.回写数据
        String str = "二推拿dfghjk";
        OutputStream os = socket.getOutputStream();
        os.write(str.getBytes());

        //释放资源
        ss.close();
        socket.close();
    }
}

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

/**
 * 接收和反馈
 * 客户端:发送一条数据，接收服务端反馈的消息并打印
 * 服务器:接收数据并打印，再给客户端反馈消息
 */
public class Client {
    public static void main(String[] args) throws IOException {
        //1.创建集合
        Socket socket = new Socket("127.0.0.1", 6666);

        //2.写出数据
        String str = "sdfgh地方规划局";
        OutputStream os = socket.getOutputStream();
        os.write(str.getBytes());

        //写一个结束的标记
        socket.shutdownOutput();

        //3.接收服务端回写的数据
        InputStream is = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        int b;
        while ((b = isr.read()) != -1) {
            System.out.print((char) b);
        }
        //释放资源
        socket.close();
    }
}