Java动态代理实现细粒度权限控制示例

原创﹏ヽ暗。殇╰゛Y 2024-11-22 12:09 8阅读 0赞

在Java中，我们可以使用动态代理来实现细粒度的权限控制。以下是一个简单的示例：

1. 创建一个权限接口（Role Interface）：

```java
public interface Role {
    boolean hasPermission(String action);
}
```

2. 创建一个角色类（Role Class），并定义具体权限：

```java
public class User implements Role {
    private Map<String, Boolean> permissions;

public User() {
        permissions = new HashMap<>();
        permissions.put("read", true);
        permissions.put("write", false);
    }

@Override
    public boolean hasPermission(String action) {
        return permissions.containsKey(action) && permissions.get(action);
    }
}
```

3. 创建一个代理类（Proxy Class），并使用反射来实现权限控制：

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

public class PermissionInterceptor implements InvocationHandler {

private Role role;

public PermissionInterceptor(Role role) {
        this.role = role;
    }

@Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String action = method.getName().substring("invoke".length() + 1);
        if (role.hasPermission(action)) {
            return method.invoke(proxy, args);
        } else {
            throw new IllegalAccessException("User does not have permission to " + action));
        }
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        Role role = new User();
        PermissionInterceptor interceptor = new PermissionInterceptor(role);

// 创建代理对象
        MyService myService = (MyService) Proxy.newProxyInstance(
                MyService.class.getClassLoader(),
                new Class[]{MyService.class}},
                interceptor
        );

myService.action("read");
        try {
            myService.action("write");
        } catch (IllegalAccessException e) {
            System.out.println(e.getMessage());
        }
    }
}

// 定义服务接口
interface MyService {
    void action(String action);
}
```

以上代码中，`User`实现了`Role`接口，定义了具体的权限。`PermissionInterceptor`是代理类，通过反射调用方法并进行权限控制。在`main`方法中，我们创建了一个代理对象，并尝试执行不同的操作以展示权限控制。