Absolutely, both approaches are totally feasible—let’s break down which might work better for your team and how to pull them off:

Yes, you absolutely can build a tailored code generator quickly, especially since your team already has a standardized backend architecture. Here’s how to approach it efficiently:

• First, map out the core mandatory components of your team’s architecture: things like API gateway integration, database access layers (e.g., JPA, MyBatis), service discovery (e.g., Eureka, Nacos), centralized logging/monitoring, global exception handlers, and configuration file standards. Break these into reusable code snippets.
• Pick a lightweight templating tool instead of building from scratch: Tools like Freemarker, Velocity, Cookiecutter (Python), or Yeoman (Node.js) are perfect for this. They let you define parameterized templates and generate full project structures with minimal code.
• Define parameterized variables: Identify values that change per service—like service name, package structure, database type, or optional components (e.g., message queue support). These become inputs when running the generator, replacing placeholders in your templates.
• Package it as a team-friendly tool: Wrap your templates and generation logic into a simple CLI tool, or integrate it into your team’s CI/CD platform. This lets anyone on the team generate a compliant microservice skeleton with a single command.
• Start small, iterate: Build a generator for the most basic service type first (e.g., a REST API service) and test it with your team. Once that’s solid, expand it to support other service variants your team uses.

If building a generator feels like overkill right now, a base template repository is a straightforward, low-effort alternative that still enforces your team’s architecture standards:

• Build a minimal, production-ready microservice skeleton: Include all non-business components required by your team’s architecture—proper dependency setup, configuration files, base code structure, example health check endpoints, and standardized error handling. Strip out any business-specific logic.
• Mark it as a team template repository: On platforms like GitHub or GitLab, you can set this project as a Template Repository. Team members can then create new microservice repos directly from this template with one click, no manual copying needed.
• Maintain and update centrally: Whenever your team’s architecture evolves (e.g., new logging standards, updated dependency versions), you just update the template repository. New services will automatically pick up the latest standards, and existing services can reference the template for upgrades.
• Add clear documentation: Include a README that explains each component’s purpose, how to customize configurations for a new service, and best practices for adding business logic. This reduces onboarding time for new team members.

Quick Comparison #

• Go with the generator if your architecture has lots of configurable components (e.g., some services need Kafka, others don’t) or if you want to automate away repetitive setup entirely.
• Pick the template if your architecture is relatively fixed, or if you need a solution that’s easy to set up and maintain right away.

For your master’s thesis, either approach demonstrates a strong understanding of microservice standardization—you could even combine them (start with a template, then wrap it in a generator) to add a nice layer of depth to your project.

内容的提问来源于stack exchange，提问作者Hugo Vinhal