The Java project I am working on currently has a complicated folder structure, and to add a new functionality, one needs to add many .java files in different places in order to let it work in our project structure. For example, when I want to add a new object User, I need to add Entity, JsonModel, Controller, Listener, Publisher.., etc. It'd be easily missed if handled manually, so I'm looking for some way to automatically generate .java files dedicated to one same object in different paths on demand.

For example, the programmer set the tool to generate .java files about User and it generates UserEntity, UserInputModel... into fit places, and then the programmer go write the actual code for those .java files.

Is there a common way to handle this problem in Java? Maybe a famous tool, or some framework? I also ain't quite sure what's the keyword I should look for on this question. Code Generation doesn't seem to mean the same, while Generate Classes leads to the similar discussions. They're both more about automatically coding or transforming natural languages into actual codes. But here I just want to automate the .java file creations, not the code in them.

I am not native English speaker, so I hope if you can, please also point me to the right word on this topic.

  • 3
    When you really need to add 6 different classes to introduce one new kind of business object, then your project might be suffering from software overengineering.
    – Philipp
    Jul 22, 2022 at 13:03
  • 1
    @Philipp maybe - or maybe the separation into 6 classes is useful because over time some or all those six classes will likely grow to to an extent where it's useful to have them separated.
    – bdsl
    Jul 22, 2022 at 14:58
  • I don't think 6 new classes is bad at all. In my current project, a new business object includes the object, its entity id, mediator pattern classes, repository and test stubs for all generated classes. This brings consistency and prevents 'forgetful' developers from creating tests.
    – Neil
    Jul 22, 2022 at 15:26
  • Many projects use a build tool or build system that not only handles compilation and generation of build artifacts (executables, JARs,...), but also pre-processing tasks like code generation. For Java I think Maven or Gradle are the most common ones, but many others exist: Visual Studio uses MSBuild, many C++ projects use CMake, etc... Many of these can support multiple languages, but a specific tool is generally better for a core set of languages that it most often used and developed with;
    – F.X.
    Jul 22, 2022 at 17:04

2 Answers 2


I think the word you're looking for is a template. Most IDEs support some kind of template mechanism; specifically in the Java world, if you happen to use IntelliJ, it supports multi-file templates that solve your exact problem. You can create a template that includes boilerplate code for all the classes you want to generate, using a variable for the object name. When you instantiate the template, it will create a bunch of files and replace the variable with the name you specify.

If you don't use IntelliJ or need to do something fancier, you can also build a custom solution based on one of the common template languages out there (IntelliJ itself uses Velocity, but there are many other options out there).

  • 1
    This is exactly the solution I am currently look for. Thank you very much! Not sure why someone downvoted this though, I am curious for reason.
    – teamol
    Jul 22, 2022 at 6:45

To automatically make .class files you compile .java files. To automatically make .java files you do something called code generation. If you do this the .java files will not be "source code" files. They will be "intermediate code" files. You should document them as that to keep people from fiddling with them.

Code generation is an old idea. Used to be Python generated C code (as it's intermediate code) that was compiled to machine code. The trick is making sure people don't edit the intermediate code thinking it's source. Once they do that things get very confusing.

If you really do have to always add 6+ classes together when making a change then code generation might be helpful. It also might be worth considering redesigning the system so you don't have to add classes that way.

  • Oops, I am really sorry, I've confused .java and .class. I meant generating .java files, for coding only. I'd be very happy to redesign the system too, but well... the design is by my bosses and I can't interfere about that too much.
    – teamol
    Jul 22, 2022 at 5:48
  • I have fixed the wording around .java files in the OP. Really sorry for the confusion!
    – teamol
    Jul 22, 2022 at 5:49
  • As for your answer, I think it's then different from what I want because the .java files generated are meant to be changed by the programmers, as they have only the minimum codes (boilerplates?) needed after generated.
    – teamol
    Jul 22, 2022 at 5:53
  • 1
    @BenCottrell Thanks for the suggestion, first time hearing about that interesting idea. The JavaPoet approach seems similar to what I was looking for.
    – teamol
    Jul 22, 2022 at 7:08
  • 1
    @XiangWeiHuang if that doesn't fit, then consider adding a concrete example to the question. Annotations are often used to generate code in that way (e.g. methods inside classes which already contains other developer-written code); indeed that code can call/use the auto-generated code despite it not being visible to developers in their IDE. (For example, Lombok generates methods called getXyz() and setXyz() -- even though developers can't actually see those methods on-screen with their own eyes, they exist and are usable just like any other method (IDEs/tools can usually see them). Jul 22, 2022 at 7:20

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.