Java代理模式控制访问权限怎么做

wen java案例 2026-07-29 1

Java代理模式控制访问权限：从原理到实战的完整指南

目录导读

代理模式核心概念
为什么用代理模式控制访问权限？
Java实现代理模式的三种方式
- 1 静态代理
- 2 JDK动态代理
- 3 CGLIB动态代理
实战：用动态代理实现权限控制
常见问题与解答（Q&A）
性能与安全最佳实践

代理模式核心概念

代理模式（Proxy Pattern）是结构型设计模式之一，其核心思想是为目标对象提供一个代理对象，来控制对该目标对象的访问，在Java应用中，代理模式最常见的应用场景之一就是访问权限控制。

Java代理模式控制访问权限怎么做

代理模式包含三个角色：

Subject（抽象主题）：定义真实对象和代理对象的公共接口
RealSubject（真实主题）：实际执行业务逻辑的对象
Proxy（代理）：持有RealSubject的引用，负责控制对其的访问

当客户端调用代理对象的方法时，代理可以在调用前后插入额外的逻辑，比如权限校验、日志记录、缓存等。

为什么用代理模式控制访问权限？

在大型企业级应用中,直接让客户端访问业务对象会带来几个问题：

安全漏洞：敏感操作（如删除用户、修改金额）可能被未授权用户执行
代码耦合：权限校验代码混杂在业务逻辑中，导致代码难以维护
复用性差：每个需要权限控制的方法都得写一遍校验逻辑

代理模式通过将权限控制逻辑抽离到代理类，让业务对象只关注核心功能，代理类负责检查调用者是否有权限，这种设计遵循单一职责原则和开闭原则。

Java实现代理模式的三种方式

1 静态代理

静态代理是手动编写代理类，在编译期就已经确定代理关系，优点是实现简单,缺点是每个目标类都需要一个对应的代理类。

// 抽象主题
interface UserService {
    void deleteUser(String userId);
}
// 真实主题
class UserServiceImpl implements UserService {
    public void deleteUser(String userId) {
        System.out.println("删除用户：" + userId);
    }
}
// 静态代理
class UserServiceProxy implements UserService {
    private UserService target;
    private String currentUserRole;
    public UserServiceProxy(UserService target, String role) {
        this.target = target;
        this.currentUserRole = role;
    }
    public void deleteUser(String userId) {
        if (!"ADMIN".equals(currentUserRole)) {
            throw new SecurityException("权限不足，仅管理员可删除用户");
        }
        target.deleteUser(userId);
    }
}

2 JDK动态代理

JDK动态代理通过java.lang.reflect.Proxy在运行时生成代理类,要求目标对象必须实现接口。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
class AccessInvocationHandler implements InvocationHandler {
    private Object target;
    private String currentUserRole;
    public AccessInvocationHandler(Object target, String role) {
        this.target = target;
        this.currentUserRole = role;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 权限控制逻辑
        if (method.getName().equals("deleteUser") && !"ADMIN".equals(currentUserRole)) {
            throw new SecurityException("权限不足");
        }
        return method.invoke(target, args);
    }
}
// 使用
UserService proxy = (UserService) Proxy.newProxyInstance(
    UserService.class.getClassLoader(),
    new Class[]{UserService.class},
    new AccessInvocationHandler(new UserServiceImpl(), "ADMIN")
);
proxy.deleteUser("u123");

3 CGLIB动态代理

CGLIB通过生成目标类的子类来实现代理，不需要接口,适用于没有实现接口的类。

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
class CglibAccessInterceptor implements MethodInterceptor {
    private String role;
    public CglibAccessInterceptor(String role) {
        this.role = role;
    }
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        if (method.getName().startsWith("delete") && !"ADMIN".equals(role)) {
            throw new SecurityException("权限不足");
        }
        return proxy.invokeSuper(obj, args);
    }
}
// 使用
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(UserServiceImpl.class);
enhancer.setCallback(new CglibAccessInterceptor("USER"));
UserServiceImpl proxy = (UserServiceImpl) enhancer.create();
proxy.deleteUser("u456");

实战：用动态代理实现权限控制

假设有一个银行账户系统,需要控制不同角色对账户操作的权限：

权限规则：

管理员（ADMIN）：可查询余额、存款、取款
普通用户（USER）：仅可查询余额

// 抽象主题
interface AccountService {
    void queryBalance();
    void deposit(double amount);
    void withdraw(double amount);
}
// 真实主题
class AccountServiceImpl implements AccountService {
    private double balance = 1000;
    public void queryBalance() {
        System.out.println("当前余额：" + balance);
    }
    public void deposit(double amount) {
        balance += amount;
        System.out.println("存入：" + amount);
    }
    public void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
            System.out.println("取出：" + amount);
        } else {
            throw new RuntimeException("余额不足");
        }
    }
}
// 权限注解，用于精细控制
import java.lang.annotation.*;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface RequiredRole {
    String value();
}
// 动态代理工厂
class SecurityProxyFactory {
    public static AccountService createProxy(AccountService target, String role) {
        return (AccountService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            (proxy, method, args) -> {
                // 检查方法是否有注解
                RequiredRole annotation = method.getAnnotation(RequiredRole.class);
                if (annotation != null) {
                    String requiredRole = annotation.value();
                    if (!role.equals(requiredRole) && !"ADMIN".equals(role)) {
                        throw new SecurityException("权限不足，需要角色：" + requiredRole);
                    }
                }
                return method.invoke(target, args);
            }
        );
    }
}
// 客户端使用
public class Client {
    public static void main(String[] args) {
        AccountService realService = new AccountServiceImpl();
        // 普通用户
        AccountService userProxy = SecurityProxyFactory.createProxy(realService, "USER");
        userProxy.queryBalance();  // 成功
        // userProxy.deposit(500); // 抛出安全异常
        // 管理员
        AccountService adminProxy = SecurityProxyFactory.createProxy(realService, "ADMIN");
        adminProxy.deposit(500);  // 成功
    }
}