chapter14 网络编程

最新推荐文章于 2024-10-11 15:53:58 发布
最新推荐文章于 2024-10-11 15:53:58 发布
阅读量3k 收藏
点赞数
分类专栏： Java之路 文章标签： 网络 udp http
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37091742/article/details/123576032
版权
本文详细介绍了网络通信的基础知识，包括双绞线、DNS解析、TCP/IP协议栈以及TCP和UDP的区别。通过Java编程展示了TCP和UDP的网络编程实践，包括建立连接、发送和接收数据、异常处理等。同时，通过实例演示了如何使用Socket和DatagramSocket进行双向通信和对象传输，最后讨论了多线程在服务器端处理用户请求的应用。
摘要由CSDN通过智能技术生成

引入

在这里插入图片描述
在这里插入图片描述

双绞线：
在这里插入图片描述
在这里插入图片描述

域名：www.baidu.com -------》DNS服务器解析---------》IP地址

设备之间进行传输的时候，必须遵照一定的规则-----》通信协议
在这里插入图片描述

TCP/IP

在这里插入图片描述

TCP、UDP

可靠的

建立连接：三次握手

释放连接：四次挥手
在这里插入图片描述
在这里插入图片描述

UDP 不可靠的，包是分开发的
在这里插入图片描述

InetAddress、InetSocketAddress类

InetAddress-------》封装了IP

InetSocketAddress----------》封装了IP，端口号
在这里插入图片描述

默认修饰符 只能在这个包下使用

public class TestIP {
    public static void main(String[] args) throws UnknownHostException {
        //封装IP：
        //InetAddress ia=new InetAddress();不能直接创建对象，因为InetAddress()被default修饰了 10.170.46.230
        InetAddress ia = InetAddress.getByName("10.170.46.230");
        System.out.println(ia);
        InetAddress ia1 = InetAddress.getByName("localhost");//localhost指代的是本机的ip地址
        System.out.println(ia1);
        InetAddress ia2 = InetAddress.getByName("127.0.0.1");//127.0.0.1指代的是本机的ip地址
        System.out.println(ia2);
        InetAddress ia3 = InetAddress.getByName("DESKTOP-MUG7H60");//封装计算机名
        System.out.println(ia3);
        InetAddress ia4 = InetAddress.getByName("www.mashibing.com");//封装域名
        System.out.println(ia4);
        System.out.println(ia4.getHostName());//www.mashibing.com获取域名
        System.out.println(ia4.getHostAddress());//8.142.18.182获取IP地址
    }
}

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

        InetAddress ia = isa.getAddress();//封装成InetAddress对象
        System.out.println(ia.getHostName());
        System.out.println(ia.getHostAddress());

    }
}

网络通信原理—套接字 socket

socket：应用层或取传输层的通信协议
在这里插入图片描述

基于TCP的网络编程

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

功能分解1：单向通信

客户端：

public class TestClient {
    public static void main(String[] args) throws IOException {
        //1.创建套接字：指定服务器的IP和端口号
        Socket s=new Socket("10.170.46.230",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 {
    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 s1 = dis.readUTF();
        System.out.println("客户端发送的："+s1);
        //5.关闭流+关闭网络资源
        dis.close();
        is.close();
        s.close();
        ss.close();
    }
}

测试：要先开启服务器，再开启客户端

先开客户端出错
在这里插入图片描述

功能分解2：双向通信

服务器：

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 s1 = dis.readUTF();
        System.out.println("客户端发送的："+s1);

        //像客户端输出一句话----》操作流----《输出流
        OutputStream os=s.getOutputStream();
        DataOutputStream dos=new DataOutputStream(os);
        dos.writeUTF("你好，我是服务器，我接收到你的请求了");

        //5.关闭流+关闭网络资源
        dos.close();
        os.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("10.170.46.230",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 s1 = dis.readUTF();
        System.out.println("服务器对我说："+s1);

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

注意：关闭防火墙，不然别人访问不到你

功能分解3：对象流传送

用户类：

public class User implements Serializable {//注意序列化，不然后续使用会报错
    private static final long serialVersionUID = 4743965775074617135L;
    private String id;
    private String pwd;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getPwd() {
        return pwd;
    }

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

    public User(String id, String pwd) {
        this.id = id;
        this.pwd = pwd;
    }
}

客户端：

public class TestClient {
    public static void main(String[] args) throws IOException {
        //1.创建套接字：指定服务器的IP和端口号
        Socket s=new Socket("10.170.46.230",8888);
        //录入用户的账号和密码
        Scanner sc=new Scanner(System.in);
        System.out.println("请录入您的账号：");
        String id=sc.next();
        System.out.println("请录入您的密码：");
        String pwd=sc.next();
        //将账号和密码封装成一个user类的对象
        User user=new User(id,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();
    }
}

服务器：

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);
        User user = (User) (ois.readObject());

        //对对象进行验证
        boolean flag=false;
        if(user.getId().equals("sky")&&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();
    }
}

功能分解4：加入完整、正确的异常处理方式

public class TestClient {
    public static void main(String[] args) {
        Socket s=null;
        OutputStream os=null;
        ObjectOutputStream oos=null;
        InputStream is=null;
        DataInputStream dis=null;
        try {
            //1.创建套接字：指定服务器的IP和端口号
             s= new Socket("10.170.46.230",8888);
            //录入用户的账号和密码
            Scanner sc=new Scanner(System.in);
            System.out.println("请录入您的账号：");
            String id=sc.next();
            System.out.println("请录入您的密码：");
            String pwd=sc.next();
            User user=new User(id,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-catch
            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();
            }
        }
    }
}

服务器端：

public class TestServer {
    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();
            //3.创建输入流
            is=s.getInputStream();
            ois=new ObjectInputStream(is);
            User user = (User) (ois.readObject());

            //对对象进行验证
            boolean flag=false;
            if(user.getId().equals("sky")&&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();
                }
                try {
                    if(s!=null){
                        s.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    if(ss!=null){
                        ss.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
}

功能分解5：多线程接收用户请求

线程：

public class ServerThread extends Thread {//线程：专门处理客户端的请求
    Socket s = null;
    InputStream is=null;
    ObjectInputStream ois=null;
    OutputStream os=null;
    DataOutputStream dos=null;

    public ServerThread(Socket s) {
        this.s = s;
    }

    @Override
    public void run() {
        try{

            is=s.getInputStream();
            ois=new ObjectInputStream(is);
            User user = (User) (ois.readObject());

            //对对象进行验证
            boolean flag=false;
            if(user.getId().equals("sky")&&user.getPwd().equals("123123")){
                flag=true;
            }

            //向客户端输出结果----》操作流----《输出流
            os=s.getOutputStream();
            dos=new DataOutputStream(os);
            dos.writeBoolean(flag);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (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();
            }
        }
    }
}

服务器：

public class TestServer {
    public static void main(String[] args) {
        System.out.println("服务器启动了！");
        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().getHostName());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        //服务器启动了！
        //当前是第1个用户访问，对应的用户是：DESKTOP-MUG7H60
        //当前是第2个用户访问，对应的用户是：DESKTOP-MUG7H60
    }
}

客户端和用户与功能分解3相同；

基于UDP的网络编程

TCP：客户端与服务器地位不平等

UDP：发送方与接收方的地位是平等的
在这里插入图片描述

UDP案例：完成网站的咨询聊天

功能分解1：单向通信

发送方：

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

        //关闭资源
        ds.close();
    }
}

接收方：

public class TestReceiver {//接收方
    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);//接收完以后dp里面就填充好内容了
        //4.取出数据
        byte[] data = dp.getData();
        String s=new String(data,0,dp.getLength());//dp.getLength()数据包中的有效长度

        System.out.println("学生说："+s);
        //5.关闭资源
        ds.close();
    }
}

功能分解2：双向通信

接收方：

public class TestReceiver {//接收方
    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);//接收完以后dp里面就填充好内容了
        //4.取出数据
        byte[] data = dp.getData();
        String s=new String(data,0,dp.getLength());//dp.getLength()数据包中的有效长度
        System.out.println("学生说："+s);
        //6.老师进行回复
        Scanner sc=new Scanner(System.in);
        System.out.print("老师可以回复了：");
        String str=sc.next();
        byte[] bytes=str.getBytes();
        //封装数据，并且指定学生的ip和端口号
        DatagramPacket dps=new DatagramPacket(bytes,bytes.length, InetAddress.getByName("10.170.46.230"),8888);
        ds.send(dps);

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

发送方：

public class TestSender {//发送方
    public static void main(String[] args) throws IOException {
        System.out.println("学生上线");
        InetAddress ia=InetAddress.getByName("10.170.46.230");
        //1.准备套接字：指定发送方端口号
        DatagramSocket ds=new DatagramSocket(8888);
        //2.准备数据包：
        System.out.print("学生可以说话了：");
        Scanner sc=new Scanner(System.in);
        String str=sc.next();

        byte[] bytes=str.getBytes();
        /*
        * 需要四个参数
        * 1、指的是传送数据转为byte数组
        * 2、byte数组的长度
        * 3、封装接收方的IP
        * 4、指定接收方的端口号
        * */
        DatagramPacket dp=new DatagramPacket(bytes,bytes.length,ia,9999);
        //4.发送：
        ds.send(dp);

        //6.接收老师发送的数据
        byte[] b=new byte[1024];
        DatagramPacket dp2=new DatagramPacket(b,b.length);//封装数组
        ds.receive(dp2);
        byte[] data = dp2.getData();//取出数据
        String s=new String(data,0,dp2.getLength());//dp2.getLength()数据包中的有效长度
        System.out.println("老师回复："+s);

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

功能分解3：异常处理

发送方：

public class TestSender {//发送方
    public static void main(String[] args)  {
        System.out.println("学生上线");

        //1.准备套接字：指定发送方端口号
        DatagramSocket ds= null;
        try {
            ds = new DatagramSocket(8888);
            //2.准备数据包：
            System.out.print("学生可以说话了：");
            Scanner sc=new Scanner(System.in);
            String str=sc.next();

            byte[] bytes=str.getBytes();
            /*
             * 需要四个参数
             * 1、指的是传送数据转为byte数组
             * 2、byte数组的长度
             * 3、封装接收方的IP
             * 4、指定接收方的端口号
             * */
            DatagramPacket dp=new DatagramPacket(bytes,bytes.length, InetAddress.getByName("10.170.46.230"),9999);
            //4.发送：
            ds.send(dp);

            //6.接收老师发送的数据
            byte[] b=new byte[1024];
            DatagramPacket dp2=new DatagramPacket(b,b.length);//封装数组
            ds.receive(dp2);
            byte[] data = dp2.getData();//取出数据
            String s=new String(data,0,dp2.getLength());//dp2.getLength()数据包中的有效长度
            System.out.println("老师回复："+s);
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //5.关闭资源
            ds.close();
        }
    }
}

接收方：

public class TestReceiver {//接收方
    public static void main(String[] args) {
        System.out.println("老师上线了");
        //1.创建套接字：指定接收方的端口
        DatagramSocket ds= null;
        try {
            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);
            //6.老师进行回复
            Scanner sc=new Scanner(System.in);
            System.out.print("老师可以回复了：");
            String str=sc.next();
            byte[] bytes=str.getBytes();
            //封装数据，并且指定学生的ip和端口号
            DatagramPacket dps=new DatagramPacket(bytes,bytes.length, InetAddress.getByName("10.170.46.230"),8888);
            ds.send(dps);
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //5.关闭资源
            ds.close();
        }
    }
}

功能分解4：完整正常通信

发送方：

public class TestSender {//发送方
    public static void main(String[] args)  {
        System.out.println("学生上线");

        //1.准备套接字：指定发送方端口号
        DatagramSocket ds= null;
        try {
            ds = new DatagramSocket(8888);
            //2.准备数据包：
            while (true){
                System.out.print("学生可以说话了：");
                Scanner sc=new Scanner(System.in);
                String str=sc.next();

                byte[] bytes=str.getBytes();
                /*
                 * 需要四个参数
                 * 1、指的是传送数据转为byte数组
                 * 2、byte数组的长度
                 * 3、封装接收方的IP
                 * 4、指定接收方的端口号
                 * */
                DatagramPacket dp=new DatagramPacket(bytes,bytes.length, InetAddress.getByName("10.170.46.230"),9999);
                //4.发送：
                ds.send(dp);
                if(str.equals("byebye")){
                    System.out.println("学生下线");
                    break;
                }

                //6.接收老师发送的数据
                byte[] b=new byte[1024];
                DatagramPacket dp2=new DatagramPacket(b,b.length);//封装数组
                ds.receive(dp2);
                byte[] data = dp2.getData();//取出数据
                String s=new String(data,0,dp2.getLength());//dp2.getLength()数据包中的有效长度
                System.out.println("老师回复："+s);
            }
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //5.关闭资源
            ds.close();
        }
    }
}

接收方：

public class TestReceiver {//接收方
    public static void main(String[] args) {
        System.out.println("老师上线了");
        //1.创建套接字：指定接收方的端口
        DatagramSocket ds= null;
        try {
            ds = new DatagramSocket(9999);
            //2.创建空数据包
            //有一个空的数据包，打算用来接收对方发送的数据包
            while(true){
                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(s.equals("byebye")){
                    System.out.println("学生下线了，老师也可以下线。");
                    break;
                }
                //6.老师进行回复
                Scanner sc=new Scanner(System.in);
                System.out.print("老师可以回复了：");
                String str=sc.next();
                byte[] bytes=str.getBytes();
                //封装数据，并且指定学生的ip和端口号
                DatagramPacket dps=new DatagramPacket(bytes,bytes.length, InetAddress.getByName("10.170.46.230"),8888);
                ds.send(dps);
            }
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //5.关闭资源
            ds.close();
        }
    }
}
sky-sto
关注
专栏目录
TCP/IP网络编程笔记Chapter I -2理解网络编程与套接字
shi_xiao_xuan的博客
05-16 426
TCP/IP网络编程笔记Chapter I -2理解网络编程与套接字1.网络编程与套接字2.流程（1）服务端--接电话套接字socket函数bind函数listen函数accept函数整理（2）客户端--打电话套接字connect函数2.服务端与客户端的调用顺序 1.网络编程与套接字 网络编程就是编写程序使两台联网的计算机相互交换数据，套接字是网络数据传输用的软件设备，是用来连接该网络的工具。 2.流程 套接字大致分为两种，我们把TCP套接字比做电话机，电话机可以同时拨打和接听，我们先讨论接听的套接字创建部
《Linux系统编程、网络编程》 第9章 高级IO
06-12
课程内容：1.非阻塞IO 如何将阻塞的读写设置为非阻塞的读写。2.文件锁 1）使用fcntl函数实现 2）使用flock函数实现3.多路IO select方式，poll方式。 4.异步IO5.存储映射
网络编程chapter1
奋斗的龙猫的博客
02-04 2071
文章目录1.2 计算机网络的概念1.3 OSI参考模型1.4 TCP/IP参考模型和TCP/IP协议IP协议子网划分发送数据包的过程域名TCP协议及端口1.5 Java编写客户/服务器程序 1.2 计算机网络的概念 1.3 OSI参考模型 OSI参考模型把网络分为了7层，分别是物理层，数据链路层，网络层，运输层，会话层，表示层，应用层。其中各层的功能如下: 物理层 物理层的任务就是为他上一层提供物理连接，以及规定通信节点之间的机械和电气等特性，如规定电缆和街头的类型。在这一层，数据作为原始的比特流传输。
Chapter 40 Socket网络编程
2302_80253507的博客
08-19 1277
在现代计算机网络中，Socket（套接字）是实现进程之间通信的重要工具。在网络应用中，Socket 充当了进程间数据传输的搬运工，负责进程之间的网络数据传输。无论是服务器还是客户端，二者通过 Socket 进行通信，形成了网络应用的基础。本章详细讲解了Socket服务端开发以及Socket客户端开发。
java基础-chapter18（网络编程）
weixin_53891720的博客
06-02 973
协议定义了数据在网络上传输的规则和格式。常见的网络协议包括TCP（Transmission Control Protocol，传输控制协议）和UDP（User Datagram Protocol，用户数据报协议）。TCP提供可靠的、面向连接的数据传输，而UDP则提供了无连接的、不可靠的数据传输。端口号范围从0到65535，其中0到1023是知名端口，用于常见的服务，比如HTTP服务使用端口号80。CS架构通常比BS架构性能更好，因为大部分业务逻辑和数据处理在客户端完成，减少了与服务器的交互次数。
unix网络编程-select函数
大草的博客
06-25 563
unix网络编程-select函数-服务端程序
JavaEE基础第14章网络编程
记录学习过程中的笔记
02-02 1021
第14章网络编程 等到JavaWeb阶段全是网络编程的内容 网络编程概述 一、网络编程中有两个主要的问题: 1.如何准确地定位网络上一台或多台主机；定位主机上的特定应用 2.找到主机后如何可靠高效地进行数据传输 二、网络编程中的两个要素： 1.对于问题一：IP 和 端口号 2.对应问题二：提供网络通信协议：TCP/IP参考模型（应用层、传输层、网络层、物理+数据链路层） IP和端口号的理解 三、通信要素一：IP和端口号 1.IP：唯一的标识Internet上的计算机（通信实体） 2.在Java中使用Inet
Java 网络编程 —— 安全网络通信
低吟不作语的博客
06-26 1501
SSL（Secure Socket Layer，安全套接字层）是一种保证网络上的两个节点进行安全通信的协议。IETF（Interet Engineering Task Force）国际组织对 SSL 作了标准化，制定了 RFC2246 规范，并将其称为传输层安全（Transport Layer Security，TLS）SSL 和 TLS 都建立在 TCP/IP 的基础上，一些应用层协议，如 HTTP 和 IMAP，都可以采用 SSL 来保证安全通信。
【网络编程】
weixin_45273750的博客
11-29 697
网络编程 软件结构 Client/Server（C/S结构） Browser/Server（B/S结构） Windows系统中执行命令： //查看占用8888端口号的进程PID netstat -aon|findstr 8888 //显示结果，找到占用8888端口号的PID TCP 0.0.0.0:8888 0.0.0.0:0 LISTENING 2696 //强制关闭（杀死） taskkill /F /pid 2696 注意，需要使用管理员的权限来运行命令窗口 Ubuntu系统中执行命令： //
GO网络编程（二）：客户端与服务端通信【重要】
技术卷的博客
10-03 1273
本节是新知识，偏应用，需要反复练习才能掌握。有五个部分：C/S通信示意图，服务端通信，客户端通信，通信测试，进阶练习：客户端间的通信
jdk6.0从入门到精通-----chapter5网络编程 新I/O（含源码下载）
07-27
本章节我们将深入探讨JDK 6.0中的网络编程，特别是新I/O（New I/O，NIO）的特性，这部分内容在Chapter 5中进行了详尽的阐述。 网络编程是Java应用中的关键部分，它允许程序通过网络进行通信，如发送和接收数据。在...
Windows网络编程技术.源代码
02-28
1. **Chapter01**：通常涵盖网络编程基础知识，如TCP/IP协议族，套接字（Socket）概念，以及如何在Windows平台上创建和初始化套接字。 2. **Chapter03**：可能深入讲解TCP连接的建立与断开，包括三次握手和四次挥手...
chapter14.rar精通Qt4编程(第2版)
12-19
4. **网络编程**：Qt提供了丰富的网络API，支持HTTP、FTP、TCP/IP等协议，使得在网络环境中开发应用变得简单。 5. **多线程**：Qt提供了线程支持，允许开发者同时执行多个任务，这对于资源密集型应用或需要并行处理...
【2024版】最新kali linux入门及常用简单工具介绍（非常详细）零基础入门到精通，收藏这一篇就够了_kalilinux
weixin_57514792的博客
10-07 1256
最新kali linux入门及常用简单工具介绍
WireShark过滤器
最新发布
ngczx的博客
10-11 534
Wireshark的过滤器规则可以分为**捕获过滤器**和**显示过滤器**，这两种过滤器有不同的编写规则
网络扫描模块python-nmap案例解析
we chat：玩转测试开发
10-07 480
它可以方便地在 Python 脚本中执行网络扫描，并解析 Nmap 的输出结果。python-nmap 模块是进行网络扫描的强大工具，通过简单的接口和丰富的功能，开发者可以轻松地在 Python 中集成网络安全检查和资产发现功能。6.1执行扫描：在 run_nmap_scan 函数中，创建了一个 nmap.PortScanner 实例，并使用 scan() 方法执行网络扫描。6.2 解析结果：扫描结果通过访问 scanner.all_hosts() 方法获取，并打印每个主机的状态和开放的端口信息。
《C++中实现高效网络流处理的关键技术与实践》
xy520521的博客
10-08 716
在一个简单的服务器程序中，如果使用阻塞式 I/O，当有大量客户端同时连接时，服务器需要为每个客户端创建一个线程，而这些线程大部分时间都处于阻塞状态，浪费了大量的系统资源。例如，Google 的 Protocol Buffers 和 Facebook 的 FlatBuffers 都是非常高效的序列化库，它们可以将数据序列化为紧凑的二进制格式，减少数据的传输量和序列化/反序列化的时间。在进行网络流处理时，可以对协议头进行优化，减少不必要的信息传输，提高数据传输的效率。选择合适的网络编程模型。
Note24100901_Portal_V18_Advanced5_Modscan的Modbus仿真
qq_51407861的博客
10-09 248
在这里插入图片描述](https://i-blog.csdnimg.cn/direct/8d85098268484044b2816d8a78c031f4.png#pic_center。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值