Azure AD‑Einrichtung und Microsoft Graph‑Authentifizierung
Aspose.Email für Java bietet eine vollständige Integration mit Microsoft Graph und ermöglicht Entwicklern das Verwalten von Nachrichten, Kontakten, Kalendern und Aufgaben aus Microsoft‑365‑Konten. Diese Anleitung führt Sie durch das Erstellen einer Azure‑AD‑Anwendung und die Konfiguration der Authentifizierung, um mit Aspose.Email zu programmieren. GraphClient.
Bevor Sie Microsoft‑Graph‑APIs mit Aspose.Email nutzen, müssen Sie eine Anwendung im Azure Active Directory (Azure AD) registrieren und die Authentifizierung konfigurieren. Diese Seite behandelt:
-
Erstellen einer Azure‑AD‑Anwendung (Projekt).
-
Zuweisen der erforderlichen Microsoft‑Graph‑Berechtigungen.
-
Erzeugen von Anmeldeinformationen (Client‑ID, Client‑Secret, Tenant‑ID).
-
Authentifizierung in Java mittels Aspose.Email‑Token‑Providern.
Nach Abschluss sind Sie bereit, von Ihrer Java‑Anwendung aus mit Microsoft Graph zu interagieren.
1. Erstellen einer Azure‑AD‑Anwendung
Befolgen Sie diese Schritte, um Ihre Anwendung im Azure‑Portal zu registrieren:
- Melden Sie sich beim Azure‑Portal.
- Navigieren Sie zu Azure Active Directory → App Registrations → New Registration.
- Geben Sie einen Name für Ihre Anwendung ein (z. B. AsposeEmailGraphApp).
- Wählen Sie unterstützte Kontotypen aus:
- Single tenant (wenn nur Ihre Organisation ihn nutzt)
- Multitenant (wenn mehrere Organisationen Zugriff benötigen)
- Optional können Sie einen Redirect URI festlegen (erforderlich für interaktive oder Web‑Authentifizierung).
- Klicken Sie auf Register.
2. Client‑Secret erstellen
- Nach der Registrierung gehen Sie zu Certificates & Secrets → New Client Secret.
- Fügen Sie eine Beschreibung und einen Ablaufzeitraum hinzu.
- Kopieren Sie den generierten Geheimwert – Sie werden ihn nicht erneut sehen.
Bewahren Sie das client secret sicher auf; es ist für die Authentifizierung eines vertraulichen Clients erforderlich.
Sie sollten das Fenster der neu registrierten Anwendungen sehen.
3. Microsoft‑Graph‑Berechtigungen konfigurieren
- Navigieren Sie zu API Permissions → Add a Permission → Microsoft Graph.
- Wählen Sie die Art der Berechtigungen: Delegated oder Application, je nach Szenario.
- Fügen Sie die für Aspose.Email‑Operationen erforderlichen Berechtigungen hinzu:
- Contacts.ReadWrite – zum Verwalten von Kontakten
- Calendars.ReadWrite – zum Verwalten von Kalendern
- Mail.ReadWrite – zum Lesen und Senden von Nachrichten
- Tasks.ReadWrite – zum Verwalten von Aufgaben
- Klicken Sie bei Bedarf auf Grant Admin Consent.
4. Öffentliche‑Client‑Flows zulassen
Geben Sie an, ob die Anwendung ein öffentlicher Client ist. Geeignet für Apps, die Token‑Grant‑Flows nutzen, die keinen Redirect‑URI verwenden.
5. Microsoft‑Graph‑Authentifizierung
Unterstützte Authentifizierungsmethoden in Aspose.Email
| Token‑Provider | Anwendungsfall | | ——————————– | ————————————————————————————— | | AzureConfidentialTokenProvider | Vertraulicher Client (Client‑ID + Secret) für serverseitige Apps | | AzureROPCConfiguration | Resource Owner Password Credentials (Benutzername + Passwort) für nicht‑interaktive Szenarien | | AzurePublicTokenProvider | Öffentlicher Client (interaktive Anmeldung) | | AzureTokenProviderBase | Basisklasse für benutzerdefinierte Authentifizierungs‑Implementierungen |
Authentifizieren mit einem vertraulichen Client
Verwenden Sie die AzureConfidentialTokenProvider zur Authentifizierung, wenn Sie Client‑ID, Client‑Secret und Tenant‑ID haben:
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");
Damit wird ein vollständig authentifizierter IGraphClient eingerichtet, der bereit ist, mit Microsoft Graph zu interagieren.
Authentifizieren mit ROPC (Benutzername & Passwort)
Für Szenarien, in denen Sie einen Benutzernamen und ein Passwort haben, verwenden Sie 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");
Benutzerdefinierte Token‑Provider für Microsoft Graph
Aspose.Email für Java integriert sich über die IGraphClient Schnittstelle. Um Anfragen zu authentifizieren, benötigen Sie eine Implementierung von ITokenProvider ist erforderlich. Während die meisten Entwickler integrierte Authentifizierungs‑Providers verwenden, gibt es Szenarien, in denen Sie Ihren eigenen Provider erstellen möchten, z. B. beim Arbeiten mit dem Resource Owner Password Credentials (ROPC)‑Flow.
1. Implementieren von ITokenProvider mit AzureROPCTokenProvider
Diese Klasse bietet eine Implementierung von ITokenProvider unter Verwendung des Azure Resource Owner Password Credentials (ROPC)‑Flows. Das folgende Beispiel dient nur Demonstrationszwecken. In der Produktion empfehlen wir sicherere Flows wie Client‑Credentials oder Authorization‑Code mit 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. Erstellen eines ITokenProvider‑Objekts
Die IGraphClient Schnittstelle ist verantwortlich für das Erstellen von Anfragen, das Senden an Microsoft Graph und die Verarbeitung der Antworten. Um eine Instanz von IGraphClient, müssen Sie eine Implementierung von ITokenProvider. Der Token‑Provider authentifiziert Anfragen, indem er ein gültiges OAuth‑Zugriffstoken bereitstellt.
Das folgende Codebeispiel zeigt, wie man eine einfache Inline‑Implementierung von ITokenProvider Schnittstelle, die für die Authentifizierung von Microsoft‑Graph‑Anfragen erforderlich ist:
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. Verwenden des benutzerdefinierten Token‑Providers
Sobald das ITokenProvider ist eingerichtet, können Sie ein GraphClient Instanz. Dieser Client verwendet den bereitgestellten Token‑Provider für die Authentifizierung bei Aufrufen von 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());
}
Nachdem der Client erstellt und authentifiziert wurde, können Sie Anfragen an die Microsoft‑Graph‑Dienste stellen.