Configuração do Azure AD e Autenticação do Microsoft Graph
Aspose.Email for Java oferece integração completa com o Microsoft Graph, permitindo que desenvolvedores gerenciem mensagens, contatos, calendários e tarefas de contas Microsoft 365. Este guia orienta você a criar um aplicativo Azure AD e configurar a autenticação para começar a programar com Aspose.Email GraphClient.
Antes de usar as APIs do Microsoft Graph com Aspose.Email, você precisa registrar um aplicativo no Azure Active Directory (Azure AD) e configurar a autenticação. Esta página cobre:
-
Criando um aplicativo Azure AD (projeto).
-
Atribuindo as permissões necessárias do Microsoft Graph.
-
Gerando credenciais (client ID, client secret, tenant ID).
-
Autenticando em Java usando provedores de token do Aspose.Email.
Quando concluído, você estará pronto para interagir com o Microsoft Graph a partir de seu aplicativo Java.
1. Criar um Aplicativo Azure AD
Siga estes passos para registrar seu aplicativo no portal Azure:
- Faça login no Portal Azure.
- Navegue até Azure Active Directory → App Registrations → New Registration.
- Insira um Nome para sua aplicação (por exemplo, AsposeEmailGraphApp).
- Escolha os tipos de conta suportados:
- Single tenant (se apenas sua organização for usar)
- Multitenant (se várias organizações precisarem de acesso)
- Opcionalmente, defina um Redirect URI (necessário para autenticação interativa ou web).
- Clique em Register.
2. Criar Client Secret
- Após o registro, vá para Certificates & Secrets → New Client Secret.
- Adicione uma descrição e o período de validade.
- Copie o valor secreto gerado – você não o verá novamente.
Mantenha o client secret seguro; ele é necessário para a autenticação de cliente confidencial.
Você deverá ver o painel de aplicativos recém‑registrados.
3. Configurar Permissões do Microsoft Graph
- Navegue até API Permissions → Add a Permission → Microsoft Graph.
- Escolha o tipo de permissões: Delegated ou Application, dependendo do seu cenário.
- Adicione as permissões necessárias para as operações do Aspose.Email:
- Contacts.ReadWrite – para gerenciar contatos
- Calendars.ReadWrite – para gerenciar calendários
- Mail.ReadWrite – para ler e enviar mensagens
- Tasks.ReadWrite – para gerenciar tarefas
- Clique em Grant Admin Consent se necessário.
4. Permitir fluxos de cliente público
Especifique se o aplicativo é um cliente público. Apropriado para aplicativos que usam fluxos de concessão de token que não utilizam um URI de redirecionamento.
5. Autenticação do Microsoft Graph
Métodos de Autenticação Compatíveis no Aspose.Email
| Provedor de Token | Caso de Uso | | ——————————– | ————————————————————————————— | | AzureConfidentialTokenProvider | Cliente confidencial (client ID + secret) para aplicativos servidor | | AzureROPCConfiguration | Credenciais de Proprietário de Recurso (nome de usuário + senha) para cenários não interativos | | AzurePublicTokenProvider | Cliente público (login interativo) | | AzureTokenProviderBase | Classe base para implementações de autenticação personalizadas |
Autenticar Usando um Cliente Confidencial
Use o AzureConfidentialTokenProvider para autenticar quando você tem client ID, client secret e 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");
Isso configura um IGraphClient totalmente autenticado pronto para interagir com o Microsoft Graph.
Autenticar Usando ROPC (Nome de usuário e Senha)
Para cenários onde você tem nome de usuário e senha, use 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");
Provedores de Token Personalizados para Microsoft Graph
Aspose.Email for Java integra-se ao Microsoft Graph através da IGraphClient interface. Para autenticar solicitações, uma implementação da ITokenProvider é necessário. Embora a maioria dos desenvolvedores use provedores de autenticação incorporados, há cenários em que você pode querer criar seu próprio provedor, por exemplo, ao trabalhar com o fluxo Resource Owner Password Credentials (ROPC).
1. Implementar ITokenProvider usando AzureROPCTokenProvider
Esta classe fornece uma implementação de ITokenProvider usando o fluxo Azure Resource Owner Password Credentials (ROPC). O exemplo a seguir destina‑se apenas a demonstração. Em produção, recomendamos usar fluxos mais seguros, como credenciais de cliente ou código de autorização com 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. Criar um objeto ITokenProvider
O IGraphClient interface é responsável por construir solicitações, enviá-las ao Microsoft Graph e tratar as respostas. Para criar uma instância de IGraphClient, você deve fornecer uma implementação de ITokenProvider. O provedor de token autentica requisições fornecendo um token de acesso OAuth válido.
O exemplo de código a seguir demonstra como criar uma implementação básica inline da ITokenProvider interface, que é necessária para autenticar solicitações do 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. Usando o Provedor de Token Personalizado
Uma vez que ITokenProvider está configurado, você pode criar um GraphClient instância. Este cliente usará o provedor de token fornecido para autenticação ao chamar o 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());
}
Depois que o cliente for criado e autenticado, você pode começar a fazer solicitações aos serviços do Microsoft Graph.