你当前正在访问 Microsoft Azure Global Edition 技术文档网站。 如果需要访问由世纪互联运营的 Microsoft Azure 中国技术文档网站，请访问 https://docs.azure.cn。

适用于 Java 的 Azure 文档智能客户端库 - 版本 4.1.2

Azure 文档智能 (以前称为 表单识别器) 是一种云服务，它使用机器学习来分析文档中的文本和结构化数据。 它包括以下main功能：

• 布局 - 从文档中提取文本、表结构和选择标记及其边界区域坐标。
• 文档 - 使用常规预生成文档模型分析文档中的实体、键值对、表和选择标记。
• 预生成 - 使用预生成模型) 分析某些类型的常见文档 (的数据，例如收据、发票、名片、身份证或 US W2 税单。
• 自定义 - 生成自定义模型以从文档中提取文本、字段值、选择标记和表数据。 自定义模型是使用你自己的数据生成的，因此它们是针对文档定制的。
• 读取 - 除了文本语言信息外，还读取有关文本元素的信息，例如页字和行。
• 分类器 - 生成自定义分类器，将文档分类为预定义类。

源代码 | 包 (Maven) | API 参考文档 | 产品文档 | 样品

入门

先决条件

• Java 开发工具包 (JDK) 8 或更高版本。
• Azure 订阅
• 认知服务或表单识别器帐户使用此包。

包括包

包括 BOM 文件

请务必将 azure-sdk-bom 包含在项目中，以依赖于库的 GA 版本。 在以下代码段中，将 {bom_version_to_target} 占位符替换为版本号。 若要详细了解 BOM，请参阅 AZURE SDK BOM 自述文件。

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-sdk-bom</artifactId>
            <version>{bom_version_to_target}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

然后，在依赖项的部分中包括直接依赖项，不带版本标记。

<dependencies>
  <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-formrecognizer</artifactId>
  </dependency>
</dependencies>

包括直接依赖项

如果要依赖于 BOM 中不存在的特定库版本，请将直接依赖项添加到项目，如下所示。

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-formrecognizer</artifactId>
    <version>4.1.2</version>
</dependency>

注意：此版本的客户端库默认为 "2023-07-31" 服务版本。

此表显示了 SDK 版本与服务支持的 API 版本之间的关系：

SDK 版本	服务支持的 API 版本
3.0.x	2.0
3.1.X - 3.1.12	2.0、2.1 (默认)
4.0.0	2.0、2.1、2022-08-31 (默认)
4.1.0	2.0、2.1、2022-08-31、2023-07-31 (默认)

注意：从版本 4.0.X 开始，引入了一组新的客户端，以利用表单识别器服务的最新功能。 有关如何将应用程序代码从客户端库版本 3.1.X 或更低版本更新到最新版本的详细说明，请参阅 迁移指南 。 有关详细信息，请参阅 更改日志。 下表描述了每个客户端及其支持的 API 版本 () 之间的关系：

API 版本	支持的客户端
2023-07-31	DocumentAnalysisClient 和 DocumentModelAdministrationClient
2022-08-31	DocumentAnalysisClient 和 DocumentModelAdministrationClient
2.1	FormRecognizerClient 和 FormTrainingClient
2.0	FormRecognizerClient 和 FormTrainingClient

创建表单识别器资源

表单识别器支持多服务和单服务访问。 如果计划访问单个终结点/密钥下的多个认知服务，请创建认知服务的资源。 若要仅访问表单识别器，请创建表单识别器资源。

可以使用 创建任一资源

选项 1：Azure 门户

选项 2：Azure CLI

下面是如何使用 CLI 创建表单识别器资源的示例：

# Create a new resource group to hold the Form Recognizer resource -
# if using an existing resource group, skip this step
az group create --name <your-resource-group> --location <location>

# Create Form Recognizer
az cognitiveservices account create \
    --name <your-form-recognizer-resource-name> \
    --resource-group <your-resource-group> \
    --kind FormRecognizer \
    --sku <sku> \
    --location <location> \
    --yes

验证客户端

若要与 表单识别器 服务交互，需要创建文档分析客户端的实例。 可以使用 创建 DocumentAnalysisClientBuilder异步客户端和同步客户端。 调用 buildClient() 将创建同步客户端，而调用 buildAsyncClient 将创建其异步对应客户端。

需要一个 终结点和一个 密钥 来实例化客户端对象。

查找终结点

可以在 Azure 门户 或 Azure CLI 中找到表单识别器资源的终结点。

# Get the endpoint for the resource
az cognitiveservices account show --name "resource-name" --resource-group "resource-group-name" --query "endpoint"

使用 AzureKeyCredential 创建文档分析客户端

若要使用 AzureKeyCredential 身份验证，请将 密钥 作为字符串提供给 AzureKeyCredential。 可以在创建的表单识别器资源的Azure 门户中找到此密钥，也可以通过运行以下 Azure CLI 命令从表单识别器资源获取密钥：

az cognitiveservices account keys list --resource-group <your-resource-group-name> --name <your-resource-name>

使用 API 密钥作为凭据参数对客户端进行身份验证：

DocumentAnalysisClient documentAnalysisClient = new DocumentAnalysisClientBuilder()
    .credential(new AzureKeyCredential("{key}"))
    .endpoint("{endpoint}")
    .buildClient();

DocumentModelAdministrationClient client =
    new DocumentModelAdministrationClientBuilder()
        .credential(new AzureKeyCredential("{key}"))
        .endpoint("{endpoint}")
        .buildClient();

使用 Azure Active Directory 凭据创建文档分析客户端

适用于 Java 的 Azure SDK 支持 Azure 标识包，因此可以轻松地从Microsoft 标识平台获取凭据。

使用 AAD 进行身份验证需要一些初始设置：

• 添加 Azure 标识包

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.10.0</version>
</dependency>

• 注册新的 Azure Active Directory 应用程序
• 通过将角色分配给服务主体来"Cognitive Services User"授予对表单识别器的访问权限。

设置后，可以从 azure-identity 中选择要使用的 凭据 类型。 例如， 可以使用 DefaultAzureCredential 对客户端进行身份验证：将 AAD 应用程序的客户端 ID、租户 ID 和客户端密码的值设置为环境变量：AZURE_CLIENT_ID、AZURE_TENANT_ID、AZURE_CLIENT_SECRET。

使用 DefaultAzureCredential 进行授权最简单。 它会找到在其运行环境中使用的最佳凭据。 有关将 Azure Active Directory 授权与 表单识别器 配合使用的详细信息，请参阅相关文档。

DocumentAnalysisClient documentAnalysisClient = new DocumentAnalysisClientBuilder()
    .endpoint("{endpoint}")
    .credential(new DefaultAzureCredentialBuilder().build())
    .buildClient();

关键概念

DocumentAnalysisClient

DocumentAnalysisClient 和 DocumentAnalysisAsyncClient 提供同步和异步操作，用于通过 beginAnalyzeDocument 和 beginAnalyzeDocumentFromUrl 方法使用自定义模型和预生成模型分析输入文档。 在此处查看支持模型的完整列表。

此处演示使用 DocumentAnalysisClient 的示例代码片段。 可 在此处找到有关分析文档的详细信息，包括支持的功能、区域设置和文档类型。

DocumentModelAdministrationClient

DocumentModelAdministrationClient 和 DocumentModelAdministrationAsyncClient 提供同步和异步操作

• 生成自定义文档分析模型，以分析在自定义文档中找到的文本内容、字段和值。 请参阅 示例生成文档模型。 返回一个 DocumentModelDetails ，指示模型可以分析的文档类型，以及它将提取的字段和架构。
• 通过生成、列出、删除和查看帐户自定义模型的限制来管理在帐户中创建的模型。 请参阅 管理模型示例。
• 将自定义模型从一个表单识别器资源复制到另一个资源。
• 从现有生成模型集合创建组合模型。
• 列出与表单识别器资源关联的文档模型操作。

此处提供了示例代码片段来说明如何使用 DocumentModelAdministrationClient 。

长期运行的操作

长时间运行的操作包括发送到服务以启动操作的初始请求，然后按间隔轮询服务以确定操作是否已完成或失败，如果操作成功，则获取结果。

生成模型、分析文档值或复制和撰写模型的方法将建模为长时间运行的操作。 客户端公开返回 begin<MethodName>SyncPoller 或 PollerFlux 实例的方法。 调用方应通过从 方法调用 getFinalResult() 返回的操作来等待操作 begin<MethodName> 完成。 下面提供了示例代码片段来说明如何使用长时间运行的操作。

示例

以下部分提供了几个代码片段，涵盖一些最常见的表单识别器任务，包括：

• 提取布局
• 使用常规文档模型
• 使用预生成模型
• 生成文档模型
• 使用自定义模型分析文档
• 管理模型
• 对文档进行分类

提取布局

从文档中提取文本、表结构和选择标记（如单选按钮和检查框），以及它们的边界框坐标，而无需生成模型。

// analyze document layout using file input stream
File layoutDocument = new File("local/file_path/filename.png");
Path filePath = layoutDocument.toPath();
BinaryData layoutDocumentData = BinaryData.fromFile(filePath, (int) layoutDocument.length());

SyncPoller<OperationResult, AnalyzeResult> analyzeLayoutResultPoller =
    documentAnalysisClient.beginAnalyzeDocument("prebuilt-layout", layoutDocumentData);

AnalyzeResult analyzeLayoutResult = analyzeLayoutResultPoller.getFinalResult();

// pages
analyzeLayoutResult.getPages().forEach(documentPage -> {
    System.out.printf("Page has width: %.2f and height: %.2f, measured with unit: %s%n",
        documentPage.getWidth(),
        documentPage.getHeight(),
        documentPage.getUnit());

    // lines
    documentPage.getLines().forEach(documentLine ->
        System.out.printf("Line '%s' is within a bounding box %s.%n",
            documentLine.getContent(),
            documentLine.getBoundingPolygon().toString()));

    // selection marks
    documentPage.getSelectionMarks().forEach(documentSelectionMark ->
        System.out.printf("Selection mark is '%s' and is within a bounding box %s with confidence %.2f.%n",
            documentSelectionMark.getSelectionMarkState().toString(),
            documentSelectionMark.getBoundingPolygon().toString(),
            documentSelectionMark.getConfidence()));
});

// tables
List<DocumentTable> tables = analyzeLayoutResult.getTables();
for (int i = 0; i < tables.size(); i++) {
    DocumentTable documentTable = tables.get(i);
    System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTable.getRowCount(),
        documentTable.getColumnCount());
    documentTable.getCells().forEach(documentTableCell -> {
        System.out.printf("Cell '%s', has row index %d and column index %d.%n", documentTableCell.getContent(),
            documentTableCell.getRowIndex(), documentTableCell.getColumnIndex());
    });
    System.out.println();
}

使用常规文档模型

使用 表单识别器 服务提供的常规文档模型分析文档中的键值对、表、样式和选择标记。 通过将 modelId=“prebuilt-document”传递到 beginAnalyzeDocumentFromUrl 方法，选择常规文档模型，如下所示：

String documentUrl = "{document-url}";
String modelId = "prebuilt-document";
SyncPoller<OperationResult, AnalyzeResult> analyzeDocumentPoller =
    documentAnalysisClient.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

AnalyzeResult analyzeResult = analyzeDocumentPoller.getFinalResult();

for (int i = 0; i < analyzeResult.getDocuments().size(); i++) {
    final AnalyzedDocument analyzedDocument = analyzeResult.getDocuments().get(i);
    System.out.printf("----------- Analyzing document %d -----------%n", i);
    System.out.printf("Analyzed document has doc type %s with confidence : %.2f%n",
        analyzedDocument.getDocType(), analyzedDocument.getConfidence());
}

analyzeResult.getPages().forEach(documentPage -> {
    System.out.printf("Page has width: %.2f and height: %.2f, measured with unit: %s%n",
        documentPage.getWidth(),
        documentPage.getHeight(),
        documentPage.getUnit());

    // lines
    documentPage.getLines().forEach(documentLine ->
        System.out.printf("Line '%s' is within a bounding box %s.%n",
            documentLine.getContent(),
            documentLine.getBoundingPolygon().toString()));

    // words
    documentPage.getWords().forEach(documentWord ->
        System.out.printf("Word '%s' has a confidence score of %.2f.%n",
            documentWord.getContent(),
            documentWord.getConfidence()));
});

// tables
List<DocumentTable> tables = analyzeResult.getTables();
for (int i = 0; i < tables.size(); i++) {
    DocumentTable documentTable = tables.get(i);
    System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTable.getRowCount(),
        documentTable.getColumnCount());
    documentTable.getCells().forEach(documentTableCell -> {
        System.out.printf("Cell '%s', has row index %d and column index %d.%n",
            documentTableCell.getContent(),
            documentTableCell.getRowIndex(), documentTableCell.getColumnIndex());
    });
    System.out.println();
}

// Key-value
analyzeResult.getKeyValuePairs().forEach(documentKeyValuePair -> {
    System.out.printf("Key content: %s%n", documentKeyValuePair.getKey().getContent());
    System.out.printf("Key content bounding region: %s%n",
        documentKeyValuePair.getKey().getBoundingRegions().toString());

    System.out.printf("Value content: %s%n", documentKeyValuePair.getValue().getContent());
    System.out.printf("Value content bounding region: %s%n", documentKeyValuePair.getValue().getBoundingRegions().toString());
});

使用预生成模型

使用 表单识别器 服务提供的预生成模型从所选文档类型（如收据、发票、名片和标识文档）中提取字段。 支持的预生成模型包括：

• 可在此处找到使用prebuilt-receipt模型 (服务识别的字段分析收据)
• 可以使用 prebuilt-businessCard 服务识别的模型 (字段分析名片，请参阅 此处) 。
• 可以使用 prebuilt-invoice 服务识别的模型 (字段分析发票，请参阅 此处) 。
• 可在此处) 找到使用prebuilt-idDocuments模型 (服务识别的字段来分析标识文档。
• 使用 prebuilt-tax.us.w2 模型分析美国 W2 税单。 支持的字段。

例如，若要分析销售收据中的字段，请使用 beginAnalyzeDocumentFromUrl 方法：

String receiptUrl = "https://raw.githubusercontent.com/Azure/azure-sdk-for-java/main/sdk/formrecognizer"
    + "/azure-ai-formrecognizer/src/samples/resources/sample-documents/receipts/contoso-allinone.jpg";

SyncPoller<OperationResult, AnalyzeResult> analyzeReceiptPoller =
    documentAnalysisClient.beginAnalyzeDocumentFromUrl("prebuilt-receipt", receiptUrl);

AnalyzeResult receiptResults = analyzeReceiptPoller.getFinalResult();

for (int i = 0; i < receiptResults.getDocuments().size(); i++) {
    AnalyzedDocument analyzedReceipt = receiptResults.getDocuments().get(i);
    Map<String, DocumentField> receiptFields = analyzedReceipt.getFields();
    System.out.printf("----------- Analyzing receipt info %d -----------%n", i);
    DocumentField merchantNameField = receiptFields.get("MerchantName");
    if (merchantNameField != null) {
        if (DocumentFieldType.STRING == merchantNameField.getType()) {
            String merchantName = merchantNameField.getValueAsString();
            System.out.printf("Merchant Name: %s, confidence: %.2f%n",
                merchantName, merchantNameField.getConfidence());
        }
    }

    DocumentField merchantPhoneNumberField = receiptFields.get("MerchantPhoneNumber");
    if (merchantPhoneNumberField != null) {
        if (DocumentFieldType.PHONE_NUMBER == merchantPhoneNumberField.getType()) {
            String merchantAddress = merchantPhoneNumberField.getValueAsPhoneNumber();
            System.out.printf("Merchant Phone number: %s, confidence: %.2f%n",
                merchantAddress, merchantPhoneNumberField.getConfidence());
        }
    }

    DocumentField transactionDateField = receiptFields.get("TransactionDate");
    if (transactionDateField != null) {
        if (DocumentFieldType.DATE == transactionDateField.getType()) {
            LocalDate transactionDate = transactionDateField.getValueAsDate();
            System.out.printf("Transaction Date: %s, confidence: %.2f%n",
                transactionDate, transactionDateField.getConfidence());
        }
    }

    DocumentField receiptItemsField = receiptFields.get("Items");
    if (receiptItemsField != null) {
        System.out.printf("Receipt Items: %n");
        if (DocumentFieldType.LIST == receiptItemsField.getType()) {
            List<DocumentField> receiptItems = receiptItemsField.getValueAsList();
            receiptItems.stream()
                .filter(receiptItem -> DocumentFieldType.MAP == receiptItem.getType())
                .map(documentField -> documentField.getValueAsMap())
                .forEach(documentFieldMap -> documentFieldMap.forEach((key, documentField) -> {
                    if ("Name".equals(key)) {
                        if (DocumentFieldType.STRING == documentField.getType()) {
                            String name = documentField.getValueAsString();
                            System.out.printf("Name: %s, confidence: %.2fs%n",
                                name, documentField.getConfidence());
                        }
                    }
                    if ("Quantity".equals(key)) {
                        if (DocumentFieldType.DOUBLE == documentField.getType()) {
                            Double quantity = documentField.getValueAsDouble();
                            System.out.printf("Quantity: %f, confidence: %.2f%n",
                                quantity, documentField.getConfidence());
                        }
                    }
                }));
        }
    }
}

有关使用预生成模型的详细信息和示例，请参阅：

• 名片
• 标识文档
• 发票
• 收据示例

生成文档模型

根据自己的文档类型生成机器学习模型。 生成的模型将能够分析其所基于的文档类型的值。 提供用于存储训练文档的 Azure 存储 Blob 容器的容器 SAS URL。 请参阅 服务快速入门文档中有关设置此功能的详细信息。

注意

可以使用 表单识别器 Studio 预览版为训练表单创建带标签的文件。 有关设置容器和所需文件结构的更多详细信息，请参阅 此处。

// Build custom document analysis model
String blobContainerUrl = "{SAS_URL_of_your_container_in_blob_storage}";
// The shared access signature (SAS) Url of your Azure Blob Storage container with your forms.
String prefix = "{blob_name_prefix}}";
SyncPoller<OperationResult, DocumentModelDetails> buildOperationPoller =
    documentModelAdminClient.beginBuildDocumentModel(blobContainerUrl,
        DocumentModelBuildMode.TEMPLATE,
        prefix,
        new BuildDocumentModelOptions().setModelId("my-build-model").setDescription("model desc"),
        Context.NONE);

DocumentModelDetails documentModelDetails = buildOperationPoller.getFinalResult();

// Model Info
System.out.printf("Model ID: %s%n", documentModelDetails.getModelId());
System.out.printf("Model Description: %s%n", documentModelDetails.getDescription());
System.out.printf("Model created on: %s%n%n", documentModelDetails.getCreatedOn());
documentModelDetails.getDocumentTypes().forEach((key, documentTypeDetails) -> {
    System.out.printf("Document type: %s%n", key);
    documentTypeDetails.getFieldSchema().forEach((name, documentFieldSchema) -> {
        System.out.printf("Document field: %s%n", name);
        System.out.printf("Document field type: %s%n", documentFieldSchema.getType().toString());
        System.out.printf("Document field confidence: %.2f%n", documentTypeDetails.getFieldConfidence().get(name));
    });
});

使用自定义模型分析文档

分析文档中的键/值对和表数据。 这些模型是使用你自己的数据生成的，因此它们是针对你的文档定制的。 应仅分析生成自定义模型时所基于的相同文档类型的文档。

String documentUrl = "{document-url}";
String modelId = "{custom-built-model-ID}";
SyncPoller<OperationResult, AnalyzeResult> analyzeDocumentPoller =
    documentAnalysisClient.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

AnalyzeResult analyzeResult = analyzeDocumentPoller.getFinalResult();

for (int i = 0; i < analyzeResult.getDocuments().size(); i++) {
    final AnalyzedDocument analyzedDocument = analyzeResult.getDocuments().get(i);
    System.out.printf("----------- Analyzing custom document %d -----------%n", i);
    System.out.printf("Analyzed document has doc type %s with confidence : %.2f%n",
        analyzedDocument.getDocType(), analyzedDocument.getConfidence());
    analyzedDocument.getFields().forEach((key, documentField) -> {
        System.out.printf("Document Field content: %s%n", documentField.getContent());
        System.out.printf("Document Field confidence: %.2f%n", documentField.getConfidence());
        System.out.printf("Document Field Type: %s%n", documentField.getType());
        System.out.printf("Document Field found within bounding region: %s%n",
            documentField.getBoundingRegions().toString());
    });
}

analyzeResult.getPages().forEach(documentPage -> {
    System.out.printf("Page has width: %.2f and height: %.2f, measured with unit: %s%n",
        documentPage.getWidth(),
        documentPage.getHeight(),
        documentPage.getUnit());

    // lines
    documentPage.getLines().forEach(documentLine ->
        System.out.printf("Line '%s' is within a bounding box %s.%n",
            documentLine.getContent(),
            documentLine.getBoundingPolygon().toString()));

    // words
    documentPage.getWords().forEach(documentWord ->
        System.out.printf("Word '%s' has a confidence score of %.2f.%n",
            documentWord.getContent(),
            documentWord.getConfidence()));
});

// tables
List<DocumentTable> tables = analyzeResult.getTables();
for (int i = 0; i < tables.size(); i++) {
    DocumentTable documentTable = tables.get(i);
    System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTable.getRowCount(),
        documentTable.getColumnCount());
    documentTable.getCells().forEach(documentTableCell -> {
        System.out.printf("Cell '%s', has row index %d and column index %d.%n",
            documentTableCell.getContent(),
            documentTableCell.getRowIndex(), documentTableCell.getColumnIndex());
    });
    System.out.println();
}

管理模型

管理表单识别器帐户中的模型。

AtomicReference<String> modelId = new AtomicReference<>();

// First, we see how many models we have, and what our limit is
ResourceDetails resourceDetails = documentModelAdminClient.getResourceDetails();
System.out.printf("The resource has %s models, and we can have at most %s models",
    resourceDetails.getCustomDocumentModelCount(), resourceDetails.getCustomDocumentModelLimit());

// Next, we get a paged list of all of our models
PagedIterable<DocumentModelSummary> customDocumentModels = documentModelAdminClient.listDocumentModels();
System.out.println("We have following models in the account:");
customDocumentModels.forEach(documentModelSummary -> {
    System.out.printf("Model ID: %s%n", documentModelSummary.getModelId());
    modelId.set(documentModelSummary.getModelId());

    // get custom document analysis model info
    DocumentModelDetails documentModel = documentModelAdminClient.getDocumentModel(documentModelSummary.getModelId());
    System.out.printf("Model ID: %s%n", documentModel.getModelId());
    System.out.printf("Model Description: %s%n", documentModel.getDescription());
    System.out.printf("Model created on: %s%n", documentModel.getCreatedOn());
    documentModel.getDocumentTypes().forEach((key, documentTypeDetails) -> {
        documentTypeDetails.getFieldSchema().forEach((field, documentFieldSchema) -> {
            System.out.printf("Field: %s", field);
            System.out.printf("Field type: %s", documentFieldSchema.getType());
            System.out.printf("Field confidence: %.2f", documentTypeDetails.getFieldConfidence().get(field));
        });
    });
});

// Delete Model
documentModelAdminClient.deleteDocumentModel(modelId.get());

对文档进行分类

表单识别器服务支持自定义文档分类器，这些分类器可以根据训练数据集将文档分类为一组预定义类别。 可以使用 的 或 beginClassifyDocumentFromUrl 方法DocumentAnalysisClient使用 自定义分类器对文档进行beginClassifyDocument分类。 以下示例演示如何使用自定义分类器对文档进行分类：

String documentUrl = "{file_source_url}";
String classifierId = "{custom_trained_classifier_id}";

documentAnalysisClient.beginClassifyDocumentFromUrl(classifierId, documentUrl, Context.NONE)
    .getFinalResult()
    .getDocuments()
    .forEach(analyzedDocument -> System.out.printf("Doc Type: %s%n", analyzedDocument.getDocType()));

有关更详细的示例，请参阅 示例。

疑难解答

常规

表单识别器客户端引发HttpResponseException异常。 例如，如果尝试提供一个无效的文件源 URL，则会引发 HttpResponseException，并会出现一个指出失败原因的错误。 在以下代码片段中，通过捕获异常并显示有关错误的其他信息来妥善处理该错误。

try {
    documentAnalysisClient.beginAnalyzeDocumentFromUrl("prebuilt-receipt", "invalidSourceUrl");
} catch (HttpResponseException e) {
    System.out.println(e.getMessage());
    // Do something with the exception
}

启用客户端日志记录

适用于 Java 的 Azure SDK 提供一致的日志记录故事，可帮助排查应用程序错误并加快解决。 生成的日志会在到达终端状态之前捕获应用程序的流，以帮助查找根本问题。 有关启用 日志记录 的指南，请查看日志记录 Wiki。

默认的 HTTP 客户端

默认情况下，所有客户端库都使用 Netty HTTP 客户端。 添加上述依赖项以自动将客户端库配置为使用 Netty HTTP 客户端。 HTTP 客户端 Wiki 中详述了如何配置或更改 HTTP 客户端。

后续步骤

以下部分提供了几个代码片段，说明表单识别器 API 中使用的常见模式。 这些代码示例演示 Azure 表单识别器客户端库的常见方案操作。

• 从 URL 分析业务卡：AnalyzeBusinessCardFromUrl
• 从 URL 分析标识文档： AnalyzeIdentityDocumentsFromUrl
• 通过 URL 分析发票： AnalyzeInvoiceFromUrl
• 分析收据： AnalyzeReceipts
• 分析 URL 中的收据： AnalyzeReceiptsFromUrl
• 提取布局： AnalyzeLayout
• 从 URL 分析自定义文档： AnalyzeCustomDocumentFromUrl
• 生成模型： BuildModel
• 管理自定义模型： ManageCustomModels
• 在表单识别器资源之间复制模型：CopyModel
• 从自定义生成的模型集合创建组合模型： ComposeModel
• 获取/列出与表单识别器资源关联的文档模型操作：GetOperation
• 生成文档分类器： BuildDocumentClassifier

异步 API

到目前为止显示的所有示例都使用同步 API，但我们也提供对异步 API 的完全支持。 你需要使用 DocumentAnalysisAsyncClient

DocumentAnalysisAsyncClient documentAnalysisAsyncClient = new DocumentAnalysisClientBuilder()
    .credential(new AzureKeyCredential("{key}"))
    .endpoint("{endpoint}")
    .buildAsyncClient();

• 从 URL 分析业务卡：AnalyzeBusinessCardFromUrlAsync
• 从 URL 分析标识文档： AnalyzeIdentityDocumentsFromUrlAsync
• 分析发票： AnalyzeInvoiceAsync
• 分析收据： AnalyzeReceiptsAsync
• 分析来自 URL 的收据： AnalyzeReceiptsFromUrlAsync
• 从 URL 提取布局： AnalyzeLayoutFromUrlAsync
• 分析自定义文档： AnalyzeCustomDocumentAsync
• 生成文档模型： BuildModelAsync
• 管理自定义模型： ManageCustomModelsAsync
• 在表单识别器资源之间复制文档模型：CopyModelAsync
• 从自定义生成的模型集合创建组合文档模型： ComposeModelAsync
• 获取/列出与表单识别器资源关联的文档模型操作：GetOperationAsync
• 生成文档分类器： BuildDocumentClassifierAsync

其他文档

有关介绍 表单识别器 Java SDK 中使用的常见模式的多个代码片段，请参阅示例自述文件。 有关 Azure 认知服务表单识别器的更多文档，请参阅表单识别器文档。

贡献

本项目欢迎贡献和建议。 大多数贡献要求你同意贡献者许可协议 (CLA)，并声明你有权（并且确实有权）授予我们使用你的贡献的权利。

提交拉取请求时，CLA 机器人将自动确定你是否需要提供 CLA，并相应地修饰 PR（例如标签、注释）。 直接按机器人提供的说明操作。 只需使用 CLA 对所有存储库执行一次这样的操作。

此项目采用了 Microsoft 开放源代码行为准则。 有关详细信息，请参阅行为准则常见问题解答；若有其他任何问题或意见，请联系 opencode@microsoft.com。