Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/habsgleich/orbit

Orbit 🌏🧑‍🚀 - Ein modernes, typsicheres und intuitives Fluent-Style ORM fĂŒr Java, das die LeistungsfĂ€higkeit von SQL mit der Einfachheit einer Fluent-API kombiniert. Entwickelt fĂŒr maximale Lesbarkeit, Performance und Entwicklerfreundlichkeit.
https://github.com/habsgleich/orbit

fluent-design java orm postgresql

Last synced: 2 months ago
JSON representation

Orbit 🌏🧑‍🚀 - Ein modernes, typsicheres und intuitives Fluent-Style ORM fĂŒr Java, das die LeistungsfĂ€higkeit von SQL mit der Einfachheit einer Fluent-API kombiniert. Entwickelt fĂŒr maximale Lesbarkeit, Performance und Entwicklerfreundlichkeit.

Awesome Lists containing this project

README 

          
# Orbit



Eine fluent-style Java ORM-Bibliothek fĂŒr typsichere und elegante Datenbankoperationen, basierend auf [Hibernate](https://github.com/hibernate).



![Java Version](https://img.shields.io/badge/Java-8%2B-blue)

![License](https://img.shields.io/github/license/habsgleich/orbit)

![GitHub branch check runs](https://img.shields.io/github/check-runs/habsgleich/orbit/main)

![Maven Central Version](https://img.shields.io/maven-central/v/dev.habsgleich/orbit)



## Übersicht



Orbit ist ein modernes Java ORM-Framework, das eine intuitive und typsichere API fĂŒr Datenbankoperationen bietet. Es wurde entwickelt, um die KomplexitĂ€t von SQL-Abfragen zu reduzieren und gleichzeitig volle Kontrolle ĂŒber die generierten Abfragen zu behalten.



```java

// Beispiel einer Orbit-Abfrage

Optional customer = Repository.of(Customer.class)

    .query()

    .equal("firstName", "John")

    .findOne();

```



## Features



- **Fluent API**: Intuitive Methodenverkettung fĂŒr natĂŒrliche Lesbarkeit

- **Typsicherheit**: Kompilierzeitvalidierung von Abfragen und EntitÀten

- **Repository-Pattern**: Klares und einfaches Design fĂŒr Datenzugriffslogik

- **Benutzerdefinierte Abfragen**: Flexible `CustomQuery`-Schnittstelle fĂŒr komplexe Szenarien

- **Transaktionskontrolle**: Einfache Verwaltung von Datenbanktransaktionen mit `OrbitTransaction`

- **Hibernate-Integration**: Nutzt die LeistungsfÀhigkeit von Hibernate mit einer vereinfachten API

- **Minimaler Boilerplate**: Generiere weniger Code fĂŒr hĂ€ufige Operationen

- **Einfache Konfiguration**: Schneller Einstieg mit unkomplizierter Einrichtung

- **Testfreundlich**: In-Memory-Datenbank-Integration fĂŒr Tests



## Installation



### Gradle (Kotlin DSL)



```kotlin

dependencies {

    implementation("dev.habsgleich:orbit:")

}

```



### Maven



```xml



    

        dev.habsgleich

        orbit

        1.0.0

    



```



## Schnellstart



### 1. EntitÀten definieren



Erstelle deine EntitÀtsklassen mit den entsprechenden JPA-Annotationen:



```java

@Entity(name = "customer")

public class Customer {



    @Id

    @GeneratedValue(strategy = GenerationType.AUTO)

    private UUID id;



    private String firstName;

    private String lastName;

    

    @Column(unique = true, nullable = false)

    private String email;

    

    private String phone;

    private String password;

    

    // Getters und Setters oder verwende Lombok fĂŒr weniger Boilerplate-Code

    

    // Optional: Builder-Pattern

    public static CustomerBuilder builder() {

        return new CustomerBuilder();

    }

}

```



Wichtige Annotationen fĂŒr EntitĂ€ten:

- `@Entity`: Markiert die Klasse als JPA-EntitĂ€t (mit optionalem Namen fĂŒr die Tabelle)

- `@Id`: Definiert den PrimĂ€rschlĂŒssel

- `@GeneratedValue`: Konfiguriert die automatische ID-Generierung

- `@Column`: Passt die Spalteneigenschaften an (z.B. unique, nullable, length)

- `@Table`: Erlaubt weitere Tabellenkonfiguration (falls nötig)

- `@OneToMany`, `@ManyToOne`, etc.: Definiert Beziehungen zu anderen EntitÀten



### 2. Orbit initialisieren



Orbit bietet mehrere Möglichkeiten zur Initialisierung:



#### Mit Properties-Datei als InputStream



```java

// Initialisiere Orbit mit Konfigurationsdatei und EntitÀtsklassen

Orbit.initialize(

    YourApp.class.getResourceAsStream("/orbit.properties"), 

    Customer.class

);

```



#### Mit Properties-Objekt



```java

// Eigenschaften direkt als Properties-Objekt

Properties props = new Properties();

props.setProperty("hibernate.hikari.dataSource.url", "jdbc:postgresql://localhost:5432/mydb");

props.setProperty("hibernate.hikari.dataSource.user", "user");

props.setProperty("hibernate.hikari.dataSource.password", "password");



Orbit.initialize(props, Customer.class);

```



#### Mit direkten Verbindungsparametern



```java

// Einfache Initialisierung mit Verbindungsparametern

Orbit.initialize(

    "jdbc:postgresql://localhost:5432/mydb",

    "user",

    "password",

    Customer.class

);

```



### 3. Repository erstellen und nutzen



```java

// Repository fĂŒr spezifische EntitĂ€t erstellen

Repository repository = Repository.of(Customer.class);



// Neue EntitÀt speichern

Customer customer = repository.merge(

    Customer.builder()

        .firstName("John")

        .lastName("Doe")

        .email("email@email.com")

        .password("encryptedPassword")

        .phone("1234567890")

        .build()

);



// EntitÀt nach Kriterien abfragen

Optional foundCustomer = repository.query()

    .equal("firstName", "John")

    .findOne();



// Alle EntitÀten abrufen

List allCustomers = repository.query().findAll();



// EntitÀt löschen

repository.delete(customer);

```



## Abfragen



### Einfache Abfragen



```java

// Eine EntitÀt finden

Optional customer = repository.query()

    .equal("email", "test@example.com")

    .findOne();



// Mehrere EntitÀten finden

List customers = repository.query()

    .like("lastName", "Smith")

    .findAll();

```



### Komplexe Abfragen



```java

List customers = repository.query()

    .equal("active", true)

    .or(q -> q

        .notEqual("status", "INACTIVE")

        .greaterThan("lastLogin", LocalDate.now().minusDays(30))

    )

    .orderBy("lastName", true)

    .limit(20)

    .findAll();

```



### Benutzerdefinierte Abfragen mit CustomQuery



FĂŒr komplexe Szenarien kannst du mit `CustomQuery` eigene Kriterien definieren:



```java

// CustomQuery funktionales Interface

Optional vipCustomer = repository.query()

    .custom((criteriaBuilder, root) -> 

        criteriaBuilder.and(

            criteriaBuilder.equal(root.get("status"), "VIP"),

            criteriaBuilder.greaterThan(root.get("totalPurchases"), 10000)

        )

    )

    .findOne();



// Kombiniere Standard-API mit benutzerdefinierten Abfragen

List recentActiveVIPs = repository.query()

    .equal("active", true)

    .custom((cb, root) -> 

        cb.greaterThan(root.get("lastPurchaseDate"), LocalDate.now().minusDays(30))

    )

    .orderBy("totalPurchases", false) // absteigend

    .findAll();

```



## Benutzerdefinierte Transaktionen



Orbit ermöglicht dir, komplexe Transaktionen mit vollstĂ€ndiger Kontrolle ĂŒber die Session und Transaktionsverwaltung auszufĂŒhren:



```java

// Benutzerdefinierte Transaktion mit dem OrbitTransaction-Interface

Customer result = repository.transactional((session, transaction) -> {

    // FĂŒhre mehrere Datenbankoperationen innerhalb einer Transaktion aus

    Customer customer = session.get(Customer.class, 1L);

    customer.setStatus("PREMIUM");

    

    Order newOrder = new Order();

    newOrder.setCustomer(customer);

    newOrder.setAmount(199.99);

    session.save(newOrder);

    

    // Die Transaktion wird automatisch committed und die Session geschlossen

    return customer;

});



// Fehlerbehandlung erfolgt automatisch mit Rollback

try {

    repository.transactional((session, transaction) -> {

        // Fehlerhafte Operation

        throw new RuntimeException("Etwas ist schiefgelaufen");

    });

} catch (RuntimeException e) {

    // Transaktion wurde automatisch zurĂŒckgerollt

    System.out.println("Transaktion wurde zurĂŒckgerollt: " + e.getMessage());

}

```



## Konfiguration



Erstelle eine `orbit.properties` Datei im Ressourcen-Verzeichnis:



```properties

# Datenbankverbindung mit Hibernate/HikariCP

hibernate.hikari.dataSource.url=jdbc:postgresql://localhost:5432/mydb

hibernate.hikari.dataSource.user=user

hibernate.hikari.dataSource.password=password



# Optionale Hibernate-Konfigurationen

hibernate.show_sql=true

hibernate.format_sql=true

hibernate.hbm2ddl.auto=update

```



### Zugriff auf die SessionFactory



Nachdem Orbit initialisiert wurde, kannst du bei Bedarf auf die Hibernate-SessionFactory zugreifen:



```java

// Nach der Initialisierung

SessionFactory sessionFactory = Orbit.instance().sessionFactory();

```



## Mitwirken



BeitrÀge sind willkommen! Bitte lies zuerst unsere [Beitragsrichtlinien](CONTRIBUTING.md).



## Lizenz



Dieses Projekt steht unter der MIT License - siehe die [LICENSE](LICENSE) Datei fĂŒr Details.



## Dank



- Dank an alle Mitwirkenden und Benutzer, die Feedback geben

- Basiert auf [Hibernate](https://github.com/hibernate), einem der leistungsstĂ€rksten ORM-Frameworks fĂŒr Java