Jakarta EE 12: Empowering Java Architects in the Era of AI and Data

For Java software architects, Jakarta EE 12 is a pivotal release that addresses the industry’s evolving demands, including AI adoption and rapid data growth. As intelligent applications and large-scale data processing transform business requirements, enterprise platforms must offer agility, scalability, and integration with modern technologies. Jakarta EE 12 provides the tools, APIs, and cloud-native features needed to design robust, secure, AI-ready, and data-centric systems.

This session will show why Jakarta EE 12 is essential for architects designing next-generation enterprise solutions. We’ll discuss how its latest features enable you to leverage AI, manage large data volumes, and maintain architectural flexibility in a rapidly changing environment. By participating in the Jakarta EE and Eclipse Foundation community, architects can drive innovation and benefit from broad industry collaboration. In the Data Age, Jakarta EE 12 positions you to lead now and in the future.

Transcript

1. Jakarta EE 12: Advancing Enterprise Java Together Open standards, modern data, and strong foundations for enterprise Java Otávio Santana Founder, Software Engineer & Architect otavio@os.expert
2. Why Standards Matter Civilization advances when people agree on shared rules 01 02 03 04 05      Communication Science Commerce Money Technology Shared language, alphabet, symbols Measurement, units, repeatability Contracts, weights, formats, exchange Currency systems, trust, common value Protocols, APIs, interoperability “Before interoperability in software, there was interoperability in civilization.”
3. Why Jakarta EE Matters A shared enterprise programming model built through collaboration Developers Application Creators Community Vendors Global Contributors Commercial Support Jakarta EE ECOSYSTEM Eclipse Foundation Implementers Runtimes & Servers Open Governance Spec Projects API Standards  Standard APIs  Compatible Implementations  Vendor Choice  Portability  Long-Term Evolution  Community-Driven Design Consistent specification across enterprise workloads TCK-tested compliance guaranteeing reliability Avoid lock-in with multiple production runtimes Seamless migration across cloud and hybrid environments Sustainable innovation with strong backward compatibility Open development process shaped by real-world needs “Jakarta EE is not one product; it is a shared enterprise programming model.”
4. Humans Have Always Needed Persistence Persistence is not a new technological problem—it is an ancient human need. 01 02   Caves Clay Tablets Prehistoric Ancient 03  Temples & Archives Classical 04 05   Libraries Databases Medieval Digital Era 06  Distributed Data Modern
5. “Stateless” Does Not Mean “No State” The state still exists — it simply moves somewhere else STATELESS APPLICATION Ephemeral Execution & Logic Where did the state go?      Database Cache Event Store Object Storage Vector Store
6. The Database Landscape Has Expanded 26,083 Multiple database technologies now have significant developer adoption Survey Respondents PostgreSQL 55.6% MySQL 40.5% SQLite Redis MongoDB Source: Stack Overflow Developer Survey 2025 37.5% 28.0% 24.0%
7. Polyglot Persistence in Modern Applications Different workloads may require different persistence models inside the same system Transactions Cache / Sessions   Distributed Scale  Relational Key-Value Column JAVA APPLICATION Core Business Logic & Services Flexible Content Relationships   Document Graph Telemetry Semantic Search / AI   Time Series Vector
8. Is Java Ready for the Data Age? The ecosystem already provides specialized and common persistence models     Jakarta Persistence Jakarta NoSQL Jakarta Data Jakarta Query Relational / ORM Non-Relational Repository Pattern Expressive Queries Standardized object-relational mapping for SQL databases Seamless integration across NoSQL databases Decoupled data access with simplified declarative semantics Type-safe fluent API for querying complex datasets
9. Jakarta Persistence A mature programming model for relational data Entity & EntityManager Operations Object-Relational Mapping Declarative metadata mapping attributes to columns // 1. Map relational tables with simple annotations @Entity public class Product { @Id private Long id; private String name; } // 2. Execute basic persistence operations Entity Lifecycle Managed states: New, Managed, Detached, Removed Persistence Context First-level cache tracking entity instance changes // Persist a new entity instance entityManager.persist(product); // Find entity by primary key Product product = entityManager.find( Product.class, id); Transactions & Queries ACID transaction integration with JPQL & Criteria API
10. Relational Data Is About Relationships Jakarta Persistence models associations directly in the domain @OneToMany Customer @Entity 1 N @ManyToOne @ManyToMany Order N @Entity M Product @Entity @OneToOne @OneToMany @ManyToOne @ManyToMany Single domain instance directly mapped to another single instance. One entity references a collection of target entities. Most common child-to-parent association link. Bidirectional or unidirectional collection associations.
11. Relational Data Is About Relationships Object relationships map directly to relational associations Domain Model (Jakarta Persistence Mappings) @Entity public class Customer { @Id private Long id; @OneToMany(mappedBy = "customer") private List<Order> orders; } @Entity public class Order { @Id private Long id; @ManyToOne private Customer customer; @ManyToMany private Set<Product> products; } Customer @Entity Order @Entity @OneToMany / @ManyToOne Parent-child association between Customer and Order @ManyToMany Bidirectional join association between Order and Product Product @Entity @OneToOne Single instance mapping: Directly associates a single domain instance to another single instance.
12. Jakarta Persistence 4.0 More direct access, safer queries, and better control EntityAgent Direct Mutation EntityAgent Direct insert, update, delete, and upsert operations without full persistence context overhead. // Direct mutation without entity state management factory.runInTransaction(EntityAgent.class, agent -> { agent.update(book); }); Static Queries Compile-time checked query methods designed to integrate seamlessly with Jakarta Data. Criteria Builder from JPQL Base Criteria from JPQL // Parse JPQL string into dynamic Criteria Start with an intuitive JPQL query string and refine it dynamically with type-safe Criteria APIs. CriteriaQuery<Book> query = builder.createQuery( Book.class, "from Book left join fetch authors" ); Better Runtime Control Configurable lazy defaults, explicit fetch options, and finer control over flush behavior. query.where( book.get(Book_.title).like("%Persistence%") );
13. Jakarta Persistence 4.0 Meets Jakarta Data New query annotations bridge persistence-specific capabilities into repositories JPQL in a Jakarta Data repository Native SQL when relational-specific control is needed @Repository public interface Products extends DataRepository<Product, Long> { @NativeQuery(""" select * from products where available = true and price < ? """) @JakartaQuery(""" from Product where category = :category order by price """) @QueryOptions(timeout = 2_000) List<Product> findAvailable(float maxPrice); List<Product> findByCategory(String category); } @JakartaQuery Jakarta Data Repository @NativeQuery JPQL / SQL Capabilities @QueryOptions Jakarta Persistence Provider
14. Jakarta NoSQL A Java programming model for six non-relational data models Key-Value Column Document Graph Time Series Vector
15. Template A common API designed to remain extensible across different NoSQL models Template Core API (Common Operations) insert(...) update(...) find(...) delete(...) select(...) query(...) Supported NoSQL Models  Key-Value  Column  Document  Graph  Time Series  Vector Provider / Model Extensions (Optional Specific Capabilities) Custom Extensions & Native Features Allows underlying database drivers to expose specialized operations, native query languages, or model-specific enhancements without breaking the common API foundation.
16. Familiar Annotation Model Jakarta NoSQL reuses familiar mapping concepts while extending them for NoSQL needs Core Mapping Composition & Reuse @Entity @Embeddable @Id @MappedSuperclass @Column Inheritance Conversion & Projection @Inheritance @Convert @DiscriminatorColumn @Converter @DiscriminatorValue @Projection 💡 Familiar concepts for Jakarta Persistence developers help drastically reduce cognitive load when modeling NoSQL entities.
17. Product Mapping Persistable attributes must be explicitly mapped Product.java @Entity public class Product { @Id private String id; @Column private String name; @Column private String category; @Column private BigDecimal price; // Unannotated field: NOT persisted private String internalComment; } ⚠ Important In Jakarta NoSQL, persistable attributes should be explicitly annotated. Unannotated attributes are ignored.
18. Core Operations Common persistence operations without a query builder Insert Product product = new Product(...); template.insert(product); Update product.setName("Updated Name"); template.update(product); Find Optional<Product> product = template.find(Product.class, id); Delete template.delete(Product.class, id);
19. Fluent Operations Compose richer selections and deletions through a fluent API Fluent Select Fluent Delete List<Product> products = template.delete(Product.class) template.select(Product.class) .where("status").eq(ProductStatus.DISCONTINUED) .where("category").eq(ProductCategory.BOOK) .execute(); .and("price").lt(new BigDecimal("50")) .result(); Method Flow select Method Flow where and result delete where execute
20. Jakarta NoSQL 1.1 Richer mapping and more expressive fluent operations Automatic Converters Reduce manual conversion between Java types and database representations Richer Entity Mapping (Map Support) // Map attributes directly to document structures @Column private Map<String, Skill> skills; Richer Mapping Support structured attributes such as maps and nested values Fluent Update API // Expressive & type-safe fluent updates Fluent Update API Compose updates using a fluent programming model template.update(Car.class) .set("available").to(false) .where("type").eq(CarType.CLASSIC) .execute();
21. Different APIs, Familiar Patterns Persistence technologies differ, but developers repeat many of the same operations Jakarta Persistence RELATIONAL Jakarta NoSQL NON-RELATIONAL persist(...) Create / Save insert(...) Create / Save find(...) Read / Lookup find(...) Read / Lookup remove(...) Delete delete(...) Delete createQuery(...) Search / Filter select(...) Search / Filter Shared Developer Operations  Save  Find  Delete  Sort  Paginate  Query
22. Jakarta Data: The Common Ground Standardize recurring data-access patterns without replacing specialized APIs JAKARTA DATA COMMON GROUND Repository CRUD Pagination Centralized Data Interface Standard Lifecycle Operations Page & Cursor Scrolling Ordering Queries Restrictions Declarative Sorting Rules Method Name & Query Language Type-Safe Criteria & Filtering Jakarta Persistence Jakarta NoSQL Relational specialization Non-relational specialization
23. Repository A common programming model above different persistence technologies Products.java // Jakarta Data Repository Products Jakarta Data Repository @Repository public interface Products extends CrudRepository<Product, String> { // Simple finder method List<Product> findByCategory(String category); } Jakarta Persistence Jakarta NoSQL Relational model NoSQL models Specialized SQL performance, explicit mapping, & transactional guarantees Key-Value · Column · Document · Graph · Time Series · Vector
24. Custom Repository Repositories can speak the language of the domain ParkingLotRepository.java // Domain-centric repository interface @Repository public interface ParkingLotRepository { // Domain operation: park a car void park(Car car); Generic CRUD Technical Vocabulary • save(...) • find(...) • delete(...) // Domain operation: remove a car void remove(Car car); // Domain query: find cars by type List<Car> findByType(CarType type); } Domain-Centric Repository Business Vocabulary • park a car • remove a car • find cars by type
25. Annotation-Based Operations Jakarta Data supports declarative repository operations CarRepository.java Mutation Operations // Declarative annotated operations @Repository public interface CarRepository { @Insert void add(Car car); @Update void update(Car car); @Delete void remove(Car car); @Save Insert or update entity automatically @Insert Persist new entity instances @Update @Delete Modify existing persistent state Remove matching entity records @Find List<Car> findByType(CarType type); } Query Operations @Find @Query Declarative parameter-based lookup Execute explicit query language statements
26. Pagination Jakarta Data supports both offset and cursor pagination OffsetPaginationExample.java CursorPaginationExample.java // Traditional page-based lookup // Forward navigation via cursor token PageRequest page = PageRequest.ofSize(10).page(2); Page<Car> cars = repository.findAll(page); CursoredPage<Car> cars = repository.findByType( CarType.CLASSIC, PageRequest.ofSize(10), cursor ); Offset Pagination Cursor Pagination Best for fixed page numbers & traditional UI pagination controls. Optimized for continuous scrolling & high-frequency data updates. Page 1 Page 2 Page 3 Cursor A next items Cursor B
27. Fluent Queries Jakarta Data 1.1 expands dynamic queries with a rich fluent API ProductQueryExample.java Dynamic Restrictions Compose conditions at runtime // Type-safe dynamic query composition List<Product> found = products.findAll( Static Metamodel Use _Product attributes for type-safe query construction Fluent Ordering Build sorting rules in a composable way Readable Query Composition Keep dynamic queries expressive and domain-oriented Restrict.all( _Product.type.equalTo(PHYSICAL), _Product.price.greaterThan(10.00f), _Product.name.contains("Jakarta") ), Order.by( _Product.price.desc(), _Product.name.asc() ) );
28. Stateful Repository Operations Some repository features are especially valuable for relational persistence Products.java EagerFetchingExample.java // Jakarta Data stateful repository interface // Explicit fetch hints for eager attribute loading @Repository public interface Products extends DataRepository<Product, String> { @Find @Fetching(_Product.CATEGORY) @Fetching(_Product.SUPPLIER) Product productWithDetails(String id); @Persist void add(Product product); @Merge Product merge(Product product); @Remove void remove(Product product); @Refresh void reload(Product product); @Detach void detach(Product product); Optimization Hints • Hints that specific returned attributes will be accessed • Helps the implementation fetch them efficiently } 💡 Especially relevant for relational repositories backed by Jakarta Persistence
29. Jakarta Query One object-oriented query foundation across the Jakarta data ecosystem BEFORE Fragmented Query Models Capabilities defined independently across separate specifications with redundant and divergent syntax. JPQL JD-QL Jakarta Persistence Jakarta Data Jakarta NoSQL JNoSQL UNIFIED APPROACH Unified Query Standard Extracts the shared object-oriented query model into a single foundational specification. Jakarta Query Shared OO Foundation Key Advantages • Single learning curve across specifications • Consistent AST & type-safe metamodel • Seamless portability between persistence layers Common AST • Parser • Metamodel • Dialects
30. JCQL and JPQL Common capabilities for many datastores, richer semantics for relational persistence COMMON SUBSET EXTENDED RELATIONAL Jakarta Common Query Language Jakarta Persistence Query Language JCQL JPQL • Common query capabilities • Richer relational query semantics • Designed to be implementable across multiple datastore technologies • Relevant to Jakarta Persistence • May also be supported by Jakarta Data providers backed by relational persistence • Relevant to Jakarta Data and Jakarta NoSQL • Intentionally avoids relational-only assumptions LANGUAGE RELATIONSHIP JPQL Richer Relational Semantics Extends JCQL with relational features JCQL (Common Subset) Universal baseline across all datastore providers
31. One Query Foundation, Different APIs Jakarta Query connects repository-style and persistence-style programming models Jakarta Data JCQL @Repository public interface Products extends DataRepository<Product, String> { @Query(""" WHERE type = :type AND price > :price ORDER BY price """) List<Product> find(ProductType type, float price); Jakarta Persistence List<Product> products = entityManager .createQuery(""" SELECT p FROM Product p WHERE p.type = :type AND p.price > :price ORDER BY p.price """, Product.class) .setParameter("type", ProductType.PHYSICAL) .setParameter("price", 10.0f) .getResultList(); } Jakarta Data Jakarta Persistence JCQL (Common Subset) JPQL (Extended Relational) Jakarta Query JPQL
32. Jakarta NoSQL 1.1 Query API String-based queries, parameter binding, and typed projections Query API & Binding PARAMETERS List<Car> cars = template.query( "FROM Car WHERE type = :type" ).bind("type", CarType.SPORT).result(); Optional<Car> car = template.query( "FROM Car WHERE id = :id" ).bind("id", 42).singleResult(); • QUERY STRING Intuitive string-based query syntax Typed Projections PROJECTION @Projection public record TechCarView( String name, CarType type ) {} List<TechCarView> cars = template.typedQuery( "FROM Car WHERE type = 'SPORT'", TechCarView.class ).result(); • @PROJECTION ANNOTATION • PARAM BINDING Maps custom database shape directly to lightweight DTOs Safe named parameter injection • RECORD-BASED PROJECTION Leverages modern immutable Java Records for clean mapping • LIST RESULT • SINGLE RESULT Retrieve multi-record collections Safe Optional-based retrieval • TYPED QUERY RESULT Strongly-typed template queries without manual mapping
33. Jakarta Agentic AI Enterprise AI still needs an enterprise programming model AGENTIC WORKFLOW MODEL @Agent @Trigger @Decision @Action @Outcome Autonomous Context Event / Signal LLM / Logic Reasoning Tool / Service Exec State Mutation FOUNDATIONAL ENTERPRISE CONCERNS Dependency Injection Managed Agent Beans Lifecycle Scoped Contexts Concurrency Async & Virtual Threads Data Persistence & Vectors Security AuthN/AuthZ & Guardrails Observability Tracing & Audit Logs ARCHITECTURAL STATEMENT "AI changes the workload, not the need for sound software foundations."
34. Agent Sample An agent is still an application component MonitoringAgent.java @Agent public class MonitoringAgent { @Inject LargeLanguageModel llm; @Inject AlertRepository repository; @Trigger public void onSystemAlert(Alert alert) { } @Decision public boolean shouldEscalate(Alert alert) { return llm.query( "Should this alert be escalated?", alert ).contains("yes"); } } @Action public void escalate(Alert alert) { // notify operations team } Architectural Mapping JAVA AGENT FOUNDATIONS @Inject → CDI Dependency injection and lifecycle management AlertRepository → Data Persistence, querying, and transactional context Agent Execution → Concurrency Async processing, virtual threads, and event handling LargeLanguageModel → LLM Integration Managed AI service integration and prompt context EXECUTION FLOW Alert Decision Escalation @Trigger @Decision / LLM @Action
35. CDI 5.0 Overview The glue that keeps modern enterprise applications coherent Agentic AI Jakarta Persistence dependency injection producers Jakarta Data lifecycle Jakarta Concurrency CDI 5.0 interceptors scopes events Jakarta NoSQL Jakarta Security Jakarta REST "New application models still depend on strong software foundations."
36. CDI 5.0: Lifecycle Improvements More explicit control over startup, fallback, and cleanup STARTUP CLEANUP FALLBACK @Eager @AutoClose @Reserve Initialize beans eagerly instead of waiting for first use. Automatically close AutoCloseable beans upon context destruction. Define fallback/default beans that can be gracefully replaced. @Eager @ApplicationScoped class CacheWarmup { // initialized // on startup } @Produces @AutoClose Connection connect() { return new Connection(); } @Reserve class DefaultNotifier implements Notifier { // overridden if // custom present }
37. Jakarta Concurrency 3.2 Container-managed concurrency for modern Jakarta applications CORE CONCURRENCY OBJECTS ARCHITECTURE FLOW ManagedExecutorService Application Managed Container Asynchronous task execution managed by the container with task propagation. Business Code Executor Context PROPAGATED CONTAINER CONTEXTS ManagedScheduledExecutorService Delayed and periodic task execution within container-managed contexts. ContextService Security CDI Principal & Subject Request & Custom Scopes Naming Lifecycle java:comp JNDI Context Clean Thread Shutdown Captures and propagates container contexts to custom threads or tasks. ManagedThreadFactory Creates managed threads that inherit container context and lifecycle. @Inject ManagedExecutorService executor; executor.submit(() -> { processOrder });
38. Concurrency 3.2: Declarative Control Limit, lock, and schedule concurrent work declaratively LOCK THROTTLE CRON @Lock @MaxConcurrency @Schedule Control concurrent access with declarative read/write locks. Limit parallel execution across bean invocations. Declaratively schedule periodic method execution. @Lock(READ) public Data getData() { // concurrent reads return this.data; } @MaxConcurrency(5) public void process(Job job) { // managed concurrent // work bounded to 5 } @Schedule(cron = "0 */5 * * * ?") public void refreshCache() { // background task }
39. Jakarta EE 12: Even More More platform evolution beyond the topics covered today WEB & HTTP SECURITY Jakarta Security 5.0 Simplified cloud identity standards Auth & Authz Evolution Modern authentication flows SecurityManager Removal Jakarta REST 5.0 EXPRESSION & PRESENTATION Expression Language 6.1 Enhanced evaluation capabilities Jakarta Pages 4.1 & Tags 3.1 Modern web view & tag libraries Aligned with Java SE direction Modern alignment & async APIs Jakarta Servlet 6.2 Enhanced core HTTP handling Jakarta WebSocket 2.3 Real-time web protocol features Jakarta Faces 5.0 DATA FORMATS & VALIDATION PLATFORM MODERNIZATION Cleaned component model HTTP/3 direction Next-gen protocol readiness JSON-B 3.1 & JSON-P 2.2 Java SE 21+ Baseline Jakarta Validation 4.0 API Cleanup & Profiles Updated JSON binding & processing Refined constraint metadata & types Leveraging modern language features Broader evolution, Config & HTTP Jakarta EE 12 evolves across the whole platform, even beyond the specifications discussed in this session.
40. Expert Otavio Santana Software Engineer & Architect Java Champion, Oracle ACE JCP-EC-EG-EGL Apache and Eclipse Committer Jakarta EE and MicroProfile Duke Choice Award JCP Award Book and blog writer
41. Thank you! Otávio Santana OS Expert Founder, Software Engineer & Architect otavio@os.expert https://twitter.com/otaviojava https://www.linkedin.com/in/otaviojava/ https://www.youtube.com/@otaviojava
42. Session Feedback & Voting Your input helps us improve future talks — thank you for participating! WE VALUE YOUR VOICE Rate & Share Feedback Please take 1 minute to vote and leave feedback for "Jakarta EE 12: A Platform for the Next Decade of Java". How to participate: • Open your phone camera or QR scanner • Scan the QR code on the right • Submit your rating & comments SCAN TO VOTE