Java网络编程练习题详解：从基础通信到远程控制的实战代码

1. 使用`Socket`实现客户端和服务器端的简单通信

实现思路

服务器端：使用ServerSocket监听指定端口，等待客户端连接。一旦有客户端连接，通过Socket的输入输出流与客户端进行通信。
客户端：通过Socket连接到服务器的指定端口，发送消息并接收服务器的响应。

代码实现

服务器端代码

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

public class SimpleServer {
    public static void main(String[] args) {
        int port = 12345; // 服务器监听端口
        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("服务器已启动，等待客户端连接...");
            Socket clientSocket = serverSocket.accept(); // 等待客户端连接
            System.out.println("客户端已连接");

            // 获取输入输出流
            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);

            // 接收客户端消息并响应
            String clientMessage;
            while ((clientMessage = in.readLine()) != null) {
                System.out.println("客户端消息: " + clientMessage);
                out.println("服务器已收到消息: " + clientMessage);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端代码

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

public class SimpleClient {
    public static void main(String[] args) {
        String host = "localhost";
        int port = 12345; // 服务器端口
        try (Socket socket = new Socket(host, port)) {
            System.out.println("已连接到服务器");

            // 获取输入输出流
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);

            // 向服务器发送消息
            out.println("你好，服务器！");
            String serverResponse = in.readLine();
            System.out.println("服务器响应: " + serverResponse);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

说明

服务器端使用ServerSocket监听端口，通过accept()方法等待客户端连接。
客户端通过Socket连接到服务器的指定端口。
双方通过输入输出流进行通信。

2. 使用`ServerSocket`监听端口并接受客户端连接

实现思路

创建一个ServerSocket对象，绑定到一个端口。
使用accept()方法等待客户端连接。
每次有客户端连接时，打印客户端的IP地址和端口号。

代码实现

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

public class ServerSocketExample {
    public static void main(String[] args) {
        int port = 8080; // 监听端口
        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("服务器已启动，监听端口: " + port);
            while (true) {
                Socket clientSocket = serverSocket.accept(); // 等待客户端连接
                System.out.println("客户端已连接: " + clientSocket.getInetAddress().getHostAddress() + ":" + clientSocket.getPort());
                clientSocket.close(); // 关闭连接
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

说明

ServerSocket的accept()方法会阻塞，直到有客户端连接。
每次有客户端连接时，会打印客户端的IP地址和端口号。

3. 实现一个简单的文件传输客户端和服务器

实现思路

服务器端：接收客户端连接，接收文件内容并保存到本地。
客户端：连接到服务器，发送文件内容。

代码实现

服务器端代码

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

public class FileTransferServer {
    public static void main(String[] args) {
        int port = 12345; // 服务器监听端口
        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("文件传输服务器已启动，等待客户端连接...");
            Socket clientSocket = serverSocket.accept(); // 等待客户端连接
            System.out.println("客户端已连接");

            // 接收文件
            InputStream in = clientSocket.getInputStream();
            FileOutputStream fos = new FileOutputStream("received_file.txt");
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = in.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
            fos.close();
            System.out.println("文件接收完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端代码

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

public class FileTransferClient {
    public static void main(String[] args) {
        String host = "localhost";
        int port = 12345; // 服务器端口
        try (Socket socket = new Socket(host, port)) {
            System.out.println("已连接到文件传输服务器");

            // 发送文件
            File file = new File("file_to_send.txt");
            FileInputStream fis = new FileInputStream(file);
            OutputStream out = socket.getOutputStream();
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                out.write(buffer, 0, bytesRead);
            }
            fis.close();
            System.out.println("文件发送完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

说明

客户端通过FileInputStream读取文件内容，通过Socket的输出流发送到服务器。
服务器通过Socket的输入流接收文件内容，保存到本地文件中。

4. 使用`DatagramSocket`实现UDP通信

实现思路

发送端：创建DatagramSocket，通过DatagramPacket发送数据。
接收端：创建DatagramSocket，通过DatagramPacket接收数据。

代码实现

发送端代码

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

public class UDPSender {
    public static void main(String[] args) {
        String host = "localhost";
        int port = 12345; // 接收端端口
        try (DatagramSocket socket = new DatagramSocket()) {
            String message = "Hello, UDP!";
            byte[] buffer = message.getBytes();
            InetAddress address = InetAddress.getByName(host);
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length, address, port);
            socket.send(packet);
            System.out.println("消息已发送");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

接收端代码

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

public class UDPReceiver {
    public static void main(String[] args) {
        int port = 12345; // 监听端口
        try (DatagramSocket socket = new DatagramSocket(port)) {
            System.out.println("UDP接收端已启动，监听端口: " + port);
            byte[] buffer = new byte[1024];
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
            socket.receive(packet);
            String message = new String(packet.getData(), 0, packet.getLength());
            System.out.println("接收到消息: " + message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

说明

UDP通信是无连接的，发送端和接收端不需要建立连接。
数据通过DatagramPacket封装和传输。

5. 实现一个简单的聊天室服务器和客户端

实现思路

服务器端：使用ServerSocket监听端口，接受多个客户端连接。为每个客户端创建一个线程，接收客户端消息并广播给所有其他客户端。
客户端：连接到服务器，发送消息并接收其他客户端的消息。

代码实现

服务器端代码

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

public class ChatServer {
    private static final int PORT = 12345;
    private static final List<ClientHandler> clientList = Collections.synchronizedList(new ArrayList<>());

    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            System.out.println("聊天室服务器已启动，等待客户端连接...");
            while (true) {
                Socket clientSocket = serverSocket.accept();
                System.out.println("新客户端已连接: " + clientSocket.getInetAddress().getHostAddress());
                ClientHandler clientHandler = new ClientHandler(clientSocket);
                clientList.add(clientHandler);
                new Thread(clientHandler).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void broadcastMessage(String message) {
        for (ClientHandler client : clientList) {
            client.sendMessage(message);
        }
    }

    private static class ClientHandler implements Runnable {
        private final Socket clientSocket;
        private PrintWriter out;

        public ClientHandler(Socket socket) {
            this.clientSocket = socket;
        }

        @Override
        public void run() {
            try {
                BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                out = new PrintWriter(clientSocket.getOutputStream(), true);

                String clientMessage;
                while ((clientMessage = in.readLine()) != null) {
                    System.out.println("客户端消息: " + clientMessage);
                    broadcastMessage(clientMessage);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                out.close();
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        public void sendMessage(String message) {
            out.println(message);
        }
    }
}

客户端代码

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

public class ChatClient {
    private static final String SERVER_HOST = "localhost";
    private static final int SERVER_PORT = 12345;

    public static void main(String[] args) {
        try (Socket socket = new Socket(SERVER_HOST, SERVER_PORT)) {
            System.out.println("已连接到聊天室服务器");

            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            Scanner scanner = new Scanner(System.in);

            new Thread(() -> {
                try {
                    String serverMessage;
                    while ((serverMessage = in.readLine()) != null) {
                        System.out.println("服务器消息: " + serverMessage);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();

            while (true) {
                String message = scanner.nextLine();
                out.println(message);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

说明

服务器端为每个客户端创建一个线程，接收客户端消息并广播给所有其他客户端。
客户端通过Socket连接到服务器，发送消息并接收其他客户端的消息。

6. 使用`HttpURLConnection`发送HTTP请求

实现思路

创建一个HttpURLConnection对象，设置请求方法（GET、POST等）。
发送请求并接收响应。

代码实现

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

public class HttpExample {
    public static void main(String[] args) {
        String urlString = "https://api.example.com/data";
        try {
            URL url = new URL(urlString);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");

            int responseCode = connection.getResponseCode();
            System.out.println("响应码: " + responseCode);

            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                String inputLine;
                StringBuilder response = new StringBuilder();
                while ((inputLine = in.readLine()) != null) {
                    response.append(inputLine);
                }
                in.close();
                System.out.println("响应内容: " + response.toString());
            } else {
                System.out.println("请求失败");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

说明

使用HttpURLConnection发送HTTP请求，获取响应码和响应内容。

7. 实现一个简单的Web服务器

实现思路

使用ServerSocket监听端口，接收HTTP请求。
解析请求，返回简单的HTML页面。

代码实现

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

public class SimpleWebServer {
    private static final int PORT = 8080;

    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            System.out.println("Web服务器已启动，监听端口: " + PORT);
            while (true) {
                Socket clientSocket = serverSocket.accept();
                new Thread(() -> handleRequest(clientSocket)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void handleRequest(Socket clientSocket) {
        try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
             PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
            String requestLine = in.readLine();
            System.out.println("请求: " + requestLine);

            // 返回简单的HTML页面
            out.println("HTTP/1.1 200 OK");
            out.println("Content-Type: text/html");
            out.println();
            out.println("<html><body><h1>Hello, Web!</h1></body></html>");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

说明

Web服务器通过ServerSocket监听端口，接收HTTP请求。
返回简单的HTML页面作为响应。

8. 使用`Socket`实现多线程服务器

实现思路

使用ServerSocket监听端口，接受客户端连接。
为每个客户端创建一个线程，处理客户端请求。

代码实现

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

public class MultiThreadedServer {
    private static final int PORT = 12345;

    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            System.out.println("多线程服务器已启动，监听端口: " + PORT);
            while (true) {
                Socket clientSocket = serverSocket.accept();
                System.out.println("新客户端已连接: " + clientSocket.getInetAddress().getHostAddress());
                new Thread(new ClientHandler(clientSocket)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static class ClientHandler implements Runnable {
        private final Socket clientSocket;

        public ClientHandler(Socket socket) {
            this.clientSocket = socket;
        }

        @Override
        public void run() {
            try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                 PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
                String clientMessage;
                while ((clientMessage = in.readLine()) != null) {
                    System.out.println("客户端消息: " + clientMessage);
                    out.println("服务器已收到消息: " + clientMessage);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

说明

服务器为每个客户端创建一个线程，处理客户端请求。

9. 实现一个简单的文件下载客户端

实现思路

使用Socket连接到服务器，请求下载文件。
接收文件内容并保存到本地。

代码实现

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

public class FileDownloadClient {
    private static final String SERVER_HOST = "localhost";
    private static final int SERVER_PORT = 12345;

    public static void main(String[] args) {
        try (Socket socket = new Socket(SERVER_HOST, SERVER_PORT)) {
            System.out.println("已连接到文件下载服务器");

            // 接收文件
            InputStream in = socket.getInputStream();
            FileOutputStream fos = new FileOutputStream("downloaded_file.txt");
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = in.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
            fos.close();
            System.out.println("文件下载完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

说明

客户端通过Socket连接到服务器，接收文件内容并保存到本地。

10. 使用`Socket`实现一个简单的远程控制服务器

实现思路

服务器端：接收客户端连接，接收客户端发送的命令并执行。
客户端：连接到服务器，发送命令。

代码实现

服务器端代码

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

public class RemoteControlServer {
    private static final int PORT = 12345;

    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            System.out.println("远程控制服务器已启动，监听端口: " + PORT);
            while (true) {
                Socket clientSocket = serverSocket.accept();
                System.out.println("新客户端已连接: " + clientSocket.getInetAddress().getHostAddress());
                new Thread(new ClientHandler(clientSocket)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static class ClientHandler implements Runnable {
        private final Socket clientSocket;

        public ClientHandler(Socket socket) {
            this.clientSocket = socket;
        }

        @Override
        public void run() {
            try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                 PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
                String clientCommand;
                while ((clientCommand = in.readLine()) != null) {
                    System.out.println("客户端命令: " + clientCommand);
                    Process process = Runtime.getRuntime().exec(clientCommand);
                    BufferedReader processOutput = new BufferedReader(new InputStreamReader(process.getInputStream()));
                    String line;
                    while ((line = processOutput.readLine()) != null) {
                        out.println(line);
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

客户端代码

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

public class RemoteControlClient {
    private static final String SERVER_HOST = "localhost";
    private static final int SERVER_PORT = 12345;

    public static void main(String[] args) {
        try (Socket socket = new Socket(SERVER_HOST, SERVER_PORT)) {
            System.out.println("已连接到远程控制服务器");

            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            Scanner scanner = new Scanner(System.in);

            new Thread(() -> {
                try {
                    String serverResponse;
                    while ((serverResponse = in.readLine()) != null) {
                        System.out.println("服务器响应: " + serverResponse);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();

            while (true) {
                System.out.print("请输入命令: ");
                String command = scanner.nextLine();
                out.println(command);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

说明

服务器端接收客户端发送的命令，通过Runtime.exec()执行命令，并将输出发送回客户端。
客户端发送命令并接收服务器的响应。

posted @ 2025-04-06 09:49 软件职业规划阅读(21) 评论(0) 收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Java语言的安装、配置、编译与运行：从基础到高级实践指南

· 🌟 HTTP 协议在 Java Web 中的应用详解🌟

· Java学习-第一部分-第三阶段-第一节：网络编程

· Java-网络编程

· Java基础学习笔记24——网络编程

阅读排行：
· 完成微博外链备案，微博中直接可以打开园子的链接
· 推荐 3 种 .NET Windows 桌面应用程序自动更新解决方案
· .NET 10 支持Linux/Unix 的Shebang（Hashbang）
· 一个基于 .NET 开源、模块化 AI 图像生成 Web 用户界面
· 上周热点回顾（6.9-6.15）

公告

2025年6月

日

一

二

三

四

五

六

随笔分类

随笔档案

阅读排行榜

评论排行榜

1. Java 实战项目：Spring Boot + MyBatis Plus + MySQL + Shiro + Thymeleaf 赋能仓库管理系统设计与实现(3)

Java网络编程练习题详解：从基础通信到远程控制的实战代码

1. 使用Socket实现客户端和服务器端的简单通信

实现思路

代码实现

服务器端代码

客户端代码

说明

2. 使用ServerSocket监听端口并接受客户端连接

实现思路

代码实现

说明

3. 实现一个简单的文件传输客户端和服务器

实现思路

代码实现

服务器端代码

客户端代码

说明

4. 使用DatagramSocket实现UDP通信

实现思路

代码实现

发送端代码

接收端代码

说明

5. 实现一个简单的聊天室服务器和客户端

实现思路

代码实现

服务器端代码

客户端代码

说明

6. 使用HttpURLConnection发送HTTP请求

实现思路

代码实现

说明

7. 实现一个简单的Web服务器

实现思路

代码实现

说明

8. 使用Socket实现多线程服务器

实现思路

代码实现

说明

9. 实现一个简单的文件下载客户端

实现思路

代码实现

说明

10. 使用Socket实现一个简单的远程控制服务器

实现思路

代码实现

服务器端代码

客户端代码

说明

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

1. 使用`Socket`实现客户端和服务器端的简单通信

2. 使用`ServerSocket`监听端口并接受客户端连接

4. 使用`DatagramSocket`实现UDP通信

6. 使用`HttpURLConnection`发送HTTP请求

8. 使用`Socket`实现多线程服务器

10. 使用`Socket`实现一个简单的远程控制服务器