使用Spring Boot整合Shiro和JWT实现基于注解的权限控制

引言

在Web应用程序中，权限控制是保护资源和确保用户访问安全的重要组成部分。Shiro是一个强大的安全框架，而JWT（JSON Web Token）是一种用于身份验证和授权的开放标准。本文将介绍如何使用Spring Boot整合Shiro和JWT，并通过注解实现基于角色和权限的权限控制。

1. 环境准备

在开始之前，确保已经准备好以下环境：

• JDK 8+
• Maven
• Spring Boot

2. 添加依赖

首先，在pom.xml文件中添加以下依赖：

<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Shiro Starter -->
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-spring-boot-starter</artifactId>
        <version>1.7.1</version>
    </dependency>

    <!-- JWT -->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-api</artifactId>
        <version>0.11.2</version>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-impl</artifactId>
        <version>0.11.2</version>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-jackson</artifactId>
        <version>0.11.2</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>

这些依赖包括了Spring Boot Starter、Shiro Starter和JWT相关的依赖。

3. 配置Shiro

在application.properties文件中添加以下配置：

# Shiro配置
shiro:
  jwt:
    secret: your_secret_key
    expiration: 86400000

上述配置中，secret是用于生成JWT的密钥，expiration是JWT的过期时间（单位：毫秒）。

4. 编写Shiro配置类

创建一个ShiroConfig类，用于配置Shiro的相关信息和组件：

@Configuration
public class ShiroConfig {

    @Bean
    public Realm realm() {
        return new MyRealm();
    }

    @Bean
    public DefaultWebSecurityManager securityManager(Realm realm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(realm);
        return securityManager;
    }

    @Bean
    public ShiroFilterChainDefinition shiroFilterChainDefinition() {
        DefaultShiroFilterChainDefinition chainDefinition = new DefaultShiroFilterChainDefinition();
        chainDefinition.addPathDefinition("/login", "anon");
        chainDefinition.addPathDefinition("/**", "authc");
        return chainDefinition;
    }
}

上述配置中，realm()方法用于创建自定义的Realm，securityManager()方法创建SecurityManager，并设置Realm，shiroFilterChainDefinition()方法用于配置URL的访问权限。

5. 编写自定义Realm

创建一个MyRealm类，继承AuthorizingRealm，并实现相关的方法：

public class MyRealm extends AuthorizingRealm {

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        // 获取当前用户的角色和权限信息
        String username = (String) principals.getPrimaryPrincipal();
        Set<String> roles = getRolesByUsername(username);
        Set<String> permissions = getPermissionsByUsername(username);

        // 创建授权信息对象
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        authorizationInfo.setRoles(roles);
        authorizationInfo.setStringPermissions(permissions);

        return authorizationInfo;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        // 获取用户名和密码
        String username = (String) token.getPrincipal();
        String password = getPasswordByUsername(username);

        if (password == null) {
            throw new UnknownAccountException();
        }

        // 创建认证信息对象
        SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(username, password, getName());

        return authenticationInfo;
    }

    // 模拟从数据库中获取用户角色信息
    private Set<String> getRolesByUsername(String username) {
        // ...
    }

    // 模拟从数据库中获取用户权限信息
    private Set<String> getPermissionsByUsername(String username) {
        // ...
    }

    // 模拟从数据库中获取用户密码
    private String getPasswordByUsername(String username) {
        // ...
    }
}

在doGetAuthorizationInfo()方法 

    // 模拟从数据库中获取用户角色信息
    private Set<String> getRolesByUsername(String username) {
        // ...
    }

    // 模拟从数据库中获取用户权限信息
    private Set<String> getPermissionsByUsername(String username) {
        // ...
    }

    // 模拟从数据库中获取用户密码
    private String getPasswordByUsername(String username) {
        // ...
    }

在MyRealm类中，我们重写了doGetAuthorizationInfo()方法用于获取当前用户的角色和权限信息，并创建授权信息对象。在doGetAuthenticationInfo()方法中，我们根据用户名获取密码，并创建认证信息对象。

6. 编写登录接口

创建一个LoginController类，用于处理用户登录请求：

@RestController
public class LoginController {

    @PostMapping("/login")
    public String login(@RequestParam String username, @RequestParam String password) {
        // 验证用户名和密码
        boolean valid = authenticate(username, password);

        if (valid) {
            // 生成JWT
            String jwt = generateJWT(username);

            // 返回JWT给客户端
            return jwt;
        } else {
            throw new AuthenticationException("Invalid username or password");
        }
    }

    // 验证用户名和密码
    private boolean authenticate(String username, String password) {
        // ...
    }

    // 生成JWT
    private String generateJWT(String username) {
        // ...
    }
}

在LoginController类中，我们通过/login接口处理用户登录请求。首先，验证用户名和密码是否正确。如果验证通过，我们生成JWT，并将其返回给客户端。

7. 编写自定义注解

创建一个RequiresPermissions注解，用于标注需要进行权限验证的方法：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequiresPermissions {

    String[] value();
}

8. 编写权限验证切面

创建一个PermissionAspect类，用于实现权限验证的切面：

@Aspect
@Component
public class PermissionAspect {

    @Autowired
    private HttpServletRequest request;

    @Around("@annotation(requiresPermissions)")
    public Object checkPermissions(ProceedingJoinPoint joinPoint, RequiresPermissions requiresPermissions) throws Throwable {
        // 获取请求的URL和用户信息
        String url = request.getRequestURI();
        String username = getUsernameFromJWT();

        // 校验用户是否具有访问权限
        boolean hasPermission = checkUserPermissions(username, url, requiresPermissions.value());

        if (hasPermission) {
            // 允许访问
            return joinPoint.proceed();
        } else {
            throw new AuthorizationException("Access denied");
        }
    }

    // 从JWT中获取用户名
    private String getUsernameFromJWT() {
        // ...
    }

    // 校验用户是否具有访问权限
    private boolean checkUserPermissions(String username, String url, String[] permissions) {
        // ...
    }
}

在PermissionAspect类中，我们使用@Around注解定义了一个环绕通知，用于在方法执行前进行权限验证。通过@annotation(requiresPermissions)指定了需要进行权限验证的方法，并获取请求的URL和用户信息。然后，我们校验用户是否具有访问权限，如果有权限则允许访问，否则抛出异常。

9. 使用注解进行权限控制

在需要进行权限控制的方法上使用@RequiresPermissions注解：

@RestController
public class UserController {

    @GetMapping("/users")
    @RequiresPermissions("user:list")
    public List<User> getUsers() {
        // 获取用户列表
        // ...
    }

    @PostMapping("/users")
    @RequiresPermissions("user:create")
    public User createUser(@RequestBody User user) {
        // 创建用户
        // ...
    }

    @DeleteMapping("/users/{id}")
    @RequiresPermissions("user:delete")
    public void deleteUser(@PathVariable Long id) {
        // 删除用户
        // ...
    }
}

在上述示例中，我们使用@RequiresPermissions注解对getUsers()、createUser()和deleteUser()方法进行了权限控制。只有具有相应权限的用户才能访问这些方法。

结论

本文介绍了如何使用Spring Boot整合Shiro和JWT，并通过注解实现基于角色和权限的权限控制。我们通过配置Shiro和编写自定义Realm实现用户的认证和授权，使用JWT生成和验证身份信息，通过自定义注解和切面实现基于注解的权限控制。这样，我们可以轻松地在Spring Boot应用中实现灵活且安全的权限管理。

👉 💐🌸 公众号请关注 "果酱桑", 一起学习,一起进步! 🌸💐

参考文献：

• Apache Shiro Documentation
• JSON Web Token (JWT) Official Website
• Spring Boot Documentation