The proxy mode is accessed through the intermediary control object and is suitable for delayed loading, permission control, remote call and other scenarios. 1. Delay loading: The agent creates real objects only when the first call is called, saving resources; 2. Permission control: The agent checks the user role and decides whether to allow access; 3. Remote call or logging: The agent encapsulates remote services or adds logs, performance monitoring and other functions; it can also simplify the proxy class implementation through __getattr__ to reduce boilerplate code.

When writing code in Python, sometimes you don’t want to operate an object directly, but instead want to add a layer of “mediation” in front of it. This is where the proxy pattern comes in. Its core idea is to control access to real objects through a proxy object . This approach is particularly practical in remote calls, permission control, delayed loading and other scenarios.

The following is based on several common usage scenarios and talk about how to use the proxy mode in Python.

1. Lazy Loading

Sometimes creating objects is expensive, such as loading large files or connecting to databases. You can create a proxy first and initialize the real object when it is really needed.

 class HeavyObject:
    def do_work(self):
        print("High-duty tasks are being performed...")

class Proxy:
    def __init__(self):
        self._real_object = None

    def do_work(self):
        if self._real_object is None:
            self._real_object = HeavyObject()
        self._real_object.do_work()

# Use example proxy = Proxy()
proxy.do_work() # Only the first time the object will be created and executed

This way can save resources, especially if you are not sure whether that object will be used.

2. Control access rights

If you want some users to only access the function of an object under specific conditions, you can use a proxy to do permission checks.

 class RealService:
    def access_data(self):
        print("Accessing sensitive data...")

class AccessProxy:
    def __init__(self, user_role):
        self._real_service = RealService()
        self.user_role = user_role

    def access_data(self):
        if self.user_role == "admin":
            self._real_service.access_data()
        else:
            print("Insufficient permissions, unaccessible")

# Use example user_proxy = AccessProxy("guest")
user_proxy.access_data() # Output permission is insufficient admin_proxy = AccessProxy("admin")
admin_proxy.access_data() # Normal access

• If you are working in a web backend, this kind of proxy can be used as an intermediate layer to intercept requests.
• Combined with the decorator mechanism of Flask or Django, access control can be more elegantly.

3. Remote call or logging

The proxy can also be used to encapsulate remote service calls (such as RPC), and can also be used to record call logs and count time-consuming auxiliary functions.

 class RemoteService:
    def call(self):
        print("Remote interface is being called...")

class LoggingProxy:
    def __init__(self):
        self._service = RemoteService()

    def call(self):
        print("Login logging before starting call")
        self._service.call()
        print("Call completed, logged")

# Use example proxy = LoggingProxy()
proxy.call()

This structure is very suitable for plug-in and unplugged development. For example, if you want to temporarily add performance monitoring but don’t want to change the original logic, you can use the proxy to package the first layer.

Tips: Use __getattr__ to simplify the proxy class

If there are many ways to proxy objects, it is very troublesome to write and forward one by one. You can use __getattr__ to automatically transfer attribute access to internal objects.

 class SimpleProxy:
    def __init__(self, target):
        self._target = target

    def __getattr__(self, name):
        return getattr(self._target, name)

# Example target = RealService()
proxy = SimpleProxy(target)
proxy.access_data() # Directly call the RealService method

This trick is very useful when encapsulating third-party libraries or writing general agents, and can reduce a lot of boilerplate code.

Basically that's it. The proxy mode seems simple, but if used properly, it will make the code structure clearer and easier to expand and maintain. The key is to understand when to add a layer of "middleman" - when you find that the use of an object requires additional control or packaging, the agent is a good choice.

The above is the detailed content of Proxy Pattern in Python. For more information, please follow other related articles on the PHP Chinese website!