Posted on

JNoSQL API 1.0.0-b3: What’s New in This New Version

The Eclipse JNoSQL is a framework to help developers create enterprise-grade applications using Java and NoSQL technologies. It helps them create scalable applications while maintaining low coupling with the underlying NoSQL technology. This version has some features and a break-compatibility where it will talk about in this post.

At this version, there is break compatibility. This change was in the package name and not in the API itself, and it is similar to Jakarta EE big bang in version 9. Briefly, the names 'Diana' and 'Artemis' have been replaced with 'communication' and 'mapping' respectively. It will include both the package name and the project name.

Posted on

Get to Know JSF: An Easy and Straightforward a Jakarta Framework

Developing web systems is a reality in the current market, and the Jakarta Server Faces framework is a standard Jakarta EE option to solve this type of problem. One of the characteristics of JSF is to work in a way oriented towards screen components and their events (for example, clicks). In this way, we can associate these components with different aspects of our system, such as the execution of business operations, value conversions, field validations, etc. In this article, we'll talk about this JSF and how to move this application to the cloud with Platform.sh.

To celebrate the new year, let's create a small wish list in Java with Jakarta EE technologies. In the front end, we'll use Java Server Faces (JSF), a Java-based web application framework that simplifies the development and integration of web-based user interfaces with several already-made components. To store the list, let's use MongoDB.

Posted on

What’s New With Jakarta NoSQL? (Part II)

Moving to Cloud-Native

Cloud computing has brought many methodologies and techniques that have revolutionized both the business and technical worlds. Among the terms that came up were cloud-native. To meet and cover these expectations in the Java universe, Jakarta EE emerged. The purpose of this post is to talk about the concept of cloud-native and to run an application with this concept using the latest milestone version of Jakarta EE NoSQL.

You may also like: From javax.* to jakarta.*: A Simple Proof of Concept

Posted on

What’s New With Jakarta NoSQL? (Part 1): Intro to Document With MongoDB

Jakarta EE picks up where Java EE 8 left off, but the roadmap going forward will be focused on modern innovations like microservices, modularity, and NoSQL databases. This post will talk about the newest milestone version of this new specification and the subsequent actions to make the Jakarta EE community even greater in the cloud.

Why Jakarta NoSQL?

Vendor lock-in is one of the things any Java developer needs to consider when choosing NoSQL databases. If there’s a need for a switch, other considerations include time spent on the change, the learning curve of a new API to use with this database, the code that will be lost, the persistence layer that needs to be replaced. Jakarta NoSQL avoids most of these issues through Communication APIs. Jakarta NoSQL also has template classes that apply the design pattern ‘template method’ to database operations. And the Repository interface allows Java developers to create and extend interfaces, with implementation automatically provided by Jakarta NoSQL — support method queries built by developers will automatically be implemented for them.

Posted on

Microservices in the Cloud, Part Two

Are there microservices in these clouds?

Microservices are a hot topic in software design, and for good reason. They have plenty of advantages when it comes to handling infrastructure complexity, many of which were addressed in part one of our related Java posts. Now, it’s time to talk about the code and design. In this post, we’ll take a deep dive into each module.

You may also like: Microservices in the Cloud, Part One

When creating an application, clean code means thinking about design and architecture. Architecture is the software process that handles flexibility, scalability, usability, security, and other points, so you have more time to focus on business rather than on technology. Some architecture examples include:

Posted on

Java USA Tour 2019: Bringing Java and Cloud to Your City!

Stops on JAva USA TourCloud computing is the on-demand availability of computer system resources, especially data storage and computing power — without direct active management by the user. The cloud concept became a hot idea because it makes it easier for software to be available in multiple regions, without adding the maintenance, operational, and data security costs to your software project.

Platform.sh is a second-generation Platform-as-a-Service (PaaS) provider that offers hosting for your applications and their services, like MySQL, PostgreSQL, and Kafka, through the infrastructure-by-code concept. Platform.sh manages everything — from hosting and technology to global deployment and support — so developers can focus on creating amazing new apps and features. In September, we’ll have several activities to show the benefits of cloud computing and how easy it can be with Platform.sh. Stay tuned!

Posted on

Data Integrity in NoSQL and Java Applications Using Bean Validation

The NoSQL databases are famous because they are schemaless. That means a developer does need to care about a pre-defined type as it does on a relational database; thus, it makes it easier for developers to create an application. However, it has a considerable price once there is no structure that is not trivial to validate it on the database. To ensure integrity, the solution should work on the server side. There is a specification and framework in the Java world that is smoother and annotation-driven: bean validation. This post will cover how to integrate bean validation in a NoSQL database.

Bean Validation, JSR 380, is a specification which ensures that the properties of a Class match specific criteria, using annotations such as @NotNull, @Min, and @Max, also create its annotation and validation. It is worth noting bean validation does not, necessarily, mean an anemic model; in other words, a developer can use it with good practices to get data integrity.