Eclipse JNoSQL 1.0.0: Streamlining Java and NoSQL Integration With New Features and Bug Fixes

Integrating Java applications with NoSQL databases has become increasingly important in modern software development. To address the growing demands of this realm, Eclipse JNoSQL, a comprehensive framework for Java developers, has recently unveiled its highly anticipated 1.0.0 version. Packed with many new features and bug fixes, this update aims to streamline the integration process between Java and NoSQL, offering developers a more efficient and seamless experience.

NoSQL databases are popular due to their flexible data models, scalability, and high performance. However, integrating these databases with Java applications involves intricate configuration and complex coding practices. Eclipse JNoSQL has been specifically designed to alleviate these challenges, providing developers with a powerful toolkit to simplify the interaction with various NoSQL databases.

The release of Eclipse JNoSQL 1.0.0 marks a significant milestone in the framework's evolution, introducing a host of new features that enhance its usability and versatility. With this update, developers can use various advanced functionalities to optimize their Java and NoSQL integration workflow. From improved data mapping and query capabilities to enhanced support for different NoSQL databases, Eclipse JNoSQL empowers developers to harness the full potential of NoSQL technology within their Java applications.

In addition to the exciting new features, the 1.0.0 version of Eclipse JNoSQL brings an array of bug fixes, addressing various issues reported by the developer community. By rectifying these bugs and enhancing the overall stability of the framework, Eclipse JNoSQL strives to provide developers with a more reliable and efficient development environment.

This article dives into the details of the Eclipse JNoSQL 1.0.0 release, exploring the key features that make it a compelling choice for Java developers seeking simplified integration with NoSQL databases. We will examine the benefits of the new functionalities, highlight the bug fixes that enhance the framework's stability, and discuss the potential impact of this release on the Java and NoSQL development landscape.

As the Java and NoSQL ecosystems evolve, Eclipse JNoSQL remains at the forefront of providing developers with practical tools and frameworks to streamline their workflows. The 1.0.0 version represents a significant step in achieving seamless integration between Java and NoSQL, empowering developers to build robust and scalable applications more efficiently.

Features of New Eclipse JNoSQL

The latest Eclipse JNoSQL, 1.0.0, introduces exciting features that enhance the framework's capabilities and simplify the integration between Java and NoSQL databases:

• More straightforward database configuration: One of the notable enhancements in Eclipse JNoSQL 1.0.0 is the introduction of simplified database configuration. With the new version, developers can now easily configure and connect to NoSQL databases without the need for complex and time-consuming setup procedures. This feature significantly reduces the initial setup overhead and allows developers to focus more on the core aspects of their application development.
• Enhanced Java Record support: Eclipse JNoSQL 1.0.0 brings improved support for Java Records, a feature introduced in Java 14. Java Records provide a concise and convenient way to define immutable data objects. With the updated version of Eclipse JNoSQL, developers can seamlessly map Java Records to NoSQL data structures, enabling efficient and effortless data handling. This enhancement enhances code readability, maintainability, and overall development productivity.
• Several bug fixes: Alongside introducing new features, Eclipse JNoSQL 1.0.0 addresses several bugs reported by the developer community. 
• Enhanced repository interfaces: Eclipse JNoSQL 1.0.0 enhances the repository interfaces, which bridge Java applications and NoSQL databases. These interfaces provide a high-level abstraction for developers to interact with the database, simplifying data retrieval, storage, and query operations. The updated repository interfaces in Eclipse JNoSQL offer improved functionality, enabling developers to perform database operations with greater ease and flexibility.

These new features in Eclipse JNoSQL 1.0.0 significantly contribute to making the integration between Java and NoSQL smoother and more efficient. By streamlining database configuration, enhancing Java Record support, addressing bug fixes, and improving repository interfaces, Eclipse JNoSQL empowers developers to leverage the full potential of NoSQL databases within their Java applications. With these advancements, developers can now focus more on building innovative solutions rather than grappling with the complexities of database integration.

Show Me the Code

To demonstrate how the new version works, we will create a MongoDB application sample where we will handle pets.

The first step is running a MongoDB application. We can use either a MongoDB Atlas in the cloud or run it locally with Docker.

At Docker, you can run with the following command:

docker run -d --name mongodb-instance -p 27017:27017 mongo

Once we have a MongoDB instance running, the next step is a Maven project. The simplicity of database configuration is one feature we will explore today. To have MongoDB, we need to add the database dependency.

<dependency>
    <groupId>org.eclipse.jnosql.databases</groupId>
    <artifactId>jnosql-mongodb</artifactId>
    <version>1.0.0</version>
</dependency>

If you want to use another database available, check the Eclipse JNoSQL databases for more information. We also provide demos on Java SE and Web profiles.

Besides this dependency, you must have CDI, JSON-B, and Eclipse Microprofile Config as minimum requirements to take this from a Jakarta EE and Eclipse Microprofile vendor.

The credentials will resume at two properties: the database and the MongoDB URLs, where we can overwrite on production to take advantage of The Twelve-Factor App:

jnosql.document.database=pets
jnosql.mongodb.host=localhost:27017

The next step is the entities types creation for Pets, where we will create two record structures and a sealed interface:

public sealed interface Pet permits Cat, Dog {

    String name();

    String breed();

}

@Entity

public record Dog(@Id String id, @Column String name, @Column String breed) implements Pet {

}

@Entity

public record Cat(@Id String id, @Column String name, @Column String breed) implements Pet {

}

With this configuration, we can start to use the Java and MongoDB integration.

@Inject
Template template;

var faker = new Faker();

var cat = Cat.create(faker);
template.insert(cat);
Optional<Cat> optional = template.find(Cat.class, cat.id());
System.out.println("The result: " + optional);

But you can do more and explore the repositories features. As new, you can create interface modules such as to query by name and breed and make it pluggable for the interfaces. Furthermore, you can create several components to create queries and several database operations.

public interface PetQueries<T extends Pet> {

    List<T> findByName(String name);

    List<T> findByBreed(String breed);

}



@Repository

public interface DogRepository extends PageableRepository<Dog, String>,

        PetQueries<Dog> {


    default Dog register(Dog dog, Event<Pet> event) {

        event.fire(dog);

        return this.save(dog);

    }

}

We can also explore the default methods for decorating, creating an alias, and enhancing database operations. We will create a PetQueries to centralize queries by name and breed, and at DogRepository, we will include an event for dogs exploring CDI.

@Inject
DogRepository repository;
@Inject
Event<Pet> event;

var faker = new Faker();

var dog = Dog.create(faker);
System.out.println("The register result: " +   repository.register(dog, event));

var optional = repository.findByBreed(dog.breed());
System.out.println("The result: " + optional);

Conclusion

Eclipse JNoSQL 1.0.0 revolutionizes the Java and NoSQL integration landscape by introducing new features and addressing crucial bug fixes. This version provides developers with an optimized workflow, enabling them to integrate NoSQL databases into their Java applications seamlessly. With the framework's enhanced usability, productivity gains, and improved stability, Eclipse JNoSQL stands as a valuable tool for Java developers seeking to harness the power of NoSQL databases in their software projects. As the Java and NoSQL ecosystems evolve, Eclipse JNoSQL remains at the forefront of empowering developers to build robust, scalable, and efficient applications.

References

• Source code
• JNoSQL source code
• NoSQL spec