Glossary

• 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.