java 如何发送tcp心跳包并获取返回内容

转载

卫斯理 2024-10-29 13:36:47

文章标签 socket java 网络通信 udp 客户端 文章分类 Java 后端开发

文章目录

网络TCP，UDP基础
InetAddress,InetSocketAddress
TCP

模拟网站的登录，客户端录入账号密码，然后服务器端进行验证。

模拟：完成网站的咨询聊天

网络TCP，UDP基础

设备之间进行传输的时候，必须遵照一定的规则 —》通信协议：

java 如何发送tcp心跳包并获取返回内容_客户端

TCP协议：可靠建立连接，三次握手：

java 如何发送tcp心跳包并获取返回内容_udp_02

释放连接：四次挥手

java 如何发送tcp心跳包并获取返回内容_socket_03

UDP：并不可靠

InetAddress,InetSocketAddress

InetAddress： —>封装了IP

public class Test {
    public static void main(String[] args) throws UnknownHostException {
        //封装IP
        //InetAddress address = new InetAddress();不能直接创建对象，因为InetAddress()被default修饰了。
        InetAddress n = InetAddress.getByName("192.168.5.10");
        System.out.println(n);

        InetAddress n1 = InetAddress.getByName("localhost");
        System.out.println(n1);

        InetAddress n2 = InetAddress.getByName("DESKTOP------");
        System.out.println(n2);

        InetAddress n3 = InetAddress.getByName("www.baidu.com");
        System.out.println(n3);

        System.out.println(n2.getHostAddress());
        System.out.println(n.getHostName());
    }
}

InetSocketAddress: —>封装了IP，端口号

public class Test1 {
    public static void main(String[] args) {
        InetSocketAddress i = new InetSocketAddress("192.168.2.102", 8080);
        System.out.println(i);
        System.out.println(i.getHostName());
        System.out.println(i.getPort());

        InetAddress address = i.getAddress();
        System.out.println(address.getHostName());
        System.out.println(address.getHostAddress());
    }
}

TCP

模拟网站的登录，客户端录入账号密码，然后服务器端进行验证。

先开启客户端还是先开启服务器：先开服务器，再开启客户端

单向通信

public class TestClient {
    public static void main(String[] args) throws IOException {
        //1.创建套接字：指定服务器的ip和端口号：
        Socket s = new Socket("127.0.0.1",8888);
        //2.对于程序员来说，向外发送数据 感受 --》利用输出流：
        OutputStream os = s.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        //利用这个OutputStream就可以向外发送数据了，但是没有直接发送String的方法
        //所以我们又在OutputStream外面套了一个处理流：DataOutputStream
        dos.writeUTF("Hello World!你好，世界！");
        
        // 3.关闭流  +  关闭网络资源：
        dis.close();
        dos.close();
        os.close();
        s.close();
    }
}

public class TestServer {
    public static void main(String[] args) throws IOException {
        //1.创建套接字： 指定服务器的端口号
        ServerSocket ss = new ServerSocket(8888);
        //2.等着客户端发来的信息：
        Socket s = ss.accept();//阻塞方法:等待接收客户端的数据，什么时候接收到数据，什么时候程序继续向下执行。
        //accept()返回值为一个Socket，这个Socket其实就是客户端的Socket
        //接到这个Socket以后，客户端和服务器才真正产生了连接，才真正可以通信了
        //3.感受到的操作流：
        InputStream is = s.getInputStream();
        DataInputStream dis = new DataInputStream(is);
        //4.读取客户端发来的数据：
        String str = dis.readUTF();
        System.out.println("客户端发来的数据为："+str);

        //5.关闭流+关闭网络资源：
        dos.close();
        dis.close();
        is.close();
        s.close();
        ss.close();
    }
}

双向通信

public class TestClient {
    public static void main(String[] args) throws IOException {
        //1.创建套接字：指定服务器的ip和端口号：
        Socket s = new Socket("127.0.0.1",8888);
        //2.对于程序员来说，向外发送数据 感受 --》利用输出流：
        OutputStream os = s.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        //利用这个OutputStream就可以向外发送数据了，但是没有直接发送String的方法
        //所以我们又在OutputStream外面套了一个处理流：DataOutputStream
        dos.writeUTF("Hello World!你好，世界！");

        //接收服务端的会话-->输入流
        InputStream is = s.getInputStream();
        DataInputStream dis = new DataInputStream(is);
        System.out.println(dis.readUTF());


        // 3.关闭流  +  关闭网络资源：
        dis.close();
        dos.close();
        os.close();
        s.close();
    }
}

public class TestServer {
    public static void main(String[] args) throws IOException {
        //1.创建套接字： 指定服务器的端口号
        ServerSocket ss = new ServerSocket(8888);
        //2.等着客户端发来的信息：
        Socket s = ss.accept();//阻塞方法:等待接收客户端的数据，什么时候接收到数据，什么时候程序继续向下执行。
        //accept()返回值为一个Socket，这个Socket其实就是客户端的Socket
        //接到这个Socket以后，客户端和服务器才真正产生了连接，才真正可以通信了
        //3.感受到的操作流：
        InputStream is = s.getInputStream();
        DataInputStream dis = new DataInputStream(is);
        //4.读取客户端发来的数据：
        String str = dis.readUTF();
        System.out.println("客户端发来的数据为："+str);

        //向客户端输出一句话
        OutputStream os = s.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        dos.writeUTF("收到！");

        //5.关闭流+关闭网络资源：
        dos.close();
        dis.close();
        is.close();
        s.close();
        ss.close();
    }
}

对象流传送：完成登录功能

public class Users implements Serializable {
    private static final long serialVersionUID = -7978385655236428680L;
    private String name ;
    private String pwd ;

    public Users(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
}

public class TestClient {
    public static void main(String[] args) throws IOException {
        //1.创建套接字：指定服务器的ip和端口号：
        Socket s = new Socket("127.0.0.1",8888);

        //录入用户的帐号和密码
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入帐号：");
        String name = sc.next();
        System.out.print("请输入密码：");
        String pwd = sc.next();

        //将账号和密码封装成一个User对象
        Users users = new Users(name, pwd);

        //2.对于程序员来说，向外发送数据 感受 --》利用输出流：
        OutputStream os = s.getOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(os);
        oos.writeObject(users);

        //接收服务端的会话-->输入流
        InputStream is = s.getInputStream();
        DataInputStream dis = new DataInputStream(is);
        boolean b = dis.readBoolean();
        if (b){
            System.out.println("登录成功!");
        }else {
            System.out.println("登录失败！");
        }

        // 3.关闭流  +  关闭网络资源：
        dis.close();
        oos.close();
        os.close();
        s.close();
    }
}

public class TestServer {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.创建套接字： 指定服务器的端口号
        ServerSocket ss = new ServerSocket(8888);
        //2.等着客户端发来的信息：
        Socket s = ss.accept();//阻塞方法:等待接收客户端的数据，什么时候接收到数据，什么时候程序继续向下执行。
        //accept()返回值为一个Socket，这个Socket其实就是客户端的Socket
        //接到这个Socket以后，客户端和服务器才真正产生了连接，才真正可以通信了
        //3.感受到的操作流：
        InputStream is = s.getInputStream();
        ObjectInputStream ois = new ObjectInputStream(is);
        Users users = (Users)ois.readObject();

        boolean flag = false;
        if (users.getName().equals("lili")&& users.getPwd().equals("123")){
            flag = true;
        }

        //向客户端输出一句话-->输出结果
        OutputStream os = s.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        dos.writeBoolean(flag);

        //5.关闭流+关闭网络资源：
        dos.close();
        ois.close();
        is.close();
        s.close();
        ss.close();
    }
}

为上述代码功能加入完整的处理异常方式

public class TestClient {
    public static void main(String[] args) {
        Socket s = null;
        OutputStream os = null;
        ObjectOutputStream oos = null;
        DataInputStream dis = null;
        //1.创建套接字：指定服务器的ip和端口号：
        try {
            s = new Socket("127.0.0.1",8888);
            //录入用户的帐号和密码
            Scanner sc = new Scanner(System.in);
            System.out.print("请输入帐号：");
            String name = sc.next();
            System.out.print("请输入密码：");
            String pwd = sc.next();

            //将账号和密码封装成一个User对象
            Users users = new Users(name, pwd);

            //2.对于程序员来说，向外发送数据 感受 -->利用输出流：
            os = s.getOutputStream();
            oos = new ObjectOutputStream(os);
            oos.writeObject(users);

            //接收服务端的会话-->输入流
            InputStream is = s.getInputStream();
            dis = new DataInputStream(is);
            boolean b = dis.readBoolean();
            if (b){
                System.out.println("登录成功!");
            }else {
                System.out.println("登录失败！");
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3.关闭流  +  关闭网络资源：
            try {
                if (dis!=null)
                dis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (oos!=null)
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (os!=null)
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (s!=null) {
                    s.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

```java
public class TestServer {
    public static void main(String[] args){
        //1.创建套接字： 指定服务器的端口号
        ServerSocket ss = null;
        Socket s = null;
        InputStream is = null;
        ObjectInputStream ois = null;
        DataOutputStream dos = null;
        try {
            ss = new ServerSocket(8888);

            //2.等着客户端发来的信息：
            s = ss.accept();//阻塞方法:等待接收客户端的数据，什么时候接收到数据，什么时候程序继续向下执行。
            
            is = s.getInputStream();
            ois = new ObjectInputStream(is);
            Users users = (Users)ois.readObject();

            boolean flag = false;
            if (users.getName().equals("lili")&& users.getPwd().equals("123")){
                flag = true;
            }

            //向客户端输出一句话-->输出结果
            OutputStream os = s.getOutputStream();
            dos = new DataOutputStream(os);
            dos.writeBoolean(flag);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally{
            //5.关闭流+关闭网络资源：
            try {
                if (dos!=null){
                    dos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (ois!=null)
                    ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (is!=null)
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (s!=null)
                s.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (ss!=null)
                ss.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

多线程接收用户请求

可以看到上面代码经过一次客户端请求之后，服务器便就停止运行了，所以将代码改为多线程接收用户请求。即服务器针对一个请求服务，之后服务器就关闭了（程序自然结束了）
现在需要解决：服务器必须一直在监听，一直开着，等待客户端的请求

在当前代码中，客户端不用动了
修改之后的服务器端：

public class TestServer {
    public static void main(String[] args){
        System.out.println("服务器启动了");
        //1.创建套接字： 指定服务器的端口号
        Socket s = null;
        ServerSocket ss = null;
        int count = 0;
        try {
            ss = new ServerSocket(8888);
            while (true){//加入死循环，服务器一直监听客户端是否发送数据
                //阻塞方法:等待接收客户端的数据，什么时候接收到数据，什么时候程序继续向下执行。
                s = ss.accept();
                //每次过来的客户端的请求 靠 线程处理：
                new ServerThread(s).start();
                count++;
                System.out.println("当前是第"+count+
                        "个用户访问我们的服务器，对应的用户是："+
                        s.getInetAddress());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            try {
                if (ss!=null) {
                    ss.close();
                }
            }catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (s!=null) {
                    s.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

新增线程类来处理客户端需求

public class ServerThread  extends Thread{//线程：专门处理客户端请求

    ServerSocket ss = null;
    Socket s = null;
    InputStream is = null;
    ObjectInputStream ois = null;
    DataOutputStream dos = null;
    public ServerThread(Socket s){
        this.s = s ;
    }
    @Override
    public void run() {
        try {
            //3.感受到的操作流：
            is = s.getInputStream();
            ois = new ObjectInputStream(is);
            Users users = (Users)ois.readObject();

            boolean flag = false;
            if (users.getName().equals("lili")&& users.getPwd().equals("123")){
                flag = true;
            }

            //向客户端输出一句话-->输出结果
            OutputStream os = s.getOutputStream();
            dos = new DataOutputStream(os);
            dos.writeBoolean(flag);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            //5.关闭流+关闭网络资源：
            try {
                if (dos!=null){
                    dos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (ois!=null)
                    ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (is!=null)
                    is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (ss!=null)
                    ss.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

UDP

模拟：完成网站的咨询聊天

注意先启动接收方，后启动发送方，不然发送方发的数据会丢失

单向通信：学生向老师发送信息

public class TestReceive {
    public static void main(String[] args) throws IOException {
        System.out.println("老师上线了。");
        //1.创建套接字：指定接收方的端口
        DatagramSocket ds = new DatagramSocket(9999);
        //2.有一个空的数据包，打算用来接收对方传过来的数据包
        byte[] b = new byte[1024];
        DatagramPacket dp = new DatagramPacket(b,b.length);
        //3.接受对方的数据包，然后放入我们的dp数据包中填充
        ds.receive(dp);

        //4.取出数据
        byte[] data = dp.getData();
        String s = new String(data,0,dp.getLength());//dp.getLength()数组包中的有效长度
        System.out.println("学生对我说："+s);

        //5. 关闭
        ds.close();
    }
}

public class TestSend {
    public static void main(String[] args) throws IOException {
        System.out.println("学生上线。");
        //1.准备套接字，指定发送方的端口
        DatagramSocket ds = new DatagramSocket(8888);
        //2.准备数据包
        String str = "Hello World!你好，世界！";
        byte[] bytes = str.getBytes();
        /*
        需要四个参数：
        1.指的是传送数据转为字节数组
        2.字节数组的长度
        3.封装接收方的IP
        4.指定接收方的端口号
         */
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),9999);
        ds.send(dp);
        //关闭资源
        ds.close();

    }

}

双向通信：老师给学生发，学生给老师发

public class TestSend {//发送方：
    //这是一个main方法，是程序的入口：
    public static void main(String[] args){
        System.out.println("学生上线。。。");
        //1.准备套接字： 指定发送方的端口号
        try (DatagramSocket ds = new DatagramSocket(8888)) {
            //2.准备数据包
            Scanner sc = new Scanner(System.in);
            System.out.print("学生：");
            String str = sc.next();
            byte[] bytes = str.getBytes();
        /*
        需要四个参数：
        1.指的是传送数据转为Z字节数组
        2.字节数组的长度
        3.封装接收方的ip
        4.指定接收方的端口号
         */
            DatagramPacket dp = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("localhost"), 9999);
            //发送：
            ds.send(dp);
            //接收老师发送回来的信息：
            byte[] b = new byte[1024];
            DatagramPacket dp2 = new DatagramPacket(b, b.length);
            ds.receive(dp2);//接收完以后 dp2里面就填充好内容了
            //取出数据：
            byte[] data = dp2.getData();
            String s = new String(data, 0, dp2.getLength());//dp.getLength()数组包中的有效长度
            System.out.println("老师对我说：" + s);

        } catch (IOException e) {
            e.printStackTrace();
        }
        //关闭资源

    }
}

public class TestReceive {//接收方
    //这是一个main方法，是程序的入口：
    public static void main(String[] args){
        System.out.println("老师上线了。。");
        //1.创建套接字：指定接收方的端口
        try (DatagramSocket ds = new DatagramSocket(9999)) {
            //2.有一个空的数据包，打算用来接收  对方传过来的数据包：
            byte[] b = new byte[1024];
            DatagramPacket dp = new DatagramPacket(b, b.length);
            //3.接收对方的数据包，然后放入我们的dp数据包中填充
            ds.receive(dp);//接收完以后 dp里面就填充好内容了
            //4.取出数据：
            byte[] data = dp.getData();
            String s = new String(data, 0, dp.getLength());//dp.getLength()数组包中的有效长度
            System.out.println("学生对我说：" + s);
            //老师进行回复：
            Scanner sc = new Scanner(System.in);
            System.out.print("老师：");
            String str = sc.next();
            byte[] bytes = str.getBytes();
            //封装数据，并且指定学生的ip和端口号
            DatagramPacket dp2 = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("localhost"), 8888);
            //发送：
            ds.send(dp2);

        } catch (IOException e) {
            e.printStackTrace();
        }
        //5.关闭资源：
    }
}

完整通信

public class TestSend {//发送方：
    //这是一个main方法，是程序的入口：
    public static void main(String[] args){
        System.out.println("学生上线。。。");
        //1.准备套接字： 指定发送方的端口号
        try (DatagramSocket ds = new DatagramSocket(8888)) {
            while (true) {
                //2.准备数据包
                Scanner sc = new Scanner(System.in);
                System.out.print("学生：");
                String str = sc.next();
                byte[] bytes = str.getBytes();
        /*
        需要四个参数：
        1.指的是传送数据转为Z字节数组
        2.字节数组的长度
        3.封装接收方的ip
        4.指定接收方的端口号
         */
                DatagramPacket dp = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("localhost"), 9999);
                //发送：
                ds.send(dp);
                if ("byebye".equals(str)){
                    System.out.println("学生下线了。");
                    break;
                }
                //接收老师发送回来的信息：
                byte[] b = new byte[1024];
                DatagramPacket dp2 = new DatagramPacket(b, b.length);
                ds.receive(dp2);//接收完以后 dp2里面就填充好内容了
                //取出数据：
                byte[] data = dp2.getData();
                String s = new String(data, 0, dp2.getLength());//dp.getLength()数组包中的有效长度
                System.out.println("老师对我说：" + s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class TestReceive {//接收方
    //这是一个main方法，是程序的入口：
    public static void main(String[] args){
        System.out.println("老师上线了。。");
        //1.创建套接字：指定接收方的端口
        try (DatagramSocket ds = new DatagramSocket(9999)) {
            while (true){
                //2.有一个空的数据包，打算用来接收  对方传过来的数据包：
                byte[] b = new byte[1024];
                DatagramPacket dp = new DatagramPacket(b, b.length);
                //3.接收对方的数据包，然后放入我们的dp数据包中填充
                ds.receive(dp);//接收完以后 dp里面就填充好内容了
                //4.取出数据：
                byte[] data = dp.getData();
                String s = new String(data, 0, dp.getLength());//dp.getLength()数组包中的有效长度
                System.out.println("学生对我说：" + s);
                if ("byebye".equals(s)){
                    System.out.println("学生下线了，老师也下了");
                    break;
                }
                //老师进行回复：
                Scanner sc = new Scanner(System.in);
                System.out.print("老师：");
                String str = sc.next();
                byte[] bytes = str.getBytes();
                //封装数据，并且指定学生的ip和端口号
                DatagramPacket dp2 = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("localhost"), 8888);
                //发送：
                ds.send(dp2);

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

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。