Java 代理模式

package proxydemo;
// 账户服务实现类
public class BankAccountImpl implements BankAccount {

    @Override
    public void viewBalance() {
        System.out.println("Displaying account balance.");
    }

    @Override
    public void withdraw() {
        System.out.println("Withdrawing funds from account.");
    }

    @Override
    public void deposit() {
        System.out.println("Depositing funds into account.");
    }
}

package proxydemo;

// 账户服务代理类
// 代理类负责控制对实际账户服务操作的访问。只有管理员角色才能执行
// withdraw()、deposit()和 transfer()操作，而普通用户只能查看余额
// 和退出服务。

public class BankAccountProxy implements BankAccount {
    private BankAccountImpl BankAccount;
    private String userRole;

    // 构造方法，传入实际的账户服务对象和用户角色
    public BankAccountProxy(BankAccountImpl BankAccount, String userRole) {
        this.BankAccount = BankAccount;
        this.userRole = userRole;
        System.out.println("BankAccountProxy initialized with user role: " + userRole);
    }

    @Override
    public void viewBalance() {
        System.out.println("User with role " + userRole + " is viewing balance.");
        BankAccount.viewBalance(); // 所有用户都可以查看余额
    }

    @Override
    public void withdraw() {
        if ("ADMIN".equals(userRole)) {
            BankAccount.withdraw(); // 只有管理员可以取款
        } else {
            System.err.println("Access denied for user with role " + userRole + ": Only ADMIN can withdraw funds.");
        }
    }

    @Override
    public void deposit() {
        if ("ADMIN".equals(userRole)) {
            BankAccount.deposit(); // 只有管理员可以存款
        } else {
            System.err.println("Access denied for user with role " + userRole + ": Only ADMIN can deposit funds.");
        }
    }
}

package proxydemo;

public class Main {
    public static void main(String[] args) {
        BankAccountImpl BankAccount = new BankAccountImpl();

        // 创建管理员用户的代理
        System.out.println("Admin user:");
        BankAccount adminProxy = new BankAccountProxy(BankAccount, "ADMIN");
        adminProxy.viewBalance(); // 管理员可以查看余额
        adminProxy.withdraw(); // 管理员可以取款
        adminProxy.deposit(); // 管理员可以存款

        // 创建普通用户的代理
        System.out.println("\nRegular user:");
        BankAccount userProxy = new BankAccountProxy(BankAccount, "USER");
        userProxy.viewBalance(); // 普通用户可以查看余额
        userProxy.withdraw(); // 普通用户无法取款
        userProxy.deposit(); // 普通用户无法存款
    }
}

package proxydemo;

// 账户服务实现类
public class BankAccountImpl implements BankAccount {
    private double balance;

    @Override
    public void deposit(double amount) {
        balance += amount;
        System.out.println("Deposited: " + amount);
    }

    @Override
    public void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
            System.out.println("Withdrew: " + amount);
        } else {
            System.out.println("Insufficient balance");
        }
    }

    @Override
    public double getBalance() {
        return balance;
    }
}

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

public class BankAccountProxyHandler implements InvocationHandler {
    private final BankAccount target;

    public BankAccountProxyHandler(BankAccount target) {
        this.target = target;
    }

    /**
     * 当代理实例上的方法被调用时，这个方法会被触发。它接收三个参数：代理实例、被调用的方法对象和方法参数数组。该方法负责处理方法调用并返回结果
     *
     * @param proxy  代理对象本身。通常在方法中不会直接使用它。
     * @param method 表示正在调用的目标方法。它是一个 Method 对象，封装了该方法的元数据信息（如方法名、参数类型等）。
     * @param args   目标方法调用时传入的实际参数，是一个 Object[] 数组。如果没有参数，则为 null。
     * @return method的返回值（如果有返回值）。
     * @throws Throwable 如果调用目标对象的方法抛出异常，则会向上抛出异常。
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 可以在调用方法之前执行部分操作;
        // 例如，在目标方法调用前添加日志信息,记录执行时间等等
        long startTime = System.currentTimeMillis();
        System.out.println("Method " + method.getName() + " is called with arguments: " + (args != null ? java.util.Arrays.toString(args) : "[]"));
        // 使用 Method 对象调用目标对象（真实对象）的方法，并传递参数 args
        Object result = method.invoke(target, args);
        // 同样地，可以在调用方法之后执行部分操作;
        // 例如，在方法调用后添加日志
        long endTime = System.currentTimeMillis();
        System.out.println("Method " + method.getName() + " executed in " + (endTime - startTime) + " ms");

        // 返回调用结果（如果方法有返回值，则返回该值；如果没有返回值，返回 null）
        return result;
    }
}

package proxydemo;

import java.lang.reflect.Proxy;

public class Main {
    public static void main(String[] args) {
        // 创建银行账户的真实对象
        BankAccount realAccount = new BankAccountImpl();
        // 创建代理对象
        BankAccount proxyAccount = (BankAccount) JdkProxyFactory.getProxy(realAccount);
        // 使用代理对象执行方法
        proxyAccount.deposit(100);
        proxyAccount.withdraw(50);
        System.out.println("Balance: " + proxyAccount.getBalance());
    }
}

class JdkProxyFactory {
    public static Object getProxy(Object target) { // target: real object which implements BankAccount Interface
        // 通过 Proxy 类创建动态代理对象
        // 参数1：类加载器，通常使用目标对象的类加载器
        // 参数2：目标对象实现的接口，可指定多个
        // 参数3：InvocationHandler 实现类
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new BankAccountProxyHandler((BankAccount) target));
    }
}

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class BankAccountInterceptor implements MethodInterceptor {
    /**
     * 拦截器方法
     *
     * @param proxyObj 代理对象
     * @param method 被代理的方法
     * @param args 方法的参数
     * @param proxy 方法的代理对象，用于调用父类的方法
     * @return 方法的返回值
     * @throws Throwable 抛出的异常
     */
    @Override
    public Object intercept(Object proxyObj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Method" + method.getName() + "is being called with arguments: " + java.util.Arrays.toString(args));
        Object res = proxy.invoke(proxyObj, args);
        System.out.println("Method" + method.getName() + "execution completed");
        return res;
    }
}

import net.sf.cglib.proxy.Enhancer;

public class Main {
    public static void main(String[] args) {
        // 创建动态代理类
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(BankAccount.class);
        enhancer.setCallback(new BankAccountInterceptor());

        // 创建代理对象
        BankAccount proxyAccount = (BankAccount)enhancer.create();
        // 通过代理对象调用方法
        proxyAccount.deposit(100);
        proxyAccount.withdraw(50);
    }
}