Java学习17：网络编程

17.网络编程

网络的相关概念

java.net包下提供了一系列类或接口，供程序员使用，完成网络通信

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

网络通信：将数据通过网络从一台设备传输到另一台设备

网络根据覆盖范围分类：

1. 局域网：覆盖范围小，仅仅覆盖一间教室或机房
2. 城域网：覆盖范围较大，可以覆盖一个城市
3. 广域网：覆盖范围最大，可以覆盖全国，甚至全球，万维网时广域网的代表

ip地址

1. ip地址用于唯一标识网络中的每台主机

2. 表示方式：点分十进制，如192.168.16.69

3. 每个十进制数的范围：0~255，即8位二进制数，共4个字节（32位）

4. ip地址的组成=网络地址+主机地址

5. ip地址分类：A、B、C、D、E类

   

   

6. ipv6是用于替代ipv4的下一代ip协议，用16个字节（128位二进制数）表示，是ipv4的四倍

域名

把ip地址映射成域名，方便记忆

端口号

1. 用于标识计算机上某个特定的网络程序
2. 端口号范围：0~65535（两个字节）
3. 0~1024已经被占用
4. 常见端口
   1. ssh：22
   2. ftp：21
   3. smtp：25
   4. http：80
   5. tomcat：8080
   6. mysql：3306
   7. oracle：1521
   8. sqlserver：1433

协议（TCP/IP）

TCP/IP（Transmission Control Protocol / Internet Protocol）的简写，中文译名为传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议是Internet最基本的协议、Internet国际互联网的基础。

OSI和TCP/IP

TCP和UDP

TCP：

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

UDP协议：

1. 将数据、源、目的封装成数据包，不需要建立连接
2. 每个数据报的大小限制在64k内
3. 因无需链接，故是不可靠的
4. 发送数据结束时无需释放资源（因为不是面向连接的），速度快

InetAddress类

相关方法

1. getLocalHost()：获取本机InetAddress对象

InetAddress localHost = InetAddress.getLocalHost();
System.out.println(localHost); // DESKTOP-HBHCNP1/192.168.1.3

1. getByName：根据指定主机名/域名获取ip地址对象

InetAddress host0 = InetAddress.getByName("DESKTOP-HBHCNP1");
System.out.println(host0); // DESKTOP-HBHCNP1/192.168.1.3

InetAddress host1 = InetAddress.getByName("www.baidu.com");
System.out.println(host1); // www.baidu.com/110.242.68.3

1. getHostName：获取InetAddress对象主机名

String hostName = host1.getHostName();
System.out.println(hostName); // www.baidu.com

1. getHostAddress：获取InetAddress对象的地址

String hostAddress = host1.getHostAddress();
System.out.println(hostAddress); // 110.242.68.3

byte[] address = host1.getAddress();
System.out.println(Arrays.toString(address)); // [110, -14, 68, 3]

Socket

当我们需要通讯时，可以用socket获取输入流和输出流

socket.getOutputStream() // 输出流  运行类型：SocketOutputStream
socket.getInputStream() // 输入流   运行类型：SocketInputStream

注意：socket每次取到的OutputStream/getInputStream是同一个

TCP通信

基于Socket的TCP编程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mOeaOouI-1636426420359)(C:\Users\勿扰\AppData\Roaming\Typora\typora-user-images\image-20210819114121764.png)]

TCP通信分为客户端和服务器

下面是一对客户端/服务器代码，客户端向服务器发送8次hello，服务器回复谢谢

// 客户端
public class SocketTCP01Client{
    public static void main(String[] args) throws IOException, InterruptedException {
        // 连接服务器（ip，端口），创建Socket
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        // 用socket获取输出流，用于发送数据
        OutputStream outputStream = socket.getOutputStream();

        // OutputStream包装成BufferedOutputStream
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);

        // 向服务器发送信息
        // outputStream.write("hello".getBytes());
        for (int i = 0; i < 8; i++) {
            bufferedOutputStream.write("hello".getBytes());
            // 刷新到数据通道
            // bufferedOutputStream每flush一下，就会发送一次
            // 原本的outputStream是直接发送，不需要flush
            bufferedOutputStream.flush();
        }
        // 结束标记
        // 如果没有结束标记，代码继续执行，直到readLine阻塞程序，等待接收消息
        // 服务器是循环读取信息，读取不到结束标记，会继续在循环中等待消息
        // 造成双方互相等待对方发送消息，类似死锁的局面
        // shutdownOutput前必须要flush，因为shutdownOutput之后就不能再flush
        // 而关闭流的时候会默认flush
        socket.shutdownOutput();

        System.out.println("没有结束标记也会走到这一行");

        // 获取输入流，并封装成BufferedReader
        // 用于接收服务器传来的数据
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));

        // 接收服务器传来的信息
        String string = bufferedReader.readLine();
        System.out.println(string);


        // 关闭流
        bufferedReader.close();
        bufferedOutputStream.close();
        socket.close();
    }
}
// 服务器
public class SocketTCP01Server {
    public static void main(String[] args) throws IOException {
        // 创建ServerSocket
        ServerSocket serverSocket = new ServerSocket(9999);

        // 等待客户端连接，每连接一个客户端，都会生成一个用于与这个客户端通信的socket
        System.out.println("等待连接....");
        Socket socket = serverSocket.accept();

        // socket获取输入流，用于接收客户端发来的数据
        InputStream inputStream = socket.getInputStream();
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
        int buf = -1;
        byte[] bytes = new byte[8];
        System.out.println("打印收到信息");

        // 循环接收数据，直到接收到结束标记
        while ((buf = bufferedInputStream.read(bytes)) != -1){
            System.out.print(new String(bytes));
        }

        // 获取输出流
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

        // 向客户端发送消息
        bufferedWriter.write("谢谢");
        // Writer发送数据时，结束标记可以用newline
        // 每一个newline对应一个接收的readline
        bufferedWriter.newLine();
        // 必须flush才能发出去，否则发不出去
        // 这里后面接着close，所以可以不用flush
        bufferedWriter.flush();


        // 关闭流
        // close = flush + 关闭
        bufferedWriter.close();
        bufferedInputStream.close();
        socket.close();
        serverSocket.close();
    }
}

注意：

1. 关闭流会导致socket关闭
2. shutdownOutput会导致socket的outputStream关闭
3. 实际上客户端也有端口，这个端口是随机分配的
4. 程序会在read方法阻塞，直到接收到数据

UDP通信

UDP通信不需要建立连接，因此也没有客户端和服务器，只有发送者和接收者，且身份可以互换

UDP通信靠两个核心类DatagramSocket和DatagramPacket

DatagramSocket是用于通信的socket

DatagramPacket是发送和接收的数据包，需要把数据、接收方ip、接收方端口号等信息一起封装到DatagramPacket中，由socket发送，接收方收到DatagramPacket后，可以调用DatagramPacket提供的方法拆包，取出数据

代码示例：

// 用户1
public class UDPSender {
    public static void main(String[] args) throws IOException {
        // 创建socket
        DatagramSocket datagramSocket = new DatagramSocket(9998);
        
        // 发送数据
        byte[] data = "你好".getBytes();
        // 把数据、接收方ip、端口号一起封装到中
        datagramSocket.send(new DatagramPacket(data,data.length, InetAddress.getLocalHost(),9999));

        // 接收别人发来的DatagramPacket数据包
        DatagramPacket datagramPacket = new DatagramPacket(new byte[1024], 1024);
        datagramSocket.receive(datagramPacket);
        
        // 拆包取出数据，并打印到控制台
        System.out.println(new String(datagramPacket.getData(),0,datagramPacket.getLength()));

        // 关闭流
        datagramSocket.close();
    }
}
// 用户2
public class UDPReceive {
    public static void main(String[] args) throws IOException {
        // 创建socket
        DatagramSocket datagramSocket = new DatagramSocket(9999);

        // 接收DatagramPacket数据包
        byte[] buf = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(buf,buf.length);

        // 拆包取出数据
        datagramSocket.receive(datagramPacket);
        byte[] data = datagramPacket.getData();
        int length = datagramPacket.getLength();
        System.out.println(new String(data,0,length));

        // 回复信息
        byte[] bytes = "已收到信息".getBytes();
        // 把数据、接收方ip、端口号一起封装到中
        datagramSocket.send(new DatagramPacket(bytes,bytes.length, InetAddress.getLocalHost(),9998));

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

netstat指令

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

文件发送示例

public class Homework03Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("等待连接....");
        Socket accept = serverSocket.accept();
        System.out.println("连接成功！");

        // 读取文件名
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(accept.getInputStream()));
        String musicName = bufferedReader.readLine();
        String musicPath = "src\\" + musicName + ".mp3";
        System.out.println(musicPath);

        // 发送文件
        File music = new File(musicPath);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(accept.getOutputStream());
        if (music.exists()){
            // 返回指定音乐
            FileInputStream fileInputStream = new FileInputStream(music);
            byte[] buf = new byte[1024];
            int len;
            while ((len = fileInputStream.read(buf)) != -1){
                bufferedOutputStream.write(buf,0,len);
                bufferedOutputStream.flush();
            }
            fileInputStream.close();

        }else {
            // 返回默认音乐
            FileInputStream fileInputStream = new FileInputStream("src\\default.mp3");
            byte[] buf = new byte[1024];
            int len;
            while ((len = fileInputStream.read(buf)) != -1){
                bufferedOutputStream.write(buf,0,len);
                bufferedOutputStream.flush();
            }
            fileInputStream.close();
        }
        accept.shutdownOutput();

        // 关闭流
        bufferedOutputStream.close();
        bufferedReader.close();
        accept.close();
        serverSocket.close();
    }
}
public class Homework03Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入歌名：");
        String musicName = scanner.next();
        System.out.println(musicName);

        // 发送地址
        bufferedWriter.write(musicName);
        bufferedWriter.newLine();
        bufferedWriter.flush();

        // 接收文件
        BufferedInputStream bufferedInputStream = new BufferedInputStream(socket.getInputStream());
        FileOutputStream fileOutputStream = new FileOutputStream("e:\\" + musicName + ".mp3");
        byte[] buf = new byte[1024];
        int len;
        while ((len = bufferedInputStream.read(buf)) != -1){
            fileOutputStream.write(buf,0,len);
            fileOutputStream.flush();
        }

        // 关闭流
        fileOutputStream.close();
        bufferedInputStream.close();
        bufferedWriter.close();
        socket.close();

    }
}