当前位置: 开发笔记 > 运维 > 正文

Java网络编程之基于TCP协议

作者：yuzhenhua09 | 来源：互联网 | 2022-10-16 18:46

本文主要将Java基于TCP的网络编程主要分解成5个功能：功能分解1:单向通信功能分解,2:双向通信功能分解,3:对象流传送功能分解,4:加入完整的处理异常方式功能分解,5:多线程接收用户请求,需要的朋友可以参考下

一、单向通信

功能：客户端发送一句话到服务器：

客户端：

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

服务器端：

public class TestServer {//服务器
    //这是一个main方法，是程序的入口：
    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.关闭流+关闭网络资源：
        dis.close();
        is.close();
        s.close();
        ss.close();
    }
}

测试：

先开启客户端还是先开启服务器：先开服务器，再开启客户端侧面验证：先开客户端：出错。

如图：

在这里插入图片描述

二、双向通信

客户端：

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

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

服务器端：

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

public class TestServer {//服务器
    //这是一个main方法，是程序的入口：
    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();
        os.close();
        dis.close();
        is.close();
        s.close();
        ss.close();
    }
}

注意：关闭防火墙

三、对象流传送

封装的User类：

import java.io.Serializable;

public class User implements Serializable {
    private static final long serialVersiOnUID= 9050691344308365540L;
    private String name;
    private String 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 User(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }
}

客户端：

import java.io.*;
import java.net.Socket;
import java.util.Scanner;

public class TestClient {//客户端
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws IOException {
        //1.创建套接字：指定服务器的ip和端口号：
        Socket s = new Socket("192.168.199.217",8888);
        //录入用户的账号和密码：
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入您的账号：");
        String name = sc.next();
        System.out.println("请录入您的密码：");
        String pwd = sc.next();
        //将账号和密码封装为一个User的对象：
        User user = new User(name,pwd);
        //2.对于程序员来说，向外发送数据 感受 --》利用输出流：
        OutputStream os = s.getOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(os);
        oos.writeObject(user);
        //接收服务器端的回话--》利用输入流：
        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();
        is.close();
        oos.close();
        os.close();
        s.close();
    }
}

服务器：

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

public class TestServer {//服务器
    //这是一个main方法，是程序的入口：
    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);
        //4.读取客户端发来的数据：
        User user = (User)(ois.readObject());
        //对对象进行验证：
        boolean flag = false;
        if(user.getName().equals("娜娜")&&user.getPwd().equals("123123")){
            flag = true;
        }
        //向客户端输出结果：---》操作流---》输出流
        OutputStream os = s.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        dos.writeBoolean(flag);
        //5.关闭流+关闭网络资源：
        dos.close();
        os.close();
        ois.close();
        is.close();
        s.close();
        ss.close();
    }
}

四、加入完整的处理异常方式

服务器端：

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

public class TestServer {//服务器
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //1.创建套接字： 指定服务器的端口号
        ServerSocket ss = null;
        Socket s = null;
        InputStream is = null;
        ObjectInputStream ois = null;
        OutputStream os = null;
        DataOutputStream dos = null;
        try {
            ss = new ServerSocket(8888);
            //2.等着客户端发来的信息：
            s = ss.accept();//阻塞方法:等待接收客户端的数据，什么时候接收到数据，什么时候程序继续向下执行。
            //accept()返回值为一个Socket，这个Socket其实就是客户端的Socket
            //接到这个Socket以后，客户端和服务器才真正产生了连接，才真正可以通信了
            //3.感受到的操作流：
            is = s.getInputStream();
            ois = new ObjectInputStream(is);
            //4.读取客户端发来的数据：
            User user = (User)(ois.readObject());
            //对对象进行验证：
            boolean flag = false;
            if(user.getName().equals("娜娜")&&user.getPwd().equals("123123")){
                flag = true;
            }
            //向客户端输出结果：---》操作流---》输出流
            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(os!=null){
                    os.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();
            }
        }
        
        
    }
}

客户端：

import java.io.*;
import java.net.Socket;
import java.util.Scanner;

public class TestClient {//客户端
    //这是一个main方法，是程序的入口：
    public static void main(String[] args){
        //1.创建套接字：指定服务器的ip和端口号：
        Socket s = null;
        OutputStream os = null;
        ObjectOutputStream oos = null;
        InputStream is = null;
        DataInputStream dis = null;
        try {
            s = new Socket("192.168.199.217",8888);
            //录入用户的账号和密码：
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入您的账号：");
            String name = sc.next();
            System.out.println("请录入您的密码：");
            String pwd = sc.next();
            //将账号和密码封装为一个User的对象：
            User user = new User(name,pwd);
            //2.对于程序员来说，向外发送数据 感受 --》利用输出流：
            os = s.getOutputStream();
            oos = new ObjectOutputStream(os);
            oos.writeObject(user);
            //接收服务器端的回话--》利用输入流：
            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(is!=null){
                    is.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();
            }
        }
    }
}

五、多线程接收用户请求

问题：

服务器针对一个请求服务，之后服务器就关闭了（程序自然结束了）

需要解决：

服务器必须一直在监听，一直开着，等待客户端的请求
在当前代码中，客户端不用动了

在这里插入图片描述

更改服务器代码：

服务器线程：

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

public class ServerThread extends Thread {//线程：专门处理客户端的请求
    InputStream is = null;
    ObjectInputStream ois = null;
    OutputStream os = null;
    DataOutputStream dos = null;
    Socket s = null;
    public ServerThread(Socket s){
        this.s = s;
    }
    @Override
    public void run() {
        try{
            //2.等着客户端发来的信息：
            is = s.getInputStream();
            ois = new ObjectInputStream(is);
            //4.读取客户端发来的数据：
            User user = (User)(ois.readObject());
            //对对象进行验证：
            boolean flag = false;
            if(user.getName().equals("娜娜")&&user.getPwd().equals("123123")){
                flag = true;
            }
            //向客户端输出结果：---》操作流---》输出流
            os = s.getOutputStream();
            dos = new DataOutputStream(os);
            dos.writeBoolean(flag);
        }catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }finally {
            try {
                if(dos!=null){
                    dos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(os!=null){
                    os.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();
            }
        }
    }
}

服务器端：

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

public class TestServer {//服务器
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        System.out.println("服务器启动了");
        //1.创建套接字： 指定服务器的端口号
        ServerSocket ss = null;
        Socket s = 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();
        }
    }
}

到此这篇关于Java网络编程之基于TCP协议的文章就介绍到这了,更多相关Java基于TCP的网络编程内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！

推荐阅读

服务器
深入剖析电子邮件系统的安全漏洞及防范措施

随着网络安全威胁的不断演变，电子邮件系统成为攻击者频繁利用的目标。本文详细探讨了电子邮件系统中的常见漏洞及其潜在风险，并提供了专业的防护建议。 ... [详细]

蜡笔小新 2024-12-25 17:59:04
服务器
MySQL 数据库迁移指南：从本地到远程及磁盘间迁移

本文详细介绍了如何在不同场景下进行 MySQL 数据库的迁移，包括从一个硬盘迁移到另一个硬盘、从一台计算机迁移到另一台计算机，以及解决迁移过程中可能遇到的问题。 ... [详细]

蜡笔小新 2024-12-26 13:21:38
service
微软Exchange服务器遭遇2022年版“千年虫”漏洞

微软Exchange服务器在新年伊始遭遇了一个类似于‘千年虫’的日期处理漏洞，导致邮件传输受阻。该问题主要影响配置了FIP-FS恶意软件引擎的Exchange 2016和2019版本。 ... [详细]

蜡笔小新 2024-12-25 14:08:03
服务器
掌握Java EE的全面指南

探讨如何真正掌握Java EE，包括所需技能、工具和实践经验。资深软件教学总监李刚分享了对毕业生简历中常见问题的看法，并提供了详尽的标准。 ... [详细]

蜡笔小新 2024-12-25 13:38:29
service
Windows服务与数据库交互问题解析

本文探讨了在Windows 10（64位）环境下开发的Windows服务，旨在定期向本地MS SQL Server (v.11)插入记录。尽管服务已成功安装并运行，但记录并未正确插入。我们将详细分析可能的原因及解决方案。 ... [详细]

蜡笔小新 2024-12-28 10:30:14
service
存储器层次结构、随机访问存储器与数据存取机制

理解存储器的层次结构有助于程序员优化程序性能，通过合理安排数据在不同层级的存储位置，提升CPU的数据访问速度。本文详细探讨了静态随机访问存储器（SRAM）和动态随机访问存储器（DRAM）的工作原理及其应用场景，并介绍了存储器模块中的数据存取过程及局部性原理。 ... [详细]

蜡笔小新 2024-12-27 12:06:47
service
利用存储过程构建年度日历表的详细指南

本文将介绍如何使用SQL存储过程创建一个完整的年度日历表。通过实例演示，帮助读者掌握存储过程的应用技巧，并提供详细的代码解析和执行步骤。 ... [详细]

蜡笔小新 2024-12-26 18:20:17
service
自学编程与计算机专业背景者的差异分析

本文探讨了自学编程者和计算机专业毕业生在技能、知识结构及职业发展上的不同之处，结合实际案例分析两者的优势与劣势。 ... [详细]

蜡笔小新 2024-12-26 17:53:18
service
Qt 环境下 SQLite 动态创建表的实现方法

SQLite 动态创建多个表的需求在网络上有不少讨论，但很少有详细的解决方案。本文将介绍如何在 Qt 环境中使用 QString 类轻松实现 SQLite 表的动态创建，并提供详细的步骤和示例代码。 ... [详细]

蜡笔小新 2024-12-26 15:11:34
service
微信8.0新功能解析：张小龙的创新与思考

阅读本文大约需要3分钟。微信8.0版本的发布带来了许多令人振奋的新功能，如烟花特效和改进的悬浮窗，引发了用户的热烈反响。 ... [详细]

蜡笔小新 2024-12-26 12:43:49
service
深入理解Java泛型：JDK 5的新特性

本文详细介绍了Java泛型的概念及其在JDK 5中的应用，通过具体代码示例解释了泛型的引入、作用和优势。同时，探讨了泛型类、泛型方法和泛型接口的实现，并深入讲解了通配符的使用。 ... [详细]

蜡笔小新 2024-12-26 11:15:56
service
程序员的心灵迷茫与自我探索

作为一名程序员，从大学步入职场后，常常感受到一种难以言喻的空虚感。这种感觉或许源于对生活的不满、职业发展的瓶颈，或是日常琐事带来的压力。本文将深入探讨这种复杂的情感，并尝试寻找解决之道。 ... [详细]

蜡笔小新 2024-12-26 11:08:05
service
深入解析：阿里实战 SpringCloud 微服务架构与应用

本文将详细介绍 SpringCloud 在微服务架构中的应用，涵盖入门、实战和案例分析。通过丰富的代码示例和实际项目经验，帮助读者全面掌握 SpringCloud 的核心技术和最佳实践。 ... [详细]

蜡笔小新 2024-12-26 03:50:43
service
并发编程：深入理解设计原理与优化

本文探讨了并发编程中的关键设计原则，特别是Java内存模型（JMM）的happens-before规则及其对多线程编程的影响。文章详细介绍了DCL双重检查锁定模式的问题及解决方案，并总结了不同处理器和内存模型之间的关系，旨在为程序员提供更深入的理解和最佳实践。 ... [详细]

蜡笔小新 2024-12-26 01:14:06
service
深入解析C++对象模型中的细节问题

本文深入探讨了C++对象模型中的一些细节问题，特别是虚拟继承和析构函数的处理。通过具体代码示例和详细分析，揭示了书中某些观点的不足之处，并提供了更合理的解释。 ... [详细]

蜡笔小新 2024-12-25 19:29:03

yuzhenhua09

这个家伙很懒，什么也没留下！

Tags | 热门标签

RankList | 热门文章