For stable release documentation, please use the "Versioned docs" drop-down. The default view reflects the latest version at HEAD.

Questa pagina è stata tradotta dall'API Cloud Translation.

Regole Java

Segnala un problema Visualizza origine

Regole

java_binary
java_import
java_library
java_lite_proto_library
java_proto_library
java_test
java_package_configuration
java_plugin
java_runtime
java_toolchain

java_binary

Visualizza l'origine della regola

java_binary(name, deps, srcs, data, resources, args, classpath_resources, compatible_with, create_executable, deploy_env, deploy_manifest_lines, deprecation, distribs, env, exec_compatible_with, exec_properties, features, javacopts, jvm_flags, launcher, licenses, main_class, output_licenses, plugins, resource_jars, resource_strip_prefix, restricted_to, runtime_deps, stamp, tags, target_compatible_with, testonly, toolchains, use_launcher, use_testrunner, visibility)

Crea un archivio Java ("file jar") e uno script shell di wrapper con lo stesso nome della regola. Lo script shell del wrapper utilizza un classpath che include, tra le altre cose, un file jar per ogni libreria da cui dipende il programma binario. Quando esegui lo script shell del wrapper, qualsiasi variabile di ambiente JAVABIN non vuota avrà la precedenza sulla versione specificata tramite il flag --java_runtime_version di Bazel.

Lo script wrapper accetta diversi flag univoci. Consulta //src/main/java/com/google/devtools/build/lib/bazel/rules/java/java_stub_template.txt per un elenco di flag configurabili e variabili di ambiente accettati dal wrapper.

Target di output impliciti

name.jar: un archivio Java, contenente i file di classe e altre risorse corrispondenti alle dipendenze dirette del programma binario.
name-src.jar: un archivio contenente le fonti ("jar di origine").
name_deploy.jar: un archivio Java adatto per il deployment (creato solo se richiesto esplicitamente).
La creazione del target <name>_deploy.jar per la regola crea un file jar indipendente con un manifest che ne consente l'esecuzione con il comando java -jar o con l'opzione --singlejar dello script wrapper. L'utilizzo dello script wrapper è preferibile rispetto a java -jar, perché trasmette anche i flag JVM e le opzioni per caricare le librerie native.

Il file jar del deployment contiene tutte le classi che potrebbero essere trovate da un classloader che ha cercato il classpath dallo script wrapper del file binario dall'inizio alla fine. Contiene inoltre le librerie native necessarie per le dipendenze. Questi vengono caricati automaticamente nella JVM in fase di runtime.

Se il tuo target specifica un attributo launcher, anziché un normale file JAR, _deploy.jar sarà un programma binario nativo. Conterrà Avvio app ed eventuali dipendenze native (C++) della regola, il tutto collegato in un file binario statico. I byte del file jar effettivi verranno aggiunti al programma binario nativo, creando un singolo BLOB binario contenente sia l'eseguibile che il codice Java. Puoi eseguire direttamente il file jar risultante, come faresti con qualsiasi programma binario nativo.
name_deploy-src.jar: un archivio contenente le fonti raccolte dalla chiusura transitiva del target. Questi valori corrisponderanno alle classi in deploy.jar, tranne nei casi in cui i jar non hanno un jar di origine corrispondente.

Un attributo deps non è consentito in una regola java_binary senza srcs; una regola di questo tipo richiede un main_class fornito da runtime_deps.

Lo snippet di codice riportato di seguito illustra un errore comune:

java_binary(
    name = "DontDoThis",
    srcs = [
        ...,
        "GeneratedJavaFile.java",  # a generated .java file
    ],
    deps = [":generating_rule"],  # rule that generates that file
)

Procedi nel seguente modo:

java_binary(
    name = "DoThisInstead",
    srcs = [
        ...,
        ":generating_rule",
    ],
)

Argomenti

Attributi
`name`	Name (Nome), obbligatorio Un nome univoco per il target. È buona norma utilizzare il nome del file sorgente che è il punto di ingresso principale dell'applicazione (meno l'estensione). Ad esempio, se il punto di ingresso è chiamato `Main.java`, il nome potrebbe essere `Main`.
`deps`	Elenco di etichette; il valore predefinito è `[]` L'elenco di altre librerie da collegare alla destinazione. Consulta i commenti generali su `deps` nella sezione Attributi tipici definiti dalla maggior parte delle regole di build.
`srcs`	Elenco di etichette; il valore predefinito è `[]` L'elenco di file di origine elaborati per creare la destinazione. Questo attributo è quasi sempre obbligatorio; vedi le eccezioni di seguito. I file di origine di tipo `.java` vengono compilati. Nel caso di file `.java` generati, è generalmente consigliabile inserire qui il nome della regola di generazione anziché il nome del file stesso. Ciò non solo migliora la leggibilità, ma rende la regola più resiliente in caso di modifiche future: se la regola di generazione genera file diversi in futuro, dovrai correggere una sola posizione: `outs` della regola di generazione. Non devi elencare la regola di generazione in `deps` perché è inutilizzabile. I file sorgente di tipo `.srcjar` vengono decompressi e compilati. (Questo è utile se devi generare un insieme di file `.java` con una genrule). Regole: se la regola (in genere `genrule` o `filegroup`) genera uno qualsiasi dei file elencati sopra, verranno utilizzati come descritto per i file di origine. Questo argomento è quasi sempre obbligatorio, eccetto se un attributo `main_class` specifica una classe sul classpath di runtime o se specifichi l'argomento `runtime_deps`.
`resources`	Elenco di etichette; il valore predefinito è `[]` Un elenco di file di dati da includere in un jar Java. Se vengono specificate le risorse, verranno raggruppate nel jar insieme ai consueti file `.class` prodotti dalla compilazione. La posizione delle risorse all'interno del file jar è determinata dalla struttura del progetto. Bazel cerca prima il layout di directory standard di Maven, ovvero una directory "src" seguita da un nipote della directory "resources". Se non lo trova, Bazel cerca la directory di livello più alta denominata "java" o "javatests" (quindi, ad esempio, se una risorsa si trova in `<workspace root>/x/java/y/java/z`, il percorso della risorsa sarà `y/java/z`. Non è possibile eseguire l'override di questa euristica, ma è possibile utilizzare l'attributo `resource_strip_prefix` per specificare una directory alternativa specifica per i file di risorse. Le risorse possono essere file di origine o file generati.
`classpath_resources`	Elenco di etichette; il valore predefinito è `[]` NON USARE QUESTA OPZIONE A MENO CHE NON C'È IN ALTRO MODO) Un elenco di risorse che devono trovarsi nella directory radice dell'albero Java. L'unico scopo di questo attributo è supportare librerie di terze parti che richiedono che le loro risorse vengano trovate in classpath esattamente come `"myconfig.xml"`. È consentito solo su programmi binari e non su librerie, a causa del pericolo di conflitti dello spazio dei nomi.
`create_executable`	Valore booleano; non configurabile; il valore predefinito è `True` Deprecata, utilizza invece `java_single_jar`.
`deploy_env`	Elenco di etichette; il valore predefinito è `[]` Un elenco di altre destinazioni `java_binary` che rappresentano l'ambiente di deployment per questo programma binario. Imposta questo attributo durante la creazione di un plug-in che verrà caricato da un altro elemento `java_binary`. L'impostazione di questo attributo esclude tutte le dipendenze dal classpath di runtime (e dal file jar del deployment) di questo programma binario, condivise tra questo programma binario e le destinazioni specificate in `deploy_env`.
`deploy_manifest_lines`	Elenco di stringhe; il valore predefinito è `[]` Un elenco di righe da aggiungere al file `META-INF/manifest.mf` generato per il target `_deploy.jar`. I contenuti di questo attributo non* sono soggetti alla sostituzione "Crea variabile".
`javacopts`	Elenco di stringhe; il valore predefinito è `[]` Opzioni di compilazione aggiuntive per questa libreria. Soggetto alla sostituzione di "Crea variabile" e alla tokenizzazione della shell di Burne. Queste opzioni del compilatore vengono passate a javac dopo le opzioni del compilatore globale.
`jvm_flags`	Elenco di stringhe; il valore predefinito è `[]` Un elenco di flag da incorporare nello script wrapper generato per l'esecuzione di questo programma binario. Soggetto alla sostituzione di $(location) e "Make variabile", e alla tokenizzazione della shell di Bourne. Lo script wrapper per un file binario Java include una definizione CLASSPATH (per trovare tutti i jar dipendenti) e richiama l'interprete Java corretto. La riga di comando generata dallo script wrapper include il nome della classe principale seguito da `"$@"`, così puoi passare altri argomenti dopo il nome della classe. Tuttavia, gli argomenti destinati all'analisi da parte della JVM devono essere specificati prima del nome della classe nella riga di comando. I contenuti di `jvm_flags` vengono aggiunti allo script wrapper prima che il nome della classe venga elencato. Tieni presente che questo attributo non ha alcun effetto sugli output di `*_deploy.jar`.
`launcher`	Etichetta; il valore predefinito è `None` Specifica un programma binario che verrà utilizzato per eseguire il tuo programma Java anziché il normale programma `bin/java` incluso con il JDK. Il target deve essere un `cc_binary`. Qualsiasi valore `cc_binary` che implementa l' API Java Invocation può essere specificato come valore per questo attributo. Per impostazione predefinita, Bazel utilizza il normale launcher JDK (bin/java o java.exe). Il flag correlato `--java_launcher` Bazel influisce solo sui target `java_binary` e `java_test` che non hanno specificato un attributo `launcher`. Tieni presente che le dipendenze native (C++, SWIG, JNI) verranno create in modo diverso a seconda che utilizzi l'Avvio app JDK o un altro: Se utilizzi il normale Avvio app JDK (predefinito), le dipendenze native vengono create come una libreria condivisa denominata `{name}_nativedeps.so`, dove `{name}` è l'attributo `name` di questa regola java_binary. Il codice inutilizzato non viene rimosso dal linker in questa configurazione. Se utilizzi qualsiasi altro programma di avvio, le dipendenze native (C++) sono collegate in modo statico in un file binario denominato `{name}_nativedeps`, dove `{name}` è l'attributo `name` di questa regola java_binary. In questo caso, il linker rimuoverà dal programma binario risultante qualsiasi codice che ritiene non utilizzato, il che significa che qualsiasi codice C++ accessibile solo tramite JNI potrebbe non essere collegato, a meno che la destinazione `cc_library` non specifichi `alwayslink = 1`. Quando utilizzi un'utilità di avvio diversa da quella predefinita JDK, il formato dell'output `*_deploy.jar` cambia. Vedi la documentazione principale di java_binary per maggiori dettagli.
`main_class`	Stringa; il valore predefinito è `""` Nome della classe con metodo `main()` da utilizzare come punto di ingresso. Se una regola utilizza questa opzione, non ha bisogno di un elenco `srcs=[...]`. Quindi, con questo attributo è possibile creare un eseguibile da una libreria Java che contiene già uno o più metodi `main()`. Il valore di questo attributo è un nome di classe, non un file di origine. La classe deve essere disponibile in fase di runtime: può essere compilata da questa regola (da `srcs`) o fornita da dipendenze dirette o transitive (tramite `runtime_deps` o `deps`). Se la classe non è disponibile, il programma binario avrà esito negativo in fase di runtime; non viene eseguito alcun controllo in fase di build.
`plugins`	Elenco di etichette; il valore predefinito è `[]` Plug-in di compilazione Java da eseguire in fase di compilazione. Ogni `java_plugin` specificato in questo attributo verrà eseguito ogni volta che viene creata questa regola. Una libreria può anche ereditare i plug-in da dipendenze che utilizzano `exported_plugins`. Le risorse generate dal plug-in verranno incluse nel jar risultante di questa regola.
`resource_jars`	Elenco di etichette; il valore predefinito è `[]` Deprecato: utilizza java_import e deps o runtime_deps.
`resource_strip_prefix`	Stringa; il valore predefinito è `""` Il prefisso del percorso da eliminare dalle risorse Java. Se specificato, questo prefisso del percorso viene rimosso da tutti i file nell'attributo `resources`. È un errore se un file di risorse non si trova in questa directory. Se non specificato (valore predefinito), il percorso del file delle risorse viene determinato in base alla stessa logica del pacchetto Java dei file di origine. Ad esempio, un file di origine in `stuff/java/foo/bar/a.txt` si troverà in `foo/bar/a.txt`.
`runtime_deps`	Elenco di etichette; il valore predefinito è `[]` Librerie da rendere disponibili per il programma binario finale o test solo in fase di runtime. Come il normale `deps`, questi verranno visualizzati sul classpath di runtime, ma a differenza di loro, non sul classpath in fase di compilazione. Le dipendenze necessarie solo in fase di runtime devono essere elencate qui. Gli strumenti di analisi delle dipendenze devono ignorare i target visualizzati in `runtime_deps` e `deps`.
`stamp`	Numero intero; il valore predefinito è `-1` Se codificare le informazioni sulla build nel file binario. Valori possibili: `stamp = 1`: inserisci sempre le informazioni sulla build nel file binario, anche nelle build di `--nostamp`. Questa impostazione deve essere evitata, poiché potenzialmente uccide la memorizzazione nella cache remota per il programma binario e per qualsiasi azione downstream che dipende da questo. `stamp = 0`: sostituisci sempre le informazioni sulla build con valori costanti. Ciò garantisce una buona memorizzazione nella cache dei risultati di build. `stamp = -1`: l'incorporamento delle informazioni sulla build è controllato dal flag `--[no]stamp`. I file binari stampati non vengono ricreati a meno che le loro dipendenze non cambino.
`use_launcher`	Valore booleano; il valore predefinito è `True` Se il programma binario deve utilizzare un'Avvio app personalizzato. Se questo attributo è impostato su false, l'attributo Avvio app e il relativo flag `--java_launcher` verranno ignorati per questo target.
`use_testrunner`	Valore booleano; il valore predefinito è `False` Utilizza la classe dell'esecutore di test (per impostazione predefinita `com.google.testing.junit.runner.BazelTestRunner`) come punto di ingresso principale per un programma Java e fornisci la classe di test all'esecutore del test come valore della proprietà di sistema `bazel.test_suite`. Puoi utilizzarla per eseguire l'override del comportamento predefinito, ovvero utilizzare l'esecutore del test per le regole `java_test` e non per le regole `java_binary`. È improbabile che tu voglia farlo. Un utilizzo è per le regole `AllTest` richiamate da un'altra regola (ad esempio per configurare un database prima di eseguire i test). La regola `AllTest` deve essere dichiarata come `java_binary`, ma deve comunque utilizzare l'esecutore del test come punto di ingresso principale. Il nome di una classe dell'esecutore del test può essere sostituito con l'attributo `main_class`.

java_import

Visualizza l'origine della regola

java_import(name, deps, data, add_exports, add_opens, compatible_with, constraints, deprecation, distribs, exec_compatible_with, exec_properties, exports, features, jars, licenses, neverlink, proguard_specs, restricted_to, runtime_deps, srcjar, tags, target_compatible_with, testonly, toolchains, visibility)

Questa regola consente l'utilizzo di file .jar precompilati come librerie per le regole java_library e java_binary.

Esempi


    java_import(
        name = "maven_model",
        jars = [
            "maven_model/maven-aether-provider-3.2.3.jar",
            "maven_model/maven-model-3.2.3.jar",
            "maven_model/maven-model-builder-3.2.3.jar",
        ],
    )

Argomenti

Attributi
`name`	Name (Nome), obbligatorio Un nome univoco per il target.
`deps`	Elenco di etichette; il valore predefinito è `[]` L'elenco di altre librerie da collegare alla destinazione. Vedi java_library.deps.
`data`	Elenco di etichette; il valore predefinito è `[]` L'elenco dei file richiesti da questa regola al momento dell'attivazione.
`add_exports`	Elenco di stringhe; il valore predefinito è `[]` Consenti a questa libreria di accedere ai `module` o `package` specificati. Corrisponde ai flag javac e JVM --add-exports=.
`add_opens`	Elenco di stringhe; il valore predefinito è `[]` Consenti a questa libreria di accedere in modo riflessivo ai dati `module` o `package`. Corrisponde ai flag javac e JVM --add-opens=.
`constraints`	Elenco di stringhe; il valore predefinito è `[]` Vincoli aggiuntivi imposti a questa regola come libreria Java.
`exports`	Elenco di etichette; il valore predefinito è `[]` Destinazioni da rendere disponibili agli utenti di questa regola. Vedi java_library.exports.
`jars`	Elenco di etichette; obbligatorio L'elenco di file JAR forniti alle destinazioni Java che dipendono da questa destinazione.
`neverlink`	Valore booleano; il valore predefinito è `False` Usa questa libreria solo per la compilazione e non in fase di runtime. Utile se la libreria verrà fornita dall'ambiente di runtime durante l'esecuzione. Esempi di librerie come questa sono le API IDE per i plug-in IDE o `tools.jar` per qualsiasi file in esecuzione su un JDK standard.
`proguard_specs`	Elenco di etichette; il valore predefinito è `[]` File da utilizzare come specifica di Proguard. che descrivono l'insieme di specifiche che deve essere utilizzato da Proguard. Se specificati, verranno aggiunti a qualsiasi target `android_binary` a seconda di questa libreria. I file inclusi qui devono avere solo regole idempotenti, ovvero -dontnote, -dontwarn, assumenosideeffects e regole che iniziano con -keep. Altre opzioni possono essere visualizzate solo in proguard_specs di `android_binary`, per garantire unioni non tautologiche.
`runtime_deps`	Elenco di etichette; il valore predefinito è `[]` Librerie da rendere disponibili per il programma binario finale o test solo in fase di runtime. Vedi java_library.runtime_deps.
`srcjar`	Etichetta; il valore predefinito è `None` Un file JAR che contiene il codice sorgente per i file JAR compilati.

java_library

Visualizza l'origine della regola

java_library(name, deps, srcs, data, resources, add_exports, add_opens, bootclasspath, compatible_with, deprecation, distribs, exec_compatible_with, exec_properties, exported_plugins, exports, features, javabuilder_jvm_flags, javacopts, licenses, neverlink, plugins, proguard_specs, resource_strip_prefix, restricted_to, runtime_deps, tags, target_compatible_with, testonly, toolchains, visibility)

Questa regola compila e collega le origini a un file .jar.

Output impliciti

libname.jar: un archivio Java contenente i file del corso.
libname-src.jar: un archivio contenente le fonti ("jar di origine").

Argomenti

Attributi
`name`	Name (Nome), obbligatorio Un nome univoco per il target.
`deps`	Elenco di etichette; il valore predefinito è `[]` L'elenco delle librerie da collegare a questa libreria. Consulta i commenti generali su `deps` nella sezione Attributi tipici definiti dalla maggior parte delle regole di build. I jar creati in base alle regole `java_library` elencati in `deps` si troveranno nel classpath in fase di compilazione di questa regola. Inoltre, la chiusura transitiva di `deps`, `runtime_deps` e `exports` sarà sul classpath del runtime. Al contrario, le destinazioni nell'attributo `data` sono incluse nei file run, ma non nel classpath in tempo di compilazione né in quello di runtime.
`srcs`	Elenco di etichette; il valore predefinito è `[]` L'elenco di file di origine elaborati per creare la destinazione. Questo attributo è quasi sempre obbligatorio; vedi le eccezioni di seguito. I file di origine di tipo `.java` vengono compilati. Nel caso di file `.java` generati, di solito è consigliabile inserire qui il nome della regola di generazione anziché il nome del file stesso. Ciò non solo migliora la leggibilità, ma rende la regola più resiliente in caso di modifiche future: se in futuro la regola di generazione genera file diversi, dovrai correggere una sola posizione: `outs` della regola di generazione. Non dovresti elencare la regola di generazione in `deps` perché è no-op. I file sorgente di tipo `.srcjar` vengono decompressi e compilati. (Questo è utile se devi generare un insieme di file `.java` con una regola genrule). Regole: se la regola (in genere `genrule` o `filegroup`) genera uno qualsiasi dei file elencati sopra, verranno utilizzati come descritto per i file di origine. I file di origine di tipo `.properties` vengono trattati come risorse. Tutti gli altri file vengono ignorati, purché sia presente almeno un file del tipo descritto in precedenza. In caso contrario, viene segnalato un errore. Questo argomento è quasi sempre obbligatorio, tranne se specifichi l'argomento `runtime_deps`.
`data`	Elenco di etichette; il valore predefinito è `[]` L'elenco dei file necessari a questa libreria in fase di runtime. Consulta i commenti generali su `data` nella sezione Attributi tipici definiti dalla maggior parte delle regole di build. Quando crei un `java_library`, Bazel non inserisce questi file da nessuna parte; se vengono generati file di `data`, Bazel li genera. Quando crei un test che dipende da `java_library`, Bazel copia o collega i file `data` nell'area dei runfile.
`resources`	Elenco di etichette; il valore predefinito è `[]` Un elenco di file di dati da includere in un jar Java. Le risorse possono essere file di origine o file generati. Se vengono specificate le risorse, verranno raggruppate nel jar insieme ai consueti file `.class` prodotti dalla compilazione. La posizione delle risorse all'interno del file jar è determinata dalla struttura del progetto. Bazel cerca prima il layout di directory standard di Maven, ovvero una directory "src" seguita da un nipote della directory "resources". Se non lo trova, Bazel cerca la directory di livello più alta denominata "java" o "javatests" (quindi, ad esempio, se una risorsa si trova in `<workspace root>/x/java/y/java/z`, il percorso della risorsa sarà `y/java/z`. Questa euristica non può essere sottoposta a override, tuttavia l'attributo `resource_strip_prefix` può essere utilizzato per specificare una directory alternativa specifica per i file di risorse.
`add_exports`	Elenco di stringhe; il valore predefinito è `[]` Consenti a questa libreria di accedere ai `module` o `package` specificati. Corrisponde ai flag javac e JVM --add-exports=.
`add_opens`	Elenco di stringhe; il valore predefinito è `[]` Consenti a questa libreria di accedere in modo riflessivo ai dati `module` o `package`. Corrisponde ai flag javac e JVM --add-opens=.
`bootclasspath`	Etichetta; il valore predefinito è `None` API limitata. Non utilizzarla!
`exported_plugins`	Elenco di etichette; il valore predefinito è `[]` L'elenco di `java_plugin` (ad es. processori di annotazione) da esportare nelle librerie che dipendono direttamente da questa libreria. L'elenco specificato di `java_plugin` verrà applicato a qualsiasi libreria che dipende direttamente da questa libreria, proprio come se la libreria avesse dichiarato esplicitamente queste etichette in `plugins`.
`exports`	Elenco di etichette; il valore predefinito è `[]` Librerie esportate. Le regole elencate qui le renderanno disponibili per le regole padre, come se le regole principali dipendessero esplicitamente da queste regole. Questo non è valido per `deps` standard (non esportati). Riepilogo: una regola X può accedere al codice in Y se esiste un percorso di dipendenza che inizia con un bordo `deps` seguito da zero o più bordi `exports`. Vediamo alcuni esempi. Supponiamo che A dipenda da B e che B dipenda da C. In questo caso C è una dipendenza transitiva di A, quindi se cambi le origini di C e ricrea A, puoi ricreare tutto correttamente. ma A non potrà utilizzare i corsi in C. Per consentirlo, A deve dichiarare C nel suo `deps` oppure B può rendere più semplice per A (e tutto ciò che può dipendere da A) dichiarando C nel suo attributo `exports` (B). La chiusura delle librerie esportate è disponibile per tutte le regole principali dirette. Prendiamo un esempio leggermente diverso: A dipende da B, B dipende da C e D ed esporta anche C, ma non D. Ora A ha accesso a C ma non a D. Ora, se C e D esportavano alcune librerie, rispettivamente C' e D', A poteva accedere solo a C', ma non a D'. Importante: una regola esportata non è una dipendenza regolare. Continuando con l'esempio precedente, se B esporta C e vuole utilizzare anche C, deve elencarlo anche nel proprio `deps`.
`javabuilder_jvm_flags`	Elenco di stringhe; il valore predefinito è `[]` API limitata. Non utilizzarla!
`javacopts`	Elenco di stringhe; il valore predefinito è `[]` Opzioni di compilazione aggiuntive per questa libreria. Soggetto alla sostituzione "Crea variabile" e alla tokenizzazione della shell di Burne. Queste opzioni del compilatore vengono passate a javac dopo le opzioni del compilatore globale.
`neverlink`	Valore booleano; il valore predefinito è `False` Indica se questa libreria deve essere utilizzata solo per la compilazione e non in fase di runtime. Utile se la libreria verrà fornita dall'ambiente di runtime durante l'esecuzione. Esempi di tali librerie sono le API IDE per i plug-in IDE o `tools.jar` per qualsiasi file eseguito su un JDK standard. Tieni presente che `neverlink = 1` non impedisce al compilatore di incorporare il materiale di questa libreria in destinazioni di compilazione che dipendono da quest'ultimo, come consentito dalla specifica del linguaggio Java (ad esempio, costanti `static final` di `String` o di tipi primitivi). Il caso d'uso preferito è quindi quando la libreria di runtime è identica alla libreria di compilazione. Se la libreria di runtime è diversa dalla libreria di compilazione, devi assicurarti che differisca soltanto nelle posizioni in cui il JLS vieta l'incorporamento (e questo deve essere valido per tutte le versioni future del JLS).
`plugins`	Elenco di etichette; il valore predefinito è `[]` Plug-in di compilazione Java da eseguire in fase di compilazione. Ogni `java_plugin` specificato in questo attributo verrà eseguito ogni volta che viene creata questa regola. Una libreria può anche ereditare i plug-in da dipendenze che utilizzano `exported_plugins`. Le risorse generate dal plug-in saranno incluse nel jar risultante di questa regola.
`proguard_specs`	Elenco di etichette; il valore predefinito è `[]` File da utilizzare come specifica di Proguard. che descrivono l'insieme di specifiche che deve essere utilizzato da Proguard. Se specificati, verranno aggiunti a qualsiasi target `android_binary` a seconda di questa libreria. I file inclusi qui devono avere solo regole idempotenti, ovvero -dontnote, -dontwarn, assumenosideeffects e regole che iniziano con -keep. Altre opzioni possono essere visualizzate solo in proguard_specs di `android_binary`, per garantire unioni non tautologiche.
`resource_strip_prefix`	Stringa; il valore predefinito è `""` Il prefisso del percorso da eliminare dalle risorse Java. Se specificato, questo prefisso del percorso viene rimosso da tutti i file nell'attributo `resources`. È un errore se un file di risorse non si trova in questa directory. Se non specificato (valore predefinito), il percorso del file delle risorse viene determinato in base alla stessa logica del pacchetto Java dei file di origine. Ad esempio, un file di origine in `stuff/java/foo/bar/a.txt` si troverà in `foo/bar/a.txt`.
`runtime_deps`	Elenco di etichette; il valore predefinito è `[]` Librerie da rendere disponibili per il programma binario finale o test solo in fase di runtime. Come per il normale `deps`, verranno visualizzati sul classpath di runtime, ma a differenza di loro, non sul classpath in fase di compilazione. Le dipendenze necessarie solo in fase di runtime devono essere elencate qui. Gli strumenti di analisi delle dipendenze devono ignorare i target visualizzati in `runtime_deps` e `deps`.

java_lite_proto_library

Visualizza l'origine della regola

java_lite_proto_library(name, deps, compatible_with, deprecation, distribs, exec_compatible_with, exec_properties, features, restricted_to, tags, target_compatible_with, testonly, toolchains, visibility)

java_lite_proto_library genera codice Java dai file .proto.

deps deve puntare alle regole proto_library.

Esempio:


java_library(
    name = "lib",
    runtime_deps = [":foo"],
)

java_lite_proto_library(
    name = "foo",
    deps = [":bar"],
)

proto_library(
    name = "bar",
)

Argomenti

Attributi

name

Name (Nome), obbligatorio

Un nome univoco per il target.

deps

Elenco di etichette; il valore predefinito è []

L'elenco di regole proto_library per cui generare codice Java.

java_proto_library

Visualizza l'origine della regola

java_proto_library(name, deps, compatible_with, deprecation, distribs, exec_compatible_with, exec_properties, features, licenses, restricted_to, tags, target_compatible_with, testonly, toolchains, visibility)

java_proto_library genera codice Java dai file .proto.

deps deve puntare alle regole proto_library.

Esempio:


java_library(
    name = "lib",
    runtime_deps = [":foo_java_proto"],
)

java_proto_library(
    name = "foo_java_proto",
    deps = [":foo_proto"],
)

proto_library(
    name = "foo_proto",
)

Argomenti

Attributi

name

Name (Nome), obbligatorio

Un nome univoco per il target.

deps

Elenco di etichette; il valore predefinito è []

L'elenco di regole proto_library per cui generare codice Java.

java_test

Visualizza l'origine della regola

java_test(name, deps, srcs, data, resources, add_exports, add_opens, args, bootclasspath, classpath_resources, compatible_with, create_executable, deploy_manifest_lines, deprecation, distribs, env, env_inherit, exec_compatible_with, exec_properties, features, flaky, javacopts, jvm_flags, launcher, licenses, local, main_class, neverlink, plugins, resource_strip_prefix, restricted_to, runtime_deps, shard_count, size, stamp, tags, target_compatible_with, test_class, testonly, timeout, toolchains, use_launcher, use_testrunner, visibility)

Una regola java_test() compila un test Java. Un test è un wrapper binario che circonda il codice di test. Viene richiamato il metodo principale dell'esecutore del test anziché compilare la classe principale.

Target di output impliciti

name.jar: un archivio Java.
name_deploy.jar: un archivio Java adatto per il deployment. (Creata solo se richiesta esplicitamente). Per maggiori dettagli, consulta la descrizione dell'output name_deploy.jar da java_binary.

Vedi la sezione sugli argomenti java_binary(). Questa regola supporta anche tutti gli attributi comuni a tutte le regole di test (*_test).

Esempi



java_library(
    name = "tests",
    srcs = glob(["*.java"]),
    deps = [
        "//java/com/foo/base:testResources",
        "//java/com/foo/testing/util",
    ],
)

java_test(
    name = "AllTests",
    size = "small",
    runtime_deps = [
        ":tests",
        "//util/mysql",
    ],
)

Argomenti

Attributi
`name`	Name (Nome), obbligatorio Un nome univoco per il target.
`deps`	Elenco di etichette; il valore predefinito è `[]` L'elenco di altre librerie da collegare alla destinazione. Consulta i commenti generali su `deps` nella sezione Attributi tipici definiti dalla maggior parte delle regole di build.
`srcs`	Elenco di etichette; il valore predefinito è `[]` L'elenco di file di origine elaborati per creare la destinazione. Questo attributo è quasi sempre obbligatorio; vedi le eccezioni di seguito. I file di origine di tipo `.java` vengono compilati. Nel caso di file `.java` generati, di solito è consigliabile inserire qui il nome della regola di generazione anziché il nome del file stesso. Ciò non solo migliora la leggibilità, ma rende la regola più resiliente in caso di modifiche future: se in futuro la regola di generazione genera file diversi, dovrai correggere una sola posizione: `outs` della regola di generazione. Non dovresti elencare la regola di generazione in `deps` perché è no-op. I file sorgente di tipo `.srcjar` vengono decompressi e compilati. (Questo è utile se devi generare un insieme di file `.java` con una regola genrule). Regole: se la regola (in genere `genrule` o `filegroup`) genera uno qualsiasi dei file elencati sopra, verranno utilizzati come descritto per i file di origine. Questo argomento è quasi sempre obbligatorio, eccetto se un attributo `main_class` specifica una classe sul classpath di runtime o se specifichi l'argomento `runtime_deps`.
`data`	Elenco di etichette; il valore predefinito è `[]` L'elenco dei file necessari a questa libreria in fase di runtime. Consulta i commenti generali su `data` nella sezione Attributi tipici definiti dalla maggior parte delle regole di build.
`resources`	Elenco di etichette; il valore predefinito è `[]` Un elenco di file di dati da includere in un jar Java. Le risorse possono essere file di origine o file generati. Se vengono specificate le risorse, verranno raggruppate nel jar insieme ai consueti file `.class` prodotti dalla compilazione. La posizione delle risorse all'interno del file jar è determinata dalla struttura del progetto. Bazel cerca prima il layout di directory standard di Maven, ovvero una directory "src" seguita da un nipote della directory "resources". Se non lo trova, Bazel cerca la directory di livello più alta denominata "java" o "javatests" (quindi, ad esempio, se una risorsa si trova in `<workspace root>/x/java/y/java/z`, il percorso della risorsa sarà `y/java/z`. Questa euristica non può essere sottoposta a override, tuttavia l'attributo `resource_strip_prefix` può essere utilizzato per specificare una directory alternativa specifica per i file di risorse.
`add_exports`	Elenco di stringhe; il valore predefinito è `[]` Consenti a questa libreria di accedere ai `module` o `package` specificati. Corrisponde ai flag javac e JVM --add-exports=.
`add_opens`	Elenco di stringhe; il valore predefinito è `[]` Consenti a questa libreria di accedere in modo riflessivo ai dati `module` o `package`. Corrisponde ai flag javac e JVM --add-opens=.
`bootclasspath`	Etichetta; il valore predefinito è `None` API limitata. Non utilizzarla!
`classpath_resources`	Elenco di etichette; il valore predefinito è `[]` NON USARE QUESTA OPZIONE A MENO CHE NON C'È IN ALTRO MODO) Un elenco di risorse che devono trovarsi nella directory radice dell'albero Java. L'unico scopo di questo attributo è supportare le librerie di terze parti che richiedono che le loro risorse siano trovate in classpath esattamente come `"myconfig.xml"`. È consentito solo su file binari e non sulle librerie, a causa del pericolo di conflitti dello spazio dei nomi.
`create_executable`	Valore booleano; il valore predefinito è `True` Deprecata, utilizza invece `java_single_jar`.
`deploy_manifest_lines`	Elenco di stringhe; il valore predefinito è `[]` Un elenco di righe da aggiungere al file `META-INF/manifest.mf` generato per il target `_deploy.jar`. I contenuti di questo attributo non* sono soggetti alla sostituzione "Crea variabile".
`javacopts`	Elenco di stringhe; il valore predefinito è `[]` Opzioni di compilazione aggiuntive per questo programma binario. Soggetto alla sostituzione "Crea variabile" e alla tokenizzazione della shell di Burne. Queste opzioni del compilatore vengono passate a javac dopo le opzioni del compilatore globale.
`jvm_flags`	Elenco di stringhe; il valore predefinito è `[]` Un elenco di flag da incorporare nello script wrapper generato per l'esecuzione di questo programma binario. Soggetto alla sostituzione di $(location) e "Make variabile", e alla tokenizzazione della shell di Bourne. Lo script wrapper per un file binario Java include una definizione CLASSPATH (per trovare tutti i jar dipendenti) e richiama l'interprete Java corretto. La riga di comando generata dallo script wrapper include il nome della classe principale seguito da `"$@"`, così puoi passare altri argomenti dopo il nome della classe. Tuttavia, gli argomenti destinati all'analisi da parte della JVM devono essere specificati prima del nome della classe nella riga di comando. I contenuti di `jvm_flags` vengono aggiunti allo script wrapper prima che il nome della classe venga elencato. Tieni presente che questo attributo non ha alcun effetto su `*_deploy.jar` output.
`launcher`	Etichetta; il valore predefinito è `None` Specifica un programma binario che verrà utilizzato per eseguire il tuo programma Java anziché il normale programma `bin/java` incluso con il JDK. Il target deve essere un `cc_binary`. Qualsiasi valore `cc_binary` che implementa l' API Java Invocation può essere specificato come valore per questo attributo. Per impostazione predefinita, Bazel utilizza il normale launcher JDK (bin/java o java.exe). Il flag correlato `--java_launcher` Bazel influisce solo sui target `java_binary` e `java_test` che non hanno specificato un attributo `launcher`. Tieni presente che le dipendenze native (C++, SWIG, JNI) verranno create in modo diverso a seconda che tu stia utilizzando l'Avvio app JDK o un altro: Se utilizzi il normale Avvio app JDK (predefinito), le dipendenze native vengono create come una libreria condivisa denominata `{name}_nativedeps.so`, dove `{name}` è l'attributo `name` di questa regola java_binary. Il codice inutilizzato non viene rimosso dal linker in questa configurazione. Se utilizzi qualsiasi altro programma di avvio, le dipendenze native (C++) sono collegate in modo statico in un file binario denominato `{name}_nativedeps`, dove `{name}` è l'attributo `name` di questa regola java_binary. In questo caso, il linker rimuoverà dal programma binario risultante qualsiasi codice che ritiene non utilizzato, il che significa che qualsiasi codice C++ accessibile solo tramite JNI potrebbe non essere collegato, a meno che la destinazione `cc_library` non specifichi `alwayslink = 1`. Quando utilizzi un'utilità di avvio app diversa da quella predefinita JDK, il formato dell'output `*_deploy.jar` cambia. Vedi la documentazione principale java_binary per i dettagli.
`main_class`	Stringa; il valore predefinito è `""` Nome della classe con metodo `main()` da utilizzare come punto di ingresso. Se una regola utilizza questa opzione, non ha bisogno di un elenco `srcs=[...]`. Quindi, con questo attributo è possibile creare un eseguibile da una libreria Java che contiene già uno o più metodi `main()`. Il valore di questo attributo è un nome di classe, non un file di origine. La classe deve essere disponibile in fase di runtime: può essere compilata da questa regola (da `srcs`) o fornita da dipendenze dirette o transitive (tramite `runtime_deps` o `deps`). Se la classe non è disponibile, il programma binario avrà esito negativo in fase di runtime; non viene eseguito alcun controllo in fase di build.
`neverlink`	Valore booleano; il valore predefinito è `False`
`plugins`	Elenco di etichette; il valore predefinito è `[]` Plug-in di compilazione Java da eseguire in fase di compilazione. Ogni `java_plugin` specificato in questo attributo verrà eseguito ogni volta che viene creata questa regola. Una libreria può anche ereditare i plug-in da dipendenze che utilizzano `exported_plugins`. Le risorse generate dal plug-in saranno incluse nel jar risultante di questa regola.
`resource_strip_prefix`	Stringa; il valore predefinito è `""` Il prefisso del percorso da eliminare dalle risorse Java. Se specificato, questo prefisso del percorso viene rimosso da tutti i file nell'attributo `resources`. È un errore se un file di risorse non si trova in questa directory. Se non specificato (valore predefinito), il percorso del file delle risorse viene determinato in base alla stessa logica del pacchetto Java dei file di origine. Ad esempio, un file di origine in `stuff/java/foo/bar/a.txt` si troverà in `foo/bar/a.txt`.
`runtime_deps`	Elenco di etichette; il valore predefinito è `[]` Librerie da rendere disponibili per il programma binario finale o test solo in fase di runtime. Come per il normale `deps`, verranno visualizzati sul classpath di runtime, ma a differenza di loro, non sul classpath in fase di compilazione. Le dipendenze necessarie solo in fase di runtime devono essere elencate qui. Gli strumenti di analisi delle dipendenze devono ignorare i target visualizzati in `runtime_deps` e `deps`.
`stamp`	Numero intero; il valore predefinito è `0` Se codificare le informazioni sulla build nel file binario. Valori possibili: `stamp = 1`: inserisci sempre le informazioni sulla build nel file binario, anche nelle build di `--nostamp`. Questa impostazione deve essere evitata, poiché potenzialmente uccide la memorizzazione nella cache remota per il programma binario e per qualsiasi azione downstream che dipende da questo. `stamp = 0`: sostituisci sempre le informazioni sulla build con valori costanti. Ciò garantisce una buona memorizzazione nella cache dei risultati di build. `stamp = -1`: l'incorporamento delle informazioni sulla build è controllato dal flag `--[no]stamp`. I file binari stampati non vengono ricreati a meno che le loro dipendenze non cambino.
`test_class`	Stringa; il valore predefinito è `""` La classe Java che deve essere caricata dall'esecutore del test. Per impostazione predefinita, se questo argomento non è definito, viene utilizzata la modalità legacy e vengono utilizzati gli argomenti di test. Imposta il flag `--nolegacy_bazel_java_test` in modo che non utilizzi il fallback sul primo argomento. Questo attributo specifica il nome di una classe Java che deve essere eseguita da questo test. È raro che sia necessario impostare questa opzione. Se questo argomento viene omesso, verrà dedotto utilizzando `name` del target e il relativo percorso relativo alla radice di origine. Se il test si trova al di fuori di una radice di origine nota, Bazel segnalerà un errore se il criterio `test_class` non è impostato. Per JUnit3, la classe di test deve essere una sottoclasse `junit.framework.TestCase` oppure deve avere un metodo `suite()` statico pubblico che restituisca `junit.framework.Test` (o una sottoclasse `Test`). Per JUnit4, la classe deve essere annotata con `org.junit.runner.RunWith`. Questo attributo consente a più regole `java_test` di condividere lo stesso `Test` (`TestCase`, `TestSuite`, ...). Di solito, vengono trasmesse informazioni aggiuntive (ad es. tramite `jvm_flags=['-Dkey=value']`), in modo che il suo comportamento sia diverso in ciascun caso, ad esempio l'esecuzione di un sottoinsieme diverso dei test. Questo attributo consente inoltre l'utilizzo di test Java al di fuori della struttura `javatests`.
`use_launcher`	Valore booleano; il valore predefinito è `True` Se il programma binario deve utilizzare un'Avvio app personalizzato. Se questo attributo è impostato su false, l'attributo Avvio app e il relativo flag `--java_launcher` verranno ignorati per questo target.
`use_testrunner`	Valore booleano; il valore predefinito è `True` Utilizza la classe dell'esecutore del test (per impostazione predefinita `com.google.testing.junit.runner.BazelTestRunner`) come punto di ingresso principale per un programma Java e fornisci la classe di test all'esecutore del test come valore della proprietà di sistema `bazel.test_suite`. Puoi utilizzarla per eseguire l'override del comportamento predefinito, ovvero utilizzare l'esecutore del test per le regole `java_test` e non per le regole `java_binary`. È improbabile che tu voglia farlo. Un utilizzo è per le regole `AllTest` richiamate da un'altra regola (ad esempio per configurare un database prima di eseguire i test). La regola `AllTest` deve essere dichiarata come `java_binary`, ma deve comunque utilizzare l'esecutore del test come punto di ingresso principale. Il nome di una classe dell'esecutore del test può essere sostituito con l'attributo `main_class`.

java_package_configuration

Visualizza l'origine della regola

java_package_configuration(name, data, compatible_with, deprecation, distribs, exec_compatible_with, exec_properties, features, javacopts, output_licenses, packages, restricted_to, tags, target_compatible_with, testonly, toolchains, visibility)

Configurazione da applicare a un insieme di pacchetti. È possibile aggiungere configurazioni a java_toolchain.javacopts.

Esempio:



java_package_configuration(
    name = "my_configuration",
    packages = [":my_packages"],
    javacopts = ["-Werror"],
)

package_group(
    name = "my_packages",
    packages = [
        "//com/my/project/...",
        "-//com/my/project/testing/...",
    ],
)

java_toolchain(
    ...,
    package_configuration = [
        ":my_configuration",
    ]
)

Argomenti

Attributi
`name`	Name (Nome), obbligatorio Un nome univoco per il target.
`data`	Elenco di etichette; il valore predefinito è `[]` L'elenco dei file necessari per questa configurazione in fase di runtime.
`javacopts`	Elenco di stringhe; il valore predefinito è `[]` Flag del compilatore Java.
`output_licenses`	Elenco di stringhe; il valore predefinito è `[]`
`packages`	Elenco di etichette; il valore predefinito è `[]` L'insieme di `package_group` a cui deve essere applicata la configurazione.

java_plugin

Visualizza l'origine della regola

java_plugin(name, deps, srcs, data, resources, add_exports, add_opens, bootclasspath, compatible_with, deprecation, distribs, exec_compatible_with, exec_properties, features, generates_api, javabuilder_jvm_flags, javacopts, licenses, neverlink, output_licenses, plugins, processor_class, proguard_specs, resource_strip_prefix, restricted_to, tags, target_compatible_with, testonly, toolchains, visibility)

java_plugin definisce i plug-in per il compilatore Java eseguito da Bazel. Al momento, l'unico tipo di plug-in supportati sono i processori di annotazioni. Una regola java_library o java_binary può eseguire plug-in in base al loro valore tramite l'attributo plugins. Un java_library può anche esportare automaticamente i plug-in nelle librerie che dipendono direttamente da questo plug-in utilizzando exported_plugins.

Target di output impliciti

libname.jar: un archivio Java.

Gli argomenti sono identici a java_library, ad eccezione dell'aggiunta dell'argomento processor_class.

Argomenti

Attributi
`name`	Name (Nome), obbligatorio Un nome univoco per il target.
`deps`	Elenco di etichette; il valore predefinito è `[]` L'elenco delle librerie da collegare a questa libreria. Consulta i commenti generali su `deps` nella sezione Attributi tipici definiti dalla maggior parte delle regole di build. I jar creati in base alle regole `java_library` elencati in `deps` si troveranno nel classpath in fase di compilazione di questa regola. Inoltre, la chiusura transitiva di `deps`, `runtime_deps` e `exports` sarà sul classpath del runtime. Al contrario, le destinazioni nell'attributo `data` sono incluse nei file run, ma non nel classpath in tempo di compilazione né in quello di runtime.
`srcs`	Elenco di etichette; il valore predefinito è `[]` L'elenco di file di origine elaborati per creare la destinazione. Questo attributo è quasi sempre obbligatorio; vedi le eccezioni di seguito. I file di origine di tipo `.java` vengono compilati. Nel caso di file `.java` generati, di solito è consigliabile inserire qui il nome della regola di generazione anziché il nome del file stesso. Ciò non solo migliora la leggibilità, ma rende la regola più resiliente in caso di modifiche future: se in futuro la regola di generazione genera file diversi, dovrai correggere una sola posizione: `outs` della regola di generazione. Non dovresti elencare la regola di generazione in `deps` perché è no-op. I file sorgente di tipo `.srcjar` vengono decompressi e compilati. (Questo è utile se devi generare un insieme di file `.java` con una regola genrule). Regole: se la regola (in genere `genrule` o `filegroup`) genera uno qualsiasi dei file elencati sopra, verranno utilizzati come descritto per i file di origine. I file di origine di tipo `.properties` vengono trattati come risorse. Tutti gli altri file vengono ignorati, purché sia presente almeno un file del tipo descritto in precedenza. In caso contrario, viene segnalato un errore. Questo argomento è quasi sempre obbligatorio, tranne se specifichi l'argomento `runtime_deps`.
`data`	Elenco di etichette; il valore predefinito è `[]` L'elenco dei file necessari a questa libreria in fase di runtime. Consulta i commenti generali su `data` nella sezione Attributi tipici definiti dalla maggior parte delle regole di build. Quando crei un `java_library`, Bazel non inserisce questi file da nessuna parte; se vengono generati file di `data`, Bazel li genera. Quando crei un test che dipende da `java_library`, Bazel copia o collega i file `data` nell'area dei runfile.
`resources`	Elenco di etichette; il valore predefinito è `[]` Un elenco di file di dati da includere in un jar Java. Le risorse possono essere file di origine o file generati. Se vengono specificate le risorse, verranno raggruppate nel jar insieme ai consueti file `.class` prodotti dalla compilazione. La posizione delle risorse all'interno del file jar è determinata dalla struttura del progetto. Bazel cerca prima il layout di directory standard di Maven, ovvero una directory "src" seguita da un nipote della directory "resources". Se non lo trova, Bazel cerca la directory di livello più alta denominata "java" o "javatests" (quindi, ad esempio, se una risorsa si trova in `<workspace root>/x/java/y/java/z`, il percorso della risorsa sarà `y/java/z`. Questa euristica non può essere sottoposta a override, tuttavia l'attributo `resource_strip_prefix` può essere utilizzato per specificare una directory alternativa specifica per i file di risorse.
`add_exports`	Elenco di stringhe; il valore predefinito è `[]` Consenti a questa libreria di accedere ai `module` o `package` specificati. Corrisponde ai flag javac e JVM --add-exports=.
`add_opens`	Elenco di stringhe; il valore predefinito è `[]` Consenti a questa libreria di accedere in modo riflessivo ai dati `module` o `package`. Corrisponde ai flag javac e JVM --add-opens=.
`bootclasspath`	Etichetta; il valore predefinito è `None` API limitata. Non utilizzarla!
`generates_api`	Valore booleano; il valore predefinito è `False` Questo attributo contrassegna i processori di annotazioni che generano il codice API. Se una regola utilizza un processore di annotazione che genera un'API, le altre regole a seconda di questo possono fare riferimento al codice generato solo se le relative azioni di compilazione vengono pianificate dopo la regola di generazione. Questo attributo indica a Bazel di introdurre vincoli di pianificazione quando --java_header_compilation è abilitato. AVVISO: questo attributo influisce sulle prestazioni della build. Utilizzalo solo se necessario.
`javabuilder_jvm_flags`	Elenco di stringhe; il valore predefinito è `[]` API limitata. Non utilizzarla!
`javacopts`	Elenco di stringhe; il valore predefinito è `[]` Opzioni di compilazione aggiuntive per questa libreria. Soggetto alla sostituzione "Crea variabile" e alla tokenizzazione della shell di Burne. Queste opzioni del compilatore vengono passate a javac dopo le opzioni del compilatore globale.
`neverlink`	Valore booleano; il valore predefinito è `False` Indica se questa libreria deve essere utilizzata solo per la compilazione e non in fase di runtime. Utile se la libreria verrà fornita dall'ambiente di runtime durante l'esecuzione. Esempi di tali librerie sono le API IDE per i plug-in IDE o `tools.jar` per qualsiasi file eseguito su un JDK standard. Tieni presente che `neverlink = 1` non impedisce al compilatore di incorporare il materiale di questa libreria in destinazioni di compilazione che dipendono da quest'ultimo, come consentito dalla specifica del linguaggio Java (ad esempio, costanti `static final` di `String` o di tipi primitivi). Il caso d'uso preferito è quindi quando la libreria di runtime è identica alla libreria di compilazione. Se la libreria di runtime è diversa dalla libreria di compilazione, devi assicurarti che differisca soltanto nelle posizioni in cui il JLS vieta l'incorporamento (e questo deve essere valido per tutte le versioni future del JLS).
`output_licenses`	Elenco di stringhe; il valore predefinito è `[]`
`plugins`	Elenco di etichette; il valore predefinito è `[]` Plug-in di compilazione Java da eseguire in fase di compilazione. Ogni `java_plugin` specificato in questo attributo verrà eseguito ogni volta che viene creata questa regola. Una libreria può anche ereditare i plug-in da dipendenze che utilizzano `exported_plugins`. Le risorse generate dal plug-in saranno incluse nel jar risultante di questa regola.
`processor_class`	Stringa; il valore predefinito è `""` La classe del processore è il tipo completo della classe che il compilatore Java deve utilizzare come punto di ingresso al processore di annotazioni. Se non specificata, questa regola non contribuirà a un processore di annotazioni all'elaborazione delle annotazioni del compilatore Java, ma il suo classpath in runtime sarà comunque incluso nel percorso del processore di annotazioni del compilatore. È pensato principalmente per essere utilizzato dai plug-in Error Prone, che vengono caricati dal percorso del processore di annotazioni utilizzando java.util.ServiceLoader.
`proguard_specs`	Elenco di etichette; il valore predefinito è `[]` File da utilizzare come specifica di Proguard. che descrivono l'insieme di specifiche che deve essere utilizzato da Proguard. Se specificati, verranno aggiunti a qualsiasi target `android_binary` a seconda di questa libreria. I file inclusi qui devono avere solo regole idempotenti, ovvero -dontnote, -dontwarn, assumenosideeffects e regole che iniziano con -keep. Altre opzioni possono essere visualizzate solo in proguard_specs di `android_binary`, per garantire unioni non tautologiche.
`resource_strip_prefix`	Stringa; il valore predefinito è `""` Il prefisso del percorso da eliminare dalle risorse Java. Se specificato, questo prefisso del percorso viene rimosso da tutti i file nell'attributo `resources`. È un errore se un file di risorse non si trova in questa directory. Se non specificato (valore predefinito), il percorso del file delle risorse viene determinato in base alla stessa logica del pacchetto Java dei file di origine. Ad esempio, un file di origine in `stuff/java/foo/bar/a.txt` si troverà in `foo/bar/a.txt`.

java_runtime

Visualizza l'origine della regola

java_runtime(name, srcs, compatible_with, default_cds, deprecation, distribs, exec_compatible_with, exec_properties, features, hermetic_srcs, hermetic_static_libs, java, java_home, lib_ct_sym, lib_modules, output_licenses, restricted_to, tags, target_compatible_with, testonly, toolchains, version, visibility)

Specifica la configurazione per un runtime Java.

Esempio:



java_runtime(
    name = "jdk-9-ea+153",
    srcs = glob(["jdk9-ea+153/**"]),
    java_home = "jdk9-ea+153",
)

Argomenti

Attributi
`name`	Name (Nome), obbligatorio Un nome univoco per il target.
`srcs`	Elenco di etichette; il valore predefinito è `[]` Tutti i file nel runtime.
`default_cds`	Etichetta; il valore predefinito è `None` Archivio CDS predefinito per `java_runtime` ermetico. Quando ermetica è abilitata per un target `java_binary` e la destinazione non fornisce il proprio archivio CDS specificando l'attributo `classlist`, il CDS predefinito di `java_runtime` viene pacchettizzato nel JAR di deployment ermetico.
`hermetic_srcs`	Elenco di etichette; il valore predefinito è `[]` File in runtime necessari per i deployment ermetici.
`hermetic_static_libs`	Elenco di etichette; il valore predefinito è `[]` Le librerie collegate in modo statico ad Avvio applicazioni per le implementazioni ermetiche
`java`	Etichetta; il valore predefinito è `None` Il percorso dell'eseguibile Java.
`java_home`	Stringa; il valore predefinito è `""` Il percorso della directory principale del runtime. Soggetta a sostituzione della variabile"Make". Se questo percorso è assoluto, la regola indica un runtime Java non ermetico con un percorso noto. In questo caso, gli attributi `srcs` e `java` devono essere vuoti.
`lib_ct_sym`	Etichetta; il valore predefinito è `None` Il file lib/ct.sym necessario per la compilazione con `--release`. Se non specificato e in `srcs` è presente esattamente un file il cui percorso termina con `/lib/ct.sym`, viene utilizzato quel file.
`lib_modules`	Etichetta; il valore predefinito è `None` Il file lib/modules necessario per i deployment ermetici.
`output_licenses`	Elenco di stringhe; il valore predefinito è `[]`
`version`	Numero intero; il valore predefinito è `0` La versione della funzionalità del runtime Java. ovvero il numero intero restituito da `Runtime.version().feature()`.

java_toolchain

Visualizza l'origine della regola

java_toolchain(name, android_lint_data, android_lint_jvm_opts, android_lint_opts, android_lint_package_configuration, android_lint_runner, bootclasspath, compatible_javacopts, compatible_with, deprecation, deps_checker, distribs, exec_compatible_with, exec_properties, features, forcibly_disable_header_compilation, genclass, header_compiler, header_compiler_builtin_processors, header_compiler_direct, ijar, jacocorunner, java_runtime, javabuilder, javabuilder_data, javabuilder_jvm_opts, javac_supports_multiplex_workers, javac_supports_worker_cancellation, javac_supports_worker_multiplex_sandboxing, javac_supports_workers, javacopts, jspecify_implicit_deps, jspecify_javacopts, jspecify_packages, jspecify_processor, jspecify_processor_class, jspecify_stubs, jvm_opts, licenses, misc, oneversion, oneversion_allowlist_for_tests, oneversion_whitelist, package_configuration, proguard_allowlister, reduced_classpath_incompatible_processors, restricted_to, singlejar, source_version, tags, target_compatible_with, target_version, testonly, timezone_data, toolchains, tools, turbine_data, turbine_jvm_opts, visibility, xlint)

Specifica la configurazione per il compilatore Java. La toolchain da usare può essere modificata tramite l'argomento --java_toolchain. Normalmente non dovresti scrivere questo tipo di regole, a meno che tu non voglia ottimizzare il tuo compilatore Java.

Esempi

Un esempio semplice potrebbe essere:



java_toolchain(
    name = "toolchain",
    source_version = "7",
    target_version = "7",
    bootclasspath = ["//tools/jdk:bootclasspath"],
    xlint = [ "classfile", "divzero", "empty", "options", "path" ],
    javacopts = [ "-g" ],
    javabuilder = ":JavaBuilder_deploy.jar",
)

Argomenti

Attributi
`name`	Name (Nome), obbligatorio Un nome univoco per il target.
`android_lint_data`	Elenco di etichette; il valore predefinito è `[]` Etichette degli strumenti disponibili per l'espansione delle etichette in android_lint_jvm_opts.
`android_lint_jvm_opts`	Elenco di stringhe; il valore predefinito è `[]` L'elenco di argomenti per la JVM quando si richiede Android Lint.
`android_lint_opts`	Elenco di stringhe; il valore predefinito è `[]` L'elenco di argomenti Android Lint.
`android_lint_package_configuration`	Elenco di etichette; il valore predefinito è `[]` Configurazione Lint Android da applicare ai gruppi di pacchetti specificati.
`android_lint_runner`	Etichetta; il valore predefinito è `None` Etichetta dell'eventuale runner Android Lint.
`bootclasspath`	Elenco di etichette; il valore predefinito è `[]` Le voci bootclasspath di destinazione Java. Corrisponde al flag -bootclasspath di Javac.
`compatible_javacopts`	null; default is `{}` API interna. Non utilizzarla!
`deps_checker`	Etichetta; il valore predefinito è `None` Etichetta del jar del deployment di ImportDepsChecker.
`forcibly_disable_header_compilation`	Valore booleano; il valore predefinito è `False` Esegue l'override di --java_header_compilation per disabilitare la compilazione delle intestazioni sulle piattaforme che non la supportano, ad es. JDK 7 Bazel.
`genclass`	Etichetta; il valore predefinito è `None` Etichetta del jar del deployment di GenClass.
`header_compiler`	Etichetta; il valore predefinito è `None` Etichetta del compilatore delle intestazioni. Obbligatorio se --java_header_compilation è abilitato.
`header_compiler_builtin_processors`	Elenco di stringhe; il valore predefinito è `[]` API interna. Non utilizzarla!
`header_compiler_direct`	Etichetta; il valore predefinito è `None` Etichetta facoltativa del compilatore delle intestazioni da utilizzare per le azioni dirette classpath che non includono processori di annotazione per la generazione di API. Questo strumento non supporta l'elaborazione delle annotazioni.
`ijar`	Etichetta; il valore predefinito è `None` Etichetta dell'eseguibile ijar.
`jacocorunner`	Etichetta; il valore predefinito è `None` Etichetta del jar del deployment di JacocoCoperturaRunner.
`java_runtime`	Etichetta; il valore predefinito è `None` Il file java_runtime da utilizzare con questa toolchain. Il valore predefinito è java_runtime nella configurazione di esecuzione.
`javabuilder`	Etichetta; il valore predefinito è `None` Etichetta del jar di deployment di JavaBuilder.
`javabuilder_data`	Elenco di etichette; il valore predefinito è `[]` Etichette dei dati disponibili per l'espansione delle etichette in javabuilder_jvm_opts.
`javabuilder_jvm_opts`	Elenco di stringhe; il valore predefinito è `[]` L'elenco di argomenti per la JVM quando viene richiamato JavaBuilder.
`javac_supports_multiplex_workers`	Valore booleano; il valore predefinito è `True` True se JavaBuilder supporta l'esecuzione come worker permanente multiplex, false in caso contrario.
`javac_supports_worker_cancellation`	Valore booleano; il valore predefinito è `True` True se JavaBuilder supporta l'annullamento di worker permanenti, false se non supporta la cancellazione.
`javac_supports_worker_multiplex_sandboxing`	Valore booleano; il valore predefinito è `False` True se JavaBuilder supporta l'esecuzione come worker permanente multiplex con la limitazione tramite sandbox, false in caso contrario.
`javac_supports_workers`	Valore booleano; il valore predefinito è `True` True se JavaBuilder supporta l'esecuzione come worker permanente, false in caso contrario.
`javacopts`	Elenco di stringhe; il valore predefinito è `[]` L'elenco di argomenti aggiuntivi per il compilatore Java. Consulta la documentazione del compilatore Java per l'elenco completo dei possibili flag del compilatore Java.
`jspecify_implicit_deps`	Etichetta; il valore predefinito è `None` Sperimentale, non utilizzarlo.
`jspecify_javacopts`	Elenco di stringhe; il valore predefinito è `[]` Sperimentale, non utilizzarlo.
`jspecify_packages`	Elenco di etichette; il valore predefinito è `[]` Sperimentale, non utilizzarlo.
`jspecify_processor`	Etichetta; il valore predefinito è `None` Sperimentale, non utilizzarlo.
`jspecify_processor_class`	Stringa; il valore predefinito è `""` Sperimentale, non utilizzarlo.
`jspecify_stubs`	Elenco di etichette; il valore predefinito è `[]` Sperimentale, non utilizzarlo.
`jvm_opts`	Elenco di stringhe; il valore predefinito è `[]` L'elenco di argomenti per la JVM quando viene richiamato il compilatore Java. Consulta la documentazione di Java Virtual Machine per l'elenco completo dei possibili flag per questa opzione.
`misc`	Elenco di stringhe; il valore predefinito è `[]` Deprecato: utilizza javacopts
`oneversion`	Etichetta; il valore predefinito è `None` Etichetta del programma binario di applicazione di una versione.
`oneversion_allowlist_for_tests`	Etichetta; il valore predefinito è `None` Etichetta della lista consentita di una sola versione per i test.
`oneversion_whitelist`	Etichetta; il valore predefinito è `None` Etichetta della lista consentita di una sola versione.
`package_configuration`	Elenco di etichette; il valore predefinito è `[]` Configurazione da applicare ai gruppi di pacchetti specificati.
`proguard_allowlister`	Etichetta; il valore predefinito è `"@bazel_tools//tools/jdk:proguard_whitelister"` Etichetta della lista consentita di Proguard.
`reduced_classpath_incompatible_processors`	Elenco di stringhe; il valore predefinito è `[]` API interna. Non utilizzarla!
`singlejar`	Etichetta; il valore predefinito è `None` Etichetta del jar del deployment SingleJar.
`source_version`	Stringa; il valore predefinito è `""` La versione sorgente Java (ad es. "6" o "7"). e specifica quale set di strutture di codice è consentito nel codice sorgente Java.
`target_version`	Stringa; il valore predefinito è `""` La versione di destinazione Java (ad es. "6" o "7"). Specifica per quale runtime Java deve creare la classe.
`timezone_data`	Etichetta; il valore predefinito è `None` Etichetta di un jar delle risorse contenente i dati relativi al fuso orario. Se impostati, i dati relativi al fuso orario vengono aggiunti come dipendenza implicita di runtime di tutte le regole java_binary.
`tools`	Elenco di etichette; il valore predefinito è `[]` Etichette degli strumenti disponibili per l'espansione delle etichette in jvm_opts.
`turbine_data`	Elenco di etichette; il valore predefinito è `[]` Etichette dei dati disponibili per l'espansione delle etichette in turbine_jvm_opts.
`turbine_jvm_opts`	Elenco di stringhe; il valore predefinito è `[]` L'elenco di argomenti per la JVM quando viene richiamata la turbina.
`xlint`	Elenco di stringhe; il valore predefinito è `[]` L'elenco di avvisi da aggiungere o rimuovere dall'elenco predefinito. Lo precede con un trattino per rimuoverlo. Per ulteriori informazioni, consulta la documentazione Javac sulle opzioni -Xlint.