java接口如何做权限控制

Java接口的权限控制可以通过角色权限管理、注解结合AOP、Spring Security等方式实现。 在本文中，我们将详细探讨其中的注解结合AOP方式，并介绍其他方法的基本概念和实现步骤。

一、角色权限管理

角色权限管理是最常见的权限控制方式之一。通过为不同的用户分配不同的角色，并为每个角色定义可以访问的接口或资源，从而实现权限控制。

1. 用户角色设计

在角色权限管理中，首先需要设计用户角色。用户角色可以是固定的（例如管理员、普通用户等），也可以是动态的（例如根据用户的行为或者特定条件动态分配角色）。

示例：

public class User {
    private String username;
    private String password;
    private List<Role> roles;
    // getters and setters
}
public class Role {
    private String name;
    private List<Permission> permissions;
    // getters and setters
}
public class Permission {
    private String resource;
    private String action;
    // getters and setters
}

2. 权限校验逻辑

在进行接口调用时，需要校验当前用户是否拥有访问该接口的权限。可以通过在接口方法中添加权限校验逻辑来实现。

示例：

public class PermissionService {
    public boolean hasPermission(User user, String resource, String action) {
        for (Role role : user.getRoles()) {
            for (Permission permission : role.getPermissions()) {
                if (permission.getResource().equals(resource) && permission.getAction().equals(action)) {
                    return true;
                }
            }
        }
        return false;
    }
}

二、注解结合AOP

使用注解和AOP（Aspect-Oriented Programming，面向切面编程）可以方便地对接口进行权限控制。通过自定义注解标记需要权限控制的方法，并使用AOP在方法执行前进行权限校验。

1. 自定义注解

首先，需要定义一个权限控制注解。

示例：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequiresPermission {
    String resource();
    String action();
}

2. 权限校验切面

接着，使用AOP定义一个切面，在方法执行前进行权限校验。

示例：

@Aspect
@Component
public class PermissionAspect {
    @Autowired
    private PermissionService permissionService;
    @Before("@annotation(requiresPermission)")
    public void checkPermission(JoinPoint joinPoint, RequiresPermission requiresPermission) throws Throwable {
        User currentUser = getCurrentUser(); // 获取当前用户
        String resource = requiresPermission.resource();
        String action = requiresPermission.action();
        if (!permissionService.hasPermission(currentUser, resource, action)) {
            throw new AccessDeniedException("Access Denied");
        }
    }
    private User getCurrentUser() {
        // 获取当前用户的逻辑
        return new User();
    }
}

3. 使用注解

最后，在需要进行权限控制的接口方法上使用自定义注解。

示例：

@RestController
@RequestMapping("/api")
public class MyController {
    @RequiresPermission(resource = "user", action = "read")
    @GetMapping("/users")
    public List<User> getUsers() {
        // 业务逻辑
        return new ArrayList<>();
    }
}

三、Spring Security

Spring Security是一个强大的安全框架，可以非常方便地实现权限控制。它提供了全面的认证和授权功能，并且可以与Spring MVC无缝集成。

1. 配置Spring Security

首先，需要在Spring Boot项目中引入Spring Security依赖。

示例：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

2. 定义安全配置

接着，定义Spring Security配置类，设置认证和授权规则。

示例：

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 配置用户信息和角色
        auth.inMemoryAuthentication()
            .withUser("admin").password("{noop}password").roles("ADMIN")
            .and()
            .withUser("user").password("{noop}password").roles("USER");
    }
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 配置权限规则
        http.authorizeRequests()
            .antMatchers("/admin/").hasRole("ADMIN")
            .antMatchers("/user/").hasAnyRole("ADMIN", "USER")
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .and()
            .httpBasic();
    }
}

3. 使用Spring Security注解

Spring Security还提供了丰富的注解，可以方便地在方法级别进行权限控制。

示例：

@RestController
@RequestMapping("/api")
public class MyController {
    @PreAuthorize("hasRole('ROLE_ADMIN')")
    @GetMapping("/admin")
    public String adminEndpoint() {
        return "Admin Access";
    }
    @PreAuthorize("hasAnyRole('ROLE_ADMIN', 'ROLE_USER')")
    @GetMapping("/user")
    public String userEndpoint() {
        return "User Access";
    }
}

四、基于JWT的权限控制

JWT（JSON Web Token）是一种用于在各方之间传递安全信息的紧凑、自包含的方式。通过JWT可以实现分布式系统中的认证和授权。

1. 引入JWT依赖

首先，在Spring Boot项目中引入JWT依赖。

示例：

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

2. 生成和解析JWT

接着，编写工具类用于生成和解析JWT。

示例：

public class JwtUtil {
    private static final String SECRET_KEY = "mySecretKey";
    public static String generateToken(String username, List<String> roles) {
        return Jwts.builder()
            .setSubject(username)
            .claim("roles", roles)
            .setIssuedAt(new Date())
            .setExpiration(new Date(System.currentTimeMillis() + 86400000)) // 1 day
            .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
            .compact();
    }
    public static Claims parseToken(String token) {
        return Jwts.parser()
            .setSigningKey(SECRET_KEY)
            .parseClaimsJws(token)
            .getBody();
    }
}

3. JWT过滤器

编写JWT过滤器，在每次请求时解析JWT并进行权限校验。

示例：

public class JwtFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        String token = request.getHeader("Authorization");
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            Claims claims = JwtUtil.parseToken(token);
            if (claims != null) {
                String username = claims.getSubject();
                List<String> roles = claims.get("roles", List.class);
                // 生成认证对象并设置到SecurityContext中
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                        username, null, roles.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList()));
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        }
        filterChain.doFilter(request, response);
    }
}

4. 配置JWT过滤器

在Spring Security配置类中添加JWT过滤器。

示例：

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .antMatchers("/login").permitAll()
            .anyRequest().authenticated()
            .and()
            .addFilterBefore(new JwtFilter(), UsernamePasswordAuthenticationFilter.class);
    }
}

5. 生成和返回JWT

在登录接口中生成并返回JWT。

示例：

@RestController
public class AuthController {
    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestBody LoginRequest request) {
        // 验证用户名和密码
        if ("user".equals(request.getUsername()) && "password".equals(request.getPassword())) {
            List<String> roles = Arrays.asList("ROLE_USER");
            String token = JwtUtil.generateToken(request.getUsername(), roles);
            return ResponseEntity.ok(new LoginResponse(token));
        }
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
    }
}

通过以上几种方式，可以在Java接口中实现灵活的权限控制。每种方式都有其优缺点和适用场景，开发者可以根据实际需求选择合适的实现方案。