Shiro整合JWT – 通过URL控制权限

在现代的Web应用中，权限控制是一个非常重要的功能。Apache Shiro是一个强大且灵活的安全框架，而JSON Web Token（JWT）则是一种流行的身份验证和授权机制。本文将介绍如何使用Shiro整合JWT，并通过URL控制权限。

目录

• 介绍
• 准备工作
• 整合Shiro和JWT
  • 添加依赖
  • 配置Shiro
  • 编写自定义Realm
  • 编写登录接口
  • 生成和验证JWT
• 通过URL控制权限
  • 自定义注解
  • 编写权限验证切面
  • 使用注解进行权限控制
• 总结

介绍

权限控制是保护Web应用中敏感资源的关键。Shiro是一个功能强大且易于使用的Java安全框架，提供了身份验证、授权、加密和会话管理等功能。而JWT是一种轻量级的身份验证和授权机制，通过使用JSON格式的令牌来传递安全凭据。

本文将介绍如何使用Shiro整合JWT，通过URL控制权限。我们将使用Spring Boot作为基础框架，并通过示例代码详细讲解每个步骤。

准备工作

在开始之前，确保你已经安装了以下工具和环境：

• JDK 8+
• Maven
• IDE（如IntelliJ IDEA或Eclipse）

整合Shiro和JWT

添加依赖

首先，我们需要在pom.xml文件中添加Shiro和JWT的依赖：

<!-- Shiro -->
<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>

配置Shiro

在application.properties文件中配置Shiro：

# 配置Shiro的Web过滤器
shiro.filter.loginUrl = /login
shiro.filter.successUrl = /home
shiro.filter.unauthorizedUrl = /unauthorized

# 配置Shiro的Realm
shiro.realm = com.example.MyRealm

编写自定义Realm

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

public class MyRealm extends AuthorizingRealm {

    // 重写方法，用于获取用户角色和权限信息
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        // ...
    }

    // 重写方法，用于验证用户身份
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        // ...
    }

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

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

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

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

编写登录接口

创建一个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，并将其返回给客户端。

生成和验证JWT

创建一个JwtUtils类，用于生成和验证JWT：

public class JwtUtils {

    private static final String SECRET_KEY = "your_secret_key";
    private static final long EXPIRATION_TIME = 86400000; // 24 hours

    public static String generateJWT(String username) {
        Date now = new Date();
        Date expiration = new Date(now.getTime() + EXPIRATION_TIME);

        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(now)
                .setExpiration(expiration)
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                .compact();
    }

    public static String getUsernameFromJWT(String jwt) {
        Claims claims = Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(jwt)
                .getBody();

        return claims.getSubject();
    }

    public static boolean validateJWT(String jwt) {
        try {
            Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(jwt);
            return true;
        } catch (JwtException | IllegalArgumentException e) {
            return false;
        }
    }
}

在JwtUtils类中，我们定义了生成JWT、从JWT中获取用户名和验证JWT的方法。

通过URL控制权限

自定义注解

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

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

    String[] value();
}

编写权限验证切面

创建一个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 = JwtUtils.getUsernameFromJWT(getJWTFromRequest());

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

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

    private String getJWTFromRequest() {
        // 从请求头或请求参数中获取JWT
        // ...
    }

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

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

使用注解进行权限控制

在需要进行权限控制的方法上使用@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()方法进行了权限控制。只有具有相应权限的用户才能访问这些方法。

总结

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

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