网络编程

网络编程中的要素

IP和端口号
网络通信协议 TCP、UDP

IP

ip地址：inetaddress

定位计算机
本机：localhost 127.0.0.1
IP地址分类
- IPV4：4个字节组成：127.0.0.1
- IPV6：8个无符号整数：1234:33aa:cd98:46bc:991a:782d:3267:88a1
- 公网（互联网）-私网（局域网）

代码测试

package com.internet;

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

public class TestInetAddress {
    public static void main(String[] args) {
        //测试IP
        try {
            //查询本机地址
            InetAddress inetAddress01 = InetAddress.getByName("127.0.0.1");
            System.out.println(inetAddress01);
            InetAddress inetAddress02 = InetAddress.getByName("localHost");
            System.out.println(inetAddress02);
            InetAddress inetAddress03 = InetAddress.getLocalHost();
            System.out.println(inetAddress03);

            //查询网站ip地址
            InetAddress inetAddress04 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress04);

            //常用方法
            System.out.println(inetAddress04.getAddress());
            System.out.println(inetAddress04.getHostAddress());//获取IP
            System.out.println(inetAddress04.getHostName());//获取域名
            System.out.println(inetAddress04.getCanonicalHostName());

        } catch (UnknownHostException e) {
            throw new RuntimeException(e);
        }
    }
}

端口

端口表示计算机上的一个程序的进程：

不同的进程有不同的端口，用来区分软件
规定端口号区间：0~65535
TCP、UDP：单个协议下，端口号不能冲突
端口分类：
- 公有端口0~1023
  - HTTP：80
  - HTTPS：443
  - FTP：21
  - Telnet：23
- 程序注册端口：1024~49151，分配用户或者程序
  - Tomcat：8080
  - MySQL：3306
  - Oracle：1521
- 动态、私有端口：49152~65535
```
netstat -ano//查看所有端口
netstat -ano|finstr "6255"//查看指定端口
tasklist|findstr "9903"//查看指定端口进程
```

通信协议

TCP/UDP协议簇

TCP：用户传输协议
UDP：用户数据报协议

IP协议：网络互连协议

TCP UDP对比：

TCP
- 面向连接，稳定
- 三次握手，四次挥手
  - 三次握手
    - 图解：
    - 1, TCP服务器进程先创建传输控制块TCB, 时刻准备接受客户端进程的连接请求, 此时服务器就进入了 LISTEN（监听）状态
    - 2, TCP客户端进程也是先创建传输控制块TCB, 然后向服务器发出连接请求报文，此时报文首部中的同步标志位SYN=1, 同时选择一个初始序列号 seq = x, 此时，TCP客户端进程进入了 SYN-SENT（同步已发送状态）状态。TCP规定, SYN报文段（SYN=1的报文段）不能携带数据，但需要消耗掉一个序号。
    - 3, TCP服务器收到请求报文后, 如果同意连接, 则发出确认报文。确认报文中的 ACK=1, SYN=1, 确认序号是 x+1, 同时也要为自己初始化一个序列号 seq = y, 此时, TCP服务器进程进入了SYN-RCVD（同步收到）状态。这个报文也不能携带数据, 但是同样要消耗一个序号。
    - 4, TCP客户端进程收到确认后还, 要向服务器给出确认。确认报文的ACK=1，确认序号是 y+1，自己的序列号是 x+1.
    - 5, 此时，TCP连接建立，客户端进入ESTABLISHED（已建立连接）状态。当服务器收到客户端的确认后也进入ESTABLISHED状态，此后双方就可以开始通信了。
  - 四次挥手
    - 图解：
    - 1, 客户端进程发出连接释放报文，并且停止发送数据。释放数据报文首部，FIN=1，其序列号为seq=u（等于前面已经传送过来的数据的最后一个字节的序号加1），此时客户端进入FIN-WAIT-1（终止等待1）状态。 TCP规定，FIN报文段即使不携带数据，也要消耗一个序号。
    - 2, 服务器收到连接释放报文，发出确认报文，ACK=1，确认序号为 u+1，并且带上自己的序列号seq=v，此时服务端就进入了CLOSE-WAIT（关闭等待）状态。 TCP服务器通知高层的应用进程，客户端向服务器的方向就释放了，这时候处于半关闭状态，即客户端已经没有数据要发送了，但是服务器若发送数据，客户端依然要接受。这个状态还要持续一段时间，也就是整个CLOSE-WAIT状态持续的时间。
    - 3, 客户端收到服务器的确认请求后，此时客户端就进入FIN-WAIT-2（终止等待2）状态，等待服务器发送连接释放报文（在这之前还需要接受服务器发送的最终数据）
    - 4, 服务器将最后的数据发送完毕后，就向客户端发送连接释放报文，FIN=1，确认序号为v+1，由于在半关闭状态，服务器很可能又发送了一些数据，假定此时的序列号为seq=w，此时，服务器就进入了LAST-ACK（最后确认）状态，等待客户端的确认。
    - 5, 客户端收到服务器的连接释放报文后，必须发出确认，ACK=1，确认序号为w+1，而自己的序列号是u+1，此时，客户端就进入了TIME-WAIT（时间等待）状态。注意此时TCP连接还没有释放，必须经过2∗MSL（最长报文段寿命）的时间后，当客户端撤销相应的TCB后，才进入CLOSED状态。
    - 6, 服务器只要收到了客户端发出的确认，立即进入CLOSED状态。同样，撤销TCB后，就结束了这次的TCP连接。可以看到，服务器结束TCP连接的时间要比客户端早一些。
- 客户端，服务端
- 传输完成，释放连接，效率低
UDP
- 不面向连接，不稳定
- 客户端、服务端没有明确的界限
- DDOS：洪水攻击（饱和攻击）

TCP

测试客户端-服务端建立连接

package com.internet.demo02;

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

//服务端
public class TcpServerDemo01 {

    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            //1、服务端地址
            serverSocket = new ServerSocket(9999);
            //2、等待客户端发起连接
            socket = serverSocket.accept();
            //3、3读取客户端信息
            is = socket.getInputStream();
            //4、管道流
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }

            System.out.println(baos.toString());


        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            //关闭流

            if (baos != null) {
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }


        }
    }
}

package com.internet.demo02;

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

//客户端
public class TcpClientDemo01 {

    public static void main(String[] args) {
        Socket socket = null;
        OutputStream os = null;
        try {
            //1、服务端地址
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            //2、端口号
            int port = 9999;
            //3、创建一个socket连接
            socket = new Socket(serverIP, port);
            //4、发送信息 IO流
            os = socket.getOutputStream();
            os.write("你好，欢迎测试TCP三次握手".getBytes());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭流
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

上传文件

服务器端

package com.internet.demo02;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPServerDemo02 {
    public static void main(String[] args) throws Exception {
        //1、创建服务
        ServerSocket serverSocket = new ServerSocket(9000);

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

        //3、获取输入流
        InputStream is = socket.getInputStream();

        //4、文件输出
        FileOutputStream fos = new FileOutputStream(new File("D:\\receive.txt"));
        byte[] bytes = new byte[1024];
        int len;
        while ((len = is.read(bytes)) != -1) {
            fos.write(bytes, 0, len);
        }

        //通知客户端接收完毕
        OutputStream os = socket.getOutputStream();
        os.write("我接收完毕，你可以断开了".getBytes());

        //5、关闭流
        os.close();
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();

    }
}

客户端

package com.internet.demo02;

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

public class TcpClientDemo02 {
    public static void main(String[] args) throws Exception {
        //1、创建一个socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);

        //2、创建一个输出流
        OutputStream outputStream = socket.getOutputStream();

        //3、读取文件
        FileInputStream fileInputStream = new FileInputStream(new File("D:\\news01.txt"));

        //4、写出文件
        byte[] bytes = new byte[1024];
        int len;
        while ((len = fileInputStream.read(bytes)) != -1) {
            outputStream.write(bytes, 0, len);
        }

        //通知服务器，我这边已经结束了
        socket.shutdownOutput();

        //确定服务接收完毕，才能断开连接
        InputStream is = socket.getInputStream();


        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        byte[] bytes1 = new byte[1024];
        int len1;
        while ((len1 = is.read(bytes1)) != -1) {
            baos.write(bytes1, 0, len1);
        }

        System.out.println(baos.toString());

        //5、关闭流
        baos.close();
        is.close();
        fileInputStream.close();
        outputStream.close();
        socket.close();

    }
}

UDP

发送端：

package com.internet.demo03;

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

public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception {
        //1、建立一个socket
        DatagramSocket socket = new DatagramSocket();

        //2、建个包
        String msg = "你好啊，服务器";
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9999;

        //参数：数组，数组起始点，数组终点，接收者，端口
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);

        //3、发送包
        socket.send(packet);
    }
}

接收端

package com.internet.demo03;

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

public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception {
        //开放端口
        DatagramSocket socket = new DatagramSocket(9999);

        //接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);

        socket.receive(packet);//阻塞接收

        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(), 0, packet.getLength()));

        //关闭连接
        socket.close();
    }
}

发送消息

发送方：

package com.internet.chat;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class UdpSenderDemo01 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(8888);

        //控制台读取system.in
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));


        while (true) {
            String data = reader.readLine();
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress("localhost", 6666));

            socket.send(packet);

            if (data.equals("bye")) {
                break;
            }
        }
        socket.close();

    }
}

接收方：

package com.internet.chat;


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

public class UdpReceiveDemo01 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(6666);

        while (true) {

            //接收包裹
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            socket.receive(packet);

            //断开连接
            byte[] data = packet.getData();
            String receiveData = new String(data, 0, data.length);

            System.out.println(receiveData);

            if (receiveData.equals("bye")) {
                break;
            }

        }
        socket.close();
    }
}

实现聊天

package com.internet.chat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class TalkSend implements Runnable {

    DatagramSocket socket = null;
    BufferedReader reader = null;

    private int fromIP;
    private String toIP;
    private int toPort;

    public TalkSend(int fromIP, String toIP, int toPort) {
        this.fromIP = fromIP;
        this.toIP = toIP;
        this.toPort = toPort;

        try {
            socket = new DatagramSocket(fromIP);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }


    @Override
    public void run() {

        while (true) {
            try {
                String data = reader.readLine();
                byte[] datas = data.getBytes();
                DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress(this.toIP, this.toPort));

                socket.send(packet);
                if (data.equals("bye")) {
                    break;
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

package com.internet.chat;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class TalkReceive implements Runnable {
    DatagramSocket socket = null;
    private int port;
    private String msgFrom;

    public TalkReceive(int port, String msgFrom) {
        this.port = port;
        this.msgFrom = msgFrom;

        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {

        while (true) {

            try {
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);
                socket.receive(packet);

                //断开连接
                byte[] data = packet.getData();
                String receiveData = new String(data, 0, data.length);

                System.out.println(msgFrom + ":" + receiveData);

                if (receiveData.equals("bye")) {
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
        socket.close();
    }
}

测试：

package com.internet.chat;

public class TalkStudent {
    public static void main(String[] args) {

        //开两个线程
        new Thread(new TalkSend(7777, "localhost", 9999)).start();
        new Thread(new TalkReceive(8888, "老师")).start();

    }
}

package com.internet.chat;

public class TalkTeacher {
    public static void main(String[] args) {

        new Thread(new TalkSend(5555, "localhost", 8888)).start();
        new Thread(new TalkReceive(9999, "学生")).start();
    }
}

URL

协议：//IP地址：端口/项目名/资源

posted @ 2022-08-05 14:48 每年桃花开的时候阅读(44) 评论(0) 收藏举报

刷新页面返回顶部

xiaojian1995

网络编程

网络编程中的要素

IP

代码测试

端口

通信协议

TCP

测试客户端-服务端建立连接

上传文件

UDP

发送消息

实现聊天

URL

公告