Java EE 7 Application Developer key terms

The fixed sequence in which the container manages a servlet instance: loading and instantiation, then init() once, then repeated service() calls for each request, and finally destroy() before garbage collection.

A single object per web application that holds application-wide initialization parameters, attributes, and resources, and allows servlets to communicate with the container and with each other across sessions.

An ordered set of filters the container invokes around a request, each calling chain.doFilter() to pass control onward to the next filter or to the target servlet or JSP page.

The mechanism by which the container associates successive HTTP requests with one user, typically through a JSESSIONID cookie or URL rewriting, exposing state via HttpSession attributes with configurable timeout and invalidation.

A small name-value pair the server sends to the browser and the browser returns on later requests, configured with path, domain, max-age, and HttpOnly or Secure flags through the Cookie class.

Predefined variables available in JSP scriptlets and expressions, including request, response, session, application, out, config, pageContext, page, exception, and the EL-visible scopes pageScope through applicationScope.

The translation of a JSP page into a servlet source file, its compilation, and then the standard servlet init, service, and destroy phases, with the container recompiling when the page changes.

A concise ${...} syntax for reading and writing scoped attributes and bean properties in JSP and JSF pages, supporting implicit objects, operators, method invocation, and lambda expressions in later versions.

A standardized set of JSP tag libraries covering core flow control, formatting and i18n, XML processing, SQL access, and common functions, used with the JSTL taglib URI declarations instead of scriptlets.

A jar-packaged META-INF/web-fragment.xml that contributes servlets, filters, listeners, and other deployment descriptors to a web application without editing the main web.xml, enabling modular library packaging.

Declaring web and enterprise components with annotations such as @WebServlet, @WebFilter, @WebListener, @EJB, @Inject, and @Path instead of XML descriptors, with web.xml metadata-complete controlling whether annotations are scanned.

The six ordered phases of a JavaServer Faces request: restore view, apply request values, process validations, update model values, invoke application, and render response, with conversion, validation, and events firing along the way.

The view declaration language for JSF that uses XHTML files with JSF tag libraries, supporting templating, composite components, and EL binding in place of JSP-based views.

A reusable JSF component defined in a Facelets resource file under resources/, exposing an interface section for attributes and facets and a implementation section for its markup, used by tag name in views.

Server-side objects that back JSF views, exposed to EL by name and scope; in Java EE 7 CDI beans with @Named and CDI scopes replace the deprecated JSF-specific managed bean annotations.

JSF extension points that translate between string input and model types and that enforce constraints on submitted values, registered by class, by id, or implicitly through Bean Validation annotations on the model.

A JSF component setting that moves its action, action listener, and validation processing to the apply request values phase, so the event fires before the remaining inputs are validated and updated.

Stateless session beans hold no conversational state, stateful beans keep per-client state across calls, and singleton beans have exactly one instance shared by all clients, each with its own concurrency semantics.

Annotated methods such as @PostConstruct, @PreDestroy, @PostActivate, and @PrePassivate that let a bean react to creation, removal, activation, and passivation, with restrictions on which bean types support which callbacks.

An EJB that consumes messages asynchronously from a JMS destination, implementing MessageListener or using @MessageDriven, and running under container-managed transactions and pooling.

The Java EE dependency injection and contextual lifecycle model, providing type-safe injection with @Inject, qualifiers, producers, interceptors, decorators, events, and well-defined scopes such as request and conversation.

An annotation applied to an injection point and to a bean to disambiguate among candidates of the same type, with @Default and @Any as built-in qualifiers and @Named as a name-based alternative.

A method or field annotated @Produces that supplies objects the container cannot construct itself, optionally combined with a qualifier and a scope annotation to control selection and lifetime.

A lifetime bound to a bean, such as @RequestScoped, @SessionScoped, @ApplicationScoped, @Dependent, or @ConversationScoped, where the conversation scope spans multiple requests bounded by begin and end calls.

A named configuration grouping entity classes, a data source or JDBC settings, and provider properties, declared in META-INF/persistence.xml and referenced by name when building an EntityManagerFactory.

The API for creating, finding, merging, and removing entities, backed by a persistence context that tracks managed entity instances and flushes changes to the database at commit or query time.

The four conditions an entity instance can occupy relative to a persistence context: new or transient, managed, detached, and removed, each governing whether changes are tracked and persisted.

The primary key declaration on an entity, generated by strategies such as IDENTITY, SEQUENCE, TABLE, or AUTO, or assigned by the application, and combined with @EmbeddedId or @IdClass for composite keys.

Annotations such as @OneToMany, @ManyToOne, @OneToOne, and @ManyToMany, together with @JoinColumn or @JoinTable and mappedBy, that define association direction, ownership, and foreign key or join table mapping.

Propagating entity operations such as persist, merge, or remove from a parent to associated entities via cascade settings, and deleting a child automatically when it is removed from its owning relationship.

Two query approaches in JPA: the string-based Java Persistence Query Language operating on entities and fields, and the type-safe programmatic Criteria API building queries through metamodel objects.

Two transaction management types for a persistence unit: JTA integrates entity operations with container-managed transactions and supports multiple resources, while RESOURCE_LOCAL relies on application-controlled EntityTransaction.

A POJO annotated @Path that serves REST requests, with methods selected by HTTP verb annotations such as @GET and @POST and refined by @Produces, @Consumes, and sub-resource locators.

Bindings that extract request data into method arguments: @PathParam from URI templates, @QueryParam from the query string, @FormParam from form bodies, @HeaderParam, @CookieParam, @MatrixParam, and @BeanParam for aggregation.

SPI contracts that convert an HTTP entity body to a Java type and back, selected by media type and generic type, with built-in providers for text, XML, JSON, and form data.

A javax.ws.rs.core.Application subclass listing resource and provider classes and setting the base URI, plus cross-cutting providers such as filters, interceptors, and exception mappers registered with the runtime.

A SOAP web service implementation declared with @WebService, whose methods become operations and whose parameters map to WSDL messages, deployed in a web container or published with Endpoint.publish.

The XML contract describing a SOAP service's types, messages, port types, bindings, and service address, from which JAX-WS generates portable artifacts and to which annotations map Java declarations.

A generated or injected client-side stub, obtained from a Service instance or an @WebServiceRef, that exposes the remote operations as local method calls and handles SOAP serialization.

A JAX-WS extension implementing SOAPHandler or LogicalHandler that intercepts inbound and outbound messages on a handler chain, used for logging, header processing, and security enforcement.

Container-enforced access control declared in code, using @RolesAllowed, @PermitAll, @DenyAll, and @RunAs on EJB or servlet classes and methods rather than programmatic checks.

Protecting SOAP and REST endpoints through transport security, message-level signing and encryption, and container-managed authentication, often configured via deployment descriptors or handler chains.

Transaction demarcation controlled by the EJB container according to @TransactionAttribute values such as REQUIRED, REQUIRES_NEW, MANDATORY, SUPPORTS, NOT_SUPPORTED, and NEVER, with rollback rules for system and application exceptions.

Registering callbacks with a JTA transaction so application code runs at points such as before completion or after completion, useful for flushing caches or emitting events only on commit.

A queue provides point-to-point delivery to one consumer, while a topic provides publish-subscribe delivery to all subscribers; both are administered objects addressed by JNDI name.

The simplified JMS 2.0 API using JMSContext to create producers and consumers, send messages, and register message listeners, complementing the classic Connection, Session, and MessageProducer objects.