# GenerateAllSetter: an IntelliJ plugin for the boilerplate you keep retyping
> GenerateAllSetter is a Java plugin for IntelliJ IDEA and Android Studio that writes the call to a class's setter for you, generates a converter inside a method, and produces default values for List, Set and Map returns. It is a small, focused tool for a specific kind of repetitive line, and it targets recent IDE builds.
**gejun123456/intellij-generateAllSetMethod** — Intellij plugin to generate call to setter method value for class
- Repository: https://github.com/gejun123456/intellij-generateAllSetMethod
- Stars: 592 · Forks: 150
- Language: Java
- License: GPL-2.0
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/gejun123456-intellij-generateallsetmethod
## Three features, and none of them is general purpose generation
The plugin does three things, and the README lists them with a screenshot for each.
The first is generating setter default values when the cursor is on a local variable. In practice that means the plugin writes the call to a setter for the object you are pointing at, filling in whatever values it can derive, so you do not have to type the class name, the method name and the argument list by hand.
The second is generating a converter when the cursor is in a method. The screenshot is named generate_the_conveter, and the phrase suggests this is about producing a conversion call, for instance turning one type into another, at the point in the method where you need it.
The third is generating List, Set and Map return values, with the screenshot named generate_list_default_value. That is the case where a method is declared to return a collection and you need a non-null value to work with, either to return or to keep building up.
Taken together, these are three narrow shortcuts rather than a code generator. That is worth saying up front, because the name GenerateAllSetter suggests something broader. The scope is the appeal for a lot of developers: a plugin that does three tedious things quietly, rather than one that tries to model your domain.
The plugin is published on the JetBrains plugin marketplace under the identifier 9360, and the README carries badges for the marketplace version and download counts. There is also a GitHub release badge, so both channels exist.
## Installation, and the build version floor
The README is explicit that the plugin supports product build version greater than 141, and lists the products it works in: Android Studio, IntelliJ IDEA, and IntelliJ IDEA Community Edition. That version floor is a real constraint for anyone on an older IDE, and it also tells you the plugin tracks the current platform APIs rather than the legacy ones.
There are two documented installation routes.
The first uses the IDE plugin system:
```text
- Preferences(Settings) > Plugins > Browse repositories... > find"GenerateAllSetter" > Install Plugin
```
The second is manual, and it is for the case where the marketplace is not an option. You download the latest plugin zip from the GitHub releases page and then use the disk install option:
```text
- download[`lastest plugin zip`][latest-release] -> Preferences(Settings) > Plugins > Install plugin from disk...
```
The IDE is then restarted.
The manual route is the one that matters for a managed or air-gapped environment, where the plugin marketplace is unreachable and you need to distribute a zip file yourself. The README does not describe any signature verification step for that path.
The project description on the repository calls it an IntelliJ plugin to generate a call to the setter method value for a class, which matches the first feature, and the topics list includes intellij, java and andriod, the last being a typo in the repository's own topic list.
## Reading the documentation and the source layout
There is a dedicated documentation site for the plugin, hosted as a GitHub Pages site at gejun123456.github.io/intellij-generateAllSetMethod, and the README links a badge to it. The repository also has a docs/ directory at the top level, so the site is built from content that lives in the repository rather than written elsewhere.
The top level listing shows the shape of a Gradle-based IntelliJ plugin project. There is a build.gradle and a settings.gradle, a gradle/ directory and the gradlew and gradlew.bat wrappers, a src/ directory for the plugin code, and the docs directory. There is also a todo.md, which is unusual to find in a published plugin and suggests the author keeps a running list of what is not finished yet.
The screenshot/ directory holds the animated images used in the README, and _config.yml is the configuration for the GitHub Pages site rather than for the build.
The contribute section is short and gives the three steps for working on the plugin: import the project into IntelliJ, add a Gradle task named runIde, then change the code and run the task to see the change. runIde is the standard IntelliJ plugin development entry point, and running the IDE from the sandbox with the plugin loaded is how you confirm a change behaves as intended before packaging it.
The licence is GPL-2.0, held in a file named license at the root. For a plugin distributed through the JetBrains marketplace, the licence terms and the marketplace's own distribution terms both apply, which is a different arrangement from a library you pull into a build.
## The release history and what the gap between tags tells you
The listed releases are 2.8.4 on 2023-10-30, 2.8.2 on 2022-12-01 and 2.8.1 on 2022-07-08. The last push to the repository was on 2026-07-08.
That gap between the newest tag and the most recent commit is close to three years, and it is the first thing to weigh before installing. A plugin that targets IntelliJ platform APIs has to keep up with the platform, because plugin code is compiled against platform libraries and the IDE version on your machine is a moving target. The build version floor of greater than 141 shows the author does raise the floor, but the tags tell you the packaged releases are not being cut often.
There is also a missing patch version in the list, 2.8.3 is not there between 2.8.2 and 2.8.4. That is probably a tag that was never published to the marketplace rather than a release that never happened, but the list alone does not say.
What this means in practice is that the documentation site and the marketplace listing are likely a more reliable description of the current behaviour than the release notes in the repository, and that a plugin with a build version floor this high will refuse to load in an older IDE rather than misbehave. The README's own instruction to restart the IDE after installing is a reminder that plugin changes do not always take effect immediately.
The author also links two other plugins, MybatisCodeHelper-Pro and IntellijGoToStackOverFlow, which tells you the audience is Java and Android developers working with MyBatis and with stack traces, and that this plugin sits alongside a small set of similarly practical tools rather than a large catalogue.
## When this plugin helps and when it does not
The honest test of a plugin this small is whether the repetition it removes is real in your code.
The setter generation is the clearest win. Any Java codebase with DTOs, entities or builder-style classes contains a large number of lines that set one property on an object. When a constructor takes ten arguments, or when the object has a dozen fields, the line is long, easy to mistype, and completely uninteresting. Generating it removes a class of copy-paste error along with the typing.
The collection return values are the second win, in test code and in builder methods where you need an empty or default list rather than a null.
The converter generation is the one that depends on context, since the screenshot alone does not tell you which conversions are covered. This is exactly the kind of feature to evaluate on your own code rather than on the description.
The limits are equally clear. This is a plugin for one IDE family, and the listed products are the JetBrains ones, so it does nothing for you in Eclipse or in a plain Gradle build. It is a development-time aid, so it has no effect on your build output or on runtime behaviour. And the version floor means it is not usable on an older IDE at all, which rules it out on teams that have not upgraded.
For a team, the cost of adopting it is close to zero, since the plugin is installed per developer rather than added to a build, and the plugin id makes it easy to distribute through an internal plugin repository if the marketplace is not reachable.
## Conclusion
Adopt GenerateAllSetter if you work in Java in IntelliJ IDEA or Android Studio and keep writing the same kind of assignment line by hand, especially when a constructor or setter takes many arguments. Do not adopt it for code generation beyond that scope, because the three documented features are all it does. Before installing, check the build version requirement, which the README states as product build version greater than 141, and note that the newest tagged release is 2.8.4 from 2023 while the last push was on 2026-07-08, so the plugin may behave differently in a current IDE than the documentation describes.
## FAQ
### What does the GenerateAllSetter IntelliJ plugin do?
It has three documented features: generating setter default values when the cursor is on a local variable, generating a converter when the cursor is in a method, and generating List, Set and Map return values.
### Which IDEs and build versions does GenerateAllSetter support?
It supports product build version greater than 141, and the listed products are Android Studio, IntelliJ IDEA and IntelliJ IDEA Community Edition. The plugin is published on the JetBrains marketplace under the identifier 9360.
### How do I install GenerateAllSetter?
Through the IDE plugin system, by going to Preferences or Settings, then Plugins, then Browse repositories, finding GenerateAllSetter and choosing Install Plugin. Alternatively download the latest plugin zip from the GitHub releases page and use Install plugin from disk, then restart the IDE.
### How do I work on the GenerateAllSetter plugin source?
Import the project into IntelliJ, add a Gradle task named runIde, then change the code and run that task to see the change in a sandbox IDE with the plugin loaded.
### Where is the documentation for GenerateAllSetter?
At the documentation site, gejun123456.github.io/intellij-generateAllSetMethod, which is hosted as a GitHub Pages site built from the docs directory in the repository.
## Sources
- [gejun123456/intellij-generateAllSetMethod on GitHub](https://github.com/gejun123456/intellij-generateAllSetMethod)
- [Issues](https://github.com/gejun123456/intellij-generateAllSetMethod/issues)
- [License: GPL-2.0](https://github.com/gejun123456/intellij-generateAllSetMethod/blob/master/LICENSE)
- [README](https://github.com/gejun123456/intellij-generateAllSetMethod/blob/master/README.md)
- [Releases](https://github.com/gejun123456/intellij-generateAllSetMethod/releases)
---
Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/gejun123456-intellij-generateallsetmethod