การลงทะเบียน BazelCon 2024 เปิดให้ลงทะเบียนแล้วในตอนนี้

หน้านี้ได้รับการแปลโดย Cloud Translation API

กฎของ Java

รายงานปัญหา ดูแหล่งที่มา รุ่น Nightly · 8.0 7.4 . 7.3 · 7.2 · 7.1 · 7.0 · 6.5

กฎ

java_binary
java_import
java_library
java_test
java_package_configuration
java_plugin
java_runtime
java_single_jar
java_toolchain

java_binary

java_binary(name, deps, srcs, data, resources, add_exports, add_opens, args, bootclasspath, 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, neverlink, output_licenses, plugins, resource_strip_prefix, restricted_to, runtime_deps, stamp, tags, target_compatible_with, testonly, toolchains, use_launcher, use_testrunner, visibility)

สร้างไฟล์เก็บถาวร Java ("ไฟล์ jar") รวมถึงสคริปต์เชลล์ที่ใช้ห่อหุ้มซึ่งมีชื่อเดียวกับกฎ สคริปต์เชลล์ของ Wrapper ใช้ classpath ที่มีไฟล์ jar สำหรับแต่ละไลบรารีที่ไบนารีนั้นใช้อยู่ เมื่อเรียกใช้สคริปต์เชลล์ของ Wrapper ตัวแปรสภาพแวดล้อม JAVABIN ที่ไม่ใช่ค่าว่างจะมีลำดับความสำคัญเหนือกว่าเวอร์ชันที่ระบุผ่าน Flag --java_runtime_version ของ Bazel

สคริปต์ Wrapper ยอมรับ Flag ที่ไม่ซ้ำกันหลายรายการ โปรดดูรายการ Flag และตัวแปรสภาพแวดล้อมที่กำหนดค่าได้ซึ่ง Wrapper ยอมรับจาก //src/main/java/com/google/devtools/build/lib/bazel/rules/java/java_stub_template.txt

เป้าหมายเอาต์พุตโดยนัย

name.jar: ไฟล์เก็บถาวร Java ที่มีไฟล์คลาสและทรัพยากรอื่นๆ ที่สอดคล้องกับทรัพยากรที่ต้องพึ่งพาโดยตรงของไบนารี
name-src.jar: ไฟล์เก็บถาวรที่มีแหล่งที่มา ("source jar")
name_deploy.jar: ไฟล์เก็บถาวร Java ที่เหมาะสมสําหรับการติดตั้งใช้งาน (จะสร้างขึ้นก็ต่อเมื่อมีการขออย่างชัดแจ้งเท่านั้น)
การสร้างเป้าหมาย <name>_deploy.jar สําหรับกฎจะสร้างไฟล์ jar แบบสําเร็จรูปที่มีไฟล์ Manifest ซึ่งช่วยให้สามารถเรียกใช้ได้โดยใช้คําสั่ง java -jar หรือตัวเลือก --singlejar ของสคริปต์ Wrapper เราขอแนะนำให้ใช้สคริปต์ Wrapper แทน java -jar เนื่องจากจะส่งFlag JVM และตัวเลือกในการโหลดไลบรารีแบบเนทีฟด้วย

ไฟล์ jar ที่ใช้ติดตั้งประกอบด้วยคลาสทั้งหมดที่ Class Loader จะพบซึ่งค้นหา classpath จากสคริปต์ Wrapper ของไบนารีตั้งแต่ต้นจนจบ รวมถึงมีไลบรารีเนทีฟที่จําเป็นสําหรับทรัพยากร Dependency ด้วย ระบบจะโหลดไฟล์เหล่านี้ลงใน JVM โดยอัตโนมัติเมื่อรันไทม์

หากเป้าหมายระบุแอตทริบิวต์ launcher ไฟล์ _deploy.jar จะเป็นไบนารีแบบเนทีฟแทนที่จะเป็นไฟล์ JAR ปกติ ซึ่งจะมีตัวเปิดใช้งานและไลบรารีแบบเนทีฟ (C++) ของกฎทั้งหมดที่ลิงก์เป็นไบนารีแบบคงที่ ระบบจะเพิ่มไบต์ของไฟล์ jar จริงต่อท้ายไบนารีเนทีฟนั้นเพื่อสร้างบล็อกไบนารีเดียวที่มีทั้งไฟล์ปฏิบัติการและโค้ด Java คุณสามารถเรียกใช้ไฟล์ jar ที่ได้โดยตรง เช่นเดียวกับการเรียกใช้ไฟล์ไบนารีเนทีฟ
name_deploy-src.jar: ที่เก็บถาวรที่มีแหล่งที่มาซึ่งรวบรวมจาก Closure แบบทรานซิทีฟของเป้าหมาย ซึ่งจะจับคู่กับคลาสใน deploy.jar ยกเว้นในกรณีที่ Jar ไม่มี Jar แหล่งที่มาที่ตรงกัน

เราขอแนะนำให้ใช้ชื่อไฟล์ต้นฉบับที่เป็นจุดแรกเข้าหลักของแอปพลิเคชัน (ไม่รวมนามสกุล) ตัวอย่างเช่น หากชื่อของจุดแรกเข้าคือ Main.java ชื่อของคุณอาจเป็น Main

ไม่อนุญาตให้ใช้แอตทริบิวต์ deps ในกฎ java_binary ที่ไม่มี srcs กฎดังกล่าวต้องมี main_class ที่ได้จาก runtime_deps

ข้อมูลโค้ดต่อไปนี้แสดงข้อผิดพลาดที่พบบ่อย


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

ให้ทำดังนี้แทน


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

อาร์กิวเมนต์

Attributes
`name`	ชื่อ ต้องระบุ ชื่อที่ไม่ซ้ำกันสำหรับเป้าหมายนี้
`deps`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการคลังอื่นๆ ที่จะลิงก์กับเป้าหมาย ดูความคิดเห็นทั่วไปเกี่ยวกับ `deps` ที่หัวข้อแอตทริบิวต์ทั่วไปที่กฎการสร้างส่วนใหญ่กำหนด
`srcs`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการไฟล์ต้นทางที่ประมวลผลเพื่อสร้างเป้าหมาย เกือบทุกครั้งจะต้องระบุแอตทริบิวต์นี้ โปรดดูข้อยกเว้นด้านล่าง คอมไพล์ไฟล์ต้นทางประเภท `.java` ในกรณีของไฟล์ `.java` ที่สร้างขึ้น โดยทั่วไปเราขอแนะนำให้ใส่ชื่อของกฎการสร้างที่นี่แทนชื่อของไฟล์ วิธีนี้ไม่เพียงช่วยปรับปรุงความอ่านง่าย แต่ยังทําให้กฎมีความยืดหยุ่นมากขึ้นเมื่อเกิดการเปลี่ยนแปลงในอนาคตด้วย เช่น หากกฎการสร้างสร้างไฟล์อื่นในอนาคต คุณก็แก้ไขได้เพียงที่เดียวเท่านั้น ซึ่งก็คือ `outs` ของกฎการสร้าง คุณไม่ควรระบุกฎการสร้างใน `deps` เนื่องจากเป็นการดำเนินการที่ไม่มีผล ระบบจะแตกไฟล์ต้นฉบับประเภท `.srcjar` และคอมไพล์ (ซึ่งมีประโยชน์ในกรณีที่คุณต้องสร้างชุดไฟล์ `.java` ด้วย genrule) กฎ: หากกฎ (โดยทั่วไปคือ `genrule` หรือ `filegroup`) สร้างไฟล์ใดไฟล์หนึ่งตามที่ระบุไว้ข้างต้น ระบบจะใช้ไฟล์ดังกล่าวในลักษณะเดียวกับที่อธิบายไว้สำหรับไฟล์ต้นทาง เกือบทุกครั้งจะต้องมีอาร์กิวเมนต์นี้ ยกเว้นในกรณีที่แอตทริบิวต์ `main_class` ระบุคลาสใน classpath รันไทม์หรือคุณระบุอาร์กิวเมนต์ `runtime_deps`
`data`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการไฟล์ที่จุลสารนี้ต้องใช้ในรันไทม์ ดูความคิดเห็นทั่วไปเกี่ยวกับ `data` ที่แอตทริบิวต์ทั่วไปที่กฎการสร้างส่วนใหญ่กำหนด
`resources`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการไฟล์ข้อมูลที่จะรวมไว้ในไฟล์ JAR ของ Java ทรัพยากรอาจเป็นไฟล์ต้นฉบับหรือไฟล์ที่สร้างขึ้น หากระบุทรัพยากร ระบบจะรวมทรัพยากรไว้ในไฟล์ jar พร้อมกับไฟล์ `.class` ปกติที่เกิดจากการคอมไพล์ ตำแหน่งของทรัพยากรภายในไฟล์ jar จะกำหนดโดยโครงสร้างโปรเจ็กต์ ก่อนอื่น Bazel จะมองหาเลย์เอาต์ไดเรกทอรีมาตรฐานของ Maven (ไดเรกทอรี "src" ตามด้วยไดเรกทอรี "resources" ซึ่งเป็นไดเรกทอรีย่อย) หากไม่พบ ทาง Bazel จะค้นหาไดเรกทอรีระดับบนสุดที่ชื่อ "java" หรือ "javatests" (เช่น หากทรัพยากรอยู่ที่ `<workspace root>/x/java/y/java/z` เส้นทางของทรัพยากรจะเป็น `y/java/z` ไม่สามารถลบล้างการคาดคะเนนี้ได้ แต่สามารถใช้แอตทริบิวต์ `resource_strip_prefix` เพื่อระบุไดเรกทอรีอื่นที่เจาะจงสำหรับไฟล์ทรัพยากรได้
`add_exports`	รายการสตริง ค่าเริ่มต้นคือ `[]` อนุญาตให้คลังนี้เข้าถึง `module` หรือ `package` ที่ระบุ ซึ่งสอดคล้องกับ Flag javac และ JVM --add-exports=
`add_opens`	รายการสตริง ค่าเริ่มต้นคือ `[]` อนุญาตให้ไลบรารีนี้เข้าถึง `module` หรือ `package` ที่ระบุโดยอัตโนมัติ ซึ่งสอดคล้องกับ Flag javac และ JVM --add-opens=
`bootclasspath`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` API ที่จำกัด โปรดอย่าใช้
`classpath_resources`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` อย่าใช้ตัวเลือกนี้ เว้นแต่จะไม่มีวิธีอื่น) รายการทรัพยากรที่ต้องอยู่ที่รูทของต้นไม้ Java วัตถุประสงค์เดียวของแอตทริบิวต์นี้คือเพื่อรองรับไลบรารีของบุคคลที่สามที่กำหนดให้ต้องพบทรัพยากรของไลบรารีใน classpath เป็น `"myconfig.xml"` เท่านั้น ใช้ได้เฉพาะในไบนารีเท่านั้น และไม่ใช้ในไลบรารีเนื่องจากมีความเสี่ยงที่จะเกิดความขัดแย้งของเนมสเปซ
`create_executable`	บูลีน ค่าเริ่มต้นคือ `True` เลิกใช้งานแล้ว โปรดใช้ `java_single_jar` แทน
`deploy_env`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการเป้าหมาย `java_binary` อื่นๆ ที่แสดงถึงสภาพแวดล้อมการนําไปใช้งานสําหรับไบนารีนี้ ตั้งค่าแอตทริบิวต์นี้เมื่อสร้างปลั๊กอินที่จะโหลดโดย `java_binary` อื่น การตั้งค่าแอตทริบิวต์นี้จะยกเว้นการพึ่งพาทั้งหมดจาก classpath รันไทม์ (และไฟล์ jar ที่ใช้ติดตั้ง) ของไบนารีนี้ที่แชร์ระหว่างไบนารีนี้กับเป้าหมายที่ระบุใน `deploy_env`
`deploy_manifest_lines`	รายการสตริง ค่าเริ่มต้นคือ `[]` รายการบรรทัดที่จะเพิ่มลงในไฟล์ `META-INF/manifest.mf` ที่สร้างขึ้นสําหรับเป้าหมาย `_deploy.jar` เนื้อหาของแอตทริบิวต์นี้ไม่*อยู่ภายใต้การแทนที่ด้วย"สร้างตัวแปร"
`javacopts`	รายการสตริง ค่าเริ่มต้นคือ `[]` ตัวเลือกเพิ่มเติมสำหรับคอมไพเลอร์ของไบนารีนี้ ขึ้นอยู่กับการแทนที่ "Make variable" และการแยกออกเป็นโทเค็นของ Bourne shell ระบบจะส่งตัวเลือกคอมไพเลอร์เหล่านี้ไปยัง javac หลังจากตัวเลือกคอมไพเลอร์ส่วนกลาง
`jvm_flags`	รายการสตริง ค่าเริ่มต้นคือ `[]` รายการ Flag ที่จะฝังในสคริปต์ Wrapper ที่สร้างขึ้นเพื่อเรียกใช้ไบนารีนี้ ขึ้นอยู่กับการแทนที่ $(location) และ "Make variable" และ การแยกคำของ Bourne shell สคริปต์ Wrapper สําหรับไบนารี Java จะมีการกําหนด CLASSPATH (เพื่อค้นหา JAR ทั้งหมดที่ต้องพึ่งพา) และเรียกใช้โปรแกรมแปลภาษา Java ที่ถูกต้อง บรรทัดคำสั่งที่สร้างขึ้นโดยสคริปต์ Wrapper จะมีชื่อของคลาสหลักตามด้วย `"$@"` เพื่อให้คุณส่งอาร์กิวเมนต์อื่นๆ ต่อจากชื่อคลาสได้ อย่างไรก็ตาม คุณต้องระบุอาร์กิวเมนต์ที่มีไว้สำหรับการแยกวิเคราะห์โดย JVM ก่อนชื่อคลาสในบรรทัดคำสั่ง ระบบจะเพิ่มเนื้อหาของ `jvm_flags` ลงในสคริปต์ Wrapper ก่อนแสดงชื่อคลาส โปรดทราบว่าแอตทริบิวต์นี้ไม่มีผลต่อเอาต์พุต `*_deploy.jar`
`launcher`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ระบุไบนารีที่จะใช้เรียกใช้โปรแกรม Java แทนโปรแกรม `bin/java` ปกติที่มาพร้อมกับ JDK เป้าหมายต้องเป็น `cc_binary` คุณสามารถระบุ `cc_binary` ใดก็ได้ที่ใช้ Invocation API ของ Java เป็นค่าสำหรับแอตทริบิวต์นี้ โดยค่าเริ่มต้น Bazel จะใช้ตัวเปิด JDK ปกติ (bin/java หรือ java.exe) Flag `--java_launcher` ของ Bazel ที่เกี่ยวข้องจะมีผลกับเป้าหมาย `java_binary` และ `java_test` เท่านั้นที่ไม่ได้ระบุแอตทริบิวต์ `launcher` โปรดทราบว่าระบบจะสร้างการพึ่งพาแบบเนทีฟ (C++, SWIG, JNI) แตกต่างกันไป ขึ้นอยู่กับว่าคุณใช้ Launcher ของ JDK หรือ Launcher อื่น หากคุณใช้ตัวเปิด JDK ปกติ (ค่าเริ่มต้น) ระบบจะสร้าง Dependency เดิมเป็นไลบรารีที่ใช้ร่วมกันชื่อ `{name}_nativedeps.so` โดยที่ `{name}` เป็นแอตทริบิวต์ `name` ของกฎ java_binary นี้ เครื่องมือลิงก์จะไม่นำโค้ดที่ไม่ได้ใช้ออกในการกำหนดค่านี้ หากคุณใช้ Launcher อื่น ระบบจะลิงก์ไลบรารีแบบเนทีฟ (C++) แบบคงที่ไปยังไบนารีชื่อ `{name}_nativedeps` โดยที่ `{name}` เป็นแอตทริบิวต์ `name` ของกฎ java_binary นี้ ในกรณีนี้ โปรแกรมลิงก์จะนำโค้ดที่คิดว่าไม่ได้ใช้ออกจากไบนารีที่ได้ ซึ่งหมายความว่าระบบอาจไม่ลิงก์โค้ด C++ ที่เข้าถึงได้ผ่าน JNI เท่านั้น เว้นแต่เป้าหมาย `cc_library` จะระบุ `alwayslink = True` เมื่อใช้ Launcher อื่นที่ไม่ใช่ Launcher JDK เริ่มต้น รูปแบบของเอาต์พุต `*_deploy.jar` จะเปลี่ยนไป ดูรายละเอียดได้ในเอกสารหลักของ java_binary
`main_class`	สตริง ค่าเริ่มต้นคือ `""` ชื่อคลาสที่มีเมธอด `main()` เพื่อใช้เป็นจุดแรกเข้า หากกฎใช้ตัวเลือกนี้ ก็ไม่จำเป็นต้องมีรายการ `srcs=[...]` ดังนั้น คุณจึงสร้างไฟล์ปฏิบัติการจากไลบรารี Java ที่มีเมธอด `main()` อย่างน้อย 1 รายการอยู่แล้วได้โดยใช้แอตทริบิวต์นี้ ค่าของแอตทริบิวต์นี้คือชื่อคลาส ไม่ใช่ไฟล์ต้นฉบับ คลาสต้องพร้อมใช้งานที่รันไทม์ โดยอาจคอมไพล์โดยกฎนี้ (จาก `srcs`) หรือจัดหาโดยข้อกําหนดโดยตรงหรือแบบสื่อกลาง (ผ่าน `runtime_deps` หรือ `deps`) หากคลาสไม่พร้อมใช้งาน ไฟล์ไบนารีจะใช้งานไม่ได้ที่รันไทม์ จะไม่มีการตรวจสอบเวลาสร้าง
`neverlink`	บูลีน ค่าเริ่มต้นคือ `False`
`plugins`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ปลั๊กอินคอมไพเลอร์ Java เพื่อเรียกใช้ขณะคอมไพล์ ระบบจะเรียกใช้ `java_plugin` ทั้งหมดที่ระบุในแอตทริบิวต์นี้ทุกครั้งที่สร้างกฎนี้ ไลบรารียังรับช่วงปลั๊กอินจาก Dependency ที่ใช้ `exported_plugins` ได้ด้วย ทรัพยากรที่ปลั๊กอินสร้างขึ้นจะรวมอยู่ในไฟล์ jar ของกฎนี้
`resource_strip_prefix`	สตริง ค่าเริ่มต้นคือ `""` คำนำหน้าเส้นทางที่จะตัดออกจากทรัพยากร Java หากระบุไว้ ระบบจะนำคำนำหน้าเส้นทางนี้ออกจากทุกไฟล์ในแอตทริบิวต์ `resources` ไฟล์ทรัพยากรที่ไม่ได้อยู่ในไดเรกทอรีนี้จะทำให้เกิดข้อผิดพลาด หากไม่ได้ระบุ (ค่าเริ่มต้น) ระบบจะกำหนดเส้นทางของไฟล์ทรัพยากรตามตรรกะเดียวกับแพ็กเกจ Java ของไฟล์ต้นทาง เช่น ไฟล์ต้นฉบับที่ `stuff/java/foo/bar/a.txt` จะอยู่ที่ `foo/bar/a.txt`
`runtime_deps`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ไลบรารีที่จะทําให้พร้อมใช้งานในไบนารีขั้นสุดท้ายหรือทดสอบที่รันไทม์เท่านั้น เช่นเดียวกับ `deps` ทั่วไป รายการเหล่านี้จะปรากฏใน classpath รันไทม์ แต่จะต่างจาก `deps` ตรงที่ไม่ได้ปรากฏใน classpath ขณะคอมไพล์ รายการพึ่งพาที่จำเป็นเฉพาะที่รันไทม์ควรระบุไว้ที่นี่ เครื่องมือวิเคราะห์ Dependency ควรละเว้นเป้าหมายที่ปรากฏทั้งใน `runtime_deps` และ `deps`
`stamp`	จํานวนเต็ม ค่าเริ่มต้นคือ `-1` ว่าจะเข้ารหัสข้อมูลบิลด์ลงในไบนารีหรือไม่ ค่าที่เป็นไปได้ ได้แก่ `stamp = 1`: ประทับข้อมูลบิลด์ลงในไบนารีเสมอ แม้ในบิลด์ `--nostamp` ก็ตาม คุณควรหลีกเลี่ยงการตั้งค่านี้ เนื่องจากอาจทำให้แคชระยะไกลสําหรับไบนารีและการดำเนินการดาวน์สตรีมใดๆ ที่ขึ้นอยู่กับแคชนั้นใช้งานไม่ได้ `stamp = 0`: แทนที่ข้อมูลบิลด์ด้วยค่าคงที่เสมอ ซึ่งจะช่วยแคชผลลัพธ์การสร้างที่ดี `stamp = -1`: การฝังข้อมูลบิลด์จะควบคุมโดย Flag `--[no]stamp` ระบบจะไม่สร้างไฟล์ไบนารีที่มีตราประทับอีกครั้ง เว้นแต่จะมีการเปลี่ยนแปลงทรัพยากร Dependency
`use_launcher`	บูลีน ค่าเริ่มต้นคือ `True` ระบุว่าไบนารีควรใช้ตัวเปิดที่กำหนดเองหรือไม่ หากตั้งค่าแอตทริบิวต์นี้เป็น "เท็จ" ระบบจะไม่สนใจแอตทริบิวต์launcher และ Flag `--java_launcher` ที่เกี่ยวข้องสำหรับเป้าหมายนี้
`use_testrunner`	บูลีน ค่าเริ่มต้นคือ `False` ใช้คลาสโปรแกรมทดสอบ (โดยค่าเริ่มต้นคือ `com.google.testing.junit.runner.BazelTestRunner`) เป็นจุดแรกเข้าหลักสำหรับโปรแกรม Java และระบุคลาสทดสอบให้กับโปรแกรมทดสอบเป็นค่าของพร็อพเพอร์ตี้ระบบ `bazel.test_suite` คุณใช้ตัวเลือกนี้เพื่อลบล้างลักษณะการทํางานเริ่มต้นได้ ซึ่งก็คือการใช้โปรแกรมรันทดสอบสําหรับกฎ `java_test` และไม่ได้ใช้สําหรับกฎ `java_binary` คุณไม่น่าจะต้องดำเนินการนี้ การใช้งานอย่างหนึ่งคือสำหรับ`AllTest` กฎที่เรียกใช้โดยกฎอื่น (เช่น เพื่อตั้งค่าฐานข้อมูลก่อนทำการทดสอบ) คุณต้องประกาศ`AllTest` กฎเป็น `java_binary` แต่ควรใช้โปรแกรมรันทดสอบเป็นจุดแรกเข้าหลัก คุณลบล้างชื่อคลาสโปรแกรมรันทดสอบได้ด้วยแอตทริบิวต์ `main_class`

java_import

ดูแหล่งที่มาของกฎ

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)

กฎนี้อนุญาตให้ใช้ไฟล์ .jar ที่คอมไพล์ไว้ล่วงหน้าเป็นไลบรารีสำหรับกฎ java_library และ java_binary

ตัวอย่าง


    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",
        ],
    )

อาร์กิวเมนต์

Attributes
`name`	ชื่อ ต้องระบุ ชื่อที่ไม่ซ้ำกันสำหรับเป้าหมายนี้
`deps`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการคลังอื่นๆ ที่จะลิงก์กับเป้าหมาย โปรดดู java_library.deps
`data`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการไฟล์ที่จําเป็นสําหรับกฎนี้ที่รันไทม์
`add_exports`	รายการสตริง ค่าเริ่มต้นคือ `[]` อนุญาตให้คลังนี้เข้าถึง `module` หรือ `package` ที่ระบุ ซึ่งสอดคล้องกับ Flag javac และ JVM --add-exports=
`add_opens`	รายการสตริง ค่าเริ่มต้นคือ `[]` อนุญาตให้ไลบรารีนี้เข้าถึง `module` หรือ `package` ที่ระบุโดยอัตโนมัติ ซึ่งสอดคล้องกับ Flag javac และ JVM --add-opens=
`constraints`	รายการสตริง ค่าเริ่มต้นคือ `[]` ข้อจำกัดเพิ่มเติมที่กำหนดให้กับกฎนี้เป็นไลบรารี Java
`exports`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` เป้าหมายที่จะทําให้พร้อมใช้งานสําหรับผู้ใช้กฎนี้ โปรดดู java_library.exports
`jars`	รายการป้ายกำกับ (ต้องระบุ) รายการไฟล์ JAR ที่ระบุให้กับเป้าหมาย Java ที่ใช้เป้าหมายนี้
`neverlink`	บูลีน ค่าเริ่มต้นคือ `False` ใช้ไลบรารีนี้สำหรับการคอมไพล์เท่านั้น และไม่ใช้ในรันไทม์ มีประโยชน์ในกรณีที่รันไทม์จะจัดหาไลบรารีระหว่างการดําเนินการ ตัวอย่างไลบรารีลักษณะนี้คือ IDE API สำหรับปลั๊กอิน IDE หรือ `tools.jar` สำหรับทุกอย่างที่ทำงานบน JDK มาตรฐาน
`proguard_specs`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ไฟล์ที่จะใช้เป็นข้อกำหนดของ Proguard ซึ่งจะอธิบายชุดข้อมูลจำเพาะที่ Proguard จะใช้ หากระบุไว้ ระบบจะเพิ่มลงในเป้าหมาย `android_binary` ใดก็ได้โดยขึ้นอยู่กับคลังนี้ ไฟล์ที่รวมอยู่ที่นี่ต้องมีเฉพาะกฎแบบซ้ำซ้อน ซึ่งได้แก่ -dontnote, -dontwarn, assumenosideeffects และกฎที่ขึ้นต้นด้วย -keep ตัวเลือกอื่นๆ จะปรากฏใน proguard_specs ของ `android_binary` เท่านั้น เพื่อให้การผสานไม่ซ้ำกัน
`runtime_deps`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ไลบรารีที่จะทําให้พร้อมใช้งานในไบนารีขั้นสุดท้ายหรือทดสอบที่รันไทม์เท่านั้น โปรดดู java_library.runtime_deps
`srcjar`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ไฟล์ JAR ที่มีซอร์สโค้ดสำหรับไฟล์ JAR ที่คอมไพล์แล้ว

java_library

ดูแหล่งที่มาของกฎ

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)

กฎนี้จะคอมไพล์และลิงก์แหล่งข้อมูลเป็นไฟล์ .jar

เอาต์พุตโดยนัย

libname.jar: ที่เก็บถาวร Java ที่มีไฟล์คลาส
libname-src.jar: ไฟล์เก็บถาวรที่มีแหล่งที่มา ("source jar")

อาร์กิวเมนต์

Attributes
`name`	ชื่อ ต้องระบุ ชื่อที่ไม่ซ้ำกันสำหรับเป้าหมายนี้
`deps`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการคลังที่จะลิงก์กับคลังนี้ ดูความคิดเห็นทั่วไปเกี่ยวกับ `deps` ที่หัวข้อแอตทริบิวต์ทั่วไปที่กฎการสร้างส่วนใหญ่กำหนด Jar ที่สร้างขึ้นโดยกฎ `java_library` รายการใน `deps` จะอยู่ใน classpath ของเวลาคอมไพล์ของกฎนี้ นอกจากนี้ การปิดเชิงสื่อกลางของ `deps`, `runtime_deps` และ `exports` จะอยู่ใน classpath รันไทม์ ในทางตรงกันข้าม เป้าหมายในแอตทริบิวต์ `data` จะรวมอยู่ในไฟล์รันไทม์ แต่ไม่รวมอยู่ในคลาสพาธของเวลาคอมไพล์หรือรันไทม์
`srcs`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการไฟล์ต้นทางที่ประมวลผลเพื่อสร้างเป้าหมาย เกือบทุกครั้งจะต้องระบุแอตทริบิวต์นี้ โปรดดูข้อยกเว้นด้านล่าง คอมไพล์ไฟล์ต้นทางประเภท `.java` ในกรณีของไฟล์ `.java` ที่สร้างขึ้น โดยทั่วไปเราขอแนะนำให้ใส่ชื่อของกฎการสร้างที่นี่แทนชื่อของไฟล์ วิธีนี้ไม่เพียงช่วยปรับปรุงความอ่านง่าย แต่ยังทําให้กฎมีความยืดหยุ่นมากขึ้นเมื่อเกิดการเปลี่ยนแปลงในอนาคตด้วย เช่น หากกฎการสร้างสร้างไฟล์อื่นในอนาคต คุณก็แก้ไขได้เพียงที่เดียวเท่านั้น ซึ่งก็คือ `outs` ของกฎการสร้าง คุณไม่ควรระบุกฎการสร้างใน `deps` เนื่องจากเป็นการดำเนินการที่ไม่มีผล ระบบจะแตกไฟล์ต้นฉบับประเภท `.srcjar` และคอมไพล์ (ซึ่งมีประโยชน์ในกรณีที่คุณต้องสร้างชุดไฟล์ `.java` ด้วย genrule) กฎ: หากกฎ (โดยทั่วไปคือ `genrule` หรือ `filegroup`) สร้างไฟล์ใดไฟล์หนึ่งตามที่ระบุไว้ข้างต้น ระบบจะใช้ไฟล์ดังกล่าวในลักษณะเดียวกับที่อธิบายไว้สำหรับไฟล์ต้นทาง ระบบจะถือว่าไฟล์ต้นทางประเภท `.properties` เป็นทรัพยากร ระบบจะไม่สนใจไฟล์อื่นๆ ทั้งหมด ตราบใดที่มีไฟล์อย่างน้อย 1 ไฟล์ในประเภทไฟล์ที่อธิบายไว้ข้างต้น มิฉะนั้น ระบบจะแสดงข้อผิดพลาด คุณต้องระบุอาร์กิวเมนต์นี้เกือบทุกครั้ง เว้นแต่คุณจะระบุอาร์กิวเมนต์ `runtime_deps`
`data`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการไฟล์ที่จุลสารนี้ต้องใช้ในรันไทม์ ดูความคิดเห็นทั่วไปเกี่ยวกับ `data` ที่หัวข้อแอตทริบิวต์ทั่วไปที่กฎการสร้างส่วนใหญ่กำหนด เมื่อสร้าง `java_library` ทาง Bazel จะไม่วางไฟล์เหล่านี้ไว้ที่ใดเลย หากไฟล์ `data` เป็นไฟล์ที่สร้างขึ้น Bazel ก็จะสร้างไฟล์เหล่านั้น เมื่อสร้างการทดสอบที่ขึ้นอยู่กับ `java_library` นี้ Bazel จะคัดลอกหรือลิงก์ไฟล์ `data` ไปยังพื้นที่ runfiles
`resources`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการไฟล์ข้อมูลที่จะรวมไว้ในไฟล์ JAR ของ Java ทรัพยากรอาจเป็นไฟล์ต้นฉบับหรือไฟล์ที่สร้างขึ้น หากระบุทรัพยากร ระบบจะรวมทรัพยากรไว้ในไฟล์ jar พร้อมกับไฟล์ `.class` ปกติที่เกิดจากการคอมไพล์ ตำแหน่งของทรัพยากรภายในไฟล์ jar จะกำหนดโดยโครงสร้างโปรเจ็กต์ ก่อนอื่น Bazel จะมองหาเลย์เอาต์ไดเรกทอรีมาตรฐานของ Maven (ไดเรกทอรี "src" ตามด้วยไดเรกทอรี "resources" ซึ่งเป็นไดเรกทอรีย่อย) หากไม่พบ ทาง Bazel จะค้นหาไดเรกทอรีระดับบนสุดที่ชื่อ "java" หรือ "javatests" (เช่น หากทรัพยากรอยู่ที่ `<workspace root>/x/java/y/java/z` เส้นทางของทรัพยากรจะเป็น `y/java/z` ไม่สามารถลบล้างการคาดคะเนนี้ได้ แต่สามารถใช้แอตทริบิวต์ `resource_strip_prefix` เพื่อระบุไดเรกทอรีอื่นที่เจาะจงสำหรับไฟล์ทรัพยากรได้
`add_exports`	รายการสตริง ค่าเริ่มต้นคือ `[]` อนุญาตให้คลังนี้เข้าถึง `module` หรือ `package` ที่ระบุ ซึ่งสอดคล้องกับ Flag javac และ JVM --add-exports=
`add_opens`	รายการสตริง ค่าเริ่มต้นคือ `[]` อนุญาตให้ไลบรารีนี้เข้าถึง `module` หรือ `package` ที่ระบุโดยอัตโนมัติ ซึ่งสอดคล้องกับ Flag javac และ JVM --add-opens=
`bootclasspath`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` API ที่จำกัด โปรดอย่าใช้
`exported_plugins`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการ `java_plugin` (เช่น โปรแกรมประมวลผลคำอธิบายประกอบ) เพื่อส่งออกไปยังไลบรารีที่ขึ้นต่อกันกับไลบรารีนี้โดยตรง รายการ `java_plugin` ที่ระบุจะมีผลกับไลบรารีที่ขึ้นต่อกันกับไลบรารีนี้โดยตรง เหมือนกับว่าไลบรารีดังกล่าวได้ประกาศป้ายกำกับเหล่านี้อย่างชัดเจนใน `plugins`
`exports`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ไลบรารีที่ส่งออก การระบุกฎที่นี่จะทำให้กฎเหล่านั้นพร้อมใช้งานสำหรับกฎหลัก ราวกับว่ากฎหลักใช้กฎเหล่านี้อย่างชัดเจน แต่จะไม่ใช้กับ `deps` ปกติ (ที่ไม่ได้ส่งออก) สรุป: กฎ X สามารถเข้าถึงโค้ดใน Y ได้หากมีเส้นทางการพึ่งพาระหว่างกันซึ่งเริ่มต้นด้วยขอบ `deps` ตามด้วยขอบ `exports` อย่างน้อย 1 เส้น มาดูตัวอย่างที่แสดงให้เห็นเรื่องนี้กัน สมมติว่า A ขึ้นอยู่กับ B และ B ขึ้นอยู่กับ C ในกรณีนี้ C เป็นสิ่งที่ต้องพึ่งพาแบบเปลี่ยนผ่านของ A ดังนั้นการเปลี่ยนแหล่งที่มาของ C และการสร้าง A อีกครั้งจะสร้างทุกอย่างขึ้นใหม่ได้อย่างถูกต้อง แต่ A จะใช้คลาสใน C ไม่ได้ หากต้องการอนุญาตการดำเนินการดังกล่าว ก จะต้องประกาศ ค ใน `deps` หรือ ข อาจทําให้ ก (และทุกอย่างที่อาจขึ้นอยู่กับ ก) ดำเนินการได้ง่ายขึ้นโดยการประกาศ ค ในแอตทริบิวต์ `exports` (ของ ข) การปิดไลบรารีที่ส่งออกใช้ได้กับกฎหลักโดยตรงทั้งหมด ลองดูตัวอย่างที่แตกต่างออกไปเล็กน้อย: A ขึ้นอยู่กับ B, B ขึ้นอยู่กับ C และ D และส่งออก C แต่ไม่ส่งออก D ตอนนี้ A มีสิทธิ์เข้าถึง C แต่ไม่มีสิทธิ์เข้าถึง D ตอนนี้หาก C และ D ส่งออกคลังบางรายการเป็น C' และ D' ตามลำดับ A จะเข้าถึงได้เฉพาะ C' เท่านั้น แต่เข้าถึง D' ไม่ได้ สำคัญ: กฎที่ส่งออกไม่ใช่ข้อกำหนดทั่วไป กลับมาที่ตัวอย่างก่อนหน้านี้ หาก B ส่งออก C และต้องการใช้ C ด้วย ก็จะต้องระบุ C ใน `deps` ของตัวเองด้วย
`javabuilder_jvm_flags`	รายการสตริง ค่าเริ่มต้นคือ `[]` API ที่จำกัด โปรดอย่าใช้
`javacopts`	รายการสตริง ค่าเริ่มต้นคือ `[]` ตัวเลือกคอมไพเลอร์เพิ่มเติมสำหรับไลบรารีนี้ ขึ้นอยู่กับการแทนที่ "Make variable" และการแยกออกเป็นโทเค็นของ Bourne shell ระบบจะส่งตัวเลือกคอมไพเลอร์เหล่านี้ไปยัง javac หลังจากตัวเลือกคอมไพเลอร์ส่วนกลาง
`neverlink`	บูลีน ค่าเริ่มต้นคือ `False` ควรใช้ไลบรารีนี้สำหรับการคอมไพล์เท่านั้นและไม่ควรใช้ในรันไทม์ มีประโยชน์ในกรณีที่สภาพแวดล้อมรันไทม์จะจัดหาไลบรารีระหว่างการดำเนินการ ตัวอย่างของไลบรารีดังกล่าว ได้แก่ IDE API สําหรับปลั๊กอิน IDE หรือ `tools.jar` สําหรับทุกอย่างที่ทํางานบน JDK มาตรฐาน โปรดทราบว่า `neverlink = True` ไม่ได้ป้องกันไม่ให้คอมไพเลอร์ฝังเนื้อหาจากไลบรารีนี้ลงในเป้าหมายการคอมไพล์ที่ขึ้นอยู่กับไลบรารีดังกล่าว ตามที่ข้อกำหนดภาษา Java อนุญาต (เช่น `static final` ค่าคงที่ของ `String` หรือของประเภทพื้นฐาน) ดังนั้น Use Case ที่แนะนำคือเมื่อไลบรารีรันไทม์เหมือนกับไลบรารีการคอมไพล์ หากไลบรารีรันไทม์แตกต่างจากไลบรารีการคอมไพล์ คุณต้องตรวจสอบว่าไลบรารีดังกล่าวแตกต่างกันเฉพาะในส่วนที่ JLS ห้ามไม่ให้คอมไพเลอร์ฝัง (และข้อกำหนดนี้ต้องใช้ได้กับ JLS เวอร์ชันทั้งหมดในอนาคต)
`plugins`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ปลั๊กอินคอมไพเลอร์ Java เพื่อเรียกใช้ขณะคอมไพล์ ระบบจะเรียกใช้ `java_plugin` ทั้งหมดที่ระบุในแอตทริบิวต์นี้ทุกครั้งที่สร้างกฎนี้ ไลบรารียังรับช่วงปลั๊กอินจาก Dependency ที่ใช้ `exported_plugins` ได้ด้วย ทรัพยากรที่ปลั๊กอินสร้างขึ้นจะรวมอยู่ในไฟล์ jar ของกฎนี้
`proguard_specs`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ไฟล์ที่จะใช้เป็นข้อกำหนดของ Proguard ซึ่งจะอธิบายชุดข้อมูลจำเพาะที่ Proguard จะใช้ หากระบุไว้ ระบบจะเพิ่มลงในเป้าหมาย `android_binary` ใดก็ได้โดยขึ้นอยู่กับคลังนี้ ไฟล์ที่รวมอยู่ที่นี่ต้องมีเฉพาะกฎแบบซ้ำซ้อน ซึ่งได้แก่ -dontnote, -dontwarn, assumenosideeffects และกฎที่ขึ้นต้นด้วย -keep ตัวเลือกอื่นๆ จะปรากฏใน proguard_specs ของ `android_binary` เท่านั้น เพื่อให้การผสานไม่ซ้ำกัน
`resource_strip_prefix`	สตริง ค่าเริ่มต้นคือ `""` คำนำหน้าเส้นทางที่จะตัดออกจากทรัพยากร Java หากระบุไว้ ระบบจะนำคำนำหน้าเส้นทางนี้ออกจากทุกไฟล์ในแอตทริบิวต์ `resources` ไฟล์ทรัพยากรที่ไม่ได้อยู่ในไดเรกทอรีนี้จะทำให้เกิดข้อผิดพลาด หากไม่ได้ระบุ (ค่าเริ่มต้น) ระบบจะกำหนดเส้นทางของไฟล์ทรัพยากรตามตรรกะเดียวกับแพ็กเกจ Java ของไฟล์ต้นทาง เช่น ไฟล์ต้นฉบับที่ `stuff/java/foo/bar/a.txt` จะอยู่ที่ `foo/bar/a.txt`
`runtime_deps`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ไลบรารีที่จะทําให้พร้อมใช้งานในไบนารีขั้นสุดท้ายหรือทดสอบที่รันไทม์เท่านั้น เช่นเดียวกับ `deps` ทั่วไป รายการเหล่านี้จะปรากฏใน classpath รันไทม์ แต่จะต่างจาก `deps` ตรงที่ไม่ได้ปรากฏใน classpath ขณะคอมไพล์ รายการพึ่งพาที่จำเป็นเฉพาะที่รันไทม์ควรระบุไว้ที่นี่ เครื่องมือวิเคราะห์ Dependency ควรละเว้นเป้าหมายที่ปรากฏทั้งใน `runtime_deps` และ `deps`

java_test

ดูแหล่งที่มาของกฎ

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)

กฎ java_test() จะคอมไพล์การทดสอบ Java การทดสอบคือไฟล์กลุ่มไบนารีรอบโค้ดทดสอบ ระบบจะเรียกใช้เมธอดหลักของโปรแกรมรันทดสอบแทนการคอมไพล์คลาสหลัก

เป้าหมายเอาต์พุตโดยนัย

name.jar: ที่เก็บ Java
name_deploy.jar: ไฟล์เก็บถาวร Java ที่เหมาะสมสําหรับการนําไปใช้งาน (จะสร้างขึ้นก็ต่อเมื่อมีการขออย่างชัดเจนเท่านั้น) ดูรายละเอียดเพิ่มเติมได้ในคำอธิบายname_deploy.jarเอาต์พุตจาก java_binary

ดูส่วนเกี่ยวกับอาร์กิวเมนต์ java_binary() กฎนี้ยังรองรับแอตทริบิวต์ทั่วไปทั้งหมดสำหรับกฎการทดสอบทั้งหมด ("*_test)") ด้วย

ตัวอย่าง



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",
    ],
)

อาร์กิวเมนต์

Attributes
`name`	ชื่อ ต้องระบุ ชื่อที่ไม่ซ้ำกันสำหรับเป้าหมายนี้
`deps`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการคลังอื่นๆ ที่จะลิงก์กับเป้าหมาย ดูความคิดเห็นทั่วไปเกี่ยวกับ `deps` ที่หัวข้อแอตทริบิวต์ทั่วไปที่กฎการสร้างส่วนใหญ่กำหนด
`srcs`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการไฟล์ต้นทางที่ประมวลผลเพื่อสร้างเป้าหมาย เกือบทุกครั้งจะต้องระบุแอตทริบิวต์นี้ โปรดดูข้อยกเว้นด้านล่าง คอมไพล์ไฟล์ต้นทางประเภท `.java` ในกรณีของไฟล์ `.java` ที่สร้างขึ้น โดยทั่วไปเราขอแนะนำให้ใส่ชื่อของกฎการสร้างที่นี่แทนชื่อของไฟล์ วิธีนี้ไม่เพียงช่วยปรับปรุงความอ่านง่าย แต่ยังทําให้กฎมีความยืดหยุ่นมากขึ้นเมื่อเกิดการเปลี่ยนแปลงในอนาคตด้วย เช่น หากกฎการสร้างสร้างไฟล์อื่นในอนาคต คุณก็แก้ไขได้เพียงที่เดียวเท่านั้น ซึ่งก็คือ `outs` ของกฎการสร้าง คุณไม่ควรระบุกฎการสร้างใน `deps` เนื่องจากเป็นการดำเนินการที่ไม่มีผล ระบบจะแตกไฟล์ต้นฉบับประเภท `.srcjar` และคอมไพล์ (ซึ่งมีประโยชน์ในกรณีที่คุณต้องสร้างชุดไฟล์ `.java` ด้วย genrule) กฎ: หากกฎ (โดยทั่วไปคือ `genrule` หรือ `filegroup`) สร้างไฟล์ใดไฟล์หนึ่งตามที่ระบุไว้ข้างต้น ระบบจะใช้ไฟล์ดังกล่าวในลักษณะเดียวกับที่อธิบายไว้สำหรับไฟล์ต้นทาง เกือบทุกครั้งจะต้องมีอาร์กิวเมนต์นี้ ยกเว้นในกรณีที่แอตทริบิวต์ `main_class` ระบุคลาสใน classpath รันไทม์หรือคุณระบุอาร์กิวเมนต์ `runtime_deps`
`data`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการไฟล์ที่จุลสารนี้ต้องใช้ในรันไทม์ ดูความคิดเห็นทั่วไปเกี่ยวกับ `data` ที่แอตทริบิวต์ทั่วไปที่กฎการสร้างส่วนใหญ่กำหนด
`resources`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการไฟล์ข้อมูลที่จะรวมไว้ในไฟล์ JAR ของ Java ทรัพยากรอาจเป็นไฟล์ต้นฉบับหรือไฟล์ที่สร้างขึ้น หากระบุทรัพยากร ระบบจะรวมทรัพยากรไว้ในไฟล์ jar พร้อมกับไฟล์ `.class` ปกติที่เกิดจากการคอมไพล์ ตำแหน่งของทรัพยากรภายในไฟล์ jar จะกำหนดโดยโครงสร้างโปรเจ็กต์ ก่อนอื่น Bazel จะมองหาเลย์เอาต์ไดเรกทอรีมาตรฐานของ Maven (ไดเรกทอรี "src" ตามด้วยไดเรกทอรี "resources" ซึ่งเป็นไดเรกทอรีย่อย) หากไม่พบ ทาง Bazel จะค้นหาไดเรกทอรีระดับบนสุดที่ชื่อ "java" หรือ "javatests" (เช่น หากทรัพยากรอยู่ที่ `<workspace root>/x/java/y/java/z` เส้นทางของทรัพยากรจะเป็น `y/java/z` ไม่สามารถลบล้างการคาดคะเนนี้ได้ แต่สามารถใช้แอตทริบิวต์ `resource_strip_prefix` เพื่อระบุไดเรกทอรีอื่นที่เจาะจงสำหรับไฟล์ทรัพยากรได้
`add_exports`	รายการสตริง ค่าเริ่มต้นคือ `[]` อนุญาตให้คลังนี้เข้าถึง `module` หรือ `package` ที่ระบุ ซึ่งสอดคล้องกับ Flag javac และ JVM --add-exports=
`add_opens`	รายการสตริง ค่าเริ่มต้นคือ `[]` อนุญาตให้ไลบรารีนี้เข้าถึง `module` หรือ `package` ที่ระบุโดยอัตโนมัติ ซึ่งสอดคล้องกับ Flag javac และ JVM --add-opens=
`bootclasspath`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` API ที่จำกัด โปรดอย่าใช้
`classpath_resources`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` อย่าใช้ตัวเลือกนี้ เว้นแต่จะไม่มีวิธีอื่น) รายการทรัพยากรที่ต้องอยู่ที่รูทของต้นไม้ Java วัตถุประสงค์เดียวของแอตทริบิวต์นี้คือเพื่อรองรับไลบรารีของบุคคลที่สามที่กำหนดให้ต้องพบทรัพยากรของไลบรารีใน classpath เป็น `"myconfig.xml"` เท่านั้น ใช้ได้เฉพาะในไบนารีเท่านั้น และไม่ใช้ในไลบรารีเนื่องจากมีความเสี่ยงที่จะเกิดความขัดแย้งของเนมสเปซ
`create_executable`	บูลีน ค่าเริ่มต้นคือ `True` เลิกใช้งานแล้ว โปรดใช้ `java_single_jar` แทน
`deploy_manifest_lines`	รายการสตริง ค่าเริ่มต้นคือ `[]` รายการบรรทัดที่จะเพิ่มลงในไฟล์ `META-INF/manifest.mf` ที่สร้างขึ้นสําหรับเป้าหมาย `_deploy.jar` เนื้อหาของแอตทริบิวต์นี้ไม่*อยู่ภายใต้การแทนที่ด้วย"สร้างตัวแปร"
`javacopts`	รายการสตริง ค่าเริ่มต้นคือ `[]` ตัวเลือกเพิ่มเติมสำหรับคอมไพเลอร์ของไบนารีนี้ ขึ้นอยู่กับการแทนที่ "Make variable" และการแยกออกเป็นโทเค็นของ Bourne shell ระบบจะส่งตัวเลือกคอมไพเลอร์เหล่านี้ไปยัง javac หลังจากตัวเลือกคอมไพเลอร์ส่วนกลาง
`jvm_flags`	รายการสตริง ค่าเริ่มต้นคือ `[]` รายการ Flag ที่จะฝังในสคริปต์ Wrapper ที่สร้างขึ้นเพื่อเรียกใช้ไบนารีนี้ ขึ้นอยู่กับการแทนที่ $(location) และ "Make variable" และ การแยกคำของ Bourne shell สคริปต์ Wrapper สําหรับไบนารี Java จะมีการกําหนด CLASSPATH (เพื่อค้นหา JAR ทั้งหมดที่ต้องพึ่งพา) และเรียกใช้โปรแกรมแปลภาษา Java ที่ถูกต้อง บรรทัดคำสั่งที่สร้างขึ้นโดยสคริปต์ Wrapper จะมีชื่อของคลาสหลักตามด้วย `"$@"` เพื่อให้คุณส่งอาร์กิวเมนต์อื่นๆ ต่อจากชื่อคลาสได้ อย่างไรก็ตาม คุณต้องระบุอาร์กิวเมนต์ที่มีไว้สำหรับการแยกวิเคราะห์โดย JVM ก่อนชื่อคลาสในบรรทัดคำสั่ง ระบบจะเพิ่มเนื้อหาของ `jvm_flags` ลงในสคริปต์ Wrapper ก่อนแสดงชื่อคลาส โปรดทราบว่าแอตทริบิวต์นี้ไม่มีผลต่อเอาต์พุต `*_deploy.jar`
`launcher`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ระบุไบนารีที่จะใช้เรียกใช้โปรแกรม Java แทนโปรแกรม `bin/java` ปกติที่มาพร้อมกับ JDK เป้าหมายต้องเป็น `cc_binary` คุณสามารถระบุ `cc_binary` ใดก็ได้ที่ใช้ Invocation API ของ Java เป็นค่าสำหรับแอตทริบิวต์นี้ โดยค่าเริ่มต้น Bazel จะใช้ตัวเปิด JDK ปกติ (bin/java หรือ java.exe) Flag `--java_launcher` ของ Bazel ที่เกี่ยวข้องจะมีผลกับเป้าหมาย `java_binary` และ `java_test` เท่านั้นที่ไม่ได้ระบุแอตทริบิวต์ `launcher` โปรดทราบว่าระบบจะสร้างการพึ่งพาแบบเนทีฟ (C++, SWIG, JNI) แตกต่างกันไป ขึ้นอยู่กับว่าคุณใช้ Launcher ของ JDK หรือ Launcher อื่น หากคุณใช้ตัวเปิด JDK ปกติ (ค่าเริ่มต้น) ระบบจะสร้าง Dependency เดิมเป็นไลบรารีที่ใช้ร่วมกันชื่อ `{name}_nativedeps.so` โดยที่ `{name}` เป็นแอตทริบิวต์ `name` ของกฎ java_binary นี้ เครื่องมือลิงก์จะไม่นำโค้ดที่ไม่ได้ใช้ออกในการกำหนดค่านี้ หากคุณใช้ Launcher อื่น ระบบจะลิงก์ไลบรารีแบบเนทีฟ (C++) แบบคงที่ไปยังไบนารีชื่อ `{name}_nativedeps` โดยที่ `{name}` เป็นแอตทริบิวต์ `name` ของกฎ java_binary นี้ ในกรณีนี้ โปรแกรมลิงก์จะนำโค้ดที่คิดว่าไม่ได้ใช้ออกจากไบนารีที่ได้ ซึ่งหมายความว่าระบบอาจไม่ลิงก์โค้ด C++ ที่เข้าถึงได้ผ่าน JNI เท่านั้น เว้นแต่เป้าหมาย `cc_library` จะระบุ `alwayslink = True` เมื่อใช้ Launcher อื่นที่ไม่ใช่ Launcher JDK เริ่มต้น รูปแบบของเอาต์พุต `*_deploy.jar` จะเปลี่ยนไป ดูรายละเอียดได้ในเอกสารหลักของ java_binary
`main_class`	สตริง ค่าเริ่มต้นคือ `""` ชื่อคลาสที่มีเมธอด `main()` เพื่อใช้เป็นจุดแรกเข้า หากกฎใช้ตัวเลือกนี้ ก็ไม่จำเป็นต้องมีรายการ `srcs=[...]` ดังนั้น คุณจึงสร้างไฟล์ปฏิบัติการจากไลบรารี Java ที่มีเมธอด `main()` อย่างน้อย 1 รายการอยู่แล้วได้โดยใช้แอตทริบิวต์นี้ ค่าของแอตทริบิวต์นี้คือชื่อคลาส ไม่ใช่ไฟล์ต้นฉบับ คลาสต้องพร้อมใช้งานที่รันไทม์ โดยอาจคอมไพล์โดยกฎนี้ (จาก `srcs`) หรือจัดหาโดยข้อกําหนดโดยตรงหรือแบบสื่อกลาง (ผ่าน `runtime_deps` หรือ `deps`) หากคลาสไม่พร้อมใช้งาน ไฟล์ไบนารีจะใช้งานไม่ได้ที่รันไทม์ จะไม่มีการตรวจสอบเวลาสร้าง
`neverlink`	บูลีน ค่าเริ่มต้นคือ `False`
`plugins`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ปลั๊กอินคอมไพเลอร์ Java เพื่อเรียกใช้ขณะคอมไพล์ ระบบจะเรียกใช้ `java_plugin` ทั้งหมดที่ระบุในแอตทริบิวต์นี้ทุกครั้งที่สร้างกฎนี้ ไลบรารียังรับช่วงปลั๊กอินจาก Dependency ที่ใช้ `exported_plugins` ได้ด้วย ทรัพยากรที่ปลั๊กอินสร้างขึ้นจะรวมอยู่ในไฟล์ jar ของกฎนี้
`resource_strip_prefix`	สตริง ค่าเริ่มต้นคือ `""` คำนำหน้าเส้นทางที่จะตัดออกจากทรัพยากร Java หากระบุไว้ ระบบจะนำคำนำหน้าเส้นทางนี้ออกจากทุกไฟล์ในแอตทริบิวต์ `resources` ไฟล์ทรัพยากรที่ไม่ได้อยู่ในไดเรกทอรีนี้จะทำให้เกิดข้อผิดพลาด หากไม่ได้ระบุ (ค่าเริ่มต้น) ระบบจะกำหนดเส้นทางของไฟล์ทรัพยากรตามตรรกะเดียวกับแพ็กเกจ Java ของไฟล์ต้นทาง เช่น ไฟล์ต้นฉบับที่ `stuff/java/foo/bar/a.txt` จะอยู่ที่ `foo/bar/a.txt`
`runtime_deps`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ไลบรารีที่จะทําให้พร้อมใช้งานในไบนารีขั้นสุดท้ายหรือทดสอบที่รันไทม์เท่านั้น เช่นเดียวกับ `deps` ทั่วไป รายการเหล่านี้จะปรากฏใน classpath รันไทม์ แต่จะต่างจาก `deps` ตรงที่ไม่ได้ปรากฏใน classpath ขณะคอมไพล์ รายการพึ่งพาที่จำเป็นเฉพาะที่รันไทม์ควรระบุไว้ที่นี่ เครื่องมือวิเคราะห์ Dependency ควรละเว้นเป้าหมายที่ปรากฏทั้งใน `runtime_deps` และ `deps`
`stamp`	จํานวนเต็ม ค่าเริ่มต้นคือ `0` ว่าจะเข้ารหัสข้อมูลบิลด์ลงในไบนารีหรือไม่ ค่าที่เป็นไปได้ ได้แก่ `stamp = 1`: ประทับข้อมูลบิลด์ลงในไบนารีเสมอ แม้ในบิลด์ `--nostamp` ก็ตาม คุณควรหลีกเลี่ยงการตั้งค่านี้ เนื่องจากอาจทำให้แคชระยะไกลสําหรับไบนารีและการดำเนินการดาวน์สตรีมใดๆ ที่ขึ้นอยู่กับแคชนั้นใช้งานไม่ได้ `stamp = 0`: แทนที่ข้อมูลบิลด์ด้วยค่าคงที่เสมอ ซึ่งจะช่วยแคชผลลัพธ์การสร้างที่ดี `stamp = -1`: การฝังข้อมูลบิลด์จะควบคุมโดย Flag `--[no]stamp` ระบบจะไม่สร้างไฟล์ไบนารีที่มีตราประทับอีกครั้ง เว้นแต่จะมีการเปลี่ยนแปลงทรัพยากร Dependency
`test_class`	สตริง ค่าเริ่มต้นคือ `""` คลาส Java ที่โปรแกรมรันทดสอบจะโหลด โดยค่าเริ่มต้น หากไม่ได้กําหนดอาร์กิวเมนต์นี้ ระบบจะใช้โหมดเดิมและใช้อาร์กิวเมนต์ทดสอบแทน ตั้งค่า Flag `--nolegacy_bazel_java_test` เพื่อไม่ให้ใช้อาร์กิวเมนต์แรก แอตทริบิวต์นี้ระบุชื่อคลาส Java ที่การทดสอบนี้จะเรียกใช้ คุณไม่จำเป็นต้องตั้งค่านี้บ่อยนัก หากไม่ระบุอาร์กิวเมนต์นี้ ระบบจะอนุมานโดยใช้ `name` ของเป้าหมายและเส้นทางที่สัมพันธ์กับรูทของแหล่งที่มา หากการทดสอบอยู่นอกรูทแหล่งที่มาที่รู้จัก Bazel จะรายงานข้อผิดพลาดหากไม่ได้ตั้งค่า `test_class` สำหรับ JUnit3 คลาสทดสอบต้องเป็นคลาสย่อยของ `junit.framework.TestCase` หรือต้องมีเมธอด `suite()` แบบคงที่แบบสาธารณะที่แสดงผล `junit.framework.Test` (หรือคลาสย่อยของ `Test`) สำหรับ JUnit4 คลาสต้องมีการกำกับหมายด้วย `org.junit.runner.RunWith` แอตทริบิวต์นี้ช่วยให้กฎ `java_test` หลายรายการใช้ `Test` เดียวกันได้ (`TestCase`, `TestSuite`, ...) โดยปกติแล้ว ระบบจะส่งข้อมูลเพิ่มเติมไปยังแอตทริบิวต์นี้ (เช่น ผ่าน `jvm_flags=['-Dkey=value']`) เพื่อให้ลักษณะการทํางานแตกต่างกันไปในแต่ละกรณี เช่น การเรียกใช้ชุดทดสอบย่อยอื่น แอตทริบิวต์นี้ยังเปิดใช้การทดสอบ Java นอกต้นไม้ `javatests` ด้วย
`use_launcher`	บูลีน ค่าเริ่มต้นคือ `True` ระบุว่าไบนารีควรใช้ตัวเปิดที่กำหนดเองหรือไม่ หากตั้งค่าแอตทริบิวต์นี้เป็น "เท็จ" ระบบจะไม่สนใจแอตทริบิวต์launcher และ Flag `--java_launcher` ที่เกี่ยวข้องสำหรับเป้าหมายนี้
`use_testrunner`	บูลีน ค่าเริ่มต้นคือ `True` ใช้คลาสโปรแกรมทดสอบ (โดยค่าเริ่มต้นคือ `com.google.testing.junit.runner.BazelTestRunner`) เป็นจุดแรกเข้าหลักสำหรับโปรแกรม Java และระบุคลาสทดสอบให้กับโปรแกรมทดสอบเป็นค่าของพร็อพเพอร์ตี้ระบบ `bazel.test_suite` คุณใช้ตัวเลือกนี้เพื่อลบล้างลักษณะการทํางานเริ่มต้นได้ ซึ่งก็คือการใช้โปรแกรมรันทดสอบสําหรับกฎ `java_test` และไม่ได้ใช้สําหรับกฎ `java_binary` คุณไม่น่าจะต้องดำเนินการนี้ การใช้งานอย่างหนึ่งคือสำหรับ`AllTest` กฎที่เรียกใช้โดยกฎอื่น (เช่น เพื่อตั้งค่าฐานข้อมูลก่อนทำการทดสอบ) คุณต้องประกาศ`AllTest` กฎเป็น `java_binary` แต่ควรใช้โปรแกรมรันทดสอบเป็นจุดแรกเข้าหลัก คุณลบล้างชื่อคลาสโปรแกรมรันทดสอบได้ด้วยแอตทริบิวต์ `main_class`

java_package_configuration

ดูแหล่งที่มาของกฎ

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

การกําหนดค่าที่จะใช้กับชุดแพ็กเกจ คุณสามารถเพิ่มการกําหนดค่าลงในjava_toolchain.javacoptsได้

ตัวอย่าง



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",
    ]
)

อาร์กิวเมนต์

Attributes
`name`	ชื่อ ต้องระบุ ชื่อที่ไม่ซ้ำกันสำหรับเป้าหมายนี้
`data`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการไฟล์ที่จําเป็นสําหรับการกําหนดค่านี้เมื่อรันไทม์
`javacopts`	รายการสตริง ค่าเริ่มต้นคือ `[]` แฟล็กคอมไพเลอร์ Java
`output_licenses`	รายการสตริง ค่าเริ่มต้นคือ `[]`
`packages`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ชุด `package_group` ที่ควรใช้การกําหนดค่า
`system`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` สอดคล้องกับ Flag --system ของ javac

java_plugin

ดูแหล่งที่มาของกฎ

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 กำหนดปลั๊กอินสำหรับคอมไพเลอร์ Java ที่ Bazel เรียกใช้ ปลั๊กอินประเภทเดียวที่รองรับคือตัวประมวลผลคำอธิบายประกอบ กฎ java_library หรือ java_binary สามารถเรียกใช้ปลั๊กอินโดยอาศัยปลั๊กอินผ่านแอตทริบิวต์ plugins นอกจากนี้ java_library ยังส่งออกปลั๊กอินไปยังไลบรารีที่ขึ้นต่อกันโดยตรงได้โดยใช้ exported_plugins โดยอัตโนมัติ

เป้าหมายเอาต์พุตโดยนัย

libname.jar: ที่เก็บ Java

อาร์กิวเมนต์จะเหมือนกับ java_library ยกเว้นการใส่อาร์กิวเมนต์ processor_class

อาร์กิวเมนต์

Attributes
`name`	ชื่อ ต้องระบุ ชื่อที่ไม่ซ้ำกันสำหรับเป้าหมายนี้
`deps`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการคลังที่จะลิงก์กับคลังนี้ ดูความคิดเห็นทั่วไปเกี่ยวกับ `deps` ที่หัวข้อแอตทริบิวต์ทั่วไปที่กฎการสร้างส่วนใหญ่กำหนด Jar ที่สร้างขึ้นโดยกฎ `java_library` รายการใน `deps` จะอยู่ใน classpath ของเวลาคอมไพล์ของกฎนี้ นอกจากนี้ การปิดเชิงสื่อกลางของ `deps`, `runtime_deps` และ `exports` จะอยู่ใน classpath รันไทม์ ในทางตรงกันข้าม เป้าหมายในแอตทริบิวต์ `data` จะรวมอยู่ในไฟล์รันไทม์ แต่ไม่รวมอยู่ในคลาสพาธของเวลาคอมไพล์หรือรันไทม์
`srcs`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการไฟล์ต้นทางที่ประมวลผลเพื่อสร้างเป้าหมาย เกือบทุกครั้งจะต้องระบุแอตทริบิวต์นี้ โปรดดูข้อยกเว้นด้านล่าง คอมไพล์ไฟล์ต้นทางประเภท `.java` ในกรณีของไฟล์ `.java` ที่สร้างขึ้น โดยทั่วไปเราขอแนะนำให้ใส่ชื่อของกฎการสร้างที่นี่แทนชื่อของไฟล์ วิธีนี้ไม่เพียงช่วยปรับปรุงความอ่านง่าย แต่ยังทําให้กฎมีความยืดหยุ่นมากขึ้นเมื่อเกิดการเปลี่ยนแปลงในอนาคตด้วย เช่น หากกฎการสร้างสร้างไฟล์อื่นในอนาคต คุณก็แก้ไขได้เพียงที่เดียวเท่านั้น ซึ่งก็คือ `outs` ของกฎการสร้าง คุณไม่ควรระบุกฎการสร้างใน `deps` เนื่องจากเป็นการดำเนินการที่ไม่มีผล ระบบจะแตกไฟล์ต้นฉบับประเภท `.srcjar` และคอมไพล์ (ซึ่งมีประโยชน์ในกรณีที่คุณต้องสร้างชุดไฟล์ `.java` ด้วย genrule) กฎ: หากกฎ (โดยทั่วไปคือ `genrule` หรือ `filegroup`) สร้างไฟล์ใดไฟล์หนึ่งตามที่ระบุไว้ข้างต้น ระบบจะใช้ไฟล์ดังกล่าวในลักษณะเดียวกับที่อธิบายไว้สำหรับไฟล์ต้นทาง ระบบจะถือว่าไฟล์ต้นทางประเภท `.properties` เป็นทรัพยากร ระบบจะไม่สนใจไฟล์อื่นๆ ทั้งหมด ตราบใดที่มีไฟล์อย่างน้อย 1 ไฟล์ในประเภทไฟล์ที่อธิบายไว้ข้างต้น มิฉะนั้น ระบบจะแสดงข้อผิดพลาด คุณต้องระบุอาร์กิวเมนต์นี้เกือบทุกครั้ง เว้นแต่คุณจะระบุอาร์กิวเมนต์ `runtime_deps`
`data`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการไฟล์ที่จุลสารนี้ต้องใช้ในรันไทม์ ดูความคิดเห็นทั่วไปเกี่ยวกับ `data` ที่หัวข้อแอตทริบิวต์ทั่วไปที่กฎการสร้างส่วนใหญ่กำหนด เมื่อสร้าง `java_library` ทาง Bazel จะไม่วางไฟล์เหล่านี้ไว้ที่ใดเลย หากไฟล์ `data` เป็นไฟล์ที่สร้างขึ้น Bazel ก็จะสร้างไฟล์เหล่านั้น เมื่อสร้างการทดสอบที่ขึ้นอยู่กับ `java_library` นี้ Bazel จะคัดลอกหรือลิงก์ไฟล์ `data` ไปยังพื้นที่ runfiles
`resources`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการไฟล์ข้อมูลที่จะรวมไว้ในไฟล์ JAR ของ Java ทรัพยากรอาจเป็นไฟล์ต้นฉบับหรือไฟล์ที่สร้างขึ้น หากระบุทรัพยากร ระบบจะรวมทรัพยากรไว้ในไฟล์ jar พร้อมกับไฟล์ `.class` ปกติที่เกิดจากการคอมไพล์ ตำแหน่งของทรัพยากรภายในไฟล์ jar จะกำหนดโดยโครงสร้างโปรเจ็กต์ ก่อนอื่น Bazel จะมองหาเลย์เอาต์ไดเรกทอรีมาตรฐานของ Maven (ไดเรกทอรี "src" ตามด้วยไดเรกทอรี "resources" ซึ่งเป็นไดเรกทอรีย่อย) หากไม่พบ ทาง Bazel จะค้นหาไดเรกทอรีระดับบนสุดที่ชื่อ "java" หรือ "javatests" (เช่น หากทรัพยากรอยู่ที่ `<workspace root>/x/java/y/java/z` เส้นทางของทรัพยากรจะเป็น `y/java/z` ไม่สามารถลบล้างการคาดคะเนนี้ได้ แต่สามารถใช้แอตทริบิวต์ `resource_strip_prefix` เพื่อระบุไดเรกทอรีอื่นที่เจาะจงสำหรับไฟล์ทรัพยากรได้
`add_exports`	รายการสตริง ค่าเริ่มต้นคือ `[]` อนุญาตให้คลังนี้เข้าถึง `module` หรือ `package` ที่ระบุ ซึ่งสอดคล้องกับ Flag javac และ JVM --add-exports=
`add_opens`	รายการสตริง ค่าเริ่มต้นคือ `[]` อนุญาตให้ไลบรารีนี้เข้าถึง `module` หรือ `package` ที่ระบุโดยอัตโนมัติ ซึ่งสอดคล้องกับ Flag javac และ JVM --add-opens=
`bootclasspath`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` API ที่จำกัด โปรดอย่าใช้
`generates_api`	บูลีน ค่าเริ่มต้นคือ `False` แอตทริบิวต์นี้ทำเครื่องหมายตัวประมวลผลคำอธิบายประกอบที่สร้างโค้ด API หากกฎใช้ตัวประมวลผลคำอธิบายประกอบที่สร้าง API กฎอื่นๆ ที่ขึ้นอยู่กับกฎดังกล่าวจะอ้างอิงโค้ดที่สร้างขึ้นได้ก็ต่อเมื่อมีการตั้งเวลาการดำเนินการคอมไพล์ไว้หลังกฎที่สร้าง แอตทริบิวต์นี้บอกให้ Bazel ระบุข้อจำกัดการกําหนดเวลาเมื่อเปิดใช้ --java_header_compilation คำเตือน: แอตทริบิวต์นี้ส่งผลต่อประสิทธิภาพของบิลด์ ให้ใช้เฉพาะในกรณีที่จำเป็น
`javabuilder_jvm_flags`	รายการสตริง ค่าเริ่มต้นคือ `[]` API ที่จำกัด โปรดอย่าใช้
`javacopts`	รายการสตริง ค่าเริ่มต้นคือ `[]` ตัวเลือกคอมไพเลอร์เพิ่มเติมสำหรับไลบรารีนี้ ขึ้นอยู่กับการแทนที่ "Make variable" และการแยกออกเป็นโทเค็นของ Bourne shell ระบบจะส่งตัวเลือกคอมไพเลอร์เหล่านี้ไปยัง javac หลังจากตัวเลือกคอมไพเลอร์ส่วนกลาง
`neverlink`	บูลีน ค่าเริ่มต้นคือ `False` ควรใช้ไลบรารีนี้สำหรับการคอมไพล์เท่านั้นและไม่ควรใช้ในรันไทม์ มีประโยชน์ในกรณีที่สภาพแวดล้อมรันไทม์จะจัดหาไลบรารีระหว่างการดำเนินการ ตัวอย่างของไลบรารีดังกล่าว ได้แก่ IDE API สําหรับปลั๊กอิน IDE หรือ `tools.jar` สําหรับทุกอย่างที่ทํางานบน JDK มาตรฐาน โปรดทราบว่า `neverlink = True` ไม่ได้ป้องกันไม่ให้คอมไพเลอร์ฝังเนื้อหาจากไลบรารีนี้ลงในเป้าหมายการคอมไพล์ที่ขึ้นอยู่กับไลบรารีดังกล่าว ตามที่ข้อกำหนดภาษา Java อนุญาต (เช่น `static final` ค่าคงที่ของ `String` หรือของประเภทพื้นฐาน) ดังนั้น Use Case ที่แนะนำคือเมื่อไลบรารีรันไทม์เหมือนกับไลบรารีการคอมไพล์ หากไลบรารีรันไทม์แตกต่างจากไลบรารีการคอมไพล์ คุณต้องตรวจสอบว่าไลบรารีดังกล่าวแตกต่างกันเฉพาะในส่วนที่ JLS ห้ามไม่ให้คอมไพเลอร์ฝัง (และข้อกำหนดนี้ต้องใช้ได้กับ JLS เวอร์ชันทั้งหมดในอนาคต)
`output_licenses`	รายการสตริง ค่าเริ่มต้นคือ `[]`
`plugins`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ปลั๊กอินคอมไพเลอร์ Java เพื่อเรียกใช้ขณะคอมไพล์ ระบบจะเรียกใช้ `java_plugin` ทั้งหมดที่ระบุในแอตทริบิวต์นี้ทุกครั้งที่สร้างกฎนี้ ไลบรารียังรับช่วงปลั๊กอินจาก Dependency ที่ใช้ `exported_plugins` ได้ด้วย ทรัพยากรที่ปลั๊กอินสร้างขึ้นจะรวมอยู่ในไฟล์ jar ของกฎนี้
`processor_class`	สตริง ค่าเริ่มต้นคือ `""` คลาสตัวประมวลผลคือประเภทที่มีคุณสมบัติครบถ้วนของคลาสที่คอมไพเลอร์ Java ควรใช้เป็นจุดแรกเข้าไปยังตัวประมวลผลคําอธิบายประกอบ หากไม่ได้ระบุ กฎนี้จะไม่ส่งผ่านโปรแกรมประมวลผลคําอธิบายประกอบไปยังการประมวลผลคําอธิบายประกอบของคอมไพเลอร์ Java แต่เส้นทางคลาสรันไทม์จะยังคงรวมอยู่ในเส้นทางโปรแกรมประมวลผลคําอธิบายประกอบของคอมไพเลอร์ (มีไว้สำหรับปลั๊กอินที่มีแนวโน้มที่จะเกิดข้อผิดพลาดเป็นหลัก ซึ่งจะโหลดจากเส้นทางตัวประมวลผลคำอธิบายประกอบโดยใช้ java.util.ServiceLoader)
`proguard_specs`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ไฟล์ที่จะใช้เป็นข้อกำหนดของ Proguard ซึ่งจะอธิบายชุดข้อมูลจำเพาะที่ Proguard จะใช้ หากระบุไว้ ระบบจะเพิ่มลงในเป้าหมาย `android_binary` ใดก็ได้โดยขึ้นอยู่กับคลังนี้ ไฟล์ที่รวมอยู่ที่นี่ต้องมีเฉพาะกฎแบบซ้ำซ้อน ซึ่งได้แก่ -dontnote, -dontwarn, assumenosideeffects และกฎที่ขึ้นต้นด้วย -keep ตัวเลือกอื่นๆ จะปรากฏใน proguard_specs ของ `android_binary` เท่านั้น เพื่อให้การผสานไม่ซ้ำกัน
`resource_strip_prefix`	สตริง ค่าเริ่มต้นคือ `""` คำนำหน้าเส้นทางที่จะตัดออกจากทรัพยากร Java หากระบุไว้ ระบบจะนำคำนำหน้าเส้นทางนี้ออกจากทุกไฟล์ในแอตทริบิวต์ `resources` ไฟล์ทรัพยากรที่ไม่ได้อยู่ในไดเรกทอรีนี้จะทำให้เกิดข้อผิดพลาด หากไม่ได้ระบุ (ค่าเริ่มต้น) ระบบจะกำหนดเส้นทางของไฟล์ทรัพยากรตามตรรกะเดียวกับแพ็กเกจ Java ของไฟล์ต้นทาง เช่น ไฟล์ต้นฉบับที่ `stuff/java/foo/bar/a.txt` จะอยู่ที่ `foo/bar/a.txt`

java_runtime

ดูแหล่งที่มาของกฎ

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)

ระบุการกําหนดค่าสําหรับรันไทม์ Java

ตัวอย่าง



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

อาร์กิวเมนต์

Attributes
`name`	ชื่อ ต้องระบุ ชื่อที่ไม่ซ้ำกันสำหรับเป้าหมายนี้
`srcs`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ไฟล์ทั้งหมดในรันไทม์
`default_cds`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ที่เก็บ CDS เริ่มต้นสําหรับ `java_runtime` แบบปิด เมื่อเปิดใช้การแยกส่วนสำหรับเป้าหมาย `java_binary` ระบบจะแพ็กเกจ CDS เริ่มต้นของ `java_runtime` ใน JAR การติดตั้งแบบแยกส่วน
`hermetic_srcs`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ไฟล์ในรันไทม์ที่จําเป็นสําหรับการติดตั้งใช้งานแบบปิด
`hermetic_static_libs`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ไลบรารีที่ลิงก์แบบคงที่กับตัวเปิดใช้สําหรับการติดตั้งแบบปิด
`java`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` เส้นทางไปยังไฟล์ปฏิบัติการ Java
`java_home`	สตริง ค่าเริ่มต้นคือ `""` เส้นทางไปยังรูทของรันไทม์ ขึ้นอยู่กับการแทนที่ตัวแปร"Make" หากเส้นทางนี้เป็นเส้นทางสัมบูรณ์ กฎจะหมายถึงรันไทม์ Java ที่ไม่ปิดผนึกซึ่งมีเส้นทางที่รู้จักกันดี ในกรณีนี้ แอตทริบิวต์ `srcs` และ `java` ต้องว่างเปล่า
`lib_ct_sym`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ไฟล์ lib/ct.sym ที่จําเป็นสําหรับการคอมไพล์ด้วย `--release` หากไม่ได้ระบุและไฟล์ใน `srcs` มีเพียงไฟล์เดียวที่มีเส้นทางลงท้ายด้วย `/lib/ct.sym` ระบบจะใช้ไฟล์นั้น
`lib_modules`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ไฟล์ lib/modules ที่จําเป็นสําหรับการติดตั้งใช้งานแบบปิด
`output_licenses`	รายการสตริง ค่าเริ่มต้นคือ `[]`
`version`	จํานวนเต็ม ค่าเริ่มต้นคือ `0` เวอร์ชันฟีเจอร์ของรันไทม์ Java กล่าวคือ จํานวนเต็มซึ่ง `Runtime.version().feature()` แสดงผล

java_single_jar

ดูแหล่งที่มาของกฎ

java_single_jar(name, deps, compatible_with, compress, deploy_env, deploy_manifest_lines, deprecation, distribs, exclude_build_data, exec_compatible_with, exec_properties, features, multi_release, restricted_to, tags, target_compatible_with, testonly, toolchains, visibility)

รวบรวมไลบรารีที่ใช้ร่วมกันของ Java และไฟล์ jar ไว้ในไฟล์ jar ไฟล์เดียว `java_single_jar` จะรวบรวมไลบรารีที่ใช้ร่วมกันของ Java และไฟล์ jar ไว้ในไฟล์ jar ไฟล์เดียว ซึ่งคล้ายกับ java_binary ที่ปิดใช้ทุกอย่างที่เกี่ยวข้องกับไฟล์ปฏิบัติการ และเป็นอีกทางเลือกหนึ่งสำหรับ "การแฮ็กการทำให้ใช้งานได้ของ jar" ใน java_binary ## ตัวอย่าง ```skylark load("//tools/build_defs/java_single_jar:java_single_jar.bzl", "java_single_jar") java_single_jar( name = "my_single_jar", deps = [ "//java/com/google/foo", "//java/com/google/bar", ], ) ``` เอาต์พุต: {name}.jar: Jar ไฟล์เดียวที่มีอินพุตทั้งหมด

อาร์กิวเมนต์

Attributes
`name`	ชื่อ ต้องระบุ ชื่อที่ไม่ซ้ำกันสำหรับเป้าหมายนี้
`deps`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` เป้าหมาย Java (รวมถึง java_import และ java_library) เพื่อรวบรวม Dependency แบบทรานซิทีฟ ระบบจะรวบรวมข้อมูลเกี่ยวกับสิ่งที่ต้องอาศัยรันไทม์ผ่าน deps, exports และ runtime_deps และยังมีการรวบรวมทรัพยากรด้วย แต่จะไม่รวม cc_library หรือ java_wrap_cc ดั้งเดิม
`compress`	สตริง ค่าเริ่มต้นคือ `"preserve"` ไม่ว่าจะให้ปล่อยลมเสมอ ("ใช่") จัดเก็บเสมอ ("ไม่") หรือส่งผ่านโดยไม่มีการแก้ไข ("เก็บรักษา") ค่าเริ่มต้นคือ "preserve" และเป็นตัวเลือกที่มีประสิทธิภาพมากที่สุด เนื่องจากไม่ต้องดำเนินการเพิ่มเติมเพื่อขยายหรือยุบ
`deploy_env`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการเป้าหมาย `java_binary` หรือ `java_single_jar` ที่แสดงถึงสภาพแวดล้อมการทําให้ใช้งานได้สําหรับไบนารีนี้ ตั้งค่าแอตทริบิวต์นี้เมื่อสร้างปลั๊กอินที่จะโหลดโดย "java_binary" อื่น ระบบจะไม่รวมการพึ่งพา "deploy_env" ไว้ในไฟล์ jar ที่สร้างขึ้นโดยกฎนี้
`deploy_manifest_lines`	รายการสตริง ค่าเริ่มต้นคือ `[]` รายการบรรทัดที่จะเพิ่มลงในไฟล์ `META-INF/manifest.mf`
`exclude_build_data`	บูลีน ค่าเริ่มต้นคือ `True` ละเว้นไฟล์ build-data.properties ที่สร้างขึ้นโดยค่าเริ่มต้นหรือไม่
`multi_release`	บูลีน ค่าเริ่มต้นคือ `True` การเปิดใช้ไฟล์ jar เอาต์พุตแบบหลายรุ่น

java_toolchain

ดูแหล่งที่มาของกฎ

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, 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)

ระบุการกําหนดค่าสําหรับคอมไพเลอร์ Java คุณเปลี่ยนเครื่องมือทางเทคนิคที่จะใช้ผ่านอาร์กิวเมนต์ --java_toolchain ได้ โดยทั่วไปแล้ว คุณไม่ควรเขียนกฎประเภทดังกล่าว เว้นแต่ว่าคุณต้องการปรับแต่งคอมไพเลอร์ Java

ตัวอย่าง

ตัวอย่างง่ายๆ มีดังนี้



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",
)

อาร์กิวเมนต์

Attributes
`name`	ชื่อ ต้องระบุ ชื่อที่ไม่ซ้ำกันสำหรับเป้าหมายนี้
`android_lint_data`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ป้ายกำกับของเครื่องมือที่ใช้ได้สำหรับการขยายป้ายกำกับใน android_lint_jvm_opts
`android_lint_jvm_opts`	รายการสตริง ค่าเริ่มต้นคือ `[]` รายการอาร์กิวเมนต์สําหรับ JVM เมื่อเรียกใช้ Android Lint
`android_lint_opts`	รายการสตริง ค่าเริ่มต้นคือ `[]` รายการอาร์กิวเมนต์ของ Android Lint
`android_lint_package_configuration`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` การกําหนดค่า Android Lint ที่ควรใช้กับกลุ่มแพ็กเกจที่ระบุ
`android_lint_runner`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ป้ายกำกับของเครื่องมือเรียกใช้ Android Lint (หากมี)
`bootclasspath`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` รายการบูตแพตธ์เป้าหมาย Java สอดคล้องกับ Flag -bootclasspath ของ javac
`compatible_javacopts`	null; ค่าเริ่มต้นคือ `{}` API ภายใน โปรดอย่าใช้
`deps_checker`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ป้ายกํากับของไฟล์ jar ที่ใช้ติดตั้ง ImportDepsChecker
`forcibly_disable_header_compilation`	บูลีน ค่าเริ่มต้นคือ `False` ลบล้าง --java_header_compilation เพื่อปิดใช้การคอมไพล์ส่วนหัวบนแพลตฟอร์มที่ไม่รองรับ เช่น JDK 7 Bazel
`genclass`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ป้ายกำกับของไฟล์ JAR สำหรับติดตั้ง GenClass
`header_compiler`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ป้ายกํากับของคอมไพเลอร์ส่วนหัว ต้องระบุหากเปิดใช้ --java_header_compilation
`header_compiler_builtin_processors`	รายการสตริง ค่าเริ่มต้นคือ `[]` API ภายใน โปรดอย่าใช้
`header_compiler_direct`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ป้ายกำกับที่ไม่บังคับของคอมไพเลอร์ส่วนหัวที่จะใช้สำหรับการดำเนินการ classpath โดยตรงซึ่งไม่รวมเครื่องประมวลผลคำอธิบายประกอบที่สร้าง API เครื่องมือนี้ไม่รองรับการประมวลผลคำอธิบายประกอบ
`ijar`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ป้ายกำกับของไฟล์ปฏิบัติการ ijar
`jacocorunner`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ป้ายกํากับของไฟล์ jar ที่ใช้ติดตั้ง JacocoCoverageRunner
`java_runtime`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` java_runtime ที่จะใช้กับชุดเครื่องมือนี้ โดยค่าเริ่มต้นคือ java_runtime ในการกำหนดค่าการเรียกใช้
`javabuilder`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ป้ายกำกับของไฟล์ jar ที่ใช้ติดตั้ง JavaBuilder
`javabuilder_data`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ป้ายกำกับของข้อมูลที่พร้อมใช้งานสำหรับการขยายป้ายกำกับใน javabuilder_jvm_opts
`javabuilder_jvm_opts`	รายการสตริง ค่าเริ่มต้นคือ `[]` รายการอาร์กิวเมนต์สําหรับ JVM เมื่อเรียก JavaBuilder
`javac_supports_multiplex_workers`	บูลีน ค่าเริ่มต้นคือ `True` จริงหาก JavaBuilder รองรับการทํางานแบบผู้ทํางานแบบคงที่แบบหลายรายการ ไม่จริงหากไม่รองรับ
`javac_supports_worker_cancellation`	บูลีน ค่าเริ่มต้นคือ `True` เป็นจริงหาก JavaBuilder รองรับการยกเลิกการทํางานแบบถาวร เป็นเท็จหากไม่รองรับ
`javac_supports_worker_multiplex_sandboxing`	บูลีน ค่าเริ่มต้นคือ `False` จริงหาก JavaBuilder รองรับการทํางานแบบหลายเวิร์กเกอร์แบบถาวรที่มีแซนด์บ็อกซ์ ไม่จริงหากไม่รองรับ
`javac_supports_workers`	บูลีน ค่าเริ่มต้นคือ `True` จริงหาก JavaBuilder รองรับการทํางานแบบต่อเนื่อง ไม่จริงหากไม่รองรับ
`javacopts`	รายการสตริง ค่าเริ่มต้นคือ `[]` รายการอาร์กิวเมนต์เพิ่มเติมสำหรับคอมไพเลอร์ Java โปรดดูรายการแฟล็กคอมไพเลอร์ Java ที่เป็นไปได้จำนวนมากในเอกสารประกอบเกี่ยวกับคอมไพเลอร์ Java
`jspecify_implicit_deps`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` เวอร์ชันทดลอง โปรดอย่าใช้
`jspecify_javacopts`	รายการสตริง ค่าเริ่มต้นคือ `[]` เวอร์ชันทดลอง โปรดอย่าใช้
`jspecify_packages`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` เวอร์ชันทดลอง โปรดอย่าใช้
`jspecify_processor`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` เวอร์ชันทดลอง โปรดอย่าใช้
`jspecify_processor_class`	สตริง ค่าเริ่มต้นคือ `""` เวอร์ชันทดลอง โปรดอย่าใช้
`jspecify_stubs`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` เวอร์ชันทดลอง โปรดอย่าใช้
`jvm_opts`	รายการสตริง ค่าเริ่มต้นคือ `[]` รายการอาร์กิวเมนต์สําหรับ JVM เมื่อเรียกใช้คอมไพเลอร์ Java โปรดดูรายการ Flag ที่เป็นไปได้ทั้งหมดสำหรับตัวเลือกนี้ในเอกสารประกอบเกี่ยวกับเครื่องเสมือนของ Java
`misc`	รายการสตริง ค่าเริ่มต้นคือ `[]` เลิกใช้งานแล้ว: ให้ใช้ javacopts แทน
`oneversion`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ป้ายกำกับของไบนารีการบังคับใช้เวอร์ชันเดียว
`oneversion_allowlist`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ป้ายกำกับของรายการที่อนุญาตเวอร์ชันเดียว
`oneversion_allowlist_for_tests`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ป้ายกำกับของรายการที่อนุญาตเวอร์ชันเดียวสำหรับการทดสอบ
`oneversion_whitelist`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` เลิกใช้งานแล้ว: ให้ใช้ oneversion_allowlist แทน
`package_configuration`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` การกําหนดค่าที่ควรใช้กับกลุ่มแพ็กเกจที่ระบุ
`proguard_allowlister`	ป้ายกํากับ ค่าเริ่มต้นคือ `"@bazel_tools//tools/jdk:proguard_whitelister"` ป้ายกำกับของรายการที่อนุญาตของ Proguard
`reduced_classpath_incompatible_processors`	รายการสตริง ค่าเริ่มต้นคือ `[]` API ภายใน โปรดอย่าใช้
`singlejar`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ป้ายกํากับของไฟล์ JAR ที่ใช้ติดตั้ง SingleJar
`source_version`	สตริง ค่าเริ่มต้นคือ `""` เวอร์ชันซอร์สโค้ด Java (เช่น '6' หรือ "7") ซึ่งจะระบุชุดโครงสร้างโค้ดที่อนุญาตในซอร์สโค้ด Java
`target_version`	สตริง ค่าเริ่มต้นคือ `""` เวอร์ชันเป้าหมาย Java (เช่น '6' หรือ "7") ซึ่งจะระบุรันไทม์ Java ที่ควรสร้างคลาส
`timezone_data`	ป้ายกํากับ ค่าเริ่มต้นคือ `None` ป้ายกำกับของไฟล์ jar ของทรัพยากรที่มีข้อมูลเขตเวลา หากตั้งค่าไว้ ระบบจะเพิ่มข้อมูลเขตเวลาเป็นข้อกำหนดรันไทม์โดยนัยของกฎ java_binary ทั้งหมด
`tools`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ป้ายกำกับของเครื่องมือที่ใช้ได้สำหรับการขยายป้ายกำกับใน jvm_opts
`turbine_data`	รายการป้ายกํากับ ค่าเริ่มต้นคือ `[]` ป้ายกำกับของข้อมูลที่พร้อมใช้งานสำหรับการขยายป้ายกำกับใน turbine_jvm_opts
`turbine_jvm_opts`	รายการสตริง ค่าเริ่มต้นคือ `[]` รายการอาร์กิวเมนต์สําหรับ JVM เมื่อเรียกใช้ Turbine
`xlint`	รายการสตริง ค่าเริ่มต้นคือ `[]` รายการคำเตือนที่จะเพิ่มหรือนำออกจากรายการเริ่มต้น นำเครื่องหมายขีดกลางไปไว้หน้ารายการเพื่อนำรายการนั้นออก โปรดดูข้อมูลเพิ่มเติมในเอกสารประกอบของ Javac เกี่ยวกับตัวเลือก -Xlint