Jakarta EE

Jakarta EE Survey 2022

Do you want to have a say in what happens for the next version of Jakarta EE? Check out the new edition of the Jakarta EE Survey 2022 by OmniFish, which follows the tradition of the bi-annual OmniFaces surveys. The purpose of the survey is to help everybody understand the current status of the Jakarta EE ecosystem, what we as a community represent, which parts of Jakarta EE we all use the most and what we all expect from Jakarta EE in the future.

We’d like to invite all Jakarta EE users to participate in the survey here:

EJB support in Piranha via CDI

Enterprise Beans was once the face of Java EE, but as we discussed a while ago, is currently de-emphasised in Jakarta EE. However, since there’s so much existing code using Enterprise Beans, a certain level of support is still desired.

Piranha Cloud, a relatively new runtime supporting Jakarta EE, takes a somewhat novel approach to Enterprise Beans. Instead of implementing a separate container, Piranha Cloud, via the OmniBeans project, maps Enterprise Beans annotations to equivalent functionality in CDI itself, or to technologies in Jakarta EE leveraging CDI (such as Jakarta Transactions). Enterprise Beans features not currently present in Jakarta EE, such as the pooled concept for Stateless beans, are provided by the OmniServices library.

An overview of the mappings is depicted in the following diagram:

OmniBeans primarily consists out of a CDI extension, that observes the ProcessAnnotatedType event. When it encounters say the @Stateless annotation on a bean it adds @Pooled from OmniServices, and depending on any @jakarta.ejb.TransactionAttribute and/or @jakarta.ejb.TransactionManagement annotation the @jakarta.transaction.Transactional annotation from Jakarta Transactions.

Piranha Cloud uses the standalone and pluggable Jakarta Transactions implementation Transact (which originates from GlassFish) for the code behind the @Transactional annotation. For the @Asynchronous annotation OmniServices is currently used, but in the future a pluggable Jakarta Concurrency implementation should be used for this. The “Concurrency RI” project is a likely candidate to base such an implementation on (with the proposed name Concurro).

The development of OmniBeans is still in its early days, but it’s already able to pass a test taken from the EJB Lite TCK, which is the stateless-tx test. This contains beans such as the following:

@Stateless
public class TxBean {

    @PersistenceContext(unitName = "ejblite-pu")
    private EntityManager entityManager;

    /*
     * @testName: supports
     *
     * @test_Strategy:
     */
    @TransactionAttribute(SUPPORTS)
    public void supports(CoffeeEntity coffeeEntity, boolean flush) {
        updatePersist(coffeeEntity, flush);
    }

    // [...]

    protected void updatePersist(CoffeeEntity coffeeEntity, boolean flush) {
        coffeeEntity.setPrice(coffeeEntity.getPrice() + 100);
        entityManager.persist(coffeeEntity);

        if (flush) {
            entityManager.flush();
        }
    }

}

and

@Stateless
@TransactionManagement(BEAN)
public class TestBean {

    private EntityManager entityManager;
    private UserTransaction userTransaction;

    private TxBean txBean;

    @PersistenceContext(unitName = "ejblite-pu")
    public void setEm(EntityManager entityManager) {
      this.entityManager = entityManager;
    }

    @Resource
    public void setUt(UserTransaction userTransaction) {
      this.userTransaction = userTransaction;
    }

    @EJB(beanInterface = TxBean.class)
    public void setTxBean(TxBean b) {
        txBean = b;
    }
}

As can be seen, those beans are far from trivial from a technical perspective. The fact that OmniBeans is already able to pass such a test bodes well for the future. 

Hopefully at some point it will be able to fully pass the entire EJB Lite TCK this way, which would make for a very interesting Enterprise Beans implementation.

P.s.

If you have some time, please complete the OmniFish survey to help us prioritise what we should do for Jakarta EE 11

OmniFish supports Jakarta EE 10

OmniFish announces enterprise support for Eclipse GlassFish, Jakarta EE 10, and a new cloud-native Jakarta EE runtime

Estonia, September 22, 2022

OmniFish are proud to announce they’ve established themselves as a new international company in the field of Jakarta EE support, specifically supporting the application server Eclipse GlassFish, a new cloud‑native Jakarta EE runtime Piranha Cloud, and their associated components such as Mojarra, the Jakarta Faces implementation. 

OmniFish, based in Estonia, EU, welcomes the new Jakarta EE 10 version. They are going to support Jakarta EE 10 applications on Eclipse GlassFish 7, which will be released later in October 2022. Moreover, OmniFish have recently joined the Jakarta EE Working Group and they are strongly committed to contributing to the Jakarta EE standards. Some of the OmniFish founders are well-known Jakarta EE experts, which provides strong guarantees that OmniFish will become one of the key players in evolving and modernizing the Jakarta EE platform.

Jakarta EE 10 is coming with GlassFish 7

Jakarta EE 10 and GlassFish 7 soon (300px)

Yes, Jakarta EE 10 is just behind the door, with a rich set of new useful features. GlassFish 7 is also very close to its final release, coming with Jakarta EE 10 support. And it’s now actively maintained and commercially supported by OmniFish. Therefore you can start using Jakarta EE 10 very soon on a reliable and production‑ready server backed by a commercial company. But first, what’s coming to Jakarta EE 10?

beans

The future of EJB

EJB, or Enterprise Beans, are Java classes with a number of container provided services attached to them, such as transactions, remoting and security. In this article we will take a look at what we can expect for EJB in the future.

beans

Once upon a time EJB was almost synonymous with what was called Java EE or J2EE back then (Jakarta EE now). It suffered from many issues though, although it did incrementally got better. We’ll explore some of those issues next.