Zelfstudie: Een beveiligde web-API aanroepen in android-app

Van toepassing op: Groene cirkel met een wit vinkje dat aangeeft dat de volgende inhoud van toepassing is op werknemerstenants. Werknemerstenants Externe tenants (meer informatie)

Dit is de derde zelfstudie in de reeks zelfstudies die u begeleidt bij het aanroepen van een beveiligde web-API met behulp van externe Microsoft Entra-id.

In deze handleiding leert u:

Een beveiligde web-API aanroepen

Handleiding: Aanmelding toevoegen aan een Android-app met het Microsoft Identity Platform

Een beveiligde web-API aanroepen

Workforce-tenantconfiguratie
externe tenant-configuratie

In app>src>main>java>com.example(uw app-naam). Maak de volgende Android-fragmenten:
- MSGraphRequestWrapper

Open MSGraphRequestWrapper.java en vervang de code door het volgende codefragment om de Microsoft Graph API aan te roepen met behulp van het token van MSAL:

 package com.azuresamples.msalandroidapp;

 import android.content.Context;
 import android.util.Log;

 import androidx.annotation.NonNull;

 import com.android.volley.DefaultRetryPolicy;
 import com.android.volley.Request;
 import com.android.volley.RequestQueue;
 import com.android.volley.Response;
 import com.android.volley.toolbox.JsonObjectRequest;
 import com.android.volley.toolbox.Volley;

 import org.json.JSONObject;

 import java.util.HashMap;
 import java.util.Map;

 public class MSGraphRequestWrapper {
     private static final String TAG = MSGraphRequestWrapper.class.getSimpleName();

     // See: https://docs.microsoft.com/en-us/graph/deployments#microsoft-graph-and-graph-explorer-service-root-endpoints
     public static final String MS_GRAPH_ROOT_ENDPOINT = "https://graph.microsoft.com/";

     /**
      * Use Volley to make an HTTP request with
      * 1) a given MSGraph resource URL
      * 2) an access token
      * to obtain MSGraph data.
      **/
     public static void callGraphAPIUsingVolley(@NonNull final Context context,
                                                @NonNull final String graphResourceUrl,
                                                @NonNull final String accessToken,
                                                @NonNull final Response.Listener<JSONObject> responseListener,
                                                @NonNull final Response.ErrorListener errorListener) {
         Log.d(TAG, "Starting volley request to graph");

         /* Make sure we have a token to send to graph */
         if (accessToken == null || accessToken.length() == 0) {
             return;
         }

         RequestQueue queue = Volley.newRequestQueue(context);
         JSONObject parameters = new JSONObject();

         try {
             parameters.put("key", "value");
         } catch (Exception e) {
             Log.d(TAG, "Failed to put parameters: " + e.toString());
         }

         JsonObjectRequest request = new JsonObjectRequest(Request.Method.GET, graphResourceUrl,
                 parameters, responseListener, errorListener) {
             @Override
             public Map<String, String> getHeaders() {
                 Map<String, String> headers = new HashMap<>();
                 headers.put("Authorization", "Bearer " + accessToken);
                 return headers;
             }
         };

         Log.d(TAG, "Adding HTTP GET to Queue, Request: " + request.toString());

         request.setRetryPolicy(new DefaultRetryPolicy(
                 3000,
                 DefaultRetryPolicy.DEFAULT_MAX_RETRIES,
                 DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));
         queue.add(request);
     }
 }

Als u een web-API wilt aanroepen vanuit een Android-toepassing voor toegang tot externe gegevens of services, begint u met het maken van een secundair object in uw MainActivity-klasse. Het bijbehorende object moet de volgende code bevatten:
```
companion object {
    private const val WEB_API_BASE_URL = "" // Developers should set the respective URL of their web API here
    private const val scopes = "" // Developers should append the respective scopes of their web API.
}
```
Het bijbehorende object definieert twee privéconstanten: WEB_API_BASE_URL, waar ontwikkelaars de URL van hun web-API instellen en scopes, waarbij ontwikkelaars de respectieve scopes van hun web-API toevoegen.
Gebruik de volgende code om het proces van toegang tot een web-API af te handelen:
```
private fun accessWebApi() {
    CoroutineScope(Dispatchers.Main).launch {
        binding.txtLog.text = ""
        try {
            if (WEB_API_BASE_URL.isBlank()) {
                Toast.makeText(this@MainActivity, getString(R.string.message_web_base_url), Toast.LENGTH_LONG).show()
                return@launch
            }
            val apiResponse = withContext(Dispatchers.IO) {
                ApiClient.performGetApiRequest(WEB_API_BASE_URL, accessToken)
            }
            binding.txtLog.text = getString(R.string.log_web_api_response)  + apiResponse.toString()
        } catch (exception: Exception) {
            Log.d(TAG, "Exception while accessing web API: $exception")

            binding.txtLog.text = getString(R.string.exception_web_api) + exception
        }
    }
}
```
De code startt een coroutine in de hoofd-dispatcher. Het begint met het wissen van het tekstlogboek. Vervolgens wordt gecontroleerd of de basis-URL van de web-API leeg is; zo ja, dan wordt er een melding weergegeven en keert het terug. Vervolgens wordt er een GET-aanvraag naar de web-API uitgevoerd met behulp van het opgegeven toegangstoken in een achtergrondthread.

Nadat het API-antwoord is ontvangen, wordt het tekstlogboek bijgewerkt met de antwoordinhoud. Als er tijdens dit proces een uitzondering optreedt, wordt de uitzondering vastgelegd en wordt het tekstlogboek bijgewerkt met het bijbehorende foutbericht.

In de code, waarin we onze callback opgeven, gebruiken we een functie met de naam performGetApiRequest(). De functie moet de volgende code hebben:
```
object ApiClient {
    private val client = OkHttpClient()

    fun performGetApiRequest(WEB_API_BASE_URL: String, accessToken: String?): Response {
        val fullUrl = "$WEB_API_BASE_URL/api/todolist"

        val requestBuilder = Request.Builder()
                .url(fullUrl)
                .addHeader("Authorization", "Bearer $accessToken")
                .get()

        val request = requestBuilder.build()

        client.newCall(request).execute().use { response -> return response }
    }
}
```
De code vereenvoudigt het maken van GET aanvragen naar een web-API. De hoofdmethode is performGetApiRequest(), waarbij de basis-URL van de web-API en een toegangstoken als parameters worden gebruikt. In deze methode wordt een volledige URL samengesteld door /api/todolist toe te voegen aan de basis-URL. Vervolgens wordt er een HTTP-aanvraag gebouwd met de juiste headers, inclusief de autorisatieheader met het toegangstoken.

Ten slotte wordt de aanvraag synchroon uitgevoerd met behulp van de newCall() methode van OkHttp en wordt het antwoord geretourneerd. Het ApiClient-object onderhoudt een exemplaar van OkHttpClient voor het verwerken van HTTP-aanvragen. Als u OkHttpClientwilt gebruiken, moet u de afhankelijkheid implementation 'com.squareup.okhttp3:okhttp:4.9.0' toevoegen aan uw Android Gradle-bestand.

Zorg ervoor dat u de importverklaringen opneemt. Android Studio moet automatisch de importinstructies voor u bevatten.

Uw app testen

Bouw en implementeer de app op een testapparaat of emulator. U moet zich kunnen aanmelden en tokens voor Microsoft Entra-id ophalen.

Feedback

Is deze pagina nuttig?

Last updated on 2025-04-16