Proxy和Reflect：元编程和操作对象的新方法

# 1. 理解Proxy和Reflect

## 1.1 代理模式的原理和应用
代理模式是一种结构型设计模式，通过创建一个代理对象来控制对其他对象的访问。在实际开发中，代理模式常用于实现对目标对象的间接访问、权限控制、安全验证等功能。

代理模式的原理是通过创建一个代理对象，该代理对象可以代替原始对象进行一些操作，从而实现对目标对象的访问控制。代理对象可以在调用目标对象的方法之前或之后执行一些额外的操作，如权限验证、数据过滤等。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 定义接口
interface Subject {
    void doSomething();
}

// 实际对象
class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("RealSubject: handling business logic");
    }
}

// 代理类
class ProxyHandler implements InvocationHandler {
    private Object realObject;

    public ProxyHandler(Object realObject) {
        this.realObject = realObject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 调用目标对象之前可以执行的操作
        System.out.println("Before invoking the real object's method");
        Object result = method.invoke(realObject, args);
        // 调用目标对象之后可以执行的操作
        System.out.println("After invoking the real object's method");
        return result;
    }
}

// 使用代理
public class ProxyDemo {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        InvocationHandler handler = new ProxyHandler(realSubject);
        Subject proxySubject = (Subject) Proxy.newProxyInstance(realSubject.getClass().getClassLoader(),
                realSubject.getClass().getInterfaces(), handler);
        proxySubject.doSomething();
    }
}

代码详解：首先定义了一个`Subject`接口和一个`RealSubject`实现类，然后定义了一个`ProxyHandler`代理类，实现了`InvocationHandler`接口，用于处理代理对象的方法调用。在`ProxyDemo`中通过`Proxy.newProxyInstance`创建了代理对象，并通过代理对象调用了`doSomething`方法。在代理类中，可以在真实对象方法调用前后实现额外的操作。

代码执行结果：运行`ProxyDemo`后，会打印出以下结果：

Before invoking the real object's method
RealSubject: handling business logic
After invoking the real object's method

## 1.2 Reflect对象的作用和功能
Reflect对象是在Java 1.5版本中引入的，它提供了一组API来访问类的属性、方法和构造函数，以及在运行时动态创建和操作对象。Reflect对象为Java的元编程提供了丰富的功能和灵活性。

Reflect对象的作用包括：
- 获取类的信息，如属性、方法、构造函数等
- 动态创建对象实例
- 调用对象的方法
- 获取和设置对象的属性值
- 实现对象的动态代理等

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, NoSuchFieldException {
        // 获取类信息
        Class<?> clazz = Class.forName("com.example.demo.User");
        // 获取类的属性信息
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            System.out.println("Field: " + field.getName());
        }
        // 获取类的方法信息
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println("Method: " + method.getName());
        }
    }
}

代码详解：在`ReflectDemo`中，通过`Class.forName`获取了`com.example.demo.User`类的信息，然后通过`getDeclaredFields`和`getDeclaredMethods`方法获取了类的属性和方法信息，并逐个打印出来。

代码执行结果：运行`ReflectDemo`后，会打印出`com.example.demo.User`类的属性和方法信息。

# 2. 代理模式的应用

代理模式是一种设计模式，它允许对象充当其他对象的接口。代理对象可以控制对真实对象的访问，并允许在调用真实对象之前或之后执行特定的操作。

### 2.1 使用Proxy对象实现数据校验和过滤

在实际应用中，我们经常需要对用户输入的数据进行校验和过滤。这时候就可以利用代理模式中的Proxy对象来实现，将数据的校验和过滤逻辑封装在代理对象中，确保真实对象只能接收经过校验和过滤的数据。

import re

# 真实对象
class UserManager:
    def add_user(self, username):
        print(f"User {username} added")

# 代理对象
class UserProxy:
    def __init__(self):
        self.user_manager = UserManager()

    def add_user(self, username):
        if re.match("^[a-zA-Z0-9_]*$", username):
            self.user_manager.add_user(username)
        else:
            print("Invalid username. Only letters, numbers and underscores are allowed.")

代码总结：上述代码中，UserManager是真实对象，UserProxy是代理对象。代理对象在add_user方法中做了用户名的校验，只有符合规则的用户名才会调用真实对象的add_user方法。

结果说明：当使用代理对象调用add_user方法时，如果传入的用户名符合规则，则会调用真实对象的add_user方法，如果不符合规则，则会输出错误信息。

### 2.2 利用代理实现权限控制和安全验证

另一个常见的代理模式应用场景是权限控制和安全验证。代理对象可以在调用真实对象之前验证用户权限并进行安全验