SpringBoot新手求助：基于IP向订阅客户端推送文件的实现方法

Hey there! Since you're new to Spring Boot and need to push files from your server to subscribed clients by their IP addresses, let's walk through practical, actionable steps to make this happen.

First, you need to decide between two main approaches that fit your use case:

• WebSocket: Ideal for real-time, server-initiated pushes (perfect for your "subscription" requirement). It lets your server actively send data to clients and makes targeting specific IPs straightforward.
• REST + Client Polling: Simpler to set up, but client-initiated (clients periodically check the server for new files). Less ideal for instant pushes, but a good starting point if WebSocket feels overwhelming.

We'll focus on WebSocket first since it aligns better with your goal of actively pushing files to clients.

2.1 Add WebSocket Dependency #

For Maven (pom.xml):

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

For Gradle (build.gradle):

implementation 'org.springframework.boot:spring-boot-starter-websocket'

2.2 Configure WebSocket Endpoint #

Create a config class to enable WebSocket and register your file push handler:

import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        // Register our handler at the /file-push endpoint
        // Allow all origins (restrict this in production for security!)
        registry.addHandler(filePushHandler(), "/file-push")
                .setAllowedOrigins("*");
    }

    public FilePushHandler filePushHandler() {
        return new FilePushHandler();
    }
}

2.3 Build the WebSocket Handler (Track Client Connections) #

This handler will keep track of connected clients by their IP, so you can target specific machines for file pushes:

import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;

import java.io.IOException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.Base64;

public class FilePushHandler extends TextWebSocketHandler {

    // Thread-safe map to store client IPs and their active sessions
    private static final Map<String, WebSocketSession> clientSessions = new ConcurrentHashMap<>();

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        String clientIp = getClientIpAddress(session);
        clientSessions.put(clientIp, session);
        System.out.println("Client connected: " + clientIp);
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        String clientIp = getClientIpAddress(session);
        clientSessions.remove(clientIp);
        System.out.println("Client disconnected: " + clientIp);
    }

    // Helper to get the client's real IP (adjust for proxies like Nginx!)
    private String getClientIpAddress(WebSocketSession session) {
        // For direct connections, this works. If using a proxy, check headers like X-Forwarded-For
        return session.getRemoteAddress().getAddress().getHostAddress();
    }

    // Push a file to a specific client by IP
    public void pushFileToTargetIp(String targetIp, byte[] fileContent, String fileName) throws IOException {
        WebSocketSession targetSession = clientSessions.get(targetIp);
        if (targetSession != null && targetSession.isOpen()) {
            // Encode file content to Base64 for text transmission (use binary for large files!)
            String filePayload = String.format("{\"fileName\":\"%s\",\"content\":\"%s\"}",
                    fileName, Base64.getEncoder().encodeToString(fileContent));
            targetSession.sendMessage(new TextMessage(filePayload));
        } else {
            System.out.println("Target client not connected or session closed: " + targetIp);
        }
    }

    // Push a file to all connected clients
    public void pushFileToAllClients(byte[] fileContent, String fileName) throws IOException {
        for (WebSocketSession session : clientSessions.values()) {
            if (session.isOpen()) {
                String filePayload = String.format("{\"fileName\":\"%s\",\"content\":\"%s\"}",
                        fileName, Base64.getEncoder().encodeToString(fileContent));
                session.sendMessage(new TextMessage(filePayload));
            }
        }
    }
}

2.4 Create a Controller to Trigger Pushes #

Add a REST controller to initiate file pushes (you can call this from a dashboard, cron job, or internal service):

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

@RestController
public class FilePushController {

    @Autowired
    private FilePushHandler filePushHandler;

    // Push file to a specific IP
    @PostMapping("/push-to-ip")
    public String pushToSpecificIp(@RequestParam String targetIp, @RequestParam String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            return "Error: File not found at " + filePath;
        }

        // Read file content into bytes
        byte[] fileBytes = new byte[(int) file.length()];
        try (FileInputStream fis = new FileInputStream(file)) {
            fis.read(fileBytes);
        }

        filePushHandler.pushFileToTargetIp(targetIp, fileBytes, file.getName());
        return "Sent file " + file.getName() + " to IP: " + targetIp;
    }

    // Push file to all connected clients
    @PostMapping("/push-to-all")
    public String pushToAllClients(@RequestParam String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            return "Error: File not found at " + filePath;
        }

        byte[] fileBytes = new byte[(int) file.length()];
        try (FileInputStream fis = new FileInputStream(file)) {
            fis.read(fileBytes);
        }

        filePushHandler.pushFileToAllClients(fileBytes, file.getName());
        return "Sent file " + file.getName() + " to all connected clients";
    }
}

2.5 Client-Side Implementation (JavaScript Example) #

Your clients need to connect to the WebSocket endpoint, receive the file, and save it. Here's a simple browser-based example:

// Replace with your server's IP/port
const ws = new WebSocket('ws://your-server-address:8080/file-push');

ws.onopen = () => {
    console.log('Connected to file push server');
};

ws.onmessage = (event) => {
    const fileData = JSON.parse(event.data);
    const fileName = fileData.fileName;
    const fileContent = atob(fileData.content);

    // Convert to blob and trigger download
    const blob = new Blob([fileContent], { type: 'application/octet-stream' });
    const downloadUrl = URL.createObjectURL(blob);
    const link = document.createElement('a');
    link.href = downloadUrl;
    link.download = fileName;
    link.click();
    URL.revokeObjectURL(downloadUrl);
};

ws.onclose = () => {
    console.log('Disconnected from server');
    // Optional: Add reconnect logic here
};

• Large Files: The example uses Base64 text for simplicity, but for large files, switch to BinaryWebSocketHandler to send raw bytes (avoids encoding overhead and memory issues).
• Proxy IP Handling: If your server sits behind a proxy (like Nginx), configure the proxy to pass the real client IP via headers (e.g., X-Forwarded-For) and update the getClientIpAddress method to read these headers.
• Client Authentication: Add token-based auth in the WebSocket connection to prevent unauthorized clients from connecting. Validate tokens in the afterConnectionEstablished method.
• Error Handling: Add retry logic for failed pushes, and log errors to track issues with client connections.

If you want a simpler (but less real-time) approach, have clients periodically call a REST endpoint to check for files:

import org.springframework.core.io.FileSystemResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.io.File;

@RestController
public class FilePollingController {

    @GetMapping("/check-for-file")
    public ResponseEntity<FileSystemResource> checkForFile(@RequestParam String clientIp) {
        // Logic to get the file assigned to this IP (e.g., from a database or file system)
        File file = getFileForClient(clientIp);

        if (file != null && file.exists()) {
            return ResponseEntity.ok()
                    .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + file.getName() + "\"")
                    .body(new FileSystemResource(file));
        } else {
            return ResponseEntity.noContent().build();
        }
    }

    // Replace with your logic to fetch the file for the client
    private File getFileForClient(String clientIp) {
        // Example: Look up a file in a directory named after the IP
        return new File("./client-files/" + clientIp + "/latest-file.pdf");
    }
}

Clients can use a cron job or setInterval to call this endpoint regularly.

内容的提问来源于stack exchange，提问作者Ashish Gupta