请求以通俗易懂的示例讲解RPC（Remote Procedure Call）

Hey there! I get that RPC can feel abstract at first—let's ditch the jargon and use a real-life scenario you encounter every day: ordering food at a restaurant.

The Restaurant Analogy #

Imagine you're sitting at a table (that's your client application) and you want a plate of garlic bread. Here's how the process works, which maps directly to RPC:

• You don't walk into the kitchen (the remote server) to make the bread yourself—you just tell your waiter (AKA the RPC framework) what you want.
• The waiter takes your order (serializes your request into a format that can be sent to the kitchen), walks to the kitchen (handles network communication), and tells the chef exactly what you asked for (calls the remote method on the server).
• The chef makes the bread (the server executes the requested function), puts it on a plate (packages the result), and gives it back to the waiter.
• The waiter brings the bread to your table (sends the serialized result back to the client) and you enjoy it (your client uses the returned data).

The key here? You didn't have to worry about how the waiter got to the kitchen, how the chef made the bread, or how it came back to you—you just asked for what you needed, and it showed up. That's exactly what RPC does for your code.

Translating to Code: A Simple Python Example #

Let's turn this analogy into actual code to make it concrete. We'll build a tiny RPC system where a client calls a remote function to add two numbers.

Step 1: The Server (Kitchen) #

This is the remote service that provides the "add" function:

from xmlrpc.server import SimpleXMLRPCServer

def add_numbers(a, b):
    # This is the "chef making the bread"—executing the requested logic
    return a + b

# Start the server (kitchen open for orders)
server = SimpleXMLRPCServer(('localhost', 8000))
print("Server ready to accept requests...")
server.register_function(add_numbers, 'add')  # Register the function so clients can call it
server.serve_forever()

Step 2: The Client (You at the Table) #

This is the code that calls the remote function as if it were local:

import xmlrpc.client

# Connect to the server (call the waiter over)
client = xmlrpc.client.ServerProxy('http://localhost:8000/')

# Call the remote function as if it's a local function—no network code needed!
result = client.add(5, 3)
print(f"Result of remote add: {result}")  # Output: 8

When you run the server first, then the client, you'll get the result 8—just like getting your garlic bread. The xmlrpc library acts as the waiter, handling all the network stuff under the hood.

Core Takeaways About RPC #

• Abstraction: RPC hides the complexity of network communication (like sending data over HTTP/TCP, serializing/deserializing data) so you can focus on writing business logic.
• Local-like Calls: You call remote functions using the same syntax as local functions—no need to write custom network code for every request.
• Language/Platform Agnostic: Most RPC frameworks (like gRPC, Thrift) let you call services written in different languages (e.g., a Python client calling a Go server).

内容的提问来源于stack exchange，提问作者Lalit patidar