Hey! These docs are for version 2.10, which is no longer officially supported. Click here for the latest version, 2.17!

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 `pants.toml`:

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 [`jvm_artifact` targets](🔗):

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 [`[jvm].resolves` option](🔗).

Thirdparty symbols and the `packages` argument

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 `group`.

The `packages` argument allows you to override which symbols a `jvm_artifact` provides. See the [`jvm_artifact` docs](🔗) for more information.

### `resource` targets

To have your code [load files as "resources"](🔗):

  1. Add a `resource` or `resources` target with the relevant files in the `source` / `sources` field, respectively.

  2. 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.

  3. Add that target to the `dependencies` field of the relevant JVM target (usually the one that uses the JVM APIs to load the resource).

For example:

## Compile code

To manually check that sources compile, use `./pants check`:

## Run tests

To run tests, use `./pants test`:

You can also pass through arguments to the test runner with `--`, e.g.:

## 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 `pants.toml`.

Once enabled, `lint` and `fmt` will check and automatically reformat your code: