【JavaOOP应用】5、网络编程

最新推荐文章于 2024-08-19 17:55:12 发布

浮生146

最新推荐文章于 2024-08-19 17:55:12 发布

阅读量277

点赞数 4

分类专栏： JavaSE学习文章标签： java 学习

本文链接：https://blog.csdn.net/qq_56040271/article/details/141001641

版权

JavaSE学习专栏收录该内容

25 篇文章 0 订阅

订阅专栏

12. 网络编程

12.1 TCP/IP 编程

12.1.1 单向通讯

/**
 * tcp/ip之单向通讯-客户端
 */
public class Client01 {
    public static void main(String[] args) throws IOException {
        // 定义客户端套接字
        Socket socket = new Socket(InetAddress.getLocalHost(), 6666);
        // 根据套接字得到输出流
        OutputStream outputStream = socket.getOutputStream();
        // 将输出流转换成缓冲字符输出流
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream));
        // 定义一个Scanner输入对象
        Scanner scanner = new Scanner(System.in);
        // 获取键盘输入的一行数据
        String line = scanner.nextLine();
        // 将数据输出给服务端
        writer.write(line);
        // 关闭资源
        scanner.close();
        writer.close();
        socket.close();
    }
}

/**
 * tcp/ip之单向通讯-服务端
 */
public class Server01 {
    public static void main(String[] args) throws IOException {
        // 定义服务端套接字
        ServerSocket serverSocket = new ServerSocket(6666);
        // 通过服务端套接字获得客户端套接字
        Socket accept = serverSocket.accept();
        // 通过套接字获取输入流
        InputStream inputStream = accept.getInputStream();
        // 将输入流转换成缓存字符输入流
        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
        // 获取客户端发来的信息
        String line = reader.readLine();
        // 打印
        System.out.println("客户端说：" + line);
        // 关闭资源
        reader.close();
        accept.close();
        serverSocket.close();
    }
}

12.1.2 双向通讯

/**
 * tcp/ip之双向通讯-客户端
 */
public class Client02 {
    public static void main(String[] args) throws IOException {
        // 创建客户端套接字
        Socket socket = new Socket(InetAddress.getLocalHost(), 6666);
        // 根据客户端套接字获取输出流，并转换成缓冲输出流
        PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
        // 定义一个Scanner获取键盘输入的数据
        Scanner scanner = new Scanner(System.in);
        // 获取输入的数据
        String line = scanner.nextLine();
        // 将数据发送给服务端
        writer.println(line);

        // 根据套接字获取输入流，并转换成缓冲字符输入流
        BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        // 获取服务端发送的数据
        String line1 = reader.readLine();
        // 打印
        System.out.println("服务端说：" + line1);

        // 关闭资源
        reader.close();
        scanner.close();
        writer.close();
        socket.close();
    }
}

/**
 * tcp/ip之双向通讯-服务端
 */
public class Server02 {
    public static void main(String[] args) throws IOException {
        // 创建服务端套接字
        ServerSocket serverSocket = new ServerSocket(6666);
        // 根据服务端套接字获取客户端套接字
        Socket accept = serverSocket.accept();
        // 根据套接字获取输入流，并转换成缓冲字符输入流
        BufferedReader reader = new BufferedReader(new InputStreamReader(accept.getInputStream()));
        // 获取客户端发送的数据
        String line = reader.readLine();
        // 打印
        System.out.println("客户端说：" + line);

        // 根据套接字获取输出流，并转换成缓冲输出流
        PrintWriter writer = new PrintWriter(accept.getOutputStream(), true);
        // 定义一个Scanner获取键盘输入的数据
        Scanner scanner = new Scanner(System.in);
        // 获取输入的数据
        String line1 = scanner.nextLine();
        // 将数据发送给客户端
        writer.println(line1);

        // 关闭资源
        scanner.close();
        writer.close();
        reader.close();
        accept.close();
        serverSocket.close();
    }
}

12.2 UDP 编程

12.2.1 发送方

/**
 * 发送方
 */
public class Sender01 {
    public static void main(String[] args) throws IOException {
        // 创建发送方的套接字
        DatagramSocket socket = new DatagramSocket();
        // 定义Scanner对象
        Scanner scanner = new Scanner(System.in);
        // 定义发送数据包
        System.out.println("请输入发送信息：");
        String line = scanner.nextLine();
        // 将字符串转换为字节数组
        byte[] bytes = line.getBytes();
        // 创建要发送的数据包
        DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length, InetAddress.getLocalHost(), 6666);
        // 发送数据包
        socket.send(packet);

        // 定义一个字节数组
        byte[] b = new byte[100];
        // 创建接收的空数据包
        DatagramPacket packet1 = new DatagramPacket(b, 0, b.length);
        // 接收数据包
        socket.receive(packet1);
        // 将数据包转换成字符串
        String str = new String(packet1.getData(),0,packet1.getLength());
        // 打印
        System.out.println("接受方发来的数据包：" + str);

        // 关闭资源
        scanner.close();
        socket.close();
    }
}

12.2.2 接收方

/**
 * 接受方
 */
public class Reciver01 {
    public static void main(String[] args) throws IOException {
        // 创建接收方的套接字
        DatagramSocket socket = new DatagramSocket(6666);
        // 接收发送方发送的数据包
        byte[] bytes = new byte[100];
        DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length);
        socket.receive(packet);
        // 将数据包转换成字符串
        String str = new String(packet.getData(),0,packet.getLength());
        // 打印数据包
        System.out.println("接收到发送方的数据：" + str);

        // 创建一个Scanner对象
        Scanner scanner = new Scanner(System.in);
        // 得到键盘输入的信息
        System.out.println("向发送方发送信息：");
        String line = scanner.nextLine();
        // 转换为字节数组
        byte[] bytes1 = line.getBytes();
        // 创建发送的数据包
        DatagramPacket packet1 = new DatagramPacket(bytes1, 0, bytes1.length, packet.getAddress(), packet.getPort());
        socket.send(packet1);

        // 关闭资源
        scanner.close();
        socket.close();
    }
}

12.3 网络编程应用

案例一：通过TCP/IP传递序列化对象

/**
 * tcp传递序列化对象
 */
public class Client03 {
    public static void main(String[] args) throws IOException {
        // 创建客户端套接字
        Socket socket = new Socket(InetAddress.getLocalHost(), 6666);
        // 根据套接字获取输出流，并转换成序列化
        ObjectOutputStream stream = new ObjectOutputStream(socket.getOutputStream());
        // 输入学生信息
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入学生学号：");
        int sid = scanner.nextInt();
        System.out.println("请输入学生姓名：");
        String name = scanner.next();
        System.out.println("请输入学生性别：");
        String sex = scanner.next();
        System.out.println("请输入学生年龄：");
        int age = scanner.nextInt();
        System.out.println("请输入学生住址：");
        String addr = scanner.next();
        // 创建一个学生对象
        Student student = new Student(sid, name, sex, age, addr);
        // 将学生对象序列化输出
        stream.writeObject(student);

        // 关闭资源
        scanner.close();
        stream.close();
        socket.close();
    }
}

/**
 * tcp传递序列化对象
 */
public class Server03 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 定义一个服务端套接字
        ServerSocket serverSocket = new ServerSocket(6666);
        // 通过服务端套接字获取客户端套接字
        Socket accept = serverSocket.accept();
        // 通过套接字获取输入流，并转换成反序列化
        ObjectInputStream stream = new ObjectInputStream(accept.getInputStream());
        // 获取学生对象反序列化
        Student student = (Student) stream.readObject();
        // 打印
        System.out.println(student);

        // 关闭资源
        stream.close();
        accept.close();
        serverSocket.close();
    }
}

案例二：写一个TCP/IP的聊天程序，实现客户端与服务器端发送信息，服务器端将接收到的信息，输出到F盘的msg.txt文件中。以end结束！

public class Client04 {
    /**
     * 写一个TCP/IP的聊天程序，实现客户端与服务器端发送信息，服务器端将接收到的信息，输出到F盘的msg.txt文件中。
     * 以end结束！
     */
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        // 定义一个客户端的套接字对象
        Socket socket = new Socket(InetAddress.getLocalHost(),6666);
        // 根据套接字得到缓冲输出流对象
        PrintWriter writer = new PrintWriter(socket.getOutputStream(),true);
        // 循环输出信息给服务端
        while(true){
            // 输入一行信息
            String line = scanner.nextLine();
            // 将此信息输出给服务端
            writer.println(line);
            // 如果是end就结束
            if(line.equalsIgnoreCase("end")){
                break;
            }
        }
        // 关闭资源
        writer.close();
        scanner.close();
        socket.close();
    }
}

public class Server04 {
    /**
     * 写一个TCP/IP的聊天程序，实现客户端与服务器端发送信息，服务器端将接收到的信息，输出到F盘的msg.txt文件中。
     * 以end结束！
     */
    public static void main(String[] args) throws IOException {
        // 定义服务端套接字
        ServerSocket serverSocket = new ServerSocket(6666);
        // 根据服务端套接字得到客户端的套接字对象
        Socket accept = serverSocket.accept();
        // 构造套接字关联的输入缓冲流
        BufferedReader reader = new BufferedReader(new InputStreamReader(accept.getInputStream()));
        // 构造一个文件输出流，将得到信息输出到f盘
        File file = new File("f:/msg.txt");
        FileOutputStream fos = new FileOutputStream(file,true);
        PrintWriter writer = new PrintWriter(fos,true);
        // 循环读取并写入到f盘文件中
        while (true){
            // 每次读取一条数据
            String line = reader.readLine();
            // 先判断是否是end，是就退出
            if("end".equalsIgnoreCase(line)){
                break;
            }
            // 将读到的一行数据写入文件中
            writer.println(line);
        }
        // 关闭资源
        reader.close();
        writer.close();
        accept.close();
        serverSocket.close();
    }
}