Background

In modern game development, implementing cross-server functionality has become essential for most games (though some casual games may not require this feature). Cross-server design can enhance player engagement by fostering competition for higher power levels and consolidate player populations to prevent servers from appearing inactive.

Players on different servers cannot interact directly because their data resides in separate processes. The objective of cross-server design is to bring players from different game processes into a unified server environment.

The technical foundation of cross-server functionality is inter-process communication. Server A needs to exchange data with Server B. Common inter-process communication methods in Java include HTTP, RPC, web services, message queues, and others.

For cross-server game design, the most commonly used approaches are RPC and native socket communication. This article focuses on the distinctions between these two communication methods.

RPC Cross-Server Communication

RPC (Remote Procedure Call) enables one process to request services from another. Process A calls services in Process B as if they were local methods, without needing to understand the underlying implementation details. Below is an example of RPC usage:

@RemoteService(name = "PlayerService")
public class PlayerServiceImpl implements PlayerService {

    @Override
    @ServiceMethod
    public String greetPlayer(String playerName) {
        return "Welcome, " + playerName;
    }
}

Clients only need to reference the PlayerService interface, while the implementation (PlayerServiceImpl) is provided by the server. Clients can invoke the server's functionality using the same approach as calling local service interfaces.

Advantages and Disadvantages of RPC

Advantages:

• Simplicity: RPC abstracts underlying communication details, making it easy to use.
• Efficiency: RPC packages remote calls into interfaces and uses serialization/deserialization mechanisms to reduce communication overhead.
• Maintainability: By encapsulating remote services as interfaces, RPC improves code maintainability and extensibility.
• Cross-Language Support: RPC protocols typically support multiple programming languages, enabling communication between different languages.

Disadvantages:

• Network Dependency: RPC relies on network commmunication, which can affect performance and reliability if the network is unstable or experiences latency.
• Debugging Challenges: Since RPC calls span differant processes, debugging and troubleshooting issues can be more difficult than with local calls.
• Security Concerns: RPC communication may have security vulnerabilities that require additional security measures.
• Version Compatibility: When server interfaces change, clients need corresponding updates or compatibility handling, increasing development and maintenance complexity.

Socket Communication

While RPC focuses on service-oriented communication, socket communication operates at a lower level, similar to HTTP's request-response model. The client sends a request message to the server, which processes it and returns a response message.

Advantages and Disadvantages of Socket Communication

Advantages:

• Simplicity: Socket programming provides a straightforward method for implementing network communication, allowing developers to freely create client-server connections.
• Flexibility: Sockets offer low-level network interfaces that allow developers to customize communication protocols and data formats to meet various requirements.
• Cross-Platform: Based on TCP/IP protocols, sockets can communicate across different operating systems and platforms.
• Real-Time Capability: Socket communication can support real-time applications such as online games and live chat systems.

Disadvantages:

• Complexity: Socket programming requires handling various communication details including connection management, data transmission, encoding/decoding, packet handling, and exception management.
• Performance: Socket communication performance can be affected by network conditions and load, potentially causing delays or bandwidth limitations.
• Security: Socket communication has relatively low security and requires additional encryption and authentication mechanisms.

Comparison for Game Development

Perspective for Game Server Selection

Fundamentally, RPC is merely a service-oriented abstraction layer built on top of communication protocols like socket or HTTP. Game servers typically use sockets to accept all client requests within a well-established cross-process communication framework.

Since communication between different server nodes is essentially similar to client-server communication, introducing third-party RPC frameworks may be unnecessary. Socket-based communication can implement both request-response patterns similar to RPC and asynchronous message callbacks.

public class GameMessageClient {
    
    /**
     * Request data using a callback mechanism
     * Caller doesn't need to block the current thread
     */
    public static void asyncRequest(PlayerSession session, GameMessage message, 
            ResponseHandler handler) throws TimeoutException {
        // Implementation
    }
    
    /**
     * Request data using request-response pattern
     * Caller must block the current thread
     */
    public static Object syncRequest(PlayerSession session, GameMessage message) 
            throws TimeoutException {
        // Implementation
        return null;
    }
}