What is the difference between Enterprise Java Bean(EJB) and Entity Java Bean?

Question

Can anyone explain me the difference between Enterprise Java Beans and Entity Java Bean?

I know what EJB is but I don't understand their difference in regard to persistence.

We use the same annotations to save it, but then why call it different?

Answer 1

In the old days, as the earth was forming, Java EE had two basic kinds of Beans -- the Session Bean, and the Entity Bean.

The Session Bean is an interface to some kind of internal service. Most every framework has some basic parallel to an Session Bean.

The Entity Bean was a persistent element managed by the container.

When people talk about Java EE, and especially when they gripe about it, Entity Beans were a core problem. They simply weren't very good.

With the introduction of the Java Persistence Architecture (JPA), with frameworks like Hibernate and EclipseLink, the Java EE view of managed persistence pivoted dramatically. No longer did we have "heavyweight" constructs such as Entity Beans, but rather light weight POJOs managed by the JPA.

The confusion, however, is that objects that are managed by the JPA are referred to as Entities. A JPA Entity and an EJB Entity Bean are completely different animals. But the reuse of the term is a source of confusion.

With an EJB Entity Bean, and EJB and an Entity are the same thing. A Entity EJB IS an EJB, like a Session Bean.

A JPA Entity, however, is not. Technically, an Entity is not related to EJB at all. The JPA Entity Manager is integrated within the EJB runtime context (and by projection, any Entity managed by that Entity Manager is part of the EJB runtime context), but there's no requirement for JPA to be used within an EJB container. They're separate technologies. That said, they do work quite well within an EJB container.

So.

Today, Entity EJBs still exist, but are deprecated, and will some day go away. But the containers still support them. There is no reason to pay them any mind whatsoever unless you have some blob of legacy code. Excluding the Entity Bean, Java EE supports: Stateless Session Beans, Stateful Session Beans, and Message Driven Beans. These are all first class EJBs which represent the heart of the Java EE component model. The most notable aspect of an EJB at runtime is how they engage with the local transaction space managed within the container. Also, EJBs are a deployable construct within the EJB container, similar to a WAR. (They are also other things, this is hardly exhaustive.)

JPA Entities are not EJBs. They have no transactional context. They have a different state, as to whether they are actively managed or not by their Entity Manager. The Entity Manager is enrolled in the local transaction space (and thus the JPA managed Entities are as well, by proxy).

Finally, with CDI, and the rise of annotations, the embedding of EJBs directly within WARs, the boundaries that distinguish EJBs themselves are getting fuzzier and fuzzier every day.