or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

annotations.mdauthentication.mdclient-traits.mdcryptography.mdexceptions.mdhttp-client.mdhttp-policies.mdindex.mdmodels.mdserialization.mdutilities.md
tile.json

tessl/maven-com-azure--azure-core

Azure Core provides shared primitives, abstractions, and helpers for modern Java Azure SDK client libraries

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/com.azure/azure-core@1.55.x

To install, run

npx @tessl/cli install tessl/maven-com-azure--azure-core@1.55.0

index.mddocs/

Azure Core Java Library

Azure Core provides shared primitives, abstractions, and helpers for modern Java Azure SDK client libraries. It serves as the foundational layer enabling consistent HTTP communication, authentication, serialization, error handling, and common patterns across all Azure Java SDKs.

Package Information

  • Package Name: azure-core
  • Package Type: maven
  • Group ID: com.azure
  • Artifact ID: azure-core
  • Language: Java
  • Installation: 
    <dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-core</artifactId>
  <version>1.55.4</version>
</dependency>

Core Imports

import com.azure.core.http.HttpClient;
import com.azure.core.http.HttpPipeline;
import com.azure.core.http.HttpPipelineBuilder;
import com.azure.core.credential.TokenCredential;
import com.azure.core.util.BinaryData;
import com.azure.core.util.Context;
import com.azure.core.util.Configuration;

Basic Usage

import com.azure.core.http.*;
import com.azure.core.http.policy.*;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.BinaryData;
import com.azure.core.util.Context;

// Create an HTTP pipeline with authentication and retry policies
HttpPipeline pipeline = new HttpPipelineBuilder()
    .httpClient(HttpClient.createDefault())
    .policies(
        new UserAgentPolicy("MyApp/1.0"),
        new BearerTokenAuthenticationPolicy(credential, "https://vault.azure.net/.default"),
        new RetryPolicy(),
        new HttpLogOptions().setLogLevel(HttpLogDetailLevel.BASIC)
    )
    .build();

// Create and send an HTTP request
HttpRequest request = new HttpRequest(HttpMethod.GET, "https://api.example.com/data");
request.setHeader("Accept", "application/json");

// Execute the request
HttpResponse response = pipeline.send(request, Context.NONE).block();

// Handle binary data
BinaryData responseData = BinaryData.fromStream(response.getBodyAsInputStream());
String jsonContent = responseData.toString();

Architecture

Azure Core is structured around several key architectural patterns:

  • HTTP Pipeline: Modular request/response processing chain with pluggable policies for cross-cutting concerns (authentication, retry, logging, metrics)
  • Credential System: Unified authentication interfaces supporting Azure Active Directory tokens, keys, and custom authentication schemes
  • BinaryData: Flexible data representation supporting streams, bytes, strings, and objects with lazy serialization
  • Context: Thread-safe key-value store for passing metadata through call chains
  • Reactive Patterns: Reactor-based async operations with sync wrappers for blocking scenarios

This foundation enables all Azure Java SDKs to provide consistent patterns for authentication, error handling, telemetry, and HTTP communication while allowing service-specific customizations.

Capabilities

HTTP Operations

Core HTTP client functionality including pipeline construction, request/response handling, and policy-based middleware for authentication, retry, and logging.

interface HttpClient {
    Mono<HttpResponse> send(HttpRequest request);
    Mono<HttpResponse> send(HttpRequest request, Context context);
}

class HttpPipelineBuilder {
    public HttpPipelineBuilder httpClient(HttpClient httpClient);
    public HttpPipelineBuilder policies(HttpPipelinePolicy... policies);
    public HttpPipeline build();
}

class HttpRequest {
    public HttpRequest(HttpMethod httpMethod, String url);
    public HttpRequest setHeader(String name, String value);
    public HttpRequest setBody(BinaryData body);
}

class HttpResponse {
    public int getStatusCode();
    public HttpHeaders getHeaders();
    public BinaryData getBody();
    public Flux<ByteBuffer> getBodyAsByteBuffer();
}

HTTP Client Operations

Authentication

Credential management system supporting Azure Active Directory tokens, API keys, SAS tokens, and custom authentication schemes with automatic token refresh.

interface TokenCredential {
    Mono<AccessToken> getToken(TokenRequestContext request);
    AccessToken getTokenSync(TokenRequestContext request);
}

class AccessToken {
    public AccessToken(String token, OffsetDateTime expiresAt);
    public String getToken();
    public OffsetDateTime getExpiresAt();
    public boolean isExpired();
}

class AzureKeyCredential extends KeyCredential {
    public AzureKeyCredential(String key);
    public AzureKeyCredential update(String key);
}

class TokenRequestContext {
    public TokenRequestContext setScopes(List<String> scopes);
    public TokenRequestContext setTenantId(String tenantId);
    public TokenRequestContext setClaims(String claims);
}

Authentication System

Serialization

JSON and XML serialization utilities with pluggable serializers, binary data handling, and integration with popular Java serialization libraries.

interface JsonSerializer {
    <T> T deserialize(InputStream stream, Type type);
    <T> T deserialize(byte[] bytes, Type type);
    <T> Mono<T> deserializeAsync(InputStream stream, Type type);
    void serialize(OutputStream stream, Object value);
    byte[] serializeToBytes(Object value);
    Mono<Void> serializeAsync(OutputStream stream, Object value);
}

class BinaryData {
    public static BinaryData fromObject(Object data);
    public static BinaryData fromString(String data);
    public static BinaryData fromBytes(byte[] data);
    public static BinaryData fromStream(InputStream stream);
    public <T> T toObject(Class<T> clazz);
    public <T> T toObject(TypeReference<T> typeReference);
    public String toString();
    public byte[] toBytes();
}

Serialization Utilities

Core Data Models

Essential data types including geographic objects, cloud events, Azure cloud configurations, and common model patterns used across Azure services.

class CloudEvent {
    public CloudEvent(String source, String type);
    public CloudEvent setSubject(String subject);
    public CloudEvent setData(BinaryData data);
    public CloudEvent setDataContentType(String contentType);
    public String getId();
    public OffsetDateTime getTime();
}

enum AzureCloud {
    AZURE, AZURE_CHINA, AZURE_GERMANY, AZURE_US_GOVERNMENT;
    public String getActiveDirectoryEndpoint();
    public String getResourceManagerEndpoint();
}

class GeoPoint extends GeoObject {
    public GeoPoint(GeoPosition position);
    public GeoPosition getCoordinates();
}

class GeoPolygon extends GeoObject {
    public GeoPolygon(GeoLinearRing exteriorRing);
    public GeoLinearRing getExteriorRing();
    public List<GeoLinearRing> getHoles();
}

Core Models and Types

Utilities

Essential utilities including configuration management, logging, metrics, tracing, polling operations, and helper functions for Azure SDK development.

class Configuration {
    public static Configuration getGlobalConfiguration();
    public String get(String name);
    public String get(String name, String defaultValue);
    public Configuration put(String name, String value);
    public Configuration remove(String name);
}

class ClientLogger {
    public ClientLogger(Class<?> clazz);
    public void info(String message);
    public void warning(String message);
    public void error(String message, Throwable throwable);
    public boolean canLogAtLevel(LogLevel logLevel);
}

class Context {
    public static final Context NONE;
    public Context addData(Object key, Object value);
    public Optional<Object> getData(Object key);
}

class SyncPoller<T, U> {
    public PollResponse<T> poll();
    public PollResponse<T> waitForCompletion();
    public U getFinalResult();
    public void cancelOperation();
}

Utility Classes

HTTP Annotations

Declarative annotations for building REST APIs with automatic HTTP request generation, parameter binding, and response handling.

@Target(ElementType.METHOD)
@interface Get {
    String value();
}

@Target(ElementType.METHOD) 
@interface Post {
    String value();
}

@Target(ElementType.PARAMETER)
@interface PathParam {
    String value();
    boolean encoded() default false;
}

@Target(ElementType.PARAMETER)
@interface QueryParam {
    String value();
    boolean encoded() default false;
    boolean multipleQueryParams() default false;
}

@Target(ElementType.METHOD)
@interface ExpectedResponses {
    int[] value();
}

@Target(ElementType.TYPE)
@interface ServiceInterface {
    String name();
}

HTTP Annotations

Client Builder Traits

Trait interfaces providing consistent configuration patterns across Azure SDK client builders, enabling composable and uniform builder functionality.

interface HttpTrait<T> {
    T httpClient(HttpClient httpClient);
    T pipeline(HttpPipeline pipeline);
    T addPolicy(HttpPipelinePolicy pipelinePolicy);
    T retryOptions(RetryOptions retryOptions);
}

interface TokenCredentialTrait<T> {
    T credential(TokenCredential credential);
}

interface EndpointTrait<T> {
    T endpoint(String endpoint);
}

interface ConfigurationTrait<T> {
    T configuration(Configuration configuration);
}

Client Builder Traits

HTTP Pipeline Policies

Comprehensive HTTP pipeline policies for cross-cutting concerns like authentication, retry, logging, and request modification with configurable behavior.

interface HttpPipelinePolicy {
    Mono<HttpResponse> process(HttpPipelineCallContext context, HttpPipelineNextPolicy next);
}

class BearerTokenAuthenticationPolicy implements HttpPipelinePolicy {
    public BearerTokenAuthenticationPolicy(TokenCredential credential, String... scopes);
}

class RetryPolicy implements HttpPipelinePolicy {
    public RetryPolicy();
    public RetryPolicy(RetryOptions retryOptions);
}

class HttpLoggingPolicy implements HttpPipelinePolicy {
    public HttpLoggingPolicy();
    public HttpLoggingPolicy(HttpLogOptions httpLogOptions);
}

class UserAgentPolicy implements HttpPipelinePolicy {
    public UserAgentPolicy(String applicationId);
}

HTTP Pipeline Policies

Exception Handling

Comprehensive exception hierarchy for Azure SDK operations with specialized exception types for different failure scenarios.

class AzureException extends RuntimeException {
    public AzureException();
    public AzureException(String message);
    public AzureException(String message, Throwable cause);
}

class HttpResponseException extends AzureException {
    public HttpResponseException(HttpResponse response);
    public HttpResponseException(String message, HttpResponse response);
    public HttpResponse getResponse();
    public Object getValue();
}

class ClientAuthenticationException extends HttpResponseException {
    public ClientAuthenticationException(String message, HttpResponse response);
}

class ResourceNotFoundException extends HttpResponseException {
    public ResourceNotFoundException(String message, HttpResponse response);
}

class ResourceExistsException extends HttpResponseException {
    public ResourceExistsException(String message, HttpResponse response);
}

Exception Handling

Cryptography and Key Management

Interfaces for key encryption and cryptographic operations with support for both synchronous and asynchronous scenarios.

interface KeyEncryptionKey {
    String getKeyId();
    byte[] wrapKey(String algorithm, byte[] plaintext);
    byte[] unwrapKey(String algorithm, byte[] ciphertext);
}

interface AsyncKeyEncryptionKey {
    Mono<String> getKeyId();
    Mono<byte[]> wrapKey(String algorithm, byte[] plaintext);
    Mono<byte[]> unwrapKey(String algorithm, byte[] ciphertext);
}

interface KeyEncryptionKeyResolver {
    KeyEncryptionKey resolveKey(String keyId);
}

interface AsyncKeyEncryptionKeyResolver {
    Mono<AsyncKeyEncryptionKey> resolveKey(String keyId);
}

Cryptography and Key Management