Developing J2EE[tm] Compliant Applications ( FJ-310 )

     Course Description

The Developing J2EE[tm] Compliant Java[tm] Applications course provides students with knowledge to build and deploy enterprise applications that comply with Java 2 Enterprise Edition (J2EE). The enterprise components covered in this course range from Enterprise JavaBeans[tm] (EJB[tm]), servlets, and JavaServer Pages[tm] (JSP[tm]) to the HTML and Java technology clients that use them. Students gain hands-on experience through labs that build an end-to-end, distributed business application. The labs explore database interaction from session EJB components using Java Database Connectivity (JDBC[tm]), and entity EJB components using both bean-managed and container-managed persistence. Students build HTML and Java technology clients. The HTML clients access Java Enterprise services using servlets and JavaServer Pages. Students are taught how to assemble an application from reusable components and deploy an application into the J2EE runtime environment.

   Who Can Benefit

Students who can benefit from this course are Java technology programmers who want to develop enterprise applications that conform to the Java 2 Enterprise Edition (J2EE) standards.

     Prerequisites

To succeed fully in this course, students should be able to:

• Use Java technology syntax fluently
• Code a Java technology class and methods
• Understand the Java technology interface construct
• Understand the JavaBeans[tm] component architecture
• Create and modify simple HTML pages
• Write a Java technology program

     Skills Gained

Upon completion of this course, you should be able to:

• Create, code, and test EJB components that provide enterprise application logic
• Provide HTML client access to EJB components through servlets
• Create HTML clients using JavaServer Pages technology
• Access a database using JDBC or entity EJB components
• Assemble, deploy, and test a distributed Java technology application

     Related Ceurses

• Before: SL-285: Java Programming Language Workshop
• After: SL-310: Beyond CGI: Developing Java Servlets
• After: SL-351: Enterprise JavaBeans Programming
• After: SL-330: Database Application Programming with Java Technology

     Course Content

Module 1: Building Java 2 Platform Enterprise Edition Applications

• Describe the purpose of each of the components of the Java 2 Platform, Enterprise Edition (J2EE)
• Define the J2EE application life cycle roles
• Describe how an Integrated Development Environment supports developing J2EE applications
  

Module 2: Distributed Object Communication

• Explain how clients communicate with remote components
  

Module 3: Java 2 Platform Enterprise Edition and Enterprise JavaBeans

• Describe the purpose of the two types of Enterprise JavaBeans (EJBs): entity beans and session beans
• Explain the roles involved in creating applications using EJBs
• Explain the responsibilities of each role in the EJB development process

Module 4: Creating Session EJBs

• Describe the parts of an EJB session bean
• Create a simple EJB session bean
  

Module 5: Testing Session EJBs

• Write a simple client to test an EJB
• Define an EJB reference
• Use JNDI to look up the EJB's home object
• Assemble and deploy a session EJB
  

Module 6: JDBC and Resource Factories

• Explain how to use the Java Database Connectivity (JDBC) API to execute dynamic SQL statements
• Explain how to use a resource factory to acquire a database connection
• Code a session EJB that accesses a database using JDBC
  

Module 7: Entity EJB Overview

• Describe how entity beans and session beans differ
• Describe how an entity bean is used
• Describe the entity bean life cycle
• List the methods on an entity bean and their purpose
• Describe how container-managed persistence differs from bean-managed persistence
  

Module 8: Creating BMP Entity EJBs

• Describe bean-managed persistence (BMP)
• Build a BMP entity bean
• Code a custom finder method for a BMP EJB
• Use a Data Access Object with a BMP EJB
• Assemble and deploy a BMP entity bean
  

Module 9: Creating CMP Entity EJBs

• Describe container-managed persistence (CMP)
• Build a CMP entity bean
• Assemble and deploy a CMP entity bean
  

Module 10: Java 2 Platform Enterprise Edition Clients

• Describe the client types supported by J2EE applications
• Choose the appropriate style of client design for a given application
• Describe the factors to consider when developing client components for an application that is compliant with J2EE architecture
  

Module 11: Creating Servlets

• Describe the Servlet API and its associated classes and interfaces
• Create a servlet based on the HttpServlet class
• Assemble and run a servlet
  

Module 12: Introduction to JavaServer Pages Technology

• Explain the function of JavaServer Pages (JSP) technology
• Describe the services provided by a JSP container
• List the benefits of using JSP technology
• Explain the relationship between servlets and JSPs
  

Module 13: JSP Page Elements

• List and describe the elements of a JSP page
• Create JavaServer Pages that incorporate the major JSP elements and Java scriptlets
  

Module 14: Web-Tier Design Options

• Define the role of servlets and JavaServer Pages technology in the J2EE application programming model (APM)
• Describe the different JSP architectural models
• Explain how to implement the Model/View/Controller (MVC) design pattern using servlets and JSPs
• Design, build, and deploy a Model 2 multi-tier application using web clients, servlets, JSPs, and EJBs