Simplifying Persistence Integration With Jakarta EE Data

Receiver key

Jakarta Data makes it easy to integrate data into enterprise Java applications with multilingual stability and a flexible code base.
This multilingual approach to sustainability allows companies to select the most appropriate storage solution for each use case.
The sample application shows how Jakarta data can be used for different database styles: a relational database that uses the annotations defined in the Jakarta Persistence specification, a document-based NoSQL database that uses the annotations defined in the Jakarta NoSQL specification, and the Eclipse Store. application with Jakarta NoSQL. . Explanations:
Jakarta data can be integrated with Jakarta EE specifications to create a more robust and scalable architecture.
The data warehouse interface defined in Jakarta Data can be used for Jakarta NoSQL and Jakarta Persistence applications.

As enterprise Java applications continue to evolve, efficient data integration and persistence are critical to building reliable and scalable systems. Jakarta Data Refinement supports data management. This platform facilitates data integration, supports multilingual stability, and integrates Jakarta's energy efficiency technologies. By seamlessly interfacing with a variety of database styles, developers can focus on core business logic and speed up application development. Join us in Jakarta to explore the capabilities, benefits and real-world applications of this new energy efficiency specification in modern enterprise architecture.

It is important to note that the specification is still under development and has not yet been finalized or integrated into the Jakarta e-platform. Released to general availability in November 2023, this specification represents a promising advancement in data management for enterprise Java applications. As it continues to develop and improve, it will be able to simplify data integration, support multilingual stability, and integrate Jakarta EE. Technology is becoming more and more obvious.

This Jakarta EE specification provides insight into its capabilities, benefits, and real-world applications in today's enterprise architecture. Once the latest version is released, developers can expect to take advantage of its flexibility and open source nature, making it a valuable tool for building complex applications, from relational databases to document-based NoSQL solutions.

Increasing database development and duration of polyglot use

Why do we need Jakarta data?

In the fast-paced world of enterprise application development, seamless integration and efficient data retention management have become critical success factors. The Jakarta Data Specification was introduced in Jakarta EA to address these issues and provide maximum flexibility. The purpose of this specification is to facilitate integration, increase flexibility, and reduce cognitive load when working with multiple databases.

Figure 1: Integration where a Java developer can use multiple database engines such as SQL, NoSQL, etc.

Business vision

In today's competitive market, companies need efficient and scalable solutions to effectively manage multiple data requirements. A standardized approach to sustainability is critical so that companies can focus on their core business logic rather than getting bogged down by complex data integration tasks. The solution simplifies development, speeds time to market, and reduces maintenance costs by providing a unified way to work with disparate data sources.

Ensure multilingual stability in your enterprise architecture

Modern applications often rely on multiple data storage solutions, such as relational databases, NoSQL databases, and cloud storage. Maintaining multiple trusted technologies can be difficult and result in inconsistent data access patterns across the entire application stack. The solution solves this problem by providing a vendor-neutral and expressive API that allows developers to work with a variety of data stores without being tied to any specific vendor or technology. This multilingual approach to sustainability allows companies to select the most appropriate storage solution for each use case.

Warranty disclaimer and minimal cognitive load

Developers often encounter problems with database systems, query languages, and data access models. The specification removes this complexity by providing a consistent and intuitive API. This allows developers to focus on business logic without worrying about the details of the underlying data store. This abstraction promotes better code organization, reduces the risk of errors, and improves code maintainability. It also provides isolation between the application logic and the persistence layer so that changes in one layer do not affect the other, making the development process simpler and more manageable.

The introduction of this feature is an important step forward in simplifying Jakarta EE application data integration at the persistence layer. This enables enterprises to efficiently build robust and scalable applications that meet the needs of enterprise organizations, ensure multi-logon stability, and reduce cognitive load degradation. developers. In the following sections, we'll take a closer look at the technical aspects of this specification and look at implementation strategies to show how it will change the way data is managed in modern enterprise applications. Stay tuned for more information on this exciting development.

The next section puts this feature into practice and demonstrates its capabilities in a real-life microservices scenario. We'll use a practical example to show how this innovative API can simplify data integration and increase agility for microservices architects. By observing the seamless interaction between different microservices and their respective data sources, you will understand how this specification can facilitate a level of stability, enabling efficient and scalable enterprise application development.

Review the code.

This section shows how to simplify data integration in a persistent multilingual environment by creating three powerful brewing applications, all as Open Liberty Jakarta EE 10/11 providers.

Each application is a different type of database. are defined as a relational database using annotations defined in the Jakarta Persistence specification, a document-based NoSQL database using Couchbase or MongoDB, and an Eclipse Store application using annotations compatible with Jakarta NoSQL annotations. . By integrating this functionality into the Open Liberty implementation, we can see how the application interacts with the corresponding databases, serialize the NoSQL databases, and demonstrate that they use direct Eclipse Store interaction with the object structure. This solution allows developers to easily handle the complexities of multilingual data persistence across multiple database technologies, enabling seamless database management and recovery.

Rice. 2. Three applications using relational databases with PostgreSQL, Eclipse Store and Document NoSQL Couchbase and MongoDB.

Related database (confirmation from Jakarta):

In the first application, we use Jakarta's relational database and persistent annotations without integration. Using these annotations, we can map Beer and Address to corresponding tables in the relational database. The selected specification addresses data access and manipulation, including the relational database serialization process that converts object-oriented data into a structured format suitable for relational storage. It also establishes a one-to-one relationship between each user and the corresponding beer, establishing a normalization process to reduce redundancy and improve data integrity.

This approach to managing the consistency and interaction between an application and its relational database allows developers to work effectively using an object-oriented paradigm, ensuring that data is effectively managed and normalized within a relational structure.

Figure 3. Jakarta data with a number of Jakarta sustainability indicators

The Beer class has the @Entity Entity annotation, which points to the Jakarta constant in the database table. We define attributes such as name, style, hops, yeast, and malt using @Column annotations, which represent individual columns in a table. To establish a one-to-one relationship with Address , we use @OneToOne @JoinColumn to join the column "table beer address_id " to id address . cascade = CascadeType.ALL legal changes are converted to the corresponding Address Beer to ensure data consistency.

Additionally, the Address class is marked with @Entity , another Jakarta constant associated with a separate table in the database. The id field is defined as the primary key for the automatic id GenerationType.AUTO @Id @GeneratedValue . We use @Column annotations to map city and country attributes to individual address columns. Jakarta Persistence Annotations allows developers to link beer and address while providing efficient data management and search mode in a second application.

@Entity public class Beer { @Id private String id; @Column private String name; @Column private String style; @Column private String hop; @Column private String yeast; @Column private String malt; @OneToOne(cascade = CascadeType.ALL) @JoinColumn(name = "address_id", referencedColumnName = "id") private Address address; } @Entity @JsonbVisibility(FieldVisibilityStrategy.class) public class Address { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id; @Column private String city; @Column private String country; }

Documented NoSQL database (Jakarta NoSQL Notes Couchbase or MongoDB).

In the second application, we will focus on a document-based NoSQL database that provides greater flexibility for unstructured data. For a base NoSQL solution, we can choose between Couchbase or MongoDB. We define the mappings of Beer and Address classes using NoSQL annotations, and the NoSQL database handles the serialization process and converts the data into JSON format for storage. No matter which specification provider you choose, it simplifies data storage and recovery, ensuring that the application can easily interact with the NoSQL database of your choice.

Figure 4. NoSQL document and serialization flow

This application integrates with document-based NoSQL databases using Eclipse JNoSQL and provides seamless support for NoSQL databases such as Couchbase and MongoDB. The main difference from the previous one-to-one approach is that we model Address class as a sub-document class Beer instead of maintaining a separate one-to-one relationship.

In this updated model, Beer class is annotated with @Entity , which represents the Beer document in the NoSQL database. The content of Beer contains an Address field defined by @Column , which is a subdocument of the beer document. This way, the address information is passed directly to beer , eliminating the need for a separate address entry or individual link.

When data is stored in a Couchbase NoSQL database, the storage structure is in JSON format, while in MongoDB it is in BJSON (binary JSON) format. JSON and BJSON are flexible and efficient data storage formats that allow you to store and retrieve archived documents such as Beer body B. address , make it easier.

Because Eclipse supports JNoSQL integration, developers can focus on building the application's business logic without worrying about the complexity of interacting with NoSQL databases. Using nested documents and dynamic storage formats, Eclipse JNoSQL allows developers to efficiently work with document-based NoSQL databases to retrieve and manage data within an application. This approach allows developers to take advantage of the unique benefits of NoSQL databases and maintain a simple and efficient data modeling strategy.

@Entity("beer") public class Beer { @Id private String id; @Column private String name; @Column private String style; @Column private String hop; @Column private String yeast; @Column private String malt; @Column private Address address; @Column private String user; } @Entity public class Address { @Column private String city; @Column private String country; }

Eclipse Store App (Jakarta Explains NoSQL).

For the third application, we leverage the unique capabilities of the Eclipse Store, a single NoSQL database for in-memory storage and object serialization. Unlike previous databases, Eclipse Store works directly with the object structure, eliminating additional sequential processing. The corresponding annotations are still used to map Beer and Address interfaces to the Eclipse repository. However, Jakarta Data directly manages the interaction with the object structure, ensuring smooth and efficient data storage and query execution. Developers can use Eclipse's in-memory storage without worrying about serialization complexities.

Figure 5. Eclipse Store is the thinnest persistent tier of the three applications.

The modeling of Microstream, Beer and Address in Eclipse Store is similar to Eclipse JNoSQL, Couchbase and MongoDB. However, the sequential process will be completely different. While document-based NoSQL databases (Couchbase and MongoDB) store data in JSON or BJSON format, Eclipse Store stores data differently using the corresponding Java classes.

This approach reduces latency and saves processing power by eliminating the overhead associated with serialization and deserialization. The Eclipse Store improves data storage and retrieval by working directly with Java components, delivering faster application performance and efficient data management.

Eclipse Store հպանմարությունից՝ դարձնելով այն գրավ իչ տարբերակ այն հավելվածների համար, որոնք հենվում են ցածր հետաձգմա ն և բարձր կատարողականության վրա: Մոդելավորման կառուցվածքը համահուն NoSQL արման Eclipse Eclipse Eclipse Eclipse A ման համար:

Նbed

cordial A News Jakarta Persistence Jakarta NoSQL Information յուններին, բաղադրիչներն իրենք համահունչ են կիրառական ծրագրերում:

BeerRepository ինտերֆեյսը համօգտագործվում է բոլոր երեք հավելվածների կողմից և ընդլայնում է PageableRepository : Միացնում է Pageable Page : Տվյալների բազայի ինտերֆեյսի այս մատակարարը համակարգված կերպով օգտագործում է հարցումների հետագծման կոնվենցիա ստեղծելու հարցումներ, որոնք հատուկ հարցումներ են վերադարձնում տվյալների բազայում: Անոտացիաները սուբյեկտներից վերացարկելով՝ մատակարարը կառավարում է քարտեզագրումը Java դասերի և հիմքում ընկած տվյալների բազայի միջև՝ դարձնելով այն կատարյալ Java օգտագործողի համար:

@Repository public interface BeerRepository extends PageableRepository<Beer, String> { Page<Beer> findByHopOrderByName(String hope, Pageable pageable); Page<Beer> findByMaltOrderByName(String malt, Pageable pageable); Page<Beer> findByMaltAndHopOrderByName(String malt, String hop, Pageable pageable); }

BeerResource դասը օգտագործում է սովորական HTTP բայեր, ինչպիսիք են GET , POST և DELETE ՝ API-ի փոխազդեցությունները կառավարելու համար: Թեև ուշադրությունը կենտրոնացված չէ ամբողջական API-ի ստեղծման վրա, ռեսուրսներ բաժինը ներկայացնում է Ջակարտայի կայուն շերտի հնարավորությունները: BeerResource դասը ծանոթագրված է @ApplicationScoped , @Path , @Produces և @Consumes ներով՝ նշելու ռեսուրսի վերջնակետը, արձագանքը և մեդիայի տեսակները: Դասը պարունակում է տարբեր պարամետրերով նոր գարեջուրներ ստեղծելու մեթոդներ (օրինակ՝ գայլուկ, ածիկ կամ երկուսն էլ), գարեջուրները ID-ով ջնջելու և փորձարկման համար գարեջրի պատահական տվյալներ ստեղծելու համար:

@ApplicationScoped @Path("beers") @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) public class BeerResource { private final BeerRepository repository; @Inject public BeerResource(BeerRepository repository) { this.repository = repository; } @Deprecated BeerResource() { this(null); } @GET public List<Beer> findByAll(@BeanParam BeerParam param){ if(param.isMaltAndHopQuery()){ return this.repository.findByMaltAndHopOrderByName(param.malt(), param.hop(), param.page()).content(); } else if(param.isHopQuery()) { return this.repository.findByHopOrderByName(param.hop(), param.page()).content(); } else if(param.isMaltQuery()) { return this.repository.findByMaltOrderByName(param.malt(), param.page()).content(); } return this.repository.findAll(param.page().sortBy(Sort.asc("name"))).content(); } @POST public void create(Beer beer){ this.repository.save(beer); } @DELETE @Path("{id}") public void deleteById(@PathParam("id") String id){ this.repository.deleteById(id); } @Path("random") @POST public void random() { var faker = new Faker(); for (int index = 0; index < 1_000; index++) { var beer = Beer.of(faker); this.repository.save(beer); } } }

Ճարտարապետության շերտերը, ներառյալ ռեսուրսները և տվյալների պահեստները, համօգտագործվում են բոլոր ադապտերների վրա՝ ապահովելու հետևողականությունը և կոդի վերօգտագործումը: Տարբերությունները տեղի են ունենում մոդելավորման մակարդակում, որտեղ յուրաքանչյուր ադապտեր իրականացնում է անհրաժեշտ ծանոթագրությունները և հաջորդական գործընթացները իրենց համապատասխան տվյալների բազաների համար: Թեև տվյալների բազայի հատուկ բաղադրիչներից բաղադրիչների մեկուսացումը կարող է մեծացնել մեկուսացումը, այն կարող է նաև հանգեցնել ավելի շատ շերտերի և ավելի շատ կոդերի: Հետևաբար, ներկայիս կոլեկտիվ մոտեցումը հավասարակշռության է հասնում բացառման և զսպման միջև:

Նկար 6. Ճարտարապետական դիագրամ, որտեղ ծրագրավորողը կարող է նույնականացնել կազմակերպությունը՝ չազդելով տվյալների բազայի շարժիչի տվյալների մոդելի վրա:

Ընդհանուր առմամբ, մատակարարը և ընդհանուր ճարտարապետական բաղադրիչները ծրագրավորողներին հնարավորություն են տալիս արդյունավետ աշխատել տվյալների բազայի տարբեր տեխնոլոգիաների հետ՝ միաժամանակ պահպանելով տվյալների ինտեգրման և API-ի փոխգործունակության հետևողական և ստանդարտացված մոտեցում: Առանձին դասերում և անոտացիաներում տվյալների բազայի տարբեր ոճեր վարելու ունակությունը հեշտացնում է հավելվածների զարգացումը և խթանում է անխափան բազմալեզու կայունությունը ժամանակակից ձեռնարկատիրական ծրագրերում:

Դիպլոմ

Այս բնութագրի ներդրումը ներկայացնում է տվյալների ինտեգրումը և կայունությունը ժամանակակից ձեռնարկությունների Java հավելվածներում պարզեցնելու փորձ: Այս առաջարկված ճշգրտումը ապահովում է ստանդարտ API, որը ինտեգրվում է Ջակարտայի այլ EE տեխնոլոգիաների, ինչպիսիք են Jakarta Persistence, Jakarta NoSQL, Jakarta Context and Dependency Verification (CDI) և Jakarta Validation: Այս մոտեցման ճկունությունն ու հարմարվողականությունը թույլ է տալիս ծրագրավորողներին օգտագործել պոլիգլոտի ճկունությունը՝ օգտագործելով տվյալների բազայի տարբեր ոճերի ուժեղ կողմերը՝ միաժամանակ պահպանելով կոդերի հետևողական բազան:

Այս հոդվածում մենք ուսումնասիրեցինք NoSQL տվյալների բազաների երեք կիրառություն՝ հարաբերականից մինչև փաստաթղթերի վրա հիմնված տվյալների բազաներ, որոնցից յուրաքանչյուրը օգտագործում է տվյալների բազայի տարբեր ոճ: Տվյալների բազայի այս տարբեր տեխնոլոգիաների հետ աշխատելու նրա կարողությունը ցույց է տվել իր բազմակողմանիությունն ու շարժունությունը՝ հեշտացնելով տվյալների հասանելիությունն ու կառավարումը մշակողների համար: Այս մոտեցումը վերացնում է սերիականացման և տարբեր տվյալների բազաների հետ փոխազդեցության բարդությունը՝ ապահովելով, որ մշակողները կարող են կենտրոնանալ իրենց հիմնական բիզնես տրամաբանության վրա՝ առանց շտեմարանի հատուկ կոդի բարդության ծանրաբեռնվածության:

Այս մոտեցման եզակի ուժեղ կողմերից մեկը Ջակարտայի այլ EE բնութագրերի հետ անխափան ինտեգրումն է, որը խթանում է համահունչ և ամուր ձեռնարկության ճարտարապետությունը և հնարավորություն ընձեռելով ծրագրավորողներին հեշտությամբ ստեղծել ամուր և մասշտաբային հավելվածներ՝ տարբեր տվյալների պահանջներին համապատասխանելու համար:

Այս մոտեցումը, ըստ երևույթին, խոստումնալից ապագա ունի Ջակարտայի ԷԱ պլանում, որը կներառվի 11-ում: Որպես բաց կոդով նախագիծ, մշակողները և Java-ի էնտուզիաստները հնարավորություն ունեն քննարկելու Java-ի համառության ապագան: Ակտիվորեն մասնակցելով բաց կոդով համայնքին՝ ծրագրավորողները կարող են օգնել ձևավորել այս մոտեցման ուղղությունը և Java-ի ճկունության լանդշաֆտը՝ այն համապատասխան և ամուր պահելու ժամանակակից ձեռնարկությունների հավելվածների կարիքներին:

Այս մոտեցումը հետագա ուսումնասիրելու և գործնական փորձ ձեռք բերելու համար այս հոդվածի կոդերի նմուշները հասանելի են մեր GitHub պահոցում:

Բացի այդ, եթե դուք հետաքրքրված եք ակտիվորեն մասնակցելու կամ ծրագրի, ծրագրի հանդիպումների և սկզբնաղբյուրի մասին ավելին իմանալու, մենք հրավիրում ենք ձեզ այցելել համապատասխան մանրամասներ: