Azure AD‑inställning och Microsoft Graph‑autentisering
Aspose.Email för Java ger fullständig integration med Microsoft Graph, vilket gör det möjligt för utvecklare att hantera meddelanden, kontakter, kalendrar och uppgifter från Microsoft 365‑konton. Denna guide visar hur du skapar en Azure AD‑applikation och konfigurerar autentisering för att börja koda med Aspose.Email GraphClient.
Innan du använder Microsoft Graph‑API:er med Aspose.Email måste du registrera en applikation i Azure Active Directory (Azure AD) och konfigurera autentisering. Denna sida täcker:
-
Skapa en Azure AD‑applikation (projekt).
-
Tilldela nödvändiga Microsoft Graph‑behörigheter.
-
Generera autentiseringsuppgifter (klient‑ID, klienthemlighet, tenant‑ID).
-
Autentisering i Java med Aspose.Email‑tokenleverantörer.
När det är klart är du redo att interagera med Microsoft Graph från din Java‑applikation.
1. Skapa en Azure AD‑applikation
Följ dessa steg för att registrera din applikation i Azure‑portalen:
- Logga in på Azure‑portalen.
- Navigera till Azure Active Directory → App Registrations → New Registration.
- Ange ett Name för din applikation (t.ex. AsposeEmailGraphApp).
- Välj stödda kontotyper:
- Single tenant (om bara din organisation ska använda den)
- Multitenant (om flera organisationer behöver åtkomst)
- Eventuellt ange en Redirect URI (behövs för interaktiv eller webbautentisering).
- Klicka på Register.
2. Skapa client secret
- Efter registreringen, gå till Certificates & Secrets → New Client Secret.
- Lägg till en beskrivning och utgångsperiod.
- Kopiera det genererade hemliga värdet – du kommer inte att kunna se det igen.
Håll client secret säker; den behövs för autentisering av konfidentiell klient.
Du bör se bladet för nyregistrerade applikationer.
3. Konfigurera Microsoft Graph‑behörigheter
- Navigera till API Permissions → Add a Permission → Microsoft Graph.
- Välj typ av behörigheter: Delegated eller Application, beroende på ditt scenario.
- Lägg till behörigheter som krävs för Aspose.Email‑operationer:
- Contacts.ReadWrite – för att hantera kontakter
- Calendars.ReadWrite – för att hantera kalendrar
- Mail.ReadWrite – för att läsa och skicka meddelanden
- Tasks.ReadWrite – för att hantera uppgifter
- Klicka på Grant Admin Consent om det behövs.
4. Tillåt publika klientflöden
Ange om applikationen är en publik klient. Lämplig för appar som använder token‑grant‑flöden som inte använder en omdirigerings‑URI.
5. Microsoft Graph‑autentisering
Stödda autentiseringsmetoder i Aspose.Email
| Tokenleverantör | Användningsfall | | ——————————– | ————————————————————————————— | | AzureConfidentialTokenProvider | Konfidentiell klient (klient‑ID + hemlighet) för server‑sidiga appar | | AzureROPCConfiguration | Resource Owner Password Credentials (användarnamn + lösenord) för icke‑interaktiva scenarier | | AzurePublicTokenProvider | Publik klient (interaktiv inloggning) | | AzureTokenProviderBase | Basisklass för anpassade autentiseringsimplementationer |
Autentisera med en konfidentiell klient
Använd AzureConfidentialTokenProvider för att autentisera när du har klient‑ID, klienthemlighet och tenant‑ID:
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");
Detta konfigurerar en fullständigt autentiserad IGraphClient redo att interagera med Microsoft Graph.
Autentisera med ROPC (användarnamn & lösenord)
För scenarier där du har ett användarnamn och lösenord, använd 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");
Anpassade tokenleverantörer för Microsoft Graph
Aspose.Email för Java integreras med Microsoft Graph via IGraphClient gränssnitt. För att autentisera förfrågningar, en implementation av ITokenProvider krävs. Medan de flesta utvecklare använder inbyggda autentiseringsleverantörer, finns det situationer där du kan vilja skapa din egen leverantör, till exempel när du arbetar med Resource Owner Password Credentials (ROPC)‑flödet.
1. Implementera ITokenProvider med AzureROPCTokenProvider
Denna klass tillhandahåller en implementation av ITokenProvider med Azure Resource Owner Password Credentials (ROPC)‑flödet. Följande exempel är endast för demonstrationsändamål. I produktion rekommenderar vi att använda säkrare flöden som klientuppgifter eller auktoriseringskod med 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. Skapa ett ITokenProvider‑objekt
Den IGraphClient gränssnittet ansvarar för att bygga förfrågningar, skicka dem till Microsoft Graph och hantera svaren. För att skapa en instans av IGraphClient, måste du tillhandahålla en implementation av ITokenProvider. Tokenleverantören autentiserar förfrågningar genom att tillhandahålla en giltig OAuth‑åtkomsttoken.
Följande kodexempel visar hur man skapar en grundläggande inline‑implementation av ITokenProvider gränssnitt, som krävs för att autentisera Microsoft Graph‑förfrågningar:
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. Använda den anpassade tokenleverantören
När ITokenProvider är konfigurerad, kan du skapa en GraphClient instans. Denna klient kommer att använda den angivna token‑leverantören för autentisering vid anrop till 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());
}
Efter att klienten har skapats och autentiserats kan du börja göra förfrågningar till Microsoft Graph‑tjänster.