How to implement XML-RPC in a Python application

Use xmlrpc.server to create a server and register functions; 2. Expose the add and greet methods through SimpleXMLRPCServer; 3. The client uses ServerProxy to call remote functions; 4. Supports dictionary, list and other data types; 5. Exceptions are automatically converted to Fault responses.

Implementing XML-RPC in a Python application is straightforward using the built-in xmlrpc.server and xmlrpc.client modules. These allow you to create both servers that expose functions remotely and clients that call them over HTTP using the XML-RPC protocol.

Set Up an XML-RPC Server

Create a server that exposes callable functions. The server listens for incoming requests and maps them to local methods.

Here's a basic example of an XML-RPC server:

 from xmlrpc.server import SimpleXMLRPCServer
<p>def add_numbers(x, y):
return xy</p><p> def greet(name):
return f"Hello, {name}!"</p><h1> Create server</h1><p> server = SimpleXMLRPCServer(("localhost", 8000))
print("Listening on port 8000...")</p><h1> Register functions</h1><p> server.register_function(add_numbers, "add")
server.register_function(greet, "greet")</p><h1> Run the server</h1><p> try:
server.serve_forever()
except KeyboardInterrupt:
print("Shutting down...")
server.server_close()

This server runs locally on port 8000 and exposes two functions: add and greet .

Write an XML-RPC Client

The client connects to the server and calls remote functions as if they were local.

 import xmlrpc.client
<h1>Connect to the server</h1><p> proxy = xmlrpc.client.ServerProxy(" <a href="https://global.php.cn/link/2674cea93e3214abce13e072a2dc2ca5">https://global.php.cn/link/2674cea93e3214abce13e072a2dc2ca5</a> ")</p><h1> Call remote functions</h1><p> result1 = proxy.add(5, 3)
result2 = proxy.greet("Alice")</p><p> print(result1) #Output: 8
print(result2) # Output: Hello, Alice!

The ServerProxy object handles communication, serializing parameters and parsing responses automatically.

Support Complex Data Types

XML-RPC supports basic types (int, string, list, dict, etc.). You can pass and return dictionaries or lists seamlessly.

Example function returning a dictionary:

 def get_user_data():
    return {
        "name": "Bob",
        "age": 30,
        "roles": ["admin", "user"]
    }
<p>server.register_function(get_user_data, "get_user_data")

The client receives it as a native Python dict:

 user = proxy.get_user_data()
print(user['name']) # Output: Bob

Handle Errors Gracefully

If a server function raises an exception, XML-RPC converts it into a fault response. The client sees it as a Fault exception.

 try:
    result = proxy.divide(10, 0)
except xmlrpc.client.Fault as err:
    print(f"Remote error: {err.faultString}")

On the server, uncaught exceptions become faults automatically. You can also raise xmlrpc.client.Fault manually for custom error codes.

Basically, use standard functions, register them with the server, and access via proxy on the client side. Keep data structures simple and test with small examples first.

The above is the detailed content of How to implement XML-RPC in a Python application. For more information, please follow other related articles on the PHP Chinese website!