Verwendung von Apache Shiro zur Berechtigungskontrolle in der Java-API-Entwicklung

Verwenden Sie Apache Shiro zur Berechtigungskontrolle bei der Java-API-Entwicklung.

Mit der Entwicklung der Internettechnologie übernehmen immer mehr Anwendungen eine API-basierte Architektur. Bei dieser Architektur werden Daten oder Dienste in Form von APIs externen Systemen oder Anwendungen zugänglich gemacht. In diesem Fall ist die Kontrolle der Benutzerberechtigungen sehr wichtig. In diesem Artikel wird hauptsächlich die Verwendung von Apache Shiro zum Verwalten von Berechtigungsproblemen in der Java-API vorgestellt.

Übersicht über Apache Shiro

Apache Shiro ist ein Open-Source-Framework der Apache Software Foundation zur Bereitstellung grundlegender Funktionen wie Sicherheitsauthentifizierung, Autorisierung, Passwortverwaltung und Sitzungsverwaltung in Anwendungen. Apache Shiro ist ein einfaches, benutzerfreundliches Sicherheitsframework, das es Java-Entwicklern ermöglicht, sich auf die Geschäftslogik zu konzentrieren, ohne sich um Sicherheitsprobleme kümmern zu müssen.

Zu den Hauptkomponenten von Apache Shiro gehören:

1. Betreff: Stellt einen Benutzer dar, der mit unserer Anwendung interagiert. Dabei kann es sich um eine Person, ein Programm, einen Dienst usw. handeln. Jedes Subjekt verfügt über eine Reihe sicherheitsrelevanter „Prinzipale“, die zur Darstellung der Benutzeridentität verwendet werden können.
2. SecurityManager: Wird zur Verwaltung der Sicherheitsvorgänge von Anwendungen verwendet. Seine Hauptaufgaben sind Authentifizierung, Autorisierung, Verschlüsselung usw.
3. Realm: Wird zum Abrufen von Anwendungsdaten wie Benutzern, Rollen, Berechtigungen usw. verwendet. Daten können in Datenbanken, Dateien usw. gespeichert werden.
4. SessionManager: Sitzungsinformationen für jeden Benutzer verwalten, einschließlich Erstellung, Ungültigmachung, Wartung usw.
5. Sitzung: Verwalten Sie Sitzungsinformationen für jeden Benutzer, einschließlich Benutzeranmeldestatus usw.
6. Kryptografie: Bietet Sicherheitsdienste wie Verschlüsselung und Hashing-Algorithmen.

Basierend auf den oben genannten Komponenten bietet Shiro ein vollständiges Sicherheitsframework, mit dem Sicherheitsmodule in Java-Anwendungen entwickelt werden können.

Verwenden Sie Apache Shiro zur Berechtigungskontrolle

Bei der Entwicklung der Java-API ist es häufig erforderlich, Benutzerberechtigungen zu kontrollieren. Shiro bietet eine flexible und optimierte Lösung zur Implementierung dieser Funktion. Die spezifische Implementierungsmethode wird im Folgenden vorgestellt:

1. Einführung von Shiro-Abhängigkeitspaketen

Zunächst müssen Sie Shiros relevante Abhängigkeitspakete zum Projekt hinzufügen. In einem Maven-Projekt können Sie beispielsweise den folgenden Code zu pom hinzufügen. Daher ist die Definition der Realm-Klasse der erste Schritt zur Berechtigungskontrolle.

Wir können eine Realm-Klasse anpassen, um die Funktion zum Abrufen benutzerbezogener Informationen aus der Datenbank zu implementieren, wie unten gezeigt:

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

   Nach dem Login kopieren
Im obigen Code erhalten wir den Benutzer, indem wir die von AuthorizingRealm bereitgestellten Methoden doGetAuthorizationInfo und doGetAuthenticationInfo implementieren abstrakte Klassenrollen- und Berechtigungsinformationen und Überprüfung der Benutzeridentität. Diese Methoden rufen UserService, RoleService, PermissionService und andere Dienstschichten auf, um relevante Informationen in der Datenbank abzufragen und Benutzerdaten zu erhalten.

In der Java-API können wir Shiro-Filter so konfigurieren, dass er Anfragen abfängt und Benutzerberechtigungen steuert. Shiro Filter ist ein Servlet-Filter, der zur Berechtigungsfilterung, Sitzungsverwaltung usw. in Webanwendungen verwendet werden kann.

Bei der Konfiguration von Shiro Filter müssen wir Shiros Sicherheitsmanager, eine benutzerdefinierte Realm-Klasse, eine schriftliche Anmeldeseite usw. konfigurieren. Ein Beispiel lautet wie folgt:

3. 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;
       }
   }

   Nach dem Login kopieren
Im obigen Code verwenden wir die Annotation @Configuration, um eine ShiroConfig-Klasse zum Konfigurieren von Shiro-bezogenen Parametern zu definieren. In dieser Klasse definieren wir die Methoden shirFilter(), securityManager() und myRealm() zum Konfigurieren von Shiro-Filtern, Sicherheitsmanagern und benutzerdefinierten Realm-Klassen. In der entsprechenden Methode können wir Abhängigkeiten wie UserService, RoleService, PermissionService, HashService usw. verwenden, um verwandte Dienste durch Abhängigkeitsinjektion zu injizieren und so eine Berechtigungskontrolle und Benutzerüberprüfung zu erreichen.

Nach Abschluss der obigen Schritte können wir Shiro zur Berechtigungssteuerung in der Java-API verwenden. In einer bestimmten Implementierung können wir die von Shiro bereitgestellte Subject-Klasse verwenden, um den aktuellen Benutzer darzustellen. Mit hasRole(), isPermitted() und anderen Methoden dieser Klasse können wir überprüfen, ob der Benutzer eine bestimmte Rolle oder Berechtigung hat. Hier ist ein Beispiel:

@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();
    }
}

Im obigen Code definieren wir eine ApiController-Klasse und definieren darin eine test()-Methode. Bei dieser Methode erhalten wir zunächst das aktuelle Subjektobjekt des Benutzers und treffen dann Berechtigungsurteile, indem wir hasRole(), isPermitted() und andere Methoden aufrufen.
4. Zusammenfassung

Die Berechtigungskontrolle ist ein sehr wichtiges Thema bei der Java-API-Entwicklung. Apache Shiro bietet ein praktisches und benutzerfreundliches Sicherheitsframework, das Java-Entwicklern dabei helfen kann, Benutzerauthentifizierung, Autorisierung, Passwortverwaltung, Sitzungsverwaltung und andere Funktionen schnell zu implementieren. Ich hoffe, dass die Leser durch die Einleitung dieses Artikels klar verstehen können, wie Shiro zum Implementieren von Berechtigungskontrollfunktionen in der Java-API-Entwicklung verwendet wird.

Das obige ist der detaillierte Inhalt vonVerwendung von Apache Shiro zur Berechtigungskontrolle in der Java-API-Entwicklung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!