Configuration Azure AD et authentification Microsoft Graph
Aspose.Email for Java offre une intégration complète avec Microsoft Graph, permettant aux développeurs de gérer les messages, contacts, calendriers et tâches à partir de comptes Microsoft 365. Ce guide vous accompagne dans la création d’une application Azure AD et la configuration de l’authentification pour commencer à coder avec Aspose.Email GraphClient.
Avant d’utiliser les API Microsoft Graph avec Aspose.Email, vous devez enregistrer une application dans Azure Active Directory (Azure AD) et configurer l’authentification. Cette page couvre :
-
Création d’une application Azure AD (projet).
-
Assignation des autorisations Microsoft Graph nécessaires.
-
Génération des identifiants (ID client, secret client, ID de locataire).
-
Authentification en Java à l’aide des fournisseurs de jetons Aspose.Email.
Une fois terminé, vous serez prêt à interagir avec Microsoft Graph depuis votre application Java.
1. Créer une application Azure AD
Suivez ces étapes pour enregistrer votre application dans le portail Azure :
- Connectez-vous au Portail Azure.
- Accédez à Azure Active Directory → App Registrations → New Registration.
- Entrez un Nom pour votre application (ex. : AsposeEmailGraphApp).
- Choisissez les types de compte pris en charge :
- Single tenant (si seule votre organisation l’utilisera)
- Multitenant (si plusieurs organisations ont besoin d’accès)
- Optionnellement, définissez une URI de redirection (nécessaire pour l’authentification interactive ou web).
- Cliquez sur Register.
2. Créer un secret client
- Après l’enregistrement, accédez à Certificates & Secrets → New Client Secret.
- Ajoutez une description et une période d’expiration.
- Copiez la valeur du secret généré - vous ne la verrez plus.
Gardez le secret client en sécurité ; il est requis pour l’authentification du client confidentiel.
Vous devriez voir le volet des applications nouvellement enregistrées.
3. Configurer les autorisations Microsoft Graph
- Accédez à API Permissions → Add a Permission → Microsoft Graph.
- Choisissez le type d’autorisations : Déléguées ou Application, selon votre scénario.
- Ajoutez les autorisations requises pour les opérations Aspose.Email :
- Contacts.ReadWrite – pour gérer les contacts
- Calendars.ReadWrite – pour gérer les calendriers
- Mail.ReadWrite – pour lire et envoyer des messages
- Tasks.ReadWrite – pour gérer les tâches
- Cliquez sur Accorder le consentement administrateur si nécessaire.
4. Autoriser les flux de client public
Spécifiez si l’application est un client public. Approprié pour les applications utilisant des flux d’octroi de jeton qui n’utilisent pas d’URI de redirection.
5. Authentification Microsoft Graph
Méthodes d’authentification prises en charge dans Aspose.Email
| Fournisseur de jeton | Cas d’utilisation | | ——————————– | ————————————————————————————— | | AzureConfidentialTokenProvider | Client confidentiel (ID client + secret) pour les applications côté serveur | | AzureROPCConfiguration | Identifiants du propriétaire de la ressource (nom d’utilisateur + mot de passe) pour les scénarios non interactifs | | AzurePublicTokenProvider | Client public (connexion interactive) | | AzureTokenProviderBase | Classe de base pour les implémentations d’authentification personnalisées |
Authentifier en utilisant un client confidentiel
Utilisez le AzureConfidentialTokenProvider pour s’authentifier lorsque vous avez l’ID client, le secret client et l’ID de locataire :
AzureConfidentialTokenProvider provider = new AzureConfidentialTokenProvider(
tenantId,
clientId,
clientSecret
);
IGraphClient client = GraphClient.getClient(provider, tenantId);
client.setResource(ResourceType.Users);
client.setResourceId(username);
client.setEndpoint("https://graph.microsoft.com");
Cela configure un IGraphClient entièrement authentifié prêt à interagir avec Microsoft Graph.
Authentifier en utilisant ROPC (Nom d’utilisateur & Mot de passe)
Pour les scénarios où vous avez un nom d’utilisateur et un mot de passe, utilisez AzureROPCConfiguration:
AzureROPCConfiguration ropcConfig = new AzureROPCConfiguration(
tenantId,
clientId,
clientSecret,
username,
password
);
IGraphClient client = GraphClient.getClient(ropcConfig, tenantId);
client.setResource(ResourceType.Users);
client.setResourceId(username);
client.setEndpoint("https://graph.microsoft.com");
Fournisseurs de jetons personnalisés pour Microsoft Graph
Aspose.Email for Java s’intègre à Microsoft Graph via le IGraphClient interface. Pour authentifier les requêtes, une implémentation de la ITokenProvider est requis. Bien que la plupart des développeurs utilisent les fournisseurs d’authentification intégrés, il existe des scénarios où vous pouvez souhaiter créer votre propre fournisseur, par exemple lors de l’utilisation du flux Resource Owner Password Credentials (ROPC).
1. Implémenter ITokenProvider en utilisant AzureROPCTokenProvider
Cette classe fournit une implémentation de ITokenProvider en utilisant le flux Azure Resource Owner Password Credentials (ROPC). L’exemple suivant est uniquement à des fins de démonstration. En production, nous recommandons d’utiliser des flux plus sécurisés tels que les informations d’identification client ou le code d’autorisation avec PKCE.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
/**
* <p>
* Azure resource owner password credential (ROPC) token provider
* https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth-ropc
* https://docs.microsoft.com/en-us/exchange/client-developer/exchange-web-services/how-to-authenticate-an-ews-application-by-using-oauth
* https://portal.azure.com
* https://developer.microsoft.com/en-us/graph/graph-explorer/#
* token parser https://jwt.io
* </p>
*/
class AzureROPCTokenProvider implements ITokenProvider {
private static final String GRANT_TYPE = "password";
private final String clientId;
private final String clientSecret;
private final String userName;
private final String password;
private final String tenant;
private final String scope;
private OAuthToken token;
public AzureROPCTokenProvider(String tenant, String clientId, String clientSecret,
String userName, String password, String[] scopeAr) {
this.tenant = tenant;
this.clientId = clientId;
this.clientSecret = clientSecret;
this.userName = userName;
this.password = password;
this.scope = joinToStr(scopeAr, " ");
}
public synchronized OAuthToken getAccessToken(boolean ignoreExistingToken) {
if (this.token != null && !this.token.getExpired() && !ignoreExistingToken)
return this.token;
token = null;
Map<String, String> tokenArgs = getToken();
java.util.Calendar c = java.util.Calendar.getInstance();
c.add(java.util.Calendar.SECOND, Integer.parseInt(tokenArgs.get("expires_in")));
token = new OAuthToken(tokenArgs.get("access_token"), TokenType.AccessToken, c.getTime());
return token;
}
public final OAuthToken getAccessToken() {
return getAccessToken(false);
}
public void dispose() {
}
private String getEncodedParameters() {
return "client_id=" + urlEncode(clientId) + "&scope=" + urlEncode(scope) + "&username=" + urlEncode(userName)
+ "&password=" + urlEncode(password) + "&grant_type="
+ urlEncode(GRANT_TYPE);
}
private String getUri() {
if (tenant == null || tenant.trim().isEmpty())
return "https://login.microsoftonline.com/common/oauth2/v2.0/token";
else
return "https://login.microsoftonline.com/" + tenant + "/oauth2/v2.0/token";
}
private Map<String, String> getToken() {
try {
HttpURLConnection connection = (HttpURLConnection) new URL(getUri()).openConnection();
connection.setRequestMethod("POST");
byte[] requestData = getEncodedParameters().getBytes(StandardCharsets.UTF_8);
connection.setUseCaches(false);
connection.setDoInput(true);
connection.setDoOutput(true);
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
connection.setRequestProperty("Content-Length", "" + requestData.length);
final OutputStream st = connection.getOutputStream();
try {
st.write(requestData, 0, requestData.length);
} finally {
st.flush();
st.close();
}
connection.connect();
if (connection.getResponseCode() >= HttpURLConnection.HTTP_BAD_REQUEST) {
throw new IllegalAccessError("Operation failed: " + connection.getResponseCode() + "/" +
connection.getResponseMessage() + "\r\nDetails:\r\n{2}"
+ readInputStream(connection.getErrorStream()));
}
String responseText = readInputStream(connection.getInputStream());
Map<String, String> result = new HashMap<>();
String[] fromJsonToKeyValue = responseText.replace("{", "").replace("}", "")
.replace("\"", "").replace("\r", "")
.replace("\n", "").split(",");
for (String keyValue : fromJsonToKeyValue) {
String[] pair = keyValue.split(":");
String name = pair[0].trim().toLowerCase();
String value = urlDecode(pair[1].trim());
result.put(name, value);
}
return result;
} catch (IOException e) {
throw new IllegalAccessError(e.getMessage());
}
}
static String urlEncode(String value) {
try {
return URLEncoder.encode(value, StandardCharsets.UTF_8.toString());
} catch (UnsupportedEncodingException e) {
throw new IllegalAccessError(e.getMessage());
}
}
static String urlDecode(String value) {
try {
return URLDecoder.decode(value, StandardCharsets.UTF_8.toString());
} catch (UnsupportedEncodingException e) {
throw new IllegalAccessError(e.getMessage());
}
}
static String readInputStream(InputStream is) {
if (is == null)
return "";
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder result = new StringBuilder();
String line;
try {
while ((line = reader.readLine()) != null) {
result.append(line);
}
} catch (IOException e) {
// ignore
}
return result.toString();
}
static String joinToStr(String[] arr, String sep) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < arr.length; i++) {
if (i > 0)
sb.append(sep);
sb.append(arr[i]);
}
return sb.toString();
}
}
2. Créer un objet ITokenProvider
Le IGraphClient l’interface est responsable de la construction des requêtes, de leur envoi à Microsoft Graph et du traitement des réponses. Pour créer une instance de IGraphClient, vous devez fournir une implémentation de ITokenProvider. Le fournisseur de jetons authentifie les requêtes en fournissant un jeton d’accès OAuth valide.
L’exemple de code suivant montre comment créer une implémentation en ligne basique de ITokenProvider interface, qui est requise pour authentifier les requêtes Microsoft Graph :
ITokenProvider tokenProvider = new ITokenProvider() {
Date expirationDate = null;
@Override
public void dispose() {
// Clean up resources if necessary
}
@Override
public OAuthToken getAccessToken(boolean ignoreExistingToken) {
// Retrieve an OAuth access token.
// If ignoreExistingToken is true, always request a new token.
// Otherwise, return the existing token if it is valid, or request a new one.
return null;
}
@Override
public OAuthToken getAccessToken() {
// Return a valid OAuth token.
// If no valid token exists, request a new one.
return new OAuthToken("token", expirationDate);
}
};
3. Utilisation du fournisseur de jetons personnalisé
Une fois le ITokenProvider est configuré, vous pouvez créer un GraphClient instance. Ce client utilisera le fournisseur de jeton fourni pour l’authentification lors des appels à Microsoft Graph.
ITokenProvider provider = new AzureROPCTokenProvider(
tenantId,
clientId,
clientSecret,
userName,
password,
new String[] {"https://graph.microsoft.com/.default"}
);
IGraphClient client = GraphClient.getClient(provider, tenantId);
client.setResource(ResourceType.Users);
client.setResourceId(userName);
client.setEndpoint("https://graph.microsoft.com");
// Now you can call Microsoft Graph APIs
var folders = client.listFolders(null);
for (GraphFolderInfo folder : folders) {
System.out.println(folder.getDisplayName());
}
Après la création et l’authentification du client, vous pouvez commencer à effectuer des requêtes aux services Microsoft Graph.