第16章_网络编程拓展练习(TCP编程,UDP编程)

这篇具有很好参考价值的文章主要介绍了第16章_网络编程拓展练习(TCP编程,UDP编程)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

第16章_网络编程拓展练习


TCP编程

1、学生与老师交互

案例:客户端模拟学生咨询,服务器端模拟咨询老师,进行交互。

客户端收到信息:

​ 欢迎咨询尚硅谷!

​ 这个月的所有期班都已经满了,只能报下一个月的了!

第16章_网络编程拓展练习(TCP编程,UDP编程),JavaSE拓展练习,网络,tcp/ip,udp,网络编程

服务器端收到信息:

​ 你好,我想报名这个月的JavaEE就业班!

​ 好的,赶紧给我占个座!

第16章_网络编程拓展练习(TCP编程,UDP编程),JavaSE拓展练习,网络,tcp/ip,udp,网络编程

提示:

(1)如果是一个客户端与服务器端交互,怎么实现

(2)如果是多个客户端与服务器交互,怎么实现

package com.atguigu.exercise1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;

public class Exercise1Client {
    public static void main(String[] args) {
        Socket socket = null; // 创建Socket指定ip地址和端口号
        PrintStream ps = null;
        try {
            socket = new Socket("127.0.0.1", 8888);
            // 获取输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            System.out.println(br.readLine());

            // 获取输出流
            ps = new PrintStream(socket.getOutputStream());
            ps.println("你好,我想报名这个月的JavaEE就业班!");

            System.out.println(br.readLine());

            ps.println("好的,赶紧给我占个座!");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (ps != null)
                ps.close();
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

(1)服务端接收1个客户端访问

package com.atguigu.exercise1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.time.LocalDateTime;

public class Exercise1Server {
    public static void main(String[] args) {
        ServerSocket server = null;
        Socket socket = null;
        try {
            server = new ServerSocket(8888);
            socket = server.accept();

            // 获取输出流
            PrintStream ps = new PrintStream(socket.getOutputStream());
            ps.println("欢迎咨询尚硅谷!");

            // 获取输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            System.out.println(socket.getInetAddress().getHostAddress() + "留言:" + LocalDateTime.now());
            System.out.println(br.readLine() + "\n");

            ps.println("这个月的所有期班都已经满了,只能报下一个月的了!");

            System.out.println(socket.getInetAddress().getHostAddress() + "留言:" + LocalDateTime.now());
            System.out.println(br.readLine());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (socket != null)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (server != null)
                    server.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

(2)服务端接收多个客户端访问

package com.atguigu.exercise1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.time.LocalDateTime;

public class Exercise1 {
	public static void main(String[] args) {
        ServerSocket server = null;
        try {
            server = new ServerSocket(8888);
            boolean flag = true;
            while (flag) {
                Socket socket = server.accept();
                new Thread() {
                    public void run() {
                        try {
                            // 获取输出流
                            PrintStream ps = new PrintStream(socket.getOutputStream());
                            ps.println("欢迎咨询尚硅谷");

                            // 获取输入流
                            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                            System.out.println(socket.getInetAddress().getHostAddress() + "留言:" + LocalDateTime.now());
                            System.out.println(br.readLine() + "\n");

                            ps.println("这个月的所有期班都已经满了,只能报下一个月的了!");

                            System.out.println(socket.getInetAddress().getHostAddress() + "留言:" + LocalDateTime.now());
                            System.out.println(br.readLine());

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

2、查询单词

案例:模拟客户端输入要查询的中文,服务器返回对应的英文单词

效果如下:

第16章_网络编程拓展练习(TCP编程,UDP编程),JavaSE拓展练习,网络,tcp/ip,udp,网络编程

第16章_网络编程拓展练习(TCP编程,UDP编程),JavaSE拓展练习,网络,tcp/ip,udp,网络编程

开发提示:

(1)服务器端有一个map,key是中文词语,value是对应的单词

(2)服务器接收到客户端的词语后,从map中get,如果可以找到,就返回单词,如果找不到,就返回“没有找到”

package com.atguigu.exercise2;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;

public class Exercise2Server {
	public static void main(String[] args) {
        ServerSocket server = null;
        Socket socket = null;
        try {
            HashMap<String, String> dictionary = new HashMap<String, String>();
            dictionary.put("星期一", "Monday");
            dictionary.put("星期二", "Tuesday");
            dictionary.put("星期三", "Wednesday");
            dictionary.put("星期四", "Thursday");
            dictionary.put("星期五", "Friday");
            dictionary.put("星期六", "Saturday");
            dictionary.put("星期七", "Sunday");
            //...

            server = new ServerSocket(8888);
            socket = server.accept();

            // 获取输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            // 获取输出流
            PrintStream ps = new PrintStream(socket.getOutputStream());

            //接收客户端的中文
            String key = br.readLine();
            //查询对应的英文单词,并返回结果
            String words = dictionary.get(key);
            if (words != null) {
                ps.println(words);
            } else {
                ps.println("o(╥﹏╥)o没有找到对应的单词!");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (socket != null)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (server != null)
                    server.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

package com.atguigu.exercise2;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

public class Exercise2Client {
	public static void main(String[] args) {
        Socket socket = null;
        Scanner input = null;
        try {
            // 创建Socket指定ip地址和端口号
            socket = new Socket("127.0.0.1", 8888);

            input = new Scanner(System.in);
            System.out.print("请输入要查询的词语:");
            String content = input.next();

            // 获取输出流
            PrintStream ps = new PrintStream(socket.getOutputStream());
            ps.println(content);

            // 获取输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            System.out.println("查询结果:" + br.readLine());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (socket != null)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (input != null)
                input.close();
        }

    }
}

3、拓展:查询单词

修改前一个题目,改为并发版。

服务器端:

package com.atguigu.exercise3;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;

public class Exercise3Server {
    private static HashMap<String, String> dictionary = new HashMap<String, String>();

    static {
        dictionary.put("星期一", "Monday");
        dictionary.put("星期二", "Tuesday");
        dictionary.put("星期三", "Wednesday");
        dictionary.put("星期四", "Thursday");
        dictionary.put("星期五", "Friday");
        dictionary.put("星期六", "Saturday");
        dictionary.put("星期七", "Sunday");
    }

    public static void main(String[] args) {
        ServerSocket server = null;
        try {
            server = new ServerSocket(8888);

            while (true) {
                Socket socket = server.accept();
                new QueryThread(socket).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (server != null)
                    server.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static class QueryThread extends Thread {
        Socket socket;

        public QueryThread(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            BufferedReader br = null;
            PrintStream ps = null;
            try {
                // 获取输入流
                br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                // 获取输出流
                ps = new PrintStream(socket.getOutputStream());

                //接收客户端的中文
                String key = br.readLine();
                //查询对应的英文单词,并返回结果
                String words = dictionary.get(key);
                if (words != null) {
                    ps.println(words);
                } else {
                    ps.println("o(╥﹏╥)o没有找到对应的单词!");
                }
            } catch (IOException e) {
                e.printStackTrace();
                ;
            } finally {
                try {
                    if (br != null)
                        br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (ps != null)
                    ps.close();
                try {
                    if (socket != null)
                        socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

客户端:

package com.atguigu.exercise3;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

public class Exercise3Client {
    public static void main(String[] args) {
        Socket socket = null;
        Scanner input = null;
        PrintStream ps = null;
        BufferedReader br = null;
        try {
            // 创建Socket指定ip地址和端口号
            socket = new Socket("127.0.0.1", 8888);

            input = new Scanner(System.in);
            System.out.print("请输入要查询的词语:");
            String content = input.next();

            // 获取输出流
            ps = new PrintStream(socket.getOutputStream());
            ps.println(content);

            // 获取输入流
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            System.out.println("查询结果:" + br.readLine());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (ps != null)
                ps.close();
            try {
                if (br != null)
                    br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (socket != null)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (input != null)
                input.close();
        }
    }
}

4、图片上传

案例:客户端给服务器端上传照片

要求:

(1)客户端上传的照片,需要是jpg格式的,并且大小在2M(含)以内的,否则不能上传

(2)要求上传成功后,服务器要返回上传成功,如果上传失败,服务器返回上传失败

(3)客户端上传到服务器端的照片,存储在项目名下"photo"的文件夹中,并且以“照片原文件名+时间戳.jpg”命名

效果如下:

第16章_网络编程拓展练习(TCP编程,UDP编程),JavaSE拓展练习,网络,tcp/ip,udp,网络编程

第16章_网络编程拓展练习(TCP编程,UDP编程),JavaSE拓展练习,网络,tcp/ip,udp,网络编程

第16章_网络编程拓展练习(TCP编程,UDP编程),JavaSE拓展练习,网络,tcp/ip,udp,网络编程

第16章_网络编程拓展练习(TCP编程,UDP编程),JavaSE拓展练习,网络,tcp/ip,udp,网络编程

package com.atguigu.exercise4;

import java.io.DataInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Exercise4Server{
	public static void main(String[] args) {
        ServerSocket server = null;
        Socket socket = null;
        DataInputStream dis = null;
        PrintStream ps = null;
        FileOutputStream fos = null;
        try {
            //开启服务器
            server = new ServerSocket(8888);
            //接收一个客户端的连接
            socket = server.accept();
            //获取输入流
            dis = new DataInputStream(socket.getInputStream());
            //获取输出流
            ps = new PrintStream(socket.getOutputStream());
            //(1)先读取文件名
            String filename = dis.readUTF();

            //(2)生成唯一的文件名
            String destfile = "photo" + "/" + filename + System.currentTimeMillis() + ".jpg";

            //(3)读取文件内容,并写入目标文件
            fos = new FileOutputStream(destfile);
            try {
                byte[] data = new byte[1024];
                int len;
                while ((len = dis.read(data)) != -1) {
                    fos.write(data, 0, len);
                }
                //返回结果给客户端
                ps.println("接收成功!");
            } catch (Exception e) {
                //返回结果给客户端
                ps.println("接收失败!");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fos != null)
                    fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            ps.close();
            try {
                if (dis != null)
                    dis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (socket != null)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (server != null)
                    server.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
package com.atguigu.exercise4;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.util.Scanner;

public class Exercise4Client {
	public static void main(String[] args)throws IOException {
        //连接服务器
        Socket socket= new Socket("127.0.0.1",8888);

        //选择要上传的文件
        Scanner input = new Scanner(System.in);
        System.out.println("请选择要上传的文件:");
        //例如:D:\尚硅谷_0325班_柴林燕_JavaSE\笔记\第14章 IO流.docx
        String fileStr  = input.nextLine();
        File file = new File(fileStr);

        if(!fileStr.endsWith(".jpg")){
            System.out.println("照片必须是.jpg格式");
            input.close();
            socket.close();
            return;
        }
        if(file.length()>1024*1024*2){
            System.out.println("照片必须在2M(含)以内");
            input.close();
            socket.close();
            return;
        }

        DataOutputStream dos = null;
        //从file读取内容,给服务器发送
        FileInputStream fis = null;
        try {
            //获取输出流
            dos = new DataOutputStream(socket.getOutputStream());
            //先发送文件名
            dos.writeUTF(file.getName().substring(0, file.getName().lastIndexOf(".")));
            //发送文件内容
            fis = new FileInputStream(file);
            byte[] data = new byte[1024];
            int len;
            while((len = fis.read(data)) !=-1){
                dos.write(data, 0, len);
            }
            socket.shutdownOutput();//告诉服务器,我发送完毕
        } catch (Exception e) {
            System.out.println("上传失败");
        }finally{
            fis.close();
            dos.close();
        }

        //接收结果
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String result = br.readLine();
        System.out.println(result);

        br.close();
        socket.close();
        input.close();
    }

}

5、拓展:图片上传

相较于上题,修改为并发版。

服务器端:

package com.atguigu.exercise5;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Exercise5Server {
    public static void main(String[] args) {
        ServerSocket server = null;
        try {
            //开启服务器
            server = new ServerSocket(8888);
            while (true) {
                //接收一个客户端的连接
                Socket socket = server.accept();
                new UploadPhotoThread(socket).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (server != null)
                    server.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static class UploadPhotoThread extends Thread {
        Socket socket;

        public UploadPhotoThread(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            try (
                    //获取输入流
                    ObjectInputStream dis = new ObjectInputStream(socket.getInputStream());
                    //获取输出流
                    PrintStream ps = new PrintStream(socket.getOutputStream());
            ){
                //(1)先读取文件名
                String filename = dis.readUTF();

                //(2)生成唯一的文件名
                String destfile = "photo" + "/" + filename + System.currentTimeMillis() + ".jpg";

                //(3)读取文件内容,并写入目标文件
                FileOutputStream fos = null;
                try {
                    fos = new FileOutputStream(destfile);
                    byte[] data = new byte[1024];
                    int len;
                    while ((len = dis.read(data)) != -1) {
                        fos.write(data, 0, len);
                    }
                    //返回结果给客户端
                    ps.println("接收成功!");
                } catch (Exception e) {
                    //返回结果给客户端
                    ps.println("接收失败!");
                } finally {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

客户端:

package com.atguigu.exercise5;

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

public class Exercise5Client {
    public static void main(String[] args) throws IOException {
        //连接服务器
        Socket socket = new Socket("127.0.0.1", 8888);

        //选择要上传的文件
        Scanner input = new Scanner(System.in);
        System.out.println("请选择要上传的文件:");
        //例如:D:\尚硅谷_0325班_柴林燕_JavaSE\笔记\第14章 IO流.docx
        String fileStr = input.nextLine();
        File file = new File(fileStr);

        if (!fileStr.endsWith(".jpg")) {
            System.out.println("照片必须是.jpg格式");
            input.close();
            socket.close();
            return;
        }
        if (file.length() > 1024 * 1024 * 2) {
            System.out.println("照片必须在2M(含)以内");
            input.close();
            socket.close();
            return;
        }

        //获取输出流
        ObjectOutputStream dos = new ObjectOutputStream(socket.getOutputStream());
        //先发送文件名
        dos.writeUTF(file.getName().substring(0, file.getName().lastIndexOf(".")));

        //从file读取内容,给服务器发送
        FileInputStream fis = new FileInputStream(file);


        //发送文件内容
        byte[] data = new byte[1024];
        int len;
        while ((len = fis.read(data)) != -1) {
            dos.write(data, 0, len);
        }
        socket.shutdownOutput();//告诉服务器,我发送完毕


        //接收结果
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String result = br.readLine();
        System.out.println(result);

        fis.close();
        dos.close();
        br.close();
        socket.close();
        input.close();
    }

}

6、多个客户端上传文件

需求:每一个客户端启动后都可以给服务器上传一个文件;服务器接收到文件后保存到一个upload目录中,可以同时接收多个客户端的文件上传。

思考分析:

(1)服务器端要“同时”处理多个客户端的请求,那么必须使用多线程,每一个客户端的通信需要单独的线程来处理。

(2)服务器保存上传文件的目录只有一个upload,而每个客户端给服务器发送的文件可能重名,所以需要保证文件名的唯一。我们可以使用“时间戳”作为文件名,而后缀名不变

(3)客户端需要给服务器上传文件名(含后缀名)以及文件内容。而文件名是字符串,文件内容不一定是纯文本的,因此选择ObjectOutputStream 和 ObjectInputStream。

服务器示例代码:

package com.atguigu.exercise6;

import java.net.ServerSocket;
import java.net.Socket;

public class Exercise6Server {
    public static void main(String[] args) {
        ServerSocket server = null;
        try {
            //服务器在8888端口号监听数据
            server = new ServerSocket(8888);

            while (true) {
                //(2)等待连接
                //这句代码执行一次,意味着一个客户端连接
                Socket accept = server.accept();

                FileUploadThread ft = new FileUploadThread(accept);
                ft.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (server != null)
                    server.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
package com.atguigu.exercise6;

import java.io.*;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.Date;

public class FileUploadThread extends Thread {
    private Socket socket;
    private String dir = "upload/";//可以把它放到配置文件中

    public FileUploadThread(Socket socket) {
        this.socket = socket;
    }

    public void run() {
        FileOutputStream fos = null;
        ObjectInputStream dis = null;
        PrintStream ps = null;
        try {
            InputStream is = socket.getInputStream();
            dis = new ObjectInputStream(is);

            OutputStream out = socket.getOutputStream();
            ps = new PrintStream(out);

            //读取文件名(含后缀名)
            String filename = dis.readUTF();
            int lastIndexOfDot = filename.lastIndexOf(".");
            //截取后缀名
            String ext = filename.substring(lastIndexOfDot);
            //生成时间戳
            SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
            //拼接新文件名 = 旧文件名 + 时间戳 + 后缀名
            String newFilename = filename.substring(0, lastIndexOfDot) + sf.format(new Date()) + ext;
            //拼接文件路径
            String pathname = dir + File.separator + newFilename;
            //用新文件路径构建文件输出流
            fos = new FileOutputStream(pathname);
            //接收文件内容
            byte[] data = new byte[1024];
            long sum = 0;
            int len;
            while ((len = dis.read(data)) != -1) {
                fos.write(data, 0, len);
                fos.flush();
                sum += len;
            }
            System.out.println("sum = " + sum);

            //返回结果
            ps.println(filename + "已上传完毕");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                fos.close();

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

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

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

    }
}

客户端示例代码:

package com.atguigu.exercise6;

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

public class Exercise6Client {
    public static void main(String[] args) {
        // (1)连接服务器
        Socket socket = null;

        FileInputStream fis = null;
        ObjectOutputStream dos = null;
        OutputStream out = null;
        Scanner input = null;
        BufferedReader br = null;

        try {
            socket = new Socket("127.0.0.1", 8888);
            input = new Scanner(System.in);

            out = socket.getOutputStream();
            // 用它的目的是为了既可以单独传一个字符串,又可以写字节内容
            dos = new ObjectOutputStream(out);

            InputStream is = socket.getInputStream();
            InputStreamReader isr = new InputStreamReader(is);// 把字节流转成字符流
            br = new BufferedReader(isr);

            // (2)从键盘输入文件的路径和名称
            System.out.print("请选择要上传的文件:");
            String path = input.nextLine();
            File file = new File(path);

            // 先发送文件名(含后缀名)
            dos.writeUTF(file.getName());// 单独发一个字符串

            // 还需要一个IO流,从文件读取内容,给服务器发过去
            fis = new FileInputStream(file);
            // (3)把文件内容给服务器传过去,类似与复制文件
            byte[] data = new byte[1024];
            int len;
            long sum = 0;
            while ((len = fis.read(data)) != -1) {
                dos.write(data, 0, len);
                sum += len;
                dos.flush();
            }
            System.out.println("sum = " + sum);
            socket.shutdownOutput();//数据发送完毕,不再发送,但是还要接收,所以是半关闭

            // (4)接收服务器返回的结果
            String result = br.readLine();
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {

            // (5)关闭
            try {
                if (fis != null)
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (dos != null)
                    dos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (out != null)
                    out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (input != null)
                input.close();
            try {
                if (br != null)
                    br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (socket != null)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

7、群聊

需求:客户端与服务器连接成功后,就可以看到其他客户端的发送的聊天信息,当前客户端也可以发送自己的聊天信息。

思考分析:

(1)服务器

要同时接收多个客户端的连接,因此需要多线程

服务器这边充当转发角色,即在服务器这边的某个客户端的Socket接收到自己客户端发送的消息后,要通过服务器端这边其他客户端的Socket将信息转发出去

(2)客户端

同时能够接收和发送消息,因此也要两个线程,一个接收,一个发送

第16章_网络编程拓展练习(TCP编程,UDP编程),JavaSE拓展练习,网络,tcp/ip,udp,网络编程

服务器端示例代码:

package com.atguigu.exercise7;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Iterator;

public class Exercise7Server {
    private static ArrayList<Socket> online = new ArrayList<Socket>();

    public static void main(String[] args) {
        ServerSocket server = null;
        try {
            //1、开启服务器
            server = new ServerSocket(9999);

            while (true) {
                //2、接收客户端的连接
                Socket socket = server.accept();

                //把这个客户端加入到online中
                online.add(socket);

                //每一个客户端独立的线程
                MessageHandler mh = new MessageHandler(socket);
                mh.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (server != null)
                    server.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    private static class MessageHandler extends Thread {
        private Socket socket;
        private String ip;

        public MessageHandler(Socket socket) {
            super();
            this.socket = socket;
            this.ip = socket.getInetAddress().getHostAddress();
        }

        public void run() {
            BufferedReader br = null;
            PrintStream ps = null;
            try {
                //接收当前的客户端发送的消息
                InputStream in = socket.getInputStream();
                InputStreamReader isr = new InputStreamReader(in);
                br = new BufferedReader(isr);

                //这个客户端的一连接成功,线程一启动,就可以告诉其他人我上线了
                sendToOthers(ip + "上线了");
                while (true) {
                    String content = br.readLine();
                    if (content == null) {
                        break;
                    }
                    //收到一句,转发一句
                    sendToOthers(ip + "说:" + content);

                    if ("bye".equals(content)) {
                        //给自己发一句bye
                        OutputStream out = socket.getOutputStream();
                        ps = new PrintStream(out);
                        ps.println("bye");
                        break;
                    }
                }
                sendToOthers(ip + "下线了");
            } catch (IOException e) {
                sendToOthers(ip + "掉线了");
            } finally {
                try {
                    if (socket != null)
                        socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

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

        //因为转发的代码也很长,独立为一个方法
        public void sendToOthers(String str) {
            //遍历所有online的客户端
            Iterator<Socket> iterator = online.iterator();
            while (iterator.hasNext()) {
                Socket on = iterator.next();
                if (!on.equals(socket)) {//只给其他客户端转发
                    try {
                        OutputStream out = on.getOutputStream();
                        PrintStream ps = new PrintStream(out);
                        //不能用try(){}catch,因为这里不能关闭流和其他socket

                        ps.println(str);
                    } catch (IOException e) {
                        //说明on这个客户端要么下线了,要么掉线了
                        iterator.remove();
                    }
                }
            }
        }
    }
}

客户端示例代码:

package com.atguigu.exercise7;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Scanner;


public class Exercise7Client {
    public static void main(String[] args) {
        Socket socket = null;
        try {
            // 1、连接服务器
            socket = new Socket("127.0.0.1", 9999);

            // 2、开启两个线程,一个收消息,一个发消息
            SendThread st = new SendThread(socket);
            ReceiveThread rt = new ReceiveThread(socket);

            st.start();
            rt.start();

            // 等发送线程停下来再往下走
            st.join();
            rt.interrupt();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //关闭socket
            try {
                if (socket != null)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    static class SendThread extends Thread {
        private Socket socket;

        public SendThread(Socket socket) {
            super();
            this.socket = socket;
        }

        public void run() {
            Scanner input = null;
            PrintStream ps = null;
            try {
                // 键盘输入
                input = new Scanner(System.in);
                OutputStream out = socket.getOutputStream();
                ps = new PrintStream(out);
                while (true) {
                    // 从键盘输入
                    System.out.print("请输入要发送的消息:");
                    String content = input.nextLine();

                    // 给服务器发送
                    ps.println(content);

                    // 如果bye,就结束发送
                    if ("bye".equals(content)) {
                        break;
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (input != null)
                    input.close();
                if (ps != null)
                    ps.close();
            }
        }
    }

    static class ReceiveThread extends Thread {
        private Socket socket;

        public ReceiveThread(Socket socket) {
            super();
            this.socket = socket;
        }

        public void run() {
            BufferedReader br = null;
            try {
                InputStream in = socket.getInputStream();
                InputStreamReader isr = new InputStreamReader(in);
                br = new BufferedReader(isr);
                while (true) {
                    String line = br.readLine();
                    if ("bye".equals(line)) {
                        break;
                    }
                    System.out.println(line);
                }
            } catch (SocketException e) {
                System.out.println("退出");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (br != null) {
                    try {
                        br.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

UDP编程

8、群发消息

案例:模拟给全部同学群发“欢迎来到尚硅谷”

开发提示:使用UDP群发文章来源地址https://www.toymoban.com/news/detail-807001.html

package com.atguigu.exercise8;

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

public class Exercise8Send {
	public static void main(String[] args) {
        DatagramSocket ds = null;
        try {
            //(1)先建立一个DatagramSocket
            ds = new DatagramSocket();

            //(2)准备发送的数据
            String str = "欢迎来到尚硅谷";
            byte[] data = str.getBytes();

            for (int i = 0; i <= 255; i++) {
                //(3)把数据包装成一个数据报
                //DatagramPacket(byte[] buf, int length, InetAddress address, int port)
                /*
                 * 第一个参数:要发送的数据的字节数组
                 * 第二个参数:数组的长度
                 * 第三个参数:接收方的IP地址
                 * 第三个参数:接收方的端口号
                 *
                 * 好比发快递,需要填写接收方的IP和端口号
                 */
                InetAddress ip = InetAddress.getByName("192.168.11." + i);
                int port = 8888;
                DatagramPacket dp = new DatagramPacket(data, data.length, ip, port);


                //(4)发送数据报
                // 通过socket发送
                ds.send(dp);

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //(5)断开
            if (ds != null)
                ds.close();
        }
    }
}

package com.atguigu.exercise8;

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

public class Exercise8Receiver {
	public static void main(String[] args) {
        DatagramSocket ds = null;
        try {
            //1、准备一个socket,用来接收消息
            //接收方,先确定端口号,监听数据的端口号
            //好比,要收到快递,需要先确定自己的地址和手机号,然后对方才能给你发
            ds = new DatagramSocket(8888);

            //2、准备一个数据报,来接收数据
            //DatagramPacket(byte[] buf, int length)
            byte[] data = new byte[1024 * 64];//64K
            DatagramPacket dp = new DatagramPacket(data, data.length);

            //3、接收数据
            ds.receive(dp);

            //4、拆包裹
            byte[] result = dp.getData();
            int len = dp.getLength();//实际接收的数据的长度
            System.out.println(new String(result, 0, len));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5、关闭
            if (ds != null)
                ds.close();
        }
    }
}

到了这里,关于第16章_网络编程拓展练习(TCP编程,UDP编程)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • UDP和TCP网络编程

    特点: 无连接:发送数据前不需要建立连接。 不可靠:没有重发机制,无法保证数据的可靠性和顺序。 无拥塞控制:发送方发送数据的速度受限于网络的带宽。 快速:由于没有连接建立和拥塞控制的处理,UDP的传输速度通常比TCP快。 简单:UDP协议的头部较小,仅有8个字节

    2024年02月11日
    浏览(44)
  • TCP和UDP网络编程

    TCP和UDP协议是TCP/IP协议的核心。 TCP 传输协议:TCP 协议是一TCP (Transmission Control Protocol)和UDP(User Datagram Protocol)协议属于传输层协议。其中TCP提供IP环境下的数据可靠传输,它提供的服务包括数据流传送、可靠性、有效流控、全双工操作和多路复用。通过面向连接、端到端和可靠

    2023年04月08日
    浏览(45)
  • 基于TCP、UDP网络编程

    应用层 : 应用程序拿到数据怎么用 传输层 : 负责关注传输过程中起点和终点 网络层 :负责整个传输过程中的路线规划 数据链路层 :负责相邻节点之间的数据传输 物理层 : 基础设施,硬件设备 程序员写网络程序,主要编写的应用层代码,真正要发这个数据,调用下层协

    2024年02月07日
    浏览(49)
  • 网络编程 tcp udp http编程流程 网络基础知识

    OSI分层:应用层 表示层 会话层 传输层 网络层 数据链路层 物理层 tcp/ip: 应用层 传输层 网络层 数据链路 ip地址:唯一标识一台主机 ipv4 32位 ipv6 128位 寻址 可以反映物理上的一个变化 MAC地址:48 固化在计算机中 ip地址又两部分构成:网络号+主机号 端口号:标识一个应用程序

    2024年02月13日
    浏览(76)
  • 网络编程(TCP与UDP协议)

    Java是 Internet 上的语言,它从语言级上提供了对网络应用程序的支持,程序员能够很容易开发常见的网络应用程序。 Java提供的网络类库,可以实现无痛的网络连接,联网的底层细节被隐藏在 Java 的本机安装系统里,由 JVM 进行控制。并且 Java 实现了一个跨平台的网络库, 程序

    2023年04月27日
    浏览(52)
  • 【网络编程】TCP,UDP协议详解

    小亭子正在努力的学习编程,接下来将开启javaEE的学习~~ 分享的文章都是学习的笔记和感悟,如有不妥之处希望大佬们批评指正~~ 同时如果本文对你有帮助的话,烦请点赞关注支持一波, 感激不尽~~   目录 前言 TCP协议 TCP协议特点 TCP协议通信场景 TCP协议的几个重要机制 一、

    2023年04月19日
    浏览(53)
  • Java网络编程(UDP、TCP)

    在网络通信协议下,不同计算机上运行的程序,进行的数据传输。 应用场景:即时通信、网游对战、金融证券、国际贸易、邮件、等等。 不管是什么场景,都是计算机跟计算机之间通过网络进行数据传输。 Java中可以使用java.net包下的技术轻松开发出常见的网络应用程序。

    2024年02月05日
    浏览(63)
  • 【Java学习笔记】 68 - 网络——TCP编程、UDP编程

    https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter21/src 目录 项目代码 网络 一、网络相关概念 1.网络通讯 2.网络 3.IP地址 4.域名 5.端口号 6.网络通讯协议 TCP协议:传输控制协议 UDP协议: 二、InetAddress类 1.相关方法 三、Socket 1.基本介绍 2.TCP网络通信编程 基本介绍 应用案例

    2024年02月04日
    浏览(53)
  • 【网络编程】网络编程概念,socket套接字,基于UDP和TCP的网络编程

    前言: 大家好,我是 良辰丫 ,今天我们一起来学习网络编程,网络编程的基本概念,认识套接字,UDP与TCP编程.💞💞💞 🧑个人主页:良辰针不戳 📖所属专栏:javaEE初阶 🍎励志语句:生活也许会让我们遍体鳞伤,但最终这些伤口会成为我们一辈子的财富。 💦期待大家三连,关注

    2023年04月20日
    浏览(61)
  • 网络编程详解-UDP-TCP

    网络编程 在网络通信协议下,不同计算机上运行的程序,可以进行数据传输 网络编程的三要素是 IP地址、端口和协议 。具体分析如下: IP地址 :IP地址是网络中每一台计算机的唯一标识,它类似于现实生活中的家庭住址,用于在网络中找到具体的设备。IP地址是由数字组成

    2024年03月15日
    浏览(83)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包