OCI Lance Micronaut 1.3 Avec Micronaut Data 1.0

Object Computing, Inc. (OCI) a publié Micronaut 1.3 avec la publication de la première milestone du projet Micronaut Data 1.0, "une boîte à outils d'accès à la base de données qui utilise la compilation Ahead of Time (AoT) pour précalculer les requêtes des interfaces de repositorys qui sont ensuite exécutées par une couche d'exécution légère. "Les fonctionnalités supplémentaires de Micronaut 1.3 incluent des propriétés de configuration immuables, la prise en charge du cache pour Ehache, Hazelcast, Infinispan, etc., la prise en charge initiale des co-routines et de l'Asynchronous Flow de Kotlin, la prise en charge de GraalVM 19.3 et de la sérialisation / désérialisation XML avec Jackson XML et des améliorations de performances et de la consommation de mémoire.

Initialement, connu sous le nom de Micronaut Predator, Micronaut Data fournit une API générale pour traduire un modèle dans une Query en une requête au moment de la compilation et fournit un support d'exécution pour des backends JPA/Hibernate et SQL/JDBC. L'équipe Micronaut Data prévoit de prendre en charge d'autres implémentations de bases de données à l'avenir. Micronaut Data prend en charge H2, MySQL 5.5+, Oracle 12c +, PostgreSQL 9.5+ et SQLServer 2012+.

Inspiré par GORM et Spring Data, Micronaut Data améliore ces deux technologies en éliminant le modèle d'exécution qui utilise la réflexion, en éliminant la traduction des requêtes qui utilise des expressions régulières et le pattern matching et en ajoutant la sécurité des types. L'utilisation de la réflexion dans GORM et Spring Data pour modéliser les relations entre les entités entraîne une consommation de mémoire accrue.

Pour démarrer

Comme toute autre application Micronaut, une application de données Micronaut squelettique mais fonctionnelle peut être créée via la ligne de commande en utilisant les paramètres appropriés pour un backend JPA/Hibernate ou SQL/JDBC comme point de départ pour une application plus complète :

$ mn create-app myapp --features data-hibernate-jpa
$ mn create-app myapp --features data-jdbc
    

Avec Gradle utilisé comme outil de build par défaut pour les applications Micronaut, le fichier build.gradle généré contiendra les dépendances appropriées :

implementation "io.micronaut.data:micronaut-data-hibernate-jpa"
implementation "io.micronaut.data:micronaut-data-jdbc"
    

Prenons une simple application de base de données H2 de films modélisée avec Micronaut Data. Deux tables, movie et director, auront des POJO, des repositorys et des controllers correspondants dans l'application. La classe Movie, représentant une table movie, capturera des informations sur le film et définira un identifiant universel unique (UUID) et une relation @ManyToOne avec une table director.

@Entity
public class Movie {

    @Id
    @AutoPopulated
    private UUID id;

    private String name;
    private MovieType type;
    private int year;

    @ManyToOne
    private Director director;

    @Creator
    public Movie(String name, @Nullable Director director, MovieType type, int year) {
        // setter methods
        }
    }
    

@AutoPopulated identifie des champs qui sont automatiquement remplies par Micronaut Data et @Creator est une annotation utilisable sur un constructeur.

Création d'un Repository

Considérez l'interface de repository suivante :

    
@JdbcRepository(dialect = Dialect.H2)
public interface MovieRepository extends CrudRepository<Movie,Long> {
    Movie findByName(String name);

    @Join("director")
    Optional<Movie> findByName(String lastName);
    }
    

L'interface MovieRepository est définie comme un référentiel de données via @JdbcRepository, un référentiel de stéréotypes qui configure un Repositorypour utiliser le SQL brut. Une implémentation est automatiquement générée par Micronaut Data lors de l'exécution. L'interface CrudRepository fournit automatiquement des opérations de création, de lecture, de mise à jour et de suppression. La table movie est jointe à la table director via l'annotation @Join.

Calcul de requêtes

Sur la base des POJO, des repositorys et des contrôleurs d'une application, Micronaut Data calcule les requêtes appropriées. Considérez le test suivant :

@Inject
BeanContext beanContext;

@Test
void testQuery() {
    String query = beanContext.getBeanDefinition(MovieRepository.class)
                .getRequiredMethod("findByName",String.class)
                .getAnnotationMetadata()
                .stringValue(Query.class)
                .get();
        assertEquals(
                "SELECT ... FROM ... INNER JOIN ... ON ... WHERE ...",
                query
                );
        }
    

Le BeanContext de Micronaut injecté générera une requête complète basée sur la méthode findByName() définie dans l'interface MovieRepository.

    
SELECT movie_.`id`,movie_.`name`,movie_.`director_id`,movie_.`type`,movie_.`year`,movie_director_.`last_name` AS
director_last_name,movie_director_.`first_name` AS director_first_name,movie_director_.`name` AS director_name FROM
`movie` movie_ INNER JOIN `director` movie_director_ ON movie_.`director_id`=movie_director_.`id` WHERE (movie_.`name` = ?)
    

L'exemple complet et détaillé se trouve sur GitHub.

La route vers Micronaut 2.0

Dans la perspective de Micronaut 2.0, l'équipe Micronaut prévoit des améliorations telles que :

• Reactive Micronaut Data pour SQL, Neo4j et MongoDB
• Prise en charge HTTP/2
• Améliorations de la prise en charge serverless
• Nouveaux plugins de construction pour Maven et Gradle
• Autres améliorations des performances

Micronaut Data rejoint d'autres projets Micronaut tels que Micronaut AWS, Micronaut GCP, Micronaut for Spring, Micronaut RabbitMQ, et Micronaut Test.

Note de l'éditeur

Une récente version mineure de Micronaut 1.3.3 prend désormais en charge GraalVM 20.0.0.