Skip to content
javahacks.dev
Jakarta EE

Jakarta EE 11 New Features Explained With Practical Impact

What Jakarta EE 11 changes for application developers: the Java baseline, Jakarta Data, virtual thread support, updated specifications and removals.

6 min read
Summarize in AI
Flat illustration of a request passing through a servlet container, with the OpenJDK, Apache Tomcat and Spring logos.

Jakarta EE 11 is the first release of the platform that treats Java 17 as the floor, a modern persistence-and-data story as a headline feature and virtual threads as a supported way to run managed concurrency. It also quietly retires several pieces of legacy API. If you write enterprise Java on Payara, WildFly, Open Liberty, GlassFish or TomEE, or you depend on Jakarta specifications through Spring or Quarkus, some of this changes your code and some of it only changes what you can expect from the next server upgrade. This post separates the two. It covers the baseline, Jakarta Data with working code, virtual thread support, the updated specifications, what was removed, and a Monday checklist. The release was finalized in 2025 and the details here follow the Jakarta EE 11 release page.

Java baseline

The platform requires Java 17 or later, and supports Java 21 and later as the target for new features. In practice, a certified implementation runs on 17, 21 and 25, and the features that depend on newer language runtime capabilities, such as virtual threads, need 21 or later. If you are on Java 11, this is the release that forces the upgrade. The path through the language changes is in the modern Java guide.

Two cleanups followed from the new baseline. The platform no longer builds on the Security Manager, which Java deprecated for removal, so the permission-based references in the specifications were removed. And specification APIs can use records and sealed types in their own surface, where earlier ones were limited to what Java 8 offered.

The namespace did not change. If you already moved from javax to jakarta for Jakarta EE 9 or 10, imports stay as they are. The previous release and what it introduced are in Jakarta EE 10 new features.

Jakarta Data

Jakarta Data 1.0 is the largest new specification. It defines repository interfaces that the runtime implements for you, so a data-access class becomes an interface with annotated methods. If you have used Spring Data, the shape is familiar, with one important difference: the annotations say what a method does, and method names are not parsed into queries.

src/main/java/dev/javahacks/shop/Products.javajava
package dev.javahacks.shop;

import jakarta.data.repository.CrudRepository;
import jakarta.data.repository.Find;
import jakarta.data.repository.Query;
import jakarta.data.repository.Repository;
import jakarta.data.page.Page;
import jakarta.data.page.PageRequest;
import java.util.List;

@Repository
public interface Products extends CrudRepository<Product, Long> {

    @Find
    List<Product> byCategory(String category);

    @Find
    Page<Product> byCategory(String category, PageRequest page);

    @Query("where price < :limit order by price")
    List<Product> cheaperThan(java.math.BigDecimal limit);
}

Inject it like any CDI bean:

src/main/java/dev/javahacks/shop/CatalogService.javajava
@ApplicationScoped
public class CatalogService {

    @Inject
    Products products;

    @Transactional
    public Page<Product> browse(String category, int pageNumber) {
        return products.byCategory(category, PageRequest.ofPage(pageNumber).size(20));
    }
}

@Find matches method parameters to entity attributes by name, @Query takes Jakarta Data Query Language (a subset of the persistence query language), and PageRequest with Page gives offset pagination in the API itself. There are also @Insert, @Update, @Delete and @Save for lifecycle methods, and Sort and Order parameters. The repository can sit on Jakarta Persistence entities, and a provider can also support other stores such as NoSQL databases. Hibernate ships a Jakarta Data implementation, and the specification text is at jakarta.ee/specifications/data.

Know what it does not do: a provider's repository is only as good as the query it generates, so look at the SQL, as you would for any ORM. Features beyond the spec (derived query keywords, projections in some providers) are vendor extensions and tie you to that vendor.

Virtual threads in Concurrency

Jakarta Concurrency 3.1 adds virtual thread support to the managed executors. A managed executor definition can ask for virtual threads, so tasks submitted to it run on cheap threads that park instead of blocking an operating system thread:

java
@ManagedExecutorDefinition(
        name = "java:app/concurrent/ioExecutor",
        virtual = true)
@ApplicationScoped
public class ExecutorConfig { }
java
@Resource(lookup = "java:app/concurrent/ioExecutor")
ManagedExecutorService ioExecutor;

public CompletableFuture<String> fetch(String url) {
    return ioExecutor.supplyAsync(() -> httpClient.get(url));
}

The attribute virtual = true is the whole switch. The container still propagates the security and transaction context you configure, which is the reason to use the managed executor and not Executors.newVirtualThreadPerTaskExecutor() directly inside a Jakarta server. Requires Java 21 or later. Two cautions apply, as with virtual threads anywhere: they help I/O-bound waiting and do nothing for CPU-bound work, and code that holds a monitor (a synchronized block) while blocking can pin the carrier thread on older runtimes.

Updated specifications

Most other specifications moved forward with smaller, concrete changes.

SpecificationVersionWhat it means for you
Persistence3.2Records as embeddables, java.time.Instant and Year support, findMultiple and new query language functions
Servlet6.1Clarifications, new HttpServletRequest methods, removal of Security Manager references
Faces4.1Cleanup, UIData and Part improvements, removal of deprecated API
CDI4.1Core clarified, Bean Validation interplay and removal of deprecated features
Validation3.1Support for records as constraint targets
Security4.0Alignment with the new baseline and the removal of Security Manager references
Concurrency3.1Virtual threads, as above
Data1.0New: repositories

The persistence change that most code will notice is records. An @Embeddable can now be a Java record, which fits the value-object style:

java
@Embeddable
public record Address(String street, String city, String postalCode) { }

@Entity
public class Customer {
    @Id Long id;
    Address billing;
}

If you have been mapping this with a mutable class and getters, you can shrink it, subject to what your provider supports at the version you run. For the mapping decisions around such types, see the Hibernate and JPA guide.

Removals

Platform releases remove things that were deprecated for several versions. Jakarta EE 11 removes the Jakarta Managed Beans specification from the platform. A class annotated with @ManagedBean stops being a bean on a strict Jakarta EE 11 runtime and should be a CDI bean instead (@Named plus a scope). The same consolidation is why mixing bean models in JSF is discouraged, as laid out in JSF managed beans vs CDI beans. Other removed or optional pieces include a number of long-deprecated APIs in Servlet and Faces, and several profiles' references to the Security Manager. Check each server's compatibility notes, because the Web Profile, Core Profile and Platform each carry a different set.

The practical test is a recompile. Search your sources for javax.annotation.ManagedBean, jakarta.annotation.ManagedBean, @ManagedBean on JSF beans and calls to methods the Javadoc marks as removed, then let the compiler tell you the rest.

What to do on Monday

  1. Confirm your target server supports Jakarta EE 11 and which profile. Compatible implementations are listed on the release page.
  2. Move the build to Java 21 or 25 and the runtime to the same, so everything on the page above is available.
  3. Replace @ManagedBean with CDI beans, and recompile against the 11 APIs to find removed methods.
  4. Pick one repository class that is mostly CRUD and try rewriting it as a Jakarta Data repository behind a feature branch, then compare the generated SQL.
  5. If a service waits on remote calls, trial a virtual-thread managed executor and measure with the load you actually see.
  6. Keep dependencies on the specification APIs at provided scope so the server's version wins.

This is an upgrade of the platform, not a rewrite. Apps that moved to Jakarta EE 10 usually need an afternoon of recompilation rather than a project, while apps still on javax have the bigger step first, described in what replaced Java EE.

Where this does not apply

If you run Spring Boot, you consume parts of Jakarta EE (servlet, validation, persistence) but not the platform as a whole. Boot 4 aligns with the Jakarta EE 11 baseline for those pieces, and Jakarta Data is not part of Spring's programming model; Spring Data fills that role. If your servers are pinned to a vendor release that has not yet certified Jakarta EE 11, you cannot use these features, no matter what the specification says. And a monolith that works on Java EE 8 under a supported contract does not need this release; the cost is in the namespace change that comes first.

Share

Keep reading

Get new posts by email

We send one email when a new post is published. No spam.

Unsubscribe in one click. No spam, ever.