POJO
A plain-old-Java-object, according to the Java bean standard.
This is a class with (mostly) private members and a get- and set-method
(also called getter and setter) for each of them. The original aim
of object-relational mapping tools was to persist such pojos into the database with the
help of e.g. an external xml configuration per pojo. When Java 5 came
up this changed a bit, now it is common to use annotations in the Java
source itself. With that, strictly spoken, beans are not pojos anymore.
Entity
A pojo with an extended description. The description allows the entitiy
manger to persist the entity into the database. Common
descriptions are XML files or annotations in the Java source. This
data is called metadata.
Property
A property is a member variable of your pojo with a defined
set and get method. You have to follow the Java Bean
specification. The following examples show this syntax -
the first column, named property, shows how you would access
this property from the outside (e.g. via reflection or from a JSF-JSP-page).
The second column shows the syntax of defining the member, the next columns
the name of getter and setter.
property
member
getter
setter
userId
private String userId
getUserId
setUserId
userName
private String _userName
getUserName
setUserName
displayed
private boolean displayed
isDisplayed
setDisplayed
Entity Manager
The "entity manager" manages all your entities,
keeps track of property updates and issues the database statements
required to synchronize the entity state with the database. If you
close an entity manager you will loose the coupling between its
internal state and your entities, they are so called "detached objects"
afterwards.
Entity Manager Factory
The "entity manager factory" is
responsible for processing all the entity metadata and to create an
entity manager based on it.
DAO - Data Access Object
Usage of data access objects is based on the pattern with the same name. Data access
objects are singletons which contain
all of the database requests your application will issue - generally, one data access object
encapsulates all database requests for one entity.
Thus, the DAO is injected with an entity
manager.
Conversation
A conversation is the time-span encapsulating all the
operations in your business logic required to finish a process
(in the end, this will almost always include the need for executing database transactions).
Other names of this principle are: application transaction, unit-of-work
Session Scope
The session scope of your servlet container.
Beans put into this scope live until the configured inactivity timout
for the session has been reached or the session is closed explicitly
Request Scope
The request scope of your servlet container.
The lifetime of request-scoped-beans is as long as the duration of a
single HTTP request. Once the servlet container finishes sending
the page data, the request will die and with it all the beans put into
this scope.
JPA - Java Persistence API
The JPA standardizes the way how
you annotate your entities with regards to persistence. That way you can change the
ORM tool as long as the ORM tool follows the JPA
specification.
backing bean
A backing bean is the bean behind a JSF view
(jsp, facelet, etc page). While JSF does not require such a bean, it is
good practice to provide one backing-bean per page as a rule of thumb.