Quarkus项目中基于角色的字段级授权实现咨询

针对你需要限制不同角色修改特定字段的需求，这里提供三种实用的实现方案：

方案一：服务层结合安全上下文做字段校验 #

这是最直接的方式，在业务服务层中通过安全上下文获取当前用户角色，对比传入的更新对象与数据库原有对象的字段差异，判断是否符合权限要求。

代码示例 #

服务层逻辑：

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.security.enterprise.SecurityContext;
import jakarta.ws.rs.ForbiddenException;
import java.util.Set;

@ApplicationScoped
public class ProductService {

    @Inject
    SecurityContext securityContext;

    // 从数据库获取原有产品的方法
    public Product getProductById(Long id) {
        // 实际项目中替换为数据库查询逻辑
        return new Product();
    }

    public Product updateProduct(Long id, Product updatedProduct) {
        Product existingProduct = getProductById(id);
        Set<String> userRoles = securityContext.getCallerPrincipal().getRoles();

        // Role A仅允许修改description
        if (userRoles.contains("Role A")) {
            if (!existingProduct.getName().equals(updatedProduct.getName()) 
                || !existingProduct.getCustomerName().equals(updatedProduct.getCustomerName())) {
                throw new ForbiddenException("Role A只能修改description字段");
            }
            existingProduct.setDescription(updatedProduct.getDescription());
        } 
        // Role B仅允许修改name和customerName
        else if (userRoles.contains("Role B")) {
            if (!existingProduct.getDescription().equals(updatedProduct.getDescription())) {
                throw new ForbiddenException("Role B只能修改name和customerName字段");
            }
            existingProduct.setName(updatedProduct.getName());
            existingProduct.setCustomerName(updatedProduct.getCustomerName());
        } 
        // 兜底处理未授权角色
        else {
            throw new ForbiddenException("无权限修改产品");
        }

        // 保存到数据库的逻辑
        return existingProduct;
    }
}

控制器层保持原有端点授权：

import jakarta.annotation.security.RolesAllowed;
import jakarta.inject.Inject;
import jakarta.ws.rs.PUT;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.PathParam;

@Path("/products")
public class ProductResource {

    @Inject
    ProductService productService;

    @PUT
    @Path("/{id}")
    @RolesAllowed({"Role A", "Role B"})
    public Product updateProduct(@PathParam("id") Long id, Product product) {
        return productService.updateProduct(id, product);
    }
}

方案二：分角色DTO+映射 #

通过为不同角色创建专属的更新DTO，从源头限制可提交的字段，避免无效参数传入，同时让权限逻辑更清晰。

代码示例 #

创建角色专属DTO：

// Role A专属更新DTO
public class ProductRoleAUpdateDTO {
    private String description;

    // getter/setter
    public String getDescription() { return description; }
    public void setDescription(String description) { this.description = description; }
}

// Role B专属更新DTO
public class ProductRoleBUpdateDTO {
    private String name;
    private String customerName;

    // getter/setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getCustomerName() { return customerName; }
    public void setCustomerName(String customerName) { this.customerName = customerName; }
}

控制器层分接口处理：

import jakarta.annotation.security.RolesAllowed;
import jakarta.inject.Inject;
import jakarta.ws.rs.PUT;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.PathParam;

@Path("/products")
public class ProductResource {

    @Inject
    ProductService productService;

    @PUT
    @Path("/{id}/role-a")
    @RolesAllowed("Role A")
    public Product updateProductByRoleA(@PathParam("id") Long id, ProductRoleAUpdateDTO dto) {
        return productService.updateProductForRoleA(id, dto);
    }

    @PUT
    @Path("/{id}/role-b")
    @RolesAllowed("Role B")
    public Product updateProductByRoleB(@PathParam("id") Long id, ProductRoleBUpdateDTO dto) {
        return productService.updateProductForRoleB(id, dto);
    }
}

服务层实现对应更新逻辑：

import jakarta.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class ProductService {

    public Product getProductById(Long id) {
        // 实际项目中替换为数据库查询逻辑
        return new Product();
    }

    public Product updateProductForRoleA(Long id, ProductRoleAUpdateDTO dto) {
        Product existingProduct = getProductById(id);
        existingProduct.setDescription(dto.getDescription());
        // 保存到数据库的逻辑
        return existingProduct;
    }

    public Product updateProductForRoleB(Long id, ProductRoleBUpdateDTO dto) {
        Product existingProduct = getProductById(id);
        existingProduct.setName(dto.getName());
        existingProduct.setCustomerName(dto.getCustomerName());
        // 保存到数据库的逻辑
        return existingProduct;
    }
}

方案三：自定义拦截器做字段校验 #

如果不想在服务层重复编写权限逻辑，可以通过自定义拦截器，在请求到达服务层前自动校验字段权限。

代码示例 #

定义拦截器绑定注解：

import jakarta.interceptor.InterceptorBinding;
import java.lang.annotation.*;

@InterceptorBinding
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ValidateProductFields {
    String[] allowedRoles() default {};
    String[] allowedFields() default {};
}

实现拦截器逻辑：

import jakarta.interceptor.AroundInvoke;
import jakarta.interceptor.Interceptor;
import jakarta.interceptor.InvocationContext;
import jakarta.security.enterprise.SecurityContext;
import jakarta.ws.rs.ForbiddenException;
import jakarta.inject.Inject;
import java.lang.reflect.Field;
import java.util.Set;

@Interceptor
@ValidateProductFields
public class ProductFieldValidationInterceptor {

    @Inject
    SecurityContext securityContext;

    @AroundInvoke
    public Object intercept(InvocationContext ctx) throws Exception {
        ValidateProductFields annotation = ctx.getMethod().getAnnotation(ValidateProductFields.class);
        Set<String> userRoles = securityContext.getCallerPrincipal().getRoles();

        // 校验当前角色是否在允许列表中
        boolean hasMatchingRole = userRoles.stream().anyMatch(role -> Set.of(annotation.allowedRoles()).contains(role));
        if (!hasMatchingRole) {
            throw new ForbiddenException("无权限执行此操作");
        }

        // 获取原有产品和更新后的产品对象（需对应方法参数顺序）
        Product existingProduct = (Product) ctx.getParameters()[0];
        Product updatedProduct = (Product) ctx.getParameters()[1];

        // 检查是否修改了未授权字段
        for (Field field : Product.class.getDeclaredFields()) {
            field.setAccessible(true);
            Object oldValue = field.get(existingProduct);
            Object newValue = field.get(updatedProduct);
            if (!oldValue.equals(newValue) && !Set.of(annotation.allowedFields()).contains(field.getName())) {
                throw new ForbiddenException(String.format("当前角色不允许修改字段：%s", field.getName()));
            }
        }

        return ctx.proceed();
    }
}

服务层方法使用拦截器：

import jakarta.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class ProductService {

    public Product getProductById(Long id) {
        // 实际项目中替换为数据库查询逻辑
        return new Product();
    }

    @ValidateProductFields(allowedRoles = {"Role A"}, allowedFields = {"description"})
    public Product updateProductForRoleA(Product existingProduct, Product updatedProduct) {
        existingProduct.setDescription(updatedProduct.getDescription());
        // 保存到数据库的逻辑
        return existingProduct;
    }

    @ValidateProductFields(allowedRoles = {"Role B"}, allowedFields = {"name", "customerName"})
    public Product updateProductForRoleB(Product existingProduct, Product updatedProduct) {
        existingProduct.setName(updatedProduct.getName());
        existingProduct.setCustomerName(updatedProduct.getCustomerName());
        // 保存到数据库的逻辑
        return existingProduct;
    }
}

内容的提问来源于stack exchange，提问作者strelok