JEAF Generator

Features

Features

JEAF Generator realizes the link between UML models and code. It is designed for enterprise projects and provides a comprehensive feature set for implementing scalable, high-load, and high-performance applications.

JEAF Generator is delivered as a Maven plugin. All required configurations can be defined directly within the plugin configuration.


Supported UML Modeling Tools

JEAF Generator uses UML models as the single source of truth to generate code and configurations for various target platforms. Regardless of the expected output, the UML model is always the input.

Currently, the following UML modeling tools are supported:1)


1) Enterprise Architect from Sparx Systems is not supported because it does not fully implement the UML 2.5 feature set. Some of the missing features are mandatory for establishing a feature-rich, high-quality model-driven process.


General Features

Designed for Enterprise Software

  • Designed for enterprise projects with hundreds of microservices
  • Proven quality in mission-critical applications handling thousands of requests per second
  • Modularization support at both code and OpenAPI level
  • Same UML model can be used to generate code for Spring, Jakarta EE and Java EE
  • Enforces best practices and patterns (e.g., Builder Pattern, Circuit Breakers, HTTP connection pooling)
  • Generated code strictly follows the SemVer principle
  • Strong support for forward- and backward-compatible APIs (SemVer, API evolution approach)


Highest Quality

  • Mature process and generator, available for many years
  • Fast bug fixes and reliable support
  • Continuous maintenance and development (60+ releases since January 2024)
  • High-quality generated source code and OpenAPI specifications
  • No breaking changes in generated code when upgrading the plugin
  • Comprehensive documentation
  • Semantic Versioning also applied to the generator itself
  • Outstanding quality compared to other OpenAPI tools


Maven Integration

JEAF Generator is provided as a Maven plugin for seamless integration into your build process. All configurations are handled via the plugin configuration.


Additional information:


Extensibility

  • Extensive configuration options to influence generated code
  • Generated Java code can be customized manually using explicit markers in the UML model and derived properties

  • Extension hooks for standard templates

    • Standard templates (e.g., POJOs) can be extended without rewriting complete templates
    • OpenAPI specifications can also be customized
  • Easy extension with custom templates
  • Template Function API for simplified custom template development
  • Customizable code formatting
  • Configurable import ordering


Java

Java Classes

  • Immutable / read-only classes
  • Builder Pattern
  • Support for Java generics (e.g., generic response types)
  • Built-in mechanisms for backward compatibility to support SemVer compliance
  • Bi-directional 1:1, 1:n, and m:n associations (with transient back references)
  • Transient properties
  • Derived properties defined directly in the UML model
  • SoftLinks for decoupling
  • Custom prefixes for boolean properties
  • Proper handling of primitive arrays
  • Object validation in builders
  • of(…) factory methods
  • toString()
  • equals(…) and hashCode()


Enumerations

  • Support for extensible enums
  • Enum slots (enums referencing other enums)


Data Types

  • Support for data types (business wrappers for simple types) to add domain semantics
  • Optional implementation of Comparable


Validations

  • Java validation annotations
  • Validation groups
  • Code generation for custom validations


Additional Features

  • Alternate names for classes, properties, enums, and enum literals (used in reports and code comments)
  • Markdown support in comments
  • OpenAPI example values included in generated code comments
  • OpenAPI-compliant date representation in JSON
  • Deprecation annotations
  • Breaking change annotations


REST / Spring / Jakarta EE / Java EE

REST Code Generation

All technical aspects of REST services (Java code and OpenAPI specification) can be generated:

  • Service interfaces
  • REST controllers

  • REST clients (service proxies)

    • Act as Spring service proxies for external REST resources
    • Include HTTP connection pooling, circuit breakers, validation, etc.


Advanced Features

  • Generic response types for REST resources
  • Request and response validation
  • Request and response logging
  • Configurable REST libraries (Spring Web MVC, JAX-RS)
  • Configurable Enterprise Java Framework (Spring, Jakarta EE, Java EE)
  • Service proxies prevent REST-specific code from polluting business logic
  • BeanParams support for Spring (helps to implement SemVer)
  • Synchronous and reactive services
  • Role-based security (e.g., Spring Security)
  • Custom headers
  • Default operations for service interfaces


JSON / Jackson

Jackson Integration

  • Automatic generation of required Jackson annotations (if enabled)
  • Customizable serialization / deserialization behavior
  • Support for bi-directional associations
  • ID-based data deduplication


Serialization / Deserialization

  • Generation of Jackson module factories and ObjectMapper configurations
  • Custom serializers for extensible enums
  • Custom serializers for data types to ensure strong typing in Java and clean JSON representation
  • Object deduplication and pooling to reduce garbage during serialization
  • OpenAPI-compliant date representation in JSON


Jackson 2 and 3 in Parallel

To simplify migration (e.g., with Spring Boot 4), annotations for both Jackson 2 and 3 can be generated on the same classes to ensure a smooth transition.


OpenAPI

OpenAPI Specification

  • High-quality OpenAPI specification generated from the UML model
  • Avoids conflicts between Java and OpenAPI (e.g., oneOf, allOf, anyOf, inheritance, polymorphism)
  • OpenAPI specification is always consistent with generated code
  • Constraints / validations from UML model are also present in the OpenAPI specification (where possible)
  • Flat JSON representation for OpenAPI data types with strong Java typing
  • Mapping between Java generics and OpenAPI representation
  • Mapping of generic response types
  • Full support for OpenAPI 3.0 and 3.1 (configurable via a single parameter)


Modularization

  • Split OpenAPI specifications into multiple modules
  • Correct dependency handling
  • Transitive OpenAPI dependencies


Additional Features

  • Built-in mechanisms for backward compatibility (SemVer support)
  • Validation of the OpenAPI specification during the build process
  • Custom element ordering
  • Name mappings between OpenAPI/JSON and Java models (useful when integrating existing APIs)


Maven Project Structure

  • Generate or update complete Maven project structures from the UML model (similar to archetypes)
  • Large set of predefined archetypes and module types
  • Dependencies managed based on the UML model
  • POM files remain manually customizable


Reports

  • Model reports (package contents)
  • Types report (alternate names)
  • REST deprecation report
  • Java deprecation report
  • Breaking changes report
  • Java and breaking changes report (CSV)
  • Security roles report
  • Easy integration of custom reports