From mobile apps to microservices, from small startups to big enterprises, Gradle helps teams build, automate and deliver better software, faster.

Gradle Community

Is there any difference between:
```plugins.withType&lt;JavaBasePlugin&gt; { ... }```
and
```plugins.withId("java-base") { ... }```
and
```pluginManager.withPlugin("java-base") { ... }```
?

I don't think so. Except that the `withType` call returns a collection, so that might potentially affect multiple applied plugins (either immediately, or deferred, which is true for all cases).

`withType` could not really affect multiple applied plugins, as every plugin can only applied once and every attempt after that is a NOP.

But if you look at the JavaDoc of `getPlugins()` (which you use by `plugins.`) you see, that even if not deprecated you should not use it at all, but `pluginManager` instead.

The problem with `plugins.withType` concretely is mainly when matching 3rd party plugins because depending on class loader in effect where it is called, you might get different class instances and so not match the plugin you intend.

With built-in plugins this should not be possible, but nevertheless, just use the recommended `pluginManager.withPlugin` and you are on the safe side. :slightly_smiling_face:

Btw. never use any `...withType&lt;...&gt; { ... }` but always `...withType&lt;...&gt;().configureEach { ... }`.
Currently it is mainly making a difference with task containers to not break task-configuration avoidance, but in case another container gets treated lazily in the future, you are already on the safe side.

Yeah, I knew already that one is preferred to the other but mixed them up.

Wrt `withType` and "multiple applied plugins", you _could_ pass a base class or an interface that could be extended/implemented by more than one plugin (e.g. all plugins from the Android Gradle Plugin extend from `com.android.build.gradle.BasePlugin`).
Kind of an edge case anyway.

Ah, yeah, that's right of course :see_no_evil: