Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/victorhsr/hermes-builder
A library that automates the creation of fluent object builders and DSL in Java
https://github.com/victorhsr/hermes-builder
annotation-processing domain-specific-language dsl java kotlin maven
Last synced: 25 days ago
JSON representation
A library that automates the creation of fluent object builders and DSL in Java
- Host: GitHub
- URL: https://github.com/victorhsr/hermes-builder
- Owner: victorhsr
- License: mit
- Created: 2022-11-14T01:57:35.000Z (almost 2 years ago)
- Default Branch: main
- Last Pushed: 2024-02-01T15:58:55.000Z (9 months ago)
- Last Synced: 2024-04-23T02:24:54.008Z (7 months ago)
- Topics: annotation-processing, domain-specific-language, dsl, java, kotlin, maven
- Language: Kotlin
- Homepage:
- Size: 67.4 KB
- Stars: 4
- Watchers: 1
- Forks: 0
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Hermes Builder
[](https://github.com/victorhsr/hermes-builder/actions?query=workflow%3A"Maven+Build")
[](https://coveralls.io/github/victorhsr/hermes-builder)
[](https://opensource.org/licenses/mit)
[](https://jitpack.io/#victorhsr/hermes-builder)
Hermes is a library designed to streamline the generation of fluent object builders for your Java classes. Employing a declarative approach, it produces a straightforward Domain Specific Language (DSL) to facilitate the construction of object instances.
## Adding Hermes to your pom file
```xml
jitpack.io
https://jitpack.io
com.github.victorhsr
hermes-builder
1.0.0-beta
```
## Usage
Suppose we have classes `Person`, `Address` and `MetaDataWrapper` annotated with `@DSLRoot` and `@DSLProperty`:
```Java
@DSLRoot
public class Person {
private String name;
private Integer age;
private Address address;
@DSLProperty("metaData")
private MetaDataWrapper metaDataWrapper;
// getters and setters...
}
@DSLRoot
public class Address {
private String street;
private Integer houseNumber;
// getters and setters...
}
@DSLRoot
public class MetaDataWrapper {
private K key;
private V value;
// getters and setters...
}
```
Once you compile your project, the library will generate the classes `PersonDSL`, `AddressDSL` and `MataDataWrapperDSL` which are the builders. With it we can succinctly create an instance of `Person`:
```Java
Person personFromDsl =
person(
name("Victor"),
age(99),
address(
street("Foo street"),
houseNumber(99)
),
metaData(
key("LAST_LOGIN"),
value("01-01-2024")
)
);
````
Note that there's no need to instantiate `Address` or `MetaDataWrapper`, and more descriptive names for Person's fields can be used. All the building methods are static methods and high order functions.
## Annotations
- **@DSLRoot** - Indicates the intention to create a builder for the annotated class;
- **@DSLProperty** - Customizes the method name generated for a specific field. The default is the original field name;
- **@DSLIgnore** - Marks a field to be excluded when generating DSL code;
# Comparison with Traditional Java Classes
The equivalent implementation in traditional Java code involves a considerable amount of boilerplate:
```Java
private Person buildPerson() {
Person person = new Person();
person.setAge(99);
person.setName("Victor");
person.setAddress(buildAddress());
person.setMetaDataWrapper(buildMetaDataWrapper());
return person;
}
private MetaDataWrapper buildMetaDataWrapper() {
MetaDataWrapper metaData = new MetaDataWrapper<>();
metaData.setKey("LAST_LOGIN");
metaData.setValue("01-01-2024");
return characteristics;
}
private Address buildAddress() {
Address address = new Address();
address.setHouseNumber(99);
address.setStreet("Foo street");
return address;
}
```
That's a lot of code, almost twice the lines of our previous implementation. The Hermes Builder significantly reduces this boilerplate, providing a more concise and readable alternative.
# Using Lombok for comparison
An alternative approach using Lombok involves a cleaner syntax but may lack readability and customization
```Java
public Person buildPerson() {
return Person.builder()
.name("Victor")
.age(99)
.address(buildAddress())
.setMetaDataWrapper(buildMetaDataWrapper())
.build();
}
private MetaDataWrapper buildMetaDataWrapper() {
return MetaDataWrapper
.builder()
.key("LAST_LOGIN")
.value("01-01-2024")
.build()
}
private Address buildAddress() {
return Address.builder()
.houseNumber(99)
.street("Foo street")
.build()
}
```
In summary, the Hermes Builder strikes a balance between conciseness and customization, offering a powerful solution for building objects in a declarative manner.