Como migrar do Maven para o Bazel

Relatar um problema Conferir código-fonte Por noite · 7,3 · 7,2 · 7,1 · 7,0 · 6,5

Nesta página, descrevemos como migrar do Maven para o Bazel, incluindo as pré-requisitos e etapas de instalação. Ele descreve as diferenças entre o Maven e Bazel e fornece um exemplo de migração usando o projeto Guava.

Ao migrar de qualquer ferramenta de build para o Bazel, é melhor ter as duas ferramentas em execução em paralelo até migrar totalmente a equipe de desenvolvimento, e quaisquer outros sistemas relevantes. É possível executar Maven e Bazel na mesma repositório de dados.

Observação: embora o Bazel seja compatível com o download e a publicação de artefatos Maven rules_jvm_external , ele não é diretamente compatível com plug-ins baseados no Maven. Os plug-ins do Maven não podem ser executados diretamente pelo Bazel, já que não há uma camada de compatibilidade do Maven.

Antes de começar

• Instale o Bazel se ainda não estiver instalado.
• Se você ainda não conhece o Bazel, consulte o tutorial Introdução ao Bazel: Crie em Java antes de iniciar a migração. O tutorial explica Conceitos, estrutura e sintaxe de rótulos do Bazel.

Diferenças entre o Maven e o Bazel

• O Maven usa arquivos pom.xml de nível superior. O Bazel oferece suporte a vários arquivos de build e vários destinos por arquivo BUILD, o que permite builds mais incremental do que o do Maven.
• O Maven se encarrega das etapas do processo de implantação. O Bazel não para automatizar a implantação.
• Ele permite expressar dependências entre linguagens.
• Conforme você adiciona novas seções ao projeto, com o Bazel, pode ser necessário adicionar novas BUILD. A prática recomendada é adicionar um arquivo BUILD a cada novo arquivo Java. .

Migrar do Maven para o Bazel

As etapas abaixo descrevem como migrar seu projeto para o Bazel:

1. Crie o arquivo MODULE.bazel
2. Crie um arquivo BUILD
3. Crie mais arquivos BUILD
4. Criar usando o Bazel

Os exemplos abaixo vêm de uma migração da Guava projeto do Maven para o Bazel. A O projeto Guava usado é a versão v31.1. Os exemplos que usam Guava não caminham em cada etapa da migração, mas mostram os arquivos e o conteúdo são gerados ou adicionados manualmente para a migração.

$ git clone https://github.com/google/guava.git && cd guava
$ git checkout v31.1

1. Crie o arquivo MODULE.bazel

Crie um arquivo chamado MODULE.bazel na raiz do projeto. Se o seu projeto não tiver dependências externas, esse arquivo pode estar vazio.

Se o projeto depender de arquivos ou pacotes que não estão em um dos do projeto, especifique essas dependências externas no arquivo MODULE.bazel . É possível usar rules_jvm_external para gerenciar dependências do Maven. Para instruções sobre como usar esse conjunto de regras, consulte o README ,

Exemplo de projeto Guava: dependências externas

Você pode listar as dependências externas do Guava projeto com o rules_jvm_external grupo de regras.

Adicione o seguinte snippet ao arquivo MODULE.bazel:

bazel_dep(name = "rules_jvm_external", version = "6.2")
maven = use_extension("@rules_jvm_external//:extensions.bzl", "maven")
maven.install(
    artifacts = [
        "com.google.code.findbugs:jsr305:3.0.2",
        "com.google.errorprone:error_prone_annotations:2.11.0",
        "com.google.j2objc:j2objc-annotations:1.3",
        "org.codehaus.mojo:animal-sniffer-annotations:1.20",
        "org.checkerframework:checker-qual:3.12.0",
    ],
    repositories = [
        "https://repo1.maven.org/maven2",
    ],
)
use_repo(maven, "maven")

2. Crie um arquivo BUILD

Agora que você definiu seu espaço de trabalho e as dependências externas (se aplicável), é necessário criar arquivos BUILD para descrever como as o projeto deve ser construído. Ao contrário do Maven, com um arquivo pom.xml, o Bazel pode usar muitos arquivos BUILD para criar um projeto. Esses arquivos especificam vários builds o que permite que o Bazel produza builds incrementais.

Adicione arquivos BUILD em etapas. Comece adicionando um arquivo BUILD na raiz do seu projeto e usá-lo para fazer uma compilação inicial com o Bazel. Depois, você refina seu build adicionando mais arquivos BUILD com destinos mais granulares.

1. No mesmo diretório do arquivo MODULE.bazel, crie um arquivo de texto e nomeie-o como BUILD.

2. Neste arquivo BUILD, use a regra adequada para criar um destino para o build seu projeto. Veja algumas dicas:

   • Use a regra apropriada:

     • Para criar projetos com um único módulo do Maven, use a java_library da seguinte maneira:

       java_library(
          name = "everything",
          srcs = glob(["src/main/java/**/*.java"]),
          resources = glob(["src/main/resources/**"]),
          deps = ["//:all-external-targets"],
       )
       

     • Para criar projetos com vários módulos Maven, use a java_library da seguinte maneira:

       java_library(
          name = "everything",
          srcs = glob([
                "Module1/src/main/java/**/*.java",
                "Module2/src/main/java/**/*.java",
                ...
          ]),
          resources = glob([
                "Module1/src/main/resources/**",
                "Module2/src/main/resources/**",
                ...
          ]),
          deps = ["//:all-external-targets"],
       )
       

     • Para criar binários, use a regra java_binary:

       java_binary(
          name = "everything",
          srcs = glob(["src/main/java/**/*.java"]),
          resources = glob(["src/main/resources/**"]),
          deps = ["//:all-external-targets"],
          main_class = "com.example.Main"
       )
       

     • Especifique os atributos:

       • name: dá ao destino um nome significativo. Nos exemplos acima, o destino é chamado de "tudo".
       • srcs: use globbing para listar todos os arquivos .java no seu projeto.
       • resources: use globs para listar todos os recursos no projeto.
       • deps: você precisa determinar para quais dependências externas necessidades do projeto.

     • Dê uma olhada no exemplo abaixo deste BUILD de nível superior arquivo da migração do projeto Guava.

3. Agora que você tem um arquivo BUILD na raiz do projeto, crie seu projeto para garantir que ele funcione. Na linha de comando, no seu espaço de trabalho use bazel build //:everything para criar seu projeto com o Bazel.

   O projeto foi criado com o Bazel. Você precisará adicionar mais arquivos BUILD para permitir builds incrementais do projeto.

Exemplo de projeto Guava: comece com um arquivo BUILD

Ao migrar o projeto Guava para o Bazel, inicialmente um arquivo BUILD é usado para criar todo o projeto. Este é o conteúdo desse arquivo BUILD inicial em diretório do espaço de trabalho:

java_library(
    name = "everything",
    srcs = glob([
        "guava/src/**/*.java",
        "futures/failureaccess/src/**/*.java",
    ]),
    javacopts = ["-XepDisableAllChecks"],
    deps = [
        "@maven//:com_google_code_findbugs_jsr305",
        "@maven//:com_google_errorprone_error_prone_annotations",
        "@maven//:com_google_j2objc_j2objc_annotations",
        "@maven//:org_checkerframework_checker_qual",
        "@maven//:org_codehaus_mojo_animal_sniffer_annotations",
    ],
)

3. Crie mais arquivos BUILD (opcional)

O Bazel funciona com apenas um BUILD file, como você viu depois de concluir seu da primeira versão. Você ainda deve considerar dividir o build em partes menores adicionando mais arquivos BUILD com destinos granulares.

Vários arquivos BUILD com vários destinos darão ao build um aumento granularidade, o que permite:

• o aumento de builds incrementais do projeto,
• de aumento na execução paralela do build,
• melhor capacidade de manutenção do build para futuros usuários e
• controle sobre a visibilidade dos destinos entre pacotes, o que pode impedir problemas como bibliotecas contendo detalhes de implementação que vazam para APIs públicas.

Dicas para adicionar mais arquivos BUILD:

• Para começar, adicione um arquivo BUILD a cada pacote Java. Começar com Java pacotes que têm o menor número de dependências e trabalham até os pacotes com mais dependências.
• À medida que você adicionar arquivos BUILD e especificar destinos, adicione esses novos destinos ao deps seções de destinos que dependem deles. Observe que o glob() não ultrapassa os limites dos pacotes. Por isso, o número de pacotes aumenta os arquivos correspondentes por glob() diminuirão.
• Sempre que você adicionar um arquivo BUILD a um diretório main, adicione um BUILD ao diretório test correspondente.
• Tenha cuidado para limitar corretamente a visibilidade entre pacotes.
• Para simplificar a solução de erros na configuração de arquivos BUILD, verifique se que o projeto continua a ser compilado com o Bazel conforme você adiciona cada arquivo de build. Execute bazel build //... para garantir que todos os destinos ainda sejam criados.

4. Criar usando o Bazel

Você está compilando com o Bazel ao adicionar arquivos BUILD para validar a configuração. do build.

Quando você tem arquivos BUILD com a granularidade desejada, pode usar o Bazel para para produzir todos os seus builds.