Utilisation de l'authentification OAuth2 dans le développement d'API Java-javaDidacticiel-php.cn

Dans le développement de l'API Java, l'authentification est un problème inévitable. OAuth2 est une méthode d'authentification populaire qui protège les ressources API en accordant l'accès. Cet article explique comment utiliser OAuth2 pour l'authentification dans le développement d'API Java.

Présentation d'OAuth2

OAuth2 est une norme ouverte d'autorisation qui permet aux utilisateurs d'autoriser des applications tierces à accéder aux ressources de leur serveur sans avoir à partager leurs informations d'identification. La norme OAuth2 comprend les rôles suivants :

Resource Owner : le propriétaire de la ressource, c'est-à-dire l'utilisateur ;
Resource Server : le serveur de ressources, le serveur qui fournit les ressources ;
Client : le client, c'est-à-dire un ; application tierce ;
Serveur d'autorisation : serveur d'autorisation, utilisé pour émettre des jetons d'accès.

Le processus d'autorisation OAuth2 comprend les étapes suivantes :

Le client envoie une demande d'autorisation au serveur d'autorisation ;
Le serveur d'autorisation demande l'autorisation au propriétaire de la ressource
Une fois que le propriétaire de la ressource a autorisé, le serveur d'autorisation envoie un jeton d'accès au client ; utilise le jeton d'accès pour envoyer une demande au serveur de ressources ;
Le serveur de ressources vérifie le jeton d'accès et fournit des ressources.
OAuth2 prend en charge plusieurs types d'autorisation, notamment le mode code d'autorisation, le mode mot de passe, le mode client, le mode d'autorisation implicite, etc. Dans le développement d'API Java, le mode code d'autorisation et le mode mot de passe sont généralement utilisés.

Mode code d'autorisation OAuth2

Le mode code d'autorisation est le type d'autorisation le plus couramment utilisé dans OAuth2. Il comprend les étapes suivantes :

Le client envoie une demande d'autorisation au serveur d'autorisation, y compris l'ID client et l'URI de redirection ; envoie la connexion La page est donnée au propriétaire de la ressource, exigeant que le propriétaire de la ressource se connecte et autorise ;

Après l'autorisation du propriétaire de la ressource, le serveur d'autorisation envoie le code d'autorisation à l'URI de redirection
Le client utilise le code d'autorisation pour envoyer ; une demande au serveur d'autorisation, comprenant l'ID client et le secret client ;
Le serveur d'autorisation vérifie l'ID client et le secret client et, s'ils sont corrects, émet un jeton d'accès au client
Le client utilise le jeton d'accès pour envoyer une demande au client ; le serveur de ressources.
Dans le développement d'API Java, vous pouvez utiliser le framework Spring Security OAuth2 pour implémenter l'authentification en mode code d'autorisation.
Tout d'abord, vous devez ajouter les dépendances suivantes dans le pom,/api/** est le chemin qui nécessite une authentification.

Lorsque vous utilisez OAuth2RestTemplate pour envoyer une demande, vous devez d'abord obtenir un jeton d'accès. Le code est le suivant :

<dependency>
    <groupId>org.springframework.security.oauth</groupId>
    <artifactId>spring-security-oauth2</artifactId>
    <version>2.3.4.RELEASE</version>
</dependency>

Copier après la connexion

Parmi eux, le client est un objet de type OAuth2ProtectedResourceDetails, contenant des informations telles que l'ID client et le secret client.

Mode mot de passe OAuth2

Le mode Mot de passe est un type d'autorisation dans OAuth2 adapté aux clients de confiance. Il comprend les étapes suivantes :

Le client envoie une demande au serveur d'autorisation, comprenant l'ID client, le secret client et le nom d'utilisateur et le mot de passe du propriétaire de la ressource. ;

Le serveur d'autorisation vérifie l'ID client, le secret client, le nom d'utilisateur et le mot de passe, et s'ils sont corrects, émet un jeton d'accès au client ;

Le client utilise le jeton d'accès pour envoyer une demande au serveur de ressources.

<security:http pattern="/oauth/token" create-session="stateless"
    authentication-manager-ref="authenticationManager"
    xmlns="http://www.springframework.org/schema/security">
    <security:intercept-url pattern="/oauth/token" access="isAuthenticated()" method="POST" />
    <security:anonymous enabled="false" />
    <security:http-basic entry-point-ref="clientAuthenticationEntryPoint" />
    <security:custom-filter ref="clientCredentialsTokenEndpointFilter" before="BASIC_AUTH_FILTER" />
    <security:access-denied-handler ref="oauthAccessDeniedHandler" />
</security:http>

<security:http pattern="/api/**" create-session="never"
    entry-point-ref="oauthAuthenticationEntryPoint"
    access-decision-manager-ref="accessDecisionManager"
    xmlns="http://www.springframework.org/schema/security">
    <security:anonymous enabled="false" />
    <security:intercept-url pattern="/api/**" access="ROLE_USER" />
    <security:custom-filter ref="resourceServerFilter" before="PRE_AUTH_FILTER" />
    <security:access-denied-handler ref="oauthAccessDeniedHandler" />
</security:http>

<bean id="clientAuthenticationEntryPoint"
    class="org.springframework.security.oauth2.provider.error.OAuth2AuthenticationEntryPoint">
    <property name="realmName" value="spring-boot-oauth2" />
    <property name="typeName" value="Basic" />
</bean>

<bean id="oauthAuthenticationEntryPoint"
    class="org.springframework.security.oauth2.provider.error.OAuth2AuthenticationEntryPoint">
    <property name="realmName" value="spring-boot-oauth2" />
    <property name="typeName" value="Bearer" />
</bean>

<bean id="oauthAccessDeniedHandler"
    class="org.springframework.security.oauth2.provider.error.OAuth2AccessDeniedHandler" />

<bean id="clientCredentialsTokenEndpointFilter"
    class="org.springframework.security.oauth2.provider.client.ClientCredentialsTokenEndpointFilter">
    <property name="authenticationManager" ref="authenticationManager" />
</bean>

<bean id="resourceServerFilter"
    class="org.springframework.security.oauth2.provider.authentication.OAuth2AuthenticationProcessingFilter">
    <property name="authenticationManager" ref="authenticationManager" />
</bean>

<bean id="accessDecisionManager"
    class="org.springframework.security.access.vote.UnanimousBased"
    xmlns="http://www.springframework.org/schema/beans">
    <constructor-arg>
        <list>
            <bean class="org.springframework.security.oauth2.provider.vote.ScopeVoter" />
            <bean class="org.springframework.security.access.vote.RoleVoter" />
            <bean class="org.springframework.security.access.vote.AuthenticatedVoter" />
        </list>
    </constructor-arg>
</bean>

<security:authentication-manager id="authenticationManager">
    <security:authentication-provider user-service-ref="userDetailsService" />
</security:authentication-manager>

<bean id="userDetailsService"
    class="org.springframework.security.core.userdetails.jdbc.JdbcDaoImpl">
    <property name="dataSource" ref="dataSource" />
</bean>

Copier après la connexion

Parmi eux, les détails sont un objet de type ResourceOwnerPasswordResourceDetails, comprenant l'ID client, le secret client, le nom d'utilisateur et le mot de passe. et d'autres informations.

Résumé

L'utilisation d'OAuth2 pour l'authentification dans le développement d'API Java peut protéger la sécurité des ressources API et permettre aux utilisateurs d'autoriser plus facilement des applications tierces à accéder aux ressources de leur serveur. Cet article présente le mode code d'autorisation et le mode mot de passe d'OAuth2, et fournit un exemple de code pour implémenter l'authentification à l'aide du framework Spring Security OAuth2. J'espère que cela pourra être utile aux développeurs 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!