Utilisation d'Apache Shiro pour le contrôle des autorisations dans le développement d'API Java

Utilisez Apache Shiro pour le contrôle des autorisations dans le développement d'API Java

Avec le développement de la technologie Internet, de plus en plus d'applications adoptent une architecture basée sur les API. Pour cette architecture, les données ou services sont exposés à des systèmes ou applications externes sous forme d'API. Dans ce cas, le contrôle des autorisations des utilisateurs est très important. Cet article explique principalement comment utiliser Apache Shiro pour gérer les problèmes d'autorisation dans l'API Java.

Présentation d'Apache Shiro

Apache Shiro est un framework open source d'Apache Software Foundation pour fournir des fonctions de base telles que l'authentification de sécurité, l'autorisation, la gestion des mots de passe et la gestion des sessions dans les applications. Apache Shiro est un framework de sécurité simple et facile à utiliser qui permet aux développeurs Java de se concentrer sur la logique métier sans se soucier des problèmes de sécurité.

Les principaux composants d'Apache Shiro incluent :

1. Sujet : représente un utilisateur interagissant avec notre application, qui peut être une personne, un programme, un service, etc. Chaque sujet possède un ensemble de « principes » liés à la sécurité qui peuvent être utilisés pour représenter l'identité de l'utilisateur.
2. SecurityManager : Utilisé pour gérer les opérations de sécurité des applications. Ses principales responsabilités sont l'authentification, l'autorisation, le cryptage, etc.
3. Realm : utilisé pour obtenir des données d'application, telles que les utilisateurs, les rôles, les autorisations, etc. Les données peuvent être stockées dans des bases de données, des fichiers, etc.
4. SessionManager : gérez les informations de session pour chaque utilisateur, y compris la création, l'invalidation, la maintenance, etc.
5. Session : conservez les informations de session pour chaque utilisateur, y compris le statut de connexion de l'utilisateur, etc.
6. Cryptographie : fournit des services de sécurité tels que des algorithmes de cryptage et de hachage.

Basé sur les composants ci-dessus, Shiro fournit un cadre de sécurité complet qui peut être utilisé pour développer des modules de sécurité dans des applications Java.

Utilisez Apache Shiro pour le contrôle des autorisations

Dans le processus de développement d'API Java, il est souvent nécessaire de contrôler les autorisations des utilisateurs. Shiro fournit une solution flexible et rationalisée pour implémenter cette fonction. La méthode d'implémentation spécifique est présentée ci-dessous :

1. Présentation des packages de dépendances Shiro

Tout d'abord, vous devez ajouter les packages de dépendances pertinents de Shiro au projet. Par exemple, dans un projet Maven, vous pouvez ajouter le code suivant dans pom.xml :

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-core</artifactId>
    <version>1.5.3</version>
</dependency> 

2. Définir la classe Realm

Dans Shiro, Realm est responsable de la définition des données associées telles que les utilisateurs, les rôles et les autorisations, et en l'intégrant au framework Shiro. Par conséquent, la définition de la classe Realm est la première étape du contrôle des autorisations.

Nous pouvons personnaliser une classe Realm pour implémenter la fonction d'obtention d'informations relatives à l'utilisateur à partir de la base de données, comme indiqué ci-dessous :

public class MyRealm extends AuthorizingRealm {
    
    // 根据用户名获取用户即其角色、权限等相关信息
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        // 获取当前用户的身份信息
        String username = (String) principalCollection.getPrimaryPrincipal();
        
        // 从数据库中查询用户及其角色
        User user = userService.loadByUsername(username);
        List<Role> roles = roleService.getRolesByUsername(username);
        
        // 添加角色
        List<String> roleNames = new ArrayList<>();
        for (Role role : roles) {
            roleNames.add(role.getName());
        }
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        info.addRoles(roleNames);
        
        // 添加权限
        List<String> permissionNames = new ArrayList<>();
        for (Role role : roles) {
            List<Permission> permissions = permissionService.getPermissionsByRoleId(role.getId());
            for (Permission permission : permissions) {
                permissionNames.add(permission.getName());
            }
        }
        info.addStringPermissions(permissionNames);
        
        return info;
    }
    
    // 根据用户名和密码验证用户
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        // 获取用户提交的身份信息
        String username = (String) authenticationToken.getPrincipal();
        String password = new String((char[]) authenticationToken.getCredentials());
        
        // 根据用户名查询用户
        User user = userService.loadByUsername(username);
        if (user == null) {
            throw new UnknownAccountException();
        }
        
        // 验证用户密码
        String encodedPassword = hashService.hash(password, user.getSalt());
        if (!user.getPassword().equals(encodedPassword)) {
            throw new IncorrectCredentialsException();
        }
        
        // 如果验证成功，则返回一个身份信息
        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(username, password, getName());
        return info;
    }
}

Dans le code ci-dessus, nous obtenons l'utilisateur en implémentant la méthode doGetAuthorizationInfo et la méthode doGetAuthenticationInfo fournies par AuthorizingRealm abstrait le rôle de classe et les informations d'autorisation, et vérifie l'identité de l'utilisateur. Ces méthodes appelleront UserService, RoleService, PermissionService et d'autres couches de service pour interroger les informations pertinentes dans la base de données afin d'obtenir des données utilisateur.

3. Configurer Shiro Filter

Dans l'API Java, nous pouvons configurer Shiro Filter pour intercepter les requêtes et contrôler les autorisations des utilisateurs. Shiro Filter est un filtre Servlet qui peut être utilisé pour le filtrage des autorisations, la gestion des sessions, etc. dans les applications Web.

Lors de la configuration de Shiro Filter, nous devons configurer le gestionnaire de sécurité de Shiro, la classe Realm personnalisée, la page de connexion écrite, etc. Un exemple est le suivant :

@Configuration
public class ShiroConfig {

    @Bean
    public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();
        shiroFilter.setSecurityManager(securityManager);

        // 设置登录URL
        shiroFilter.setLoginUrl("/login");
        // 设置无权访问的URL
        shiroFilter.setUnauthorizedUrl("/unauthorized");
        
        // 配置拦截器规则
        Map<String,String> filterChainDefinitionMap = new LinkedHashMap<>();
        filterChainDefinitionMap.put("/login", "anon");
        filterChainDefinitionMap.put("/logout", "logout");
        filterChainDefinitionMap.put("/home", "authc");
        filterChainDefinitionMap.put("/admin/**", "roles[admin]");
        filterChainDefinitionMap.put("/**", "authc");
        shiroFilter.setFilterChainDefinitionMap(filterChainDefinitionMap);

        return shiroFilter;
    }

    @Bean
    public SecurityManager securityManager(MyRealm myRealm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(myRealm);

        return securityManager;
    }
    
    @Bean
    public MyRealm myRealm(HashService hashService,
                           UserService userService,
                           RoleService roleService,
                           PermissionService permissionService) {
        return new MyRealm(userService, roleService, permissionService, hashService);
    }
    
    @Bean
    public HashService hashService() {
        return new SimpleHashService();
    }
}

Dans le code ci-dessus, nous utilisons l'annotation @Configuration pour définir une classe ShiroConfig pour configurer les paramètres liés à Shiro. Dans cette classe, nous définissons la méthode shirFilter(), la méthode securityManager() et la méthode myRealm() pour configurer les filtres Shiro, les gestionnaires de sécurité et les classes Realm personnalisées. Dans la méthode correspondante, nous pouvons utiliser des dépendances telles que UserService, RoleService, PermissionService, HashService, etc. pour injecter des services associés via l'injection de dépendances afin d'obtenir le contrôle des autorisations et la vérification des utilisateurs.

4. Utilisez Shiro pour le contrôle des autorisations dans l'API Java

Après avoir terminé les étapes ci-dessus, nous pouvons utiliser Shiro pour le contrôle des autorisations dans l'API Java. Dans une implémentation spécifique, nous pouvons utiliser la classe Subject fournie par Shiro pour représenter l'utilisateur actuel. Nous pouvons vérifier si l'utilisateur dispose d'un certain rôle ou d'une certaine autorisation via hasRole(), isPerowed() et d'autres méthodes de cette classe. Voici un exemple :

@Controller
public class ApiController {

    @RequestMapping("/api/test")
    @ResponseBody
    public String test() {
        Subject currentUser = SecurityUtils.getSubject();
        if (currentUser.hasRole("admin")) {
            return "Hello, admin!";
        } else if (currentUser.isAuthenticated()) {
            return "Hello, user!";
        } else {
            return "Please login first!";
        }
    }
}

Dans le code ci-dessus, nous définissons une classe ApiController et y définissons une méthode test(). Dans cette méthode, nous obtenons d'abord l'objet Sujet de l'utilisateur actuel, puis effectuons des jugements d'autorisation en appelant hasRole(), isPerowed() et d'autres méthodes.

Résumé

Le contrôle des autorisations est une question très importante dans le développement d'API Java. Apache Shiro fournit un cadre de sécurité pratique et facile à utiliser qui peut aider les développeurs Java à mettre en œuvre rapidement l'authentification des utilisateurs, l'autorisation, la gestion des mots de passe, la gestion des sessions et d'autres fonctions. Grâce à l'introduction de cet article, j'espère que les lecteurs pourront clairement comprendre comment utiliser Shiro pour implémenter des fonctions de contrôle d'autorisation dans le développement d'API Java.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!