What is the best way to configure IntelliJ to generate Javadoc automatically for methods and classes, and how can I include tags like @author and @since?
In Eclipse, this was handled automatically, but I’m not sure how to do it in IntelliJ. I know that IntelliJ supports code templates and can semi-automatically add Javadoc, but I’m looking for a setup where IntelliJ generates Javadoc by default for every new method, class, interface, enum, or field — including during actions like “extract method,” “override/implement,” or “create getter/setter.”
Is there a built-in feature or plugin in IntelliJ IDEA (I’m using version 9.0 BETA Community Edition, #IC-90.96) that can help achieve this level of automation?
If you’re coming from Eclipse, where Javadoc generation is almost second nature, switching to IntelliJ might feel like a bit of a learning curve. But, trust me, IntelliJ has some excellent tools that can help make it easier to generate Javadoc for your classes and methods.
First, let’s talk about the built-in options. IntelliJ has something called File and Code Templates, which is pretty handy for this. Here’s how you can use it:
Steps:
- Head over to Settings (or Preferences on macOS) → Editor → File and Code Templates.
- Under the Files tab, you’ll find class types (like
Class, Interface, Enum). Pick the one you want to edit.
- In the template, at the top, you can add your standard Javadoc comment structure like:
/**
* ${NAME} class description.
*
* @author ${USER}
* @since ${DATE}
*/
- For method templates, go to the Code tab and tweak the Method Body template. This can help you auto-generate Javadoc comments when you use live templates or code generation actions (like “Generate Getter/Setter”).
Why it helps: Every time you create a new class, interface, or method, IntelliJ will automatically insert your customized Javadoc template. This ensures a consistent Javadoc format for your whole project and helps you avoid forgetting important tags like @author and @since.
With these steps, IntelliJ will generate Javadoc more efficiently, saving you time and effort on manual additions.
Alright, I totally get the need for something that’s a little less hands-on than customizing templates — maybe you just need to add Javadoc here and there but want some assistance without overhauling your workflow. IntelliJ has a pretty sweet Generate feature that can help with that.
Here’s what you do:
How to use it:
- Place your cursor on a method or class where you want to generate Javadoc.
- Press Alt + Insert (or Cmd + N on macOS), then select Generate.
- From the options, pick Javadoc.
IntelliJ will generate Javadoc with a nicely formatted block for you, including parameter names and return types. It saves you the trouble of manually writing that out.
Bonus tip: If you want IntelliJ to include specific tags like @author, you can manually add them the first time, and IntelliJ will remember your style. Just copy-paste your custom tags, and next time you generate Javadoc, it will automatically use your format. So, if you’re looking for a quicker and semi-automatic solution, this method is great for adding in your essential Javadoc tags while maintaining flexibility.
If you’re hoping for even more automation — something like IntelliJ generate Javadoc on every new action (such as when you extract a method, override a method, or create a getter/setter) — you might need to rely on an external plugin to take it to the next level.
There’s a community plugin called Javadoc Generator that could be just the thing you’re looking for. It won’t fully replace the need for templates, but it offers some nice extra features:
What to do:
- Go to Settings → Plugins.
- Search for “Javadoc Generator” or similar plugins.
- Install the plugin, restart IntelliJ, and you’re all set.
Once installed, you can right-click on any class or method, and you’ll see an option to Generate Javadoc. This gives you the flexibility to add or update Javadoc across your project in bulk, and you can customize the formatting and tag structure more easily.
Why go this route: This method is especially useful if you want to enforce a consistent Javadoc style throughout a large project, or if you want to generate Javadoc in batch without doing it manually each time. Plus, you get more control over the specific tags and the overall format, so you can ensure everything follows the exact style you want.