Java EE 7 Application Developer study plan

Map the Java EE 7 platform stack (Servlet 3.1, JSP 2.3, JSF 2.2, EJB 3.2, JPA 2.1, JAX-RS 2.0, JAX-WS 2.2, CDI 1.1, JMS 2.0, Bean Validation 1.1) onto a single deployment diagram you draw yourself, labeling which containers host which components.

Write and deploy a minimal WAR containing one stateless session bean, one CDI-managed bean, and one servlet that injects both, verifying injection works in a Java EE 7 full-profile server.

Distinguish @Stateless, @Stateful, @Singleton, and @MessageDriven lifecycles by writing a one-page comparison that states pooling, passivation, and concurrency behavior for each.

Configure CDI bean discovery (beans.xml modes, @Alternative, @Produces, qualifiers, @Stereotype) and demonstrate at least one producer method and one custom qualifier in code.

Explain the difference between @EJB injection, @Inject injection, and JNDI lookup, and note when each is required.

Implement all six EJB transaction attribute types (@REQUIRED, @REQUIRES_NEW, @SUPPORTS, @NOT_SUPPORTED, @MANDATORY, @NEVER) in a test application and log when each causes a new transaction, joins one, or throws.

Demonstrate container-managed transaction rollback rules, including which exceptions trigger rollback by default and how @ApplicationException(rollback=true) changes behavior.

Build a singleton bean with @Lock(READ/WRITE), @Startup, and @DependsOn, and describe how container-managed concurrency differs from bean-managed concurrency.

Create a JMS 2.0 producer and a @MessageDriven consumer using both the simplified API (JMSContext) and classic API, and list the difference between queue and topic semantics.

Apply Bean Validation constraints to EJB method parameters and explain method validation interception.

Map an object model of at least six entities using @OneToMany, @ManyToOne, @ManyToMany, and @OneToOne, choosing the owning side deliberately and documenting the mappedBy decision.

Implement all four JPA inheritance strategies (SINGLE_TABLE, JOINED, TABLE_PER_CLASS, and default MappedSuperclass) and compare the resulting schemas.

Write JPQL queries using joins, aggregate functions, constructor expressions, named queries, and the bulk UPDATE/DELETE statements, then verify generated SQL.

Configure the persistence unit (transaction-type, provider, schema generation) and compare RESOURCE_LOCAL with JTA transaction management in a Java EE environment.

Demonstrate first-level and second-level cache behavior and explain the optimistic locking mechanism using @Version and LockModeType.

Implement entity lifecycle callbacks (@PrePersist, @PostPersist, @PreUpdate, @PostLoad) and an @EntityListener, and record the invocation order.

Handle lazy loading failures (LazyInitializationException) by demonstrating at least two fixes: fetch join in JPQL and an EJB-backed service boundary.

Write servlets that use @WebServlet, @WebFilter, and @WebListener annotations, and compare them with the equivalent web.xml declarations.

Implement request dispatch, forwarding, and redirects, and explain the difference between forward and include semantics.

Configure session management, cookies, and URL rewriting, and describe how HttpSession listeners and attribute binding work.

Build JSP pages using scriptlets avoided in favor of JSTL tags, EL expressions, and custom tag files, and explain EL implicit objects and scope resolution order.

Write a custom tag handler and a JSP tag file, and compare them with a JSP fragment and a JSP include directive.

Construct a JSF application with facelets templates, navigation rules, and managed beans using @Named and @ViewScoped.

Implement JSF conversion, validation, and event handling, including a custom Converter and a ValueChangeListener.

Compare JSF request processing lifecycle phases and describe where immediate=true and the invoke application phase affect behavior.

Explain the JSF 2.2 features: faces flow, resource library contracts, and HTML5-friendly markup.

Create JAX-RS resources using @Path, @GET, @POST, @PUT, @DELETE, and sub-resource locators, and verify routing with a client.

Implement parameter binding with @PathParam, @QueryParam, @FormParam, @MatrixParam, @HeaderParam, and @BeanParam, and describe URI template regular expressions.

Configure content negotiation with @Produces, @Consumes, and custom MessageBodyReader/MessageBodyWriter providers.

Use the JAX-RS 2.0 client API (Client, WebTarget, Invocation.Builder) and implement filters and interceptors for logging and authentication.

Handle exceptions with WebApplicationException, ExceptionMapper, and Response status codes, and describe how JAX-RS integrates with EJB and CDI.

Explain REST constraints and how JAX-RS maps HTTP methods to CRUD semantics, including idempotency and safe methods.

Build a JAX-WS service using @WebService, @WebMethod, and @WebParam, and generate and inspect the WSDL.

Consume the service with a generated client stub using wsimport, and explain document/literal wrapped style versus RPC style.

Implement SOAP handlers (SOAPHandler, LogicalHandler) and describe handler chain configuration.

Configure container-managed security using @RolesAllowed, @PermitAll, @DenyAll, and declare a security domain with a JDBC or file realm.

Implement declarative and programmatic authentication in a web component, and explain form-based, basic, and digest authentication differences.

Compare transport-level and message-level security, and describe WS-Security and web service security policy basics.

Build a complete application that integrates JSF, CDI, EJB, JPA, and JAX-RS in one deployment, and document the packaging structure.

Review Java EE 7 packaging rules (WAR, EJB JAR, EAR) and classloader visibility, and identify at least three common deployment mistakes.

Complete a timed 60-question practice set across all eight domains and categorize each miss by domain.

Re-study every missed objective using targeted code experiments rather than rereading, and record the fix for each.

Summarize the security and transaction objectives in a one-page condensed review sheet.