# Construir e testar Java com Ant

Saiba como criar um fluxo de trabalho de CI (integração contínua) em GitHub Actions para criar e testar seu projeto de Java com o Ant.

## Introdução

Este guia mostra como criar um fluxo de trabalho que executa a CI (integração contínua) para seu projeto de Java usando o sistema de build Ant. O fluxo de trabalho que você criar permitirá que você veja quando commits em um pull request gerarão falhas de criação ou de teste em comparação com o seu branch-padrão. Essa abordagem pode ajudar a garantir que seu código seja sempre saudável. Você pode estender seu fluxo de trabalho de CI para enviar artefatos a partir da execução de um fluxo de trabalho.

Executores hospedados em GitHub têm um cache de ferramentas com software pré-instalado que inclui kits de desenvolvimento Java (JDKs) e Ant. Para obter uma lista de softwares e as versões pré-instaladas para JDK e Ant, confira [Executores hospedados no GitHub](/pt/actions/using-github-hosted-runners/about-github-hosted-runners#supported-software).

## Pré-requisitos

Você deve estar familiarizado com o YAML e a sintaxe do GitHub Actions. Para saber mais, veja:

* [Sintaxe de fluxo de trabalho para o GitHub Actions](/pt/actions/using-workflows/workflow-syntax-for-github-actions)
* [Escrevendo fluxos de trabalho](/pt/actions/learn-github-actions)

Recomendamos que você tenha uma compreensão básica do Java e da estrutura ant. Para obter mais informações, confira o [Manual do Apache Ant](https://ant.apache.org/manual/).

## Usando um modelo de fluxo de trabalho do Ant

Para uma introdução rápida, adicione um modelo de fluxo de trabalho ao diretório `.github/workflows` do repositório.

GitHub fornece um modelo de fluxo de trabalho para Ant que deve funcionar para a maioria dos projetos com Java e Ant. As seções subsequentes deste guia fornecem exemplos de como você pode personalizar esse modelo de fluxo de trabalho.

1. Em GitHub, acesse a página principal do repositório.

2. No nome do repositório, clique em **<svg version="1.1" width="16" height="16" viewBox="0 0 16 16" class="octicon octicon-play" aria-label="play" role="img"><path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Zm4.879-2.773 4.264 2.559a.25.25 0 0 1 0 .428l-4.264 2.559A.25.25 0 0 1 6 10.559V5.442a.25.25 0 0 1 .379-.215Z"></path></svg> Actions**.

   ![Captura de tela das guias do repositório "github/docs". A guia "Ações" está realçada com um contorno laranja.](/assets/images/help/repository/actions-tab-global-nav-update.png)

3. Se você já tiver um fluxo de trabalho no repositório, clique em **Novo fluxo de trabalho**.

4. A página "Escolher um fluxo de trabalho" mostra uma seleção de modelos de fluxo de trabalho recomendados. Pesquise por "Java com Ant".

5. No fluxo de trabalho "Java com Ant", clique em **Configure**.

6. Edite o fluxo de trabalho conforme necessário. Por exemplo, altere a versão do Java.

7. Clique em **Confirmar alterações**.

O arquivo de fluxo de trabalho `ant.yml` é adicionado ao diretório `.github/workflows` do seu repositório.

### Como especificar a versão e a arquitetura da JVM

O modelo de fluxo de trabalho configura o `PATH` para conter OpenJDK 8 para a plataforma x64. Se você quiser usar uma versão diferente do Java, ou escolher uma arquitetura diferente (`x64` ou `x86`), você pode usar a ação `setup-java` para escolher um ambiente de execução Java diferente.

Por exemplo, para usar a versão 11 do JDK fornecida pelo Adoptium para a plataforma x64, você poderá usar a ação `setup-java` e configurar os parâmetros `java-version`, `distribution` e `architecture` para `'11'`, `'temurin'` e `x64`.

```yaml copy
steps:
  - uses: actions/checkout@v6
  - name: Set up JDK 11 for x64
    uses: actions/setup-java@v4
    with:
      java-version: '11'
      distribution: 'temurin'
      architecture: x64
```

Para obter mais informações, confira a ação [`setup-java`](https://github.com/actions/setup-java).

## Criar e testar seu código

Você pode usar os mesmos comandos usados localmente para criar e testar seu código.

O modelo de fluxo de trabalho executará o destino padrão especificado no arquivo `build.xml`. Seu alvo-padrão será comumente definido para criar classes, executar testes e classes de pacote em seu formato distribuível como, por exemplo, um arquivo JAR.

Se você usa comandos diferentes para criar seu projeto ou se você quer executar um alvo diferente, você poderá especificá-los. Por exemplo, você pode querer executar o alvo `jar` configurado no arquivo `build-ci.xml`.

```yaml copy
steps:
  - uses: actions/checkout@v6
  - uses: actions/setup-java@v4
    with:
      java-version: '17'
      distribution: 'temurin'
  - name: Run the Ant jar target
    run: ant -noinput -buildfile build-ci.xml jar
```

## Empacotar dados do fluxo de trabalho como artefatos

Depois que o build tiver sido bem-sucedido e seus testes tiverem sido aprovados, talvez você queira carregar os pacotes de Java resultantes como um artefato de build. Isso armazenará os pacotes criados como parte da execução do fluxo de trabalho e permitirá que você faça o download desses pacotes. Os artefatos podem ajudá-lo a testar e depurar os pull requests no seu ambiente local antes de serem mesclados. Para saber mais, confira [Armazenar e compartilhar dados com artefatos de fluxo de trabalho](/pt/actions/using-workflows/storing-workflow-data-as-artifacts).

Em geral, o Ant criará arquivos de saída como JARs, EARs ou WARs no diretório `build/jar`. Você pode carregar o conteúdo desse diretório usando a ação `upload-artifact`.

```yaml copy
steps:
  - uses: actions/checkout@v6
  - uses: actions/setup-java@v4
    with:
      java-version: '17'
      distribution: 'temurin'

  - run: ant -noinput -buildfile build.xml
  - uses: actions/upload-artifact@v4
    with:
      name: Package
      path: build/jar
```