Este blog é uma continuação do nosso blog anterior, onde destacamos alguns recursos interessantes do Aspose.PDF Cloud SDK para Java sobre como adicionar Destacar ou Riscar Texto e adicionar Anotações de Linha ou Círculo em PDF usando Java REST API. Neste artigo, discutiremos particularmente os detalhes sobre adicionar Anotações de Texto, Polilinha, Squiggly e Anexo dentro de documentos PDF usando a linguagem de programação Java.
Aspose.PDF Cloud é uma API REST que permite aos usuários criar, manipular e renderizar arquivos PDF existentes para outros formatos de documentos suportados. A API Cloud pode ser acessada usando as duas abordagens a seguir:
- Acesse a API por meio de comandos cURL
- Acesse a API na linguagem de programação Java
Vamos discutir mais detalhadamente a adição de várias Anotações a documentos PDF usando comandos cURL e código Java.
Adicionar anotações usando o comando cURL
Os comandos cURL são uma das maneiras mais fáceis e legais de acessar as APIs REST. Então, vamos falar sobre adicionar as diferentes anotações usando os comandos cURL. Observe que cada API também permite que você acesse o armazenamento em nuvem onde os arquivos podem ser armazenados para processamento, portanto, para garantir a integridade dos dados, nossas APIs são acessíveis apenas a pessoas autorizadas. Portanto, você precisa primeiro visitar Aspose.Cloud dashboard e, se tiver uma conta GitHub ou Google, basta se inscrever. Caso contrário, clique no botão Create a new Account e forneça as informações necessárias. Agora, faça login no painel usando credenciais, expanda a seção Applications do painel e role para baixo em direção à seção Client Credentials para ver os detalhes do Client ID e do Client Secret.
Agora, o próximo passo é gerar um JSON Web Token (JWT) para que as APIs sejam acessíveis pelo prompt de comando.
curl -v "https://api.aspose.cloud/connect/token" \
-X POST \
-d "grant_type=client_credentials&client_id=7042694c-5251-4aba-83c9-e81e7518724f&client_secret=db246d4742e8cd22e7266c9391992689" \
-H "Content-Type: application/x-www-form-urlencoded" \
-H "Accept: application/json"
Anotação de texto
Uma Anotação de Texto é uma anotação anexada a um local específico em um documento PDF. Quando fechada, a anotação é exibida como um ícone; quando aberta, ela deve exibir uma janela pop-up contendo o texto da nota na fonte e no tamanho escolhidos pelo leitor. Para adicionar a Anotação de Texto, precisamos usar a API PostPageTextAnnotation. Use o seguinte comando cURL para adicionar a Anotação de Texto com o ícone de Nota.
curl -X POST "https://api.aspose.cloud/v3.0/pdf/PdfWithBookmarks.pdf/pages/1/annotations/text" \
-H "accept: application/json" \
-H "authorization: Bearer <JWT Token>" \
-H "Content-Type: application/json" \
-d "[{ \"Color\": { \"A\": 0, \"R\": 0xDA, \"G\": 0xA5, \"B\": 0x20 }, \"Contents\": \"Hello World \", \"Modified\": \"05/26/2021 03:10:00.000 PM\", \"Id\": \"1\", \"Flags\": [ \"Default\" ], \"Name\": \"string\", \"Rect\": { \"LLX\": 100, \"LLY\": 800, \"URX\": 100, \"URY\": 100 }, \"PageIndex\": 1, \"ZIndex\": 1, \"HorizontalAlignment\": \"Center\", \"VerticalAlignment\": \"Center\", \"CreationDate\": \"string\", \"Subject\": \"Subject of Annotation\", \"Title\": \"Annotation Title\", \"RichText\": \"string\", \"State\": \"Undefined\", \"Open\": true, \"Icon\": \"Note\" }]"
Imagem 1: Anotação de texto com ícone de nota em arquivo PDF.
Os arquivos PDF de amostra usados no exemplo acima podem ser baixados dos seguintes links
Anotação de polilinha
As anotações de polilinha são usadas para desenhar polilinhas à mão em uma página. Elas podem conter qualquer número de lados definidos pelos vértices de polilinha. Anotações de polilinha com cor de preenchimento transparente são selecionáveis somente ao redor de suas linhas visíveis. As anotações de polilinha também podem ser adicionadas usando a API PostPagePolyLineAnnotations.
curl -X POST "https://api.aspose.cloud/v3.0/pdf/PdfWithTable.pdf/pages/1/annotations/polyline" \
-H "accept: application/json" \
-H "authorization: Bearer " \
-H "Content-Type: application/json" \
-d "[ { \"Color\": { \"A\": 0, \"R\": 122, \"G\": 132, \"B\": 255 }, \"Contents\": \"Hello World...\", \"Modified\": \"05/26/2021 03:10:00.000 PM\", \"Id\": \"1\", \"Flags\": [ \"Default\" ], \"Name\": \"Polyline\", \"Rect\": { \"LLX\": 100, \"LLY\": 200, \"URX\": 150, \"URY\": 250 }, \"PageIndex\": 1, \"ZIndex\": 1, \"HorizontalAlignment\": \"Center\", \"VerticalAlignment\": \"Center\", \"CreationDate\": \"05/26/2021 03:10:00.000 PM\", \"Subject\": \"Subject of Annotation\", \"Title\": \"Title of Annotation\", \"RichText\": \"<?xml version=\\\"1.0\\\"?><body xmlns=\\\"http://www.w3.org/1999/xhtml\\\" xmlns:xfa=\\\"http://www.xfa.org/schema/xfa-data/1.0/\\\" xfa:APIVersion=\\\"Acrobat:7.0.0\\\" xfa:spec=\\\"2.0.2\\\" ><span style=\\\"text-decoration:;font-size:10.0pt\\\">Contents</span></body>\", \"InteriorColor\": { \"A\": 255, \"R\": 120, \"G\": 110, \"B\": 255 }, \"StartingStyle\": \"Circle\", \"EndingStyle\": \"OpenArrow\", \"Intent\": \"PolyLineDimension\", \"Vertices\": [ { \"X\": 164.611, \"Y\": 499.629 }, { \"X\": 192.858, \"Y\": 509.857 }, { \"X\": 226.461, \"Y\": 493.785 } ] }]"
Anotação ondulada
As Anotações sublinhadas onduladas ou irregulares ajudam a destacar as informações dentro do documento. Elas podem ser adicionadas usando a API PostPageSquigglyAnnotations. O comando abaixo ajuda você a adicionar anotações Squiggly ao documento PDF.
curl -X POST "https://api.aspose.cloud/v3.0/pdf/PdfWithTable.pdf/pages/1/annotations/squiggly" \
-H "accept: application/json" \
-H "authorization: Bearer <JWT Token>" \
-H "Content-Type: application/json" \
-d "[ { \"Color\": { \"A\": 255, \"R\": 120, \"G\": 123, \"B\": 150 }, \"Contents\": \"A squiggly Annotation\", \"Modified\": \"05/26/2021 03:10:00.000 PM\", \"Id\": \"1\", \"Flags\": [ \"Default\" ], \"Name\": \"First Annotation\", \"Rect\": { \"LLX\": 100, \"LLY\": 300, \"URX\": 120, \"URY\": 330 }, \"PageIndex\": 1, \"ZIndex\": 1, \"HorizontalAlignment\": \"Center\", \"VerticalAlignment\": \"Center\", \"CreationDate\": \"05/26/2021 03:10:00.000 PM\", \"Subject\": \"Subject \", \"Title\": \"Title of Squiggly\", \"Starting\": { \"X\": 162.663, \"Y\": 654.5 }, \"StartingStyle\": \"Circle\", \"Ending\": { \"X\": 230.845, \"Y\": 654.5 }, \"EndingStyle\": \"OpenArrow\", \"InteriorColor\": { \"A\": 255, \"R\": 220, \"G\": 220, \"B\": 220 }, \"LeaderLine\": 10, \"LeaderLineExtension\": 5, \"LeaderLineOffset\": 2.5, \"ShowCaption\": true, \"CaptionOffset\": { \"X\": 7, \"Y\": 8 }, \"CaptionPosition\": \"Top\", \"Intent\": \"LineArrow\",\"RichText\": \"string\", \"QuadPoints\": [ { \"X\": 100, \"Y\": 200 } ] }]"
Anotação de anexo
Vários arquivos podem ser adicionados como anotações de anexo ao documento PDF e, para cumprir esse requisito, a API PostPageFileAttachmentAnnotations pode ser usada. Execute o seguinte comando cURL para anexar um arquivo existente ao documento PDF. Em nosso exemplo, o arquivo chamado PdfWithTable.pdf (já disponível no armazenamento em nuvem) é usado como anexo.
curl -X POST "https://api.aspose.cloud/v3.0/pdf/PdfWithBookmarks.pdf/pages/1/annotations/fileattachment" \
-H "accept: application/json" \
-H "authorization: Bearer <JWT Token>" \
-H "Content-Type: application/json" \
-d "[ { \"Color\": { \"A\": 255, \"R\": 120, \"G\": 120, \"B\": 120 }, \"Contents\": \"Content\", \"Modified\": \"05/26/2021 03:10:00.000 PM\", \"Id\": \"1\", \"Flags\": [ \"Default\" ], \"Name\": \"FileAttachment\", \"Rect\": { \"LLX\": 100, \"LLY\": 200, \"URX\": 120, \"URY\": 2200 }, \"PageIndex\": 1, \"ZIndex\": 0, \"HorizontalAlignment\": \"Center\", \"VerticalAlignment\": \"Top\", \"CreationDate\": \"05/26/2021 03:10:00.000 PM\", \"Subject\": \"Subject\", \"Title\": \"Title\", \"RichText\": \"string\", \"Icon\": \"PushPin\", \"Opacity\": 0, \"FileDescription\": \"string\", \"FileName\": \"PdfWithTable.pdf\", \"FilePath\": \"PdfWithTable.pdf\" }]"
Adicionar anotações usando Java
Além dos comandos cURL, outra abordagem para usar nossas APIs de nuvem é acessá-las por meio de SDKs de programação. Desenvolvemos os SDKs de programação para linguagens de programação populares. Então, para trabalhar com Anotações em PDF usando a linguagem Java, tente usar Aspose.PDF Cloud SDK para Java.
O primeiro passo é instalar o SKD no sistema. O Cloud SDK está disponível para download no Maven e GitHub. Agora adicione os seguintes detalhes no seu arquivo pom.xml para baixar e usar Aspose.Pdf.jar no seu projeto de build do Maven.
<repositories>
<repository>
<id>aspose-cloud</id>
<name>artifact.aspose-cloud-releases</name>
<url>https://artifact.aspose.cloud/repo</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>com.aspose</groupId>
<artifactId>aspose-pdf-cloud</artifactId>
<version>21.1.0</version>
<scope>compile</scope>
</dependency>
</dependencies>
Para obter mais informações, visite Como instalar os SDKs do Aspose.Cloud.
Anotações de texto
Abaixo estão as etapas para adicionar Anotações de Texto aos documentos PDF.
- O primeiro passo é criar um objeto PdfApi onde fornecemos ClientID e ClientSecret como argumentos
- Em seguida, criamos o objeto Rectangle onde a anotação é adicionada
- LLX - Coordenada X do canto inferior esquerdo.
- LLY - Y - coordenada do canto inferior esquerdo.
- URY - X - coordenada do canto superior direito.
- URY - Y - coordenada do canto superior direito.
- Crie o objeto TextAnnotation onde definimos o alinhamento usando o método setHorizontalAlignment(..).Defina o assunto usando o método setSubject(…), o estado padrão usando o método setState(…), etc.
- Em seguida, crie o objeto ArrayList<> do tipo TextAnnotation e adicione o objeto TextAnnotation criado acima a ele
- Por fim, chame postPageTextAnnotations(…) onde passamos o nome do arquivo PDF de entrada, PageNumber e o Annotations ArrayList criado acima como argumentos
// Obtenha ClientID e ClientSecret de https://dashboard.aspose.cloud/
String clientId = "7042694c-5251-4aba-83c9-e81e7518724f";
String clientSecret = "db246d4742e8cd22e7266c9391992689";
// instância createPdfApi
PdfApi pdfApi = new PdfApi(clientSecret,clientId);
// documento PDF de entrada
String name = "PdfWithTable.pdf";
// Carregue o arquivo do sistema local
File file = new File("/Users/nayyershahbaz/Downloads/" + name);
// carregue o arquivo para o armazenamento em nuvem
FilesUploadResult uploadResponse = pdfApi.uploadFile(name, file, null);
// número da página onde a anotação precisa ser adicionada
int pageNumber = 1;
// crie um objeto retângulo onde a anotação é adicionada
Rectangle rect = new Rectangle()
.LLX(100.)
.LLY(600.)
.URX(200.)
.URY(650.);
// Criar ListArray de AnnotationFlags
List<AnnotationFlags> flags = new ArrayList<>();
flags.add(AnnotationFlags.DEFAULT);
// Criar objeto TextAnnotation
TextAnnotation textAnnotation = new TextAnnotation();
textAnnotation.setName("Annotation Name");
textAnnotation.setRect(rect);
textAnnotation.setFlags(flags);
textAnnotation.setHorizontalAlignment(HorizontalAlignment.CENTER);
// defina o conteúdo a ser exibido dentro da Anotação
textAnnotation.contents("Hello World...");
// Defina o ícone para anotação
textAnnotation.icon(TextIcon.KEY);
textAnnotation.setSubject("Text Box Subj");
textAnnotation.setZindex(1);
// o estado padrão do objeto de anotação
textAnnotation.setState(AnnotationState.COMPLETED);
// criar ListArray de TextAnnotation
List<TextAnnotation> annotations = new ArrayList<>();
// adicione TextAnnotation criado acima à instância da lista
annotations.add(textAnnotation);
// chame o método para adicionar anotações ao arquivo PDF
AsposeResponse response = pdfApi.postPageTextAnnotations(name, pageNumber, annotations, null, null);
assertEquals(200, (int)response.getCode());
Anotações de polilinha
O Cloud SDK também fornece os mesmos recursos para adicionar as Anotações de Polilinha ao documento PDF. Abaixo estão as etapas e o snippet de código para atender a esse requisito.
- Primeiro, precisamos criar uma instância PdfApi e enviar o arquivo de origem para o armazenamento em nuvem.
- Crie uma ArrayList do tipo Point que define os pontos nos quais as polilinhas serão desenhadas.
- O próximo passo é criar um objeto PolyLineAnnotation onde definimos a região retangular e passamos Points ListArray para o método setVertices(…).
- Para definir a cor interna, use o método setInteriorColor(…) e passe a instância Color como argumento.
- Agora chame os métodos startingStyle(…) e endingStyle(…) para definir o estilo inicial e final da anotação. Esses métodos pegam o valor da enumeração LineEnding como argumentos.
- Por fim, chame o método postPagePolyLineAnnotations(…) da classe PdfApi para renderizar a anotação dentro do documento PDF.
// Obtenha ClientID e ClientSecret de https://dashboard.aspose.cloud/
String clientId = "a41d01ef-dfd5-4e02-ad29-bd85fe41e3e4";
String clientSecret = "d87269aade6a46cdc295b711e26809af";
// instância createPdfApi
PdfApi pdfApi = new PdfApi(clientSecret,clientId);
// documento PDF de entrada
String name = "PdfWithTable.pdf";
// Carregue o arquivo do sistema local
File file = new File("/Users/nayyershahbaz/Downloads/" + name);
// carregue o arquivo para o armazenamento em nuvem
FilesUploadResult uploadResponse = pdfApi.uploadFile(name, file, null);
// número da página do arquivo de entrada onde a anotação será adicionada
int pageNumber = 1;
// região retangular para a anotação
Rectangle rect = new Rectangle()
.LLX(100.)
.LLY(600.)
.URX(200.)
.URY(650.);
// especifique os vértices para a anotação
List<Point> vertices = new ArrayList();
vertices.add(new Point().X(10.).Y(10.));
vertices.add(new Point().X(20.).Y(10.));
vertices.add(new Point().X(10.).Y(20.));
vertices.add(new Point().X(10.).Y(10.));
List<AnnotationFlags> flags = new ArrayList<>();
flags.add(AnnotationFlags.DEFAULT);
// criar objeto PolyLineAnnotation
PolyLineAnnotation annotation = new PolyLineAnnotation();
annotation.setName("Name");
annotation.setRect(rect);
annotation.setFlags(flags);
// definir o alinhamento horizontal da anotação
annotation.setHorizontalAlignment(HorizontalAlignment.CENTER);
annotation.contents("Rich Text in the PDF File...");
annotation.setSubject("Subj");
annotation.setZindex(1);
annotation.setTitle("Title");
// criar objeto colorido
Color color = new Color();
color.setA(255);
color.setR(120);
color.setG(140);
color.setB(130);
// defina a cor interna para a instância de anotação
annotation.setInteriorColor(color);
annotation.setVertices(vertices);
// especifique o estilo inicial para anotação
annotation.startingStyle(LineEnding.OPENARROW);
// definir o estilo final para anotação
annotation.endingStyle(LineEnding.SQUARE);
List<PolyLineAnnotation> annotations = new ArrayList<>();
annotations.add(annotation);
// chame o método para adicionar Anotação de Polilinha à primeira página do documento
AsposeResponse response = pdfApi.postPagePolyLineAnnotations(name, pageNumber, annotations, null, null);
assertEquals(200, (int)response.getCode());
Anotações onduladas
Uma classe separada chamada SquigglyAnnotation é usada para adicionar anotações Squiggly ao documento PDF. O snippet de código fornecido abaixo pode ser usado para adicionar anotações Squiggly ao arquivo PDF disponível no armazenamento em nuvem.
// Obtenha ClientID e ClientSecret de https://dashboard.aspose.cloud/
String clientId = "a41d01ef-dfd5-4e02-ad29-bd85fe41e3e4";
String clientSecret = "d87269aade6a46cdc295b711e26809af";
// instância createPdfApi
PdfApi pdfApi = new PdfApi(clientSecret,clientId);
// documento PDF de entrada
String name = "PdfWithTable.pdf";
// Carregue o arquivo do sistema local
File file = new File("/Users/nayyershahbaz/Downloads/" + name);
// carregue o arquivo para o armazenamento em nuvem
FilesUploadResult uploadResponse = pdfApi.uploadFile(name, file, null);
// número da página do arquivo de entrada onde a anotação será adicionada
int pageNumber = 1;
// região retangular para a anotação
Rectangle rect = new Rectangle()
.LLX(100.)
.LLY(600.)
.URX(200.)
.URY(650.);
// especifique os vértices para a anotação
List<Point> vertices = new ArrayList();
vertices.add(new Point().X(10.).Y(10.));
vertices.add(new Point().X(20.).Y(10.));
vertices.add(new Point().X(10.).Y(20.));
vertices.add(new Point().X(10.).Y(10.));
List<AnnotationFlags> flags = new ArrayList<>();
flags.add(AnnotationFlags.DEFAULT);
// criar objeto SquigglyAnnotation
SquigglyAnnotation annotation = new SquigglyAnnotation();
annotation.setName("Name");
annotation.setRect(rect);
annotation.setFlags(flags);
annotation.setHorizontalAlignment(HorizontalAlignment.CENTER);
annotation.contents("Rich Text in the PDF File...");
annotation.setSubject("Subj");
annotation.setZindex(1);
annotation.setTitle("Title");
annotation.setModified("28/05/2021 00:00:00.000 AM");
// criar objeto colorido
Color color = new Color();
color.setA(155);
color.setR(120);
color.setG(140);
color.setB(130);
// defina a cor interna para a instância de anotação
annotation.color(color);
// definir pontos de anotação
annotation.setQuadPoints(vertices);
List<SquigglyAnnotation> annotations = new ArrayList<>();
annotations.add(annotation);
// chame o método para adicionar a Anotação Squiggly à primeira página do documento
AsposeResponse response = pdfApi.postPageSquigglyAnnotations(name, pageNumber, annotations, null, null);
assertEquals(200, (int)response.getCode());
Anotações de anexos de arquivo
Para adicionar a anotação de anexo de arquivo, tente usar o seguinte trecho de código. A descrição do código é a mesma compartilhada nas seções acima, exceto que você precisa usar o objeto FileAttachmentAnnotation para cumprir esse requisito.
// Obtenha ClientID e ClientSecret de https://dashboard.aspose.cloud/
String clientId = "a41d01ef-dfd5-4e02-ad29-bd85fe41e3e4";
String clientSecret = "d87269aade6a46cdc295b711e26809af";
// instância createPdfApi
PdfApi pdfApi = new PdfApi(clientSecret,clientId);
// documento PDF de entrada
String name = "PdfWithTable.pdf";
// Carregue o arquivo do sistema local
File file = new File("/Users/nayyershahbaz/Downloads/" + name);
// carregue o arquivo para o armazenamento em nuvem
FilesUploadResult uploadResponse = pdfApi.uploadFile(name, file, null);
// número da página do arquivo de entrada onde a anotação será adicionada
int pageNumber = 1;
// região retangular para a anotação
Rectangle rect = new Rectangle()
.LLX(100.)
.LLY(100.)
.URX(200.)
.URY(200.);
List<AnnotationFlags> flags = new ArrayList<>();
flags.add(AnnotationFlags.DEFAULT);
// criar objeto FileAttachmentAnnotation
FileAttachmentAnnotation annotation = new FileAttachmentAnnotation();
annotation.setName("Name");
annotation.setRect(rect);
annotation.setFlags(flags);
annotation.setHorizontalAlignment(HorizontalAlignment.CENTER);
annotation.contents("Rich Text in the PDF File...");
annotation.setSubject("Subj");
annotation.setZindex(1);
annotation.setTitle("Title");
annotation.setModified("28/05/2021 00:00:00.000 AM");
// caminho do arquivo anexo
annotation.setFilePath("images.jpeg");
// nome do arquivo anexo
annotation.setFileName("images.jpeg");
// criar instância de lista de FileAttachment
List<FileAttachmentAnnotation> annotations = new ArrayList<>();
annotations.add(annotation);
// chame o método para adicionar a anotação FileAttachment à primeira página do documento
AsposeResponse response = pdfApi.postPageFileAttachmentAnnotations(name, pageNumber, annotations, null, null);
assertEquals(200, (int)response.getCode());
Conclusão
Neste artigo, discutimos as etapas e detalhes relacionados para adicionar Anotações de Texto, Polilinha, Squiggly e FileAttachment ao documento PDF. Como nossos Cloud SDKs são de código aberto, você pode baixar o código-fonte completo do GitHub. O repositório também contém outros exemplos úteis sobre como usar o Java Cloud SDK para criar e manipular arquivos PDF existentes. Caso tenha alguma dúvida relacionada, sinta-se à vontade para entrar em contato conosco via Free fóruns de suporte ao cliente.
Artigos relacionados
Recomendamos fortemente que você visite os seguintes artigos: