Les bases de données NoSQL font désormais partie du savoir-faire de plusieurs organisations, même les plus conservatrices, comme les institutions financières. Cependant, plusieurs outils et frameworks doivent encore être améliorés pour plusieurs langages, tels que Java. La spécification Jakarta NoSQL a été créée pour augmenter l’expérience des développeurs entre les bases de données Java et NoSQL. Cet article couvrira plus de détails sur la spécification Jakarta NoSQL et ses dernières fonctionnalités.
Qu’est-ce que Jakarta NoSQL ?
Jakarta NoSQL est une spécification conçue pour intégrer facilement les bases de données Java et NoSQL. Il utilise des annotations communes et des API spécifiques pour chacun des types de bases de données NoSQL : bases de données clé-valeur, famille de colonnes, document et graphique.
Figure 1 : Comportement typique parmi les bases de données NoSQL de documents simplifiées dans une seule interface. Le même concept peut s’appliquer aux types de base de données clé-valeur, famille de colonnes et graphique.
En utilisant cette API commune et cette API standard, il est possible d’utiliser plusieurs types de bases de données sans dépendance vis-à-vis d’un fournisseur et avec une faible charge cognitive pour apprendre une nouvelle API. Par exemple, sur l’API Document, vous pouvez utiliser MongoDB et passer à ArangoDB.
Figure 2 : Comportement NoSQL simplifié à l’aide de Jakarta NoSQL
L’entité utilisant la même annotation peut explorer et changer de base de données sans impact sur l’application. Nous pouvons explorer l’analogie JPA/JDBC ici.
Jakarta NoSQL a une implémentation, Eclipse JNoSQL, qui utilise la puissance de la spécification Jakarta Contexts and Dependency Injection (CDI) comme moteur, ce qui la rend compatible avec les fournisseurs Jakarta EE et Eclipse MicroProfile.
Nous avons récemment publié la version 1.0.0-b5, qui a simplifié plusieurs points de l’API et ajouté plus de fonctionnalités que nous explorerons dans la prochaine session.
Quoi de neuf sur Jakarta NoSQL 1.0.0-b5 ?
Nous sommes fiers d’annoncer la dernière version de Jakarta NoSQL avec les nouvelles fonctionnalités les plus en vogue : prise en charge des enregistrements Java et simplification de la configuration de démarrage.
En commençant par le premier, nous voulons éventuellement créer des entités immuables dans notre application. Au-delà des objets de valeur, nous pouvons explorer cette capacité sur l’entité dans certains cas, comme une transaction historique.
Réfléchissons à un Book entité où nous avons un id, name, authoret edition. Une fois que nous créons un nouveau book, nous ne le modifions plus. Mais qu’en est-il d’une nouvelle édition de ce même livre ? Il est considéré comme un nouveau book; ainsi, il conservera l’historique du premier.
public class Book {
private final String isbn;
private final String name;
private final String author;
private final Year year;
private final int edition;
Book(String isbn, String name, String author, Year year, int edition) {
this.isbn = isbn;
this.name = name;
this.author = author;
this.year = year;
this.edition = edition;
}
}
Nous pouvons donc créer cette instance à l’aide d’un constructeur. En utilisant Jakarta NoSQL, nous pouvons explorer les annotations au constructeur sur cette approche. Comme vous pouvez le voir, nous avons besoin des annotations sur le constructeur pour apprendre à créer une entité. Cela fonctionnera quand il y a un constructeur avec un argument ou un constructeur avec soit le @Id ou @Column annotation.
@Entity
public class Book {
@Id
private final String isbn;
@Column
private final String title;
@Column
private final String author;
@Column
private final Year year;
@Column
private final int edition;
Book(@Id String isbn, @Column("title") String title,
@Column("author") String author, @Column("year") Year year,
@Column("edition") int edition) {
this.isbn = isbn;
this.name = name;
this.author = author;
this.year = year;
this.edition = edition;
}
}
C’est bien, mais cela ressemble à beaucoup de code. Peut-on simplifier ? La réponse est oui! Si vous utilisez Java 17, la dernière version LTS, les enregistrements Java simplifient cela pour nous.
Vous pouvez en profiter avec la dernière version de Jakarta NoSQL pour réduire le code comme indiqué ci-dessous :
@Entity
public record Book(@Id String isbn,
@Column("title") String title,
@Column("author") String author,
@Convert(YearConverter.class) @Column("year") Year year,
@Column("edition") int edition) {
}
C’est ça! Exécutons ce morceau de code sur Jakarta NoSQL en explorant cette fonctionnalité d’enregistrement :
@Inject
private Template template;
String id = UUID.randomUUID().toString();
long start = System.currentTimeMillis();
Book book = new Book(id, "Java Concurrency in Practice", " Brian Goetz", Year.of(2006), 1);
template.insert(book);
Optional<Book> optional = template.find(Book.class, id);
System.out.println("The result " + optional);
long end = System.currentTimeMillis() - start;
System.out.println("The total operation is: " + end);
template.delete(Book.class, id);Fait! Nous explorons l’intégration des données avec Jakarta NoSQL. Mais attendez : où sont les informations de la base de données ? Le Template interface représente la classe commune à opérer entre les bases de données Java et NoSQL. Ainsi, il peut s’agir de clés-valeurs, de documents, de graphiques, de familles de colonnes ou d’autres types de bases de données que la spécification pourrait avoir à l’avenir.
Comme pour toute décision de conception, il y a un compromis à ne pas avoir de comportement particulier pour chaque type de base de données. Explorons la capacité de Document type avec MongoDB, où nous voulons trouver des champs et pas seulement la clé. Ainsi, nous pouvons utiliser le DocumentTemplate interface, une spécialisation du Template interface avec plus de capacité de base de données de documents.
Comme pour toute classe, nous pouvons créer des méthodes sur des enregistrements et les utiliser. Incluons un moyen de créer une édition ultérieure d’un livre, comme Java efficacequi en est actuellement à sa troisième édition.
public Book nextEdition(String isbn, Year year) {
return new Book(isbn, this.title, this.author, year, this.edition + 1);
}
Comme pour toute nouvelle fonctionnalité, il existe plusieurs approches pour l’utiliser et la rendre plus facile, comme un builder , lorsqu’il est nécessaire de créer des entités immuables plus complexes. Cependant, ce ne sera pas l’objet de cet article. L’étape suivante consiste à coder à la fois l’enregistrement Java et DocumentTemplate en action, où nous renverrons toutes ces éditions de livres classées par ordre décroissant de l’année.
@Inject
DocumentTemplate template;
Book first = new Book(randomUUID().toString(), "Effective Java", "Joshua Bloch",
Year.of(2001), 1);
Book second = first.nextEdition(randomUUID().toString(), Year.of(2008));
Book third = second.nextEdition(randomUUID().toString(), Year.of(2018));
template.insert(List.of(first, second, third));
DocumentQuery query = DocumentQuery.select().from("Book")
.where("title").eq("Effective Java")
.orderBy("year").desc().build();
System.out.println("The Effective java editions: ");
template.select(query).forEach(System.out::println);
template.delete(Book.class, first.isbn());
template.delete(Book.class, second.isbn());
template.delete(Book.class, third.isbn());Nous avons intégré MongoDB et Java, mais où est la configuration ? Jakarta NoSQL 1.0.0-b5 explore la convention sur la configuration où toutes les propriétés seront lues en temps réel en utilisant le même principe que les spécifications Jakarta Config (encore en cours de développement) et Eclipse MicroProfile Config qui suivent l’application Twelve-Factor.
Le code montre les propriétés pour exécuter MongoDB localement, où la première propriété appartient à la base de données que l’application utilisera. Vous pouvez voir les propriétés de chaque pilote NoSQL sur son référentiel. Il rompt la compatibilité avec la version précédente. Veuillez faire attention à la migration :
jnosql.document.database=library
jnosql.mongodb.host=localhost:27017
Si vous le souhaitez, vous pouvez définir la configuration par programmation. Pour cela, vous devez créer une classe qui implémente le Supplier d’un gestionnaire de base de données puis, en variante, avec une priorité supérieure à zéro. Il est naturel que vous connaissiez CDI.
@Alternative
@Priority(Interceptor.Priority.APPLICATION)
@ApplicationScoped
public class ManagerSupplier implements Supplier<DocumentManager> {
@Produces
public DocumentManager get() {
...
}
}
C’est la fin du voyage des nouvelles fonctionnalités de Jakarta NoSQL aujourd’hui. La prochaine étape consiste à travailler avec la communauté Jakarta NoSQL pour prendre en charge Jakarta Data, une nouvelle spécification lancée en 2022.
Si vous n’avez jamais entendu parler de Jakarta Data, il s’agit d’une spécification qui vise à créer un modèle de données agnostique sur Java. La première version consistait à rendre la capacité du référentiel et la pagination.
En tant qu’utilisateur Java, nous ne gérerons que quelques annotations et interfaces où les fournisseurs implémenteront tout le reste pour nous.
Résumé
Dans cet article, nous avons exploré les nouveautés de Jakarta NoSQL 1.0.0-b5. C’est un vaste effort de la part de la communauté Java pour rendre Java et NoSQL plus naturels, en particulier dans les applications d’entreprise. De plus, il y a eu un travail important pour améliorer la documentation et en faire un citoyen de premier ordre.
Dans la prochaine étape, l’équipe Jakarta NoSQL travaillera en étroite collaboration avec les spécifications Jakarta Data et Jakarta Config pour explorer les meilleures pratiques en matière de conception d’application et de code au niveau de la spécification, comme le référentiel DDD et l’application à douze facteurs.
Vous pouvez réviser, fournir des commentaires et implémenter du code en tant que projet open source et piloté par la communauté. Après tout, mieux que d’attendre une nouvelle fonctionnalité, c’est d’y participer.