Why do we need requires static in java-9 module system? [duplicate]

Question

I started to learn jigsaw java-9 feature and read some articles/video.

I can't understand concept of optional dependencies(requires static)

quote from article:

When a module needs to be compiled against types from another module but does not want to depend on it at run time, it can use a requires static clause. If foo requires static bar, the module system behaves different at compile and run time:

At compile time, bar must be present or there will be an error. During compilation bar is readable by foo.
At run time, bar might be absent and that will cause neither error nor warning. If it is present, it is readable by foo.

So I want to know couple of things:

1. What the reason to make module dependable on another module during compile time but not in runtime? any examples? instruments like lombok?

2. Any analogs of optional dependencies in java prior java-9 ?

P.S.

I found one more explanation: quote from article:

Sometimes we write code that references another module, but that users of our library will never want to use.

For instance, we might write a utility function that pretty-prints our internal state when another logging module is present. But, not every consumer of our library will want this functionality, and they don’t want to include an extra logging library.

In these cases, we want to use an optional dependency. By using the requires static directive, we create a compile-time-only dependency:

module my.module {
    requires static module.name;
}

But it is absolutely unclear for me. Could anyone explain it in a simple way?

Answer 1

1. There are a decent number of libraries out there where it only makes sense to have them at compile time. Mostly this deals with annotations that only exist to help during development (e.g. prevent bugs, reduce boilerplate). Some examples include:

   • java-annotations by JetBrains
   • spotbugs-annotations by SpotBugs (successor of FindBugs)
   • Project Lombok (as you mentioned)
   • jcip-annotations

   
   These annotations tend to have a RetentionPolicy of SOURCE or CLASS, which means they aren't useful (or even available) at runtime. Why ship these dependencies with the rest of your application when you deploy? Without requires static you would be forced to include them when you deploy, otherwise your application would fail to start due to missing dependencies.

2. You would declare these dependencies as optional pre-Java 9 as well. Many Java projects of any significance use a build tool such as Maven or Gradle. In addition to those tools automatically building and testing your project, a large part of what they do is dependency management. I'm not familiar enough with Maven, but when using Gradle one would use:

   dependencies {
       compileOnly 'group.id:artifact-id:version'
   }
   

   To declare dependencies that are not needed at runtime.