Java and Scala support is beta stage
We are done implementing most functionality for Pants's Java and Scala support ([tracked here](🔗)). However, there may be use cases that we aren't yet handling.
Please share feedback for what you need to use Pants with your JVM project by either [opening a GitHub issue](🔗) or [joining our Slack](🔗)!
Example Java and Scala repository
Check out [github.com/pantsbuild/example-jvm](🔗) to try out Pants's Java and Scala support.
## Initial setup
First, activate the relevant backends in `
Then run [`
./pants tailor`](🔗) to generate BUILD files. This will create `
java_sources` and `
scala_sources` targets in every directory containing library code, as well as test targets like `
scalatest_tests` and `
junit_tests` for filenames that look like tests.
You can run `
./pants list ::` to see all targets in your project:
### Firstparty dependencies
In many cases, the dependencies of your firstparty code are automatically inferred via [dependency inference](🔗) based on your `
import` statements. If you do need to declare additional dependencies for any reason, you can do so using Pants' [syntax for declaring dependencies for targets](🔗).
### Thirdparty dependencies and lockfiles
Thirdparty dependencies (i.e. those from repositories like [Maven central](🔗)) are also automatically inferred via dependency inference, but must first be declared once per repository as [`
Pants requires use of a lockfile for thirdparty dependencies. After adding or editing `
jvm_artifact` targets, you will need to update affected lockfiles by running `
./pants generate-lockfiles`. The default lockfile is located at `
3rdparty/jvm/default.lock`, but it can be relocated (as well as additional resolves declared) via the [`
Thirdparty symbols and the `
To efficiently determine which symbols are provided by thirdparty code (i.e., without hitting the network in order to compute dependencies in the common case), Pants relies on a static mapping of which artifacts provide which symbols, and defaults to treating each `
jvm_artifact` as providing symbols within its `
packages` argument allows you to override which symbols a `
jvm_artifact` provides. See the [`
jvm_artifact` docs](🔗) for more information.
To have your code [load files as "resources"](🔗):
Add a `
resource` or `
resources` target with the relevant files in the `
source` / `
sources` field, respectively.
Ensure that [an appropriate `
source_root`](🔗) is detected for the `
resources` target, in order to trim the relevant prefix from the filename to align with the layout of your JVM packages.
Add that target to the `
dependencies` field of the relevant JVM target (usually the one that uses the JVM APIs to load the resource).
## Compile code
To manually check that sources compile, use `
## Run tests
To run tests, use `
You can also pass through arguments to the test runner with `
## Lint and Format
scalafmt` and `
Google Java Format` can be enabled by adding the `
pants.backend.experimental.scala.lint.scalafmt` and `
pants.backend.experimental.java.lint.google_java_format` backends (respectively) to `
backend_packages` in the `
[GLOBAL]` section of `
Once enabled, `
lint` and `
fmt` will check and automatically reformat your code: