Java Enterprise Programming (EJBs, Servlets and JSPs)

Available as an in-house seminar.

This seminar introduces you to the practical development of real- world, Web-enabled, distributed applications with Java. This means covering Java2 Enterprise Edition (J2EE) and its key technologies: Enterprise JavaBeans, Servlets, Java Server Pages, and the basic architectural patterns used to combine these technologies into maintainable applications.

Because they're more complex, we'll spend more time on Enterprise JavaBeans, but we'll also spend enough time on Servlets and JSPs to give you a solid understanding of the technologies that we use on the Web tier. And we'll take a quick look at a few of the abstraction APIs that interface Java with legacy systems, like Java Database Connectivity (JDBC) and Java Naming and Directory Interface (JNDI).

You'll come out of this course with a comprehensive understanding of the J2EE architecture, of the problems that it is designed to solve, how to select the most appropriate tools, and how to code your solutions.

Prerequisites

To get the most out of this course, you should be familiar with all the topics listed in the "Thinking in Java Hands-on" course curriculum (that's the course we recommend as your entry point to Java), and have solid Java programming experience of at least one year. You should also be able to read and write relatively simple HTML and SQL code.

Curriculum Overview

Lectures

1. Introduction to the Seminar
   Seminar goals and the application we'll develop (a conference management system)
2. J2EE Architectural Overview
   J2EE managed components; J2EE tiers (EJB Tier, Web Tier, Client Tier); separation of labor
3. EJB from the Client Perspective
   Creating a simple EJB client application; using JNDI to locate your EJBs
4. Your First Enterprise JavaBean
   Implementing a Session Bean to browse the conference catalog
5. EJB Implementation Strategies
   Strategies for code reuse; using XDoclet to simplify your EJB development
6. More about Session Beans
   Stateless and Stateful Session Beans; bulk accessors and value objects
7. Turning Off Distribution
   When, why and how to use local views vs. remote views
8. Container Managed Persistence (CMP)
   Object persistence in Enterprise JavaBeans
9. Managing Entity Bean Relationships
   Using Container Managed Relationships (CMR); alternatives to CMR
10. EJB Query Language (EJB-QL)
    Finding objects with the EJB Query Language
11. Transaction Management
    Declarative and programmatic transaction demarcation
12. Customized Object Persistence
    Bean Managed Persistence (BMP) Entity Beans; implementation strategies and alternatives
13. Message-Driven Beans (MDB)
    Asynchronous, transactional and distributed messaging with MDBs
14. The Web Tier
    Components for the Web Tier
15. Implementing Servlets
    Handling HTTP requests in your Java code
16. Implementing Filters
    Intercepting and chaining HTTP requests
17. JavaServer Pages (JSP)
    Creating dynamic web pages
18. Session Management
    Java strategies to maintain session state over HTTP
19. Implementing a Model-View-Controller (MVC) Architecture
    Separating responsibilities in your Web application
20. Introducing the JSP Standard Template Library (JSTL)
    How a tag library can help you with your JSP pages
21. Assembling a Complete J2EE Application
    Pulling all the pieces together into deployable units

Exercises

1. An EJB Client Application
2. Your First Session Bean
3. Implementing an EJB with XDoclet
4. A Stateful Session Bean
5. Implementing Local Interfaces
6. Your First Entity Bean
7. Using Environment Entries
8. Implementing Entity Relationships
9. Writing EJB-QL Queries
10. Your First Servlet
11. Validating User Requests
12. Creating the Web Front-End with JSPs
13. Maintaining HTTP State Information
14. A Controller JSP
15. A Controller Servlet
16. Using JSTL Custom Tags
17. Deploying a Complete J2EE Application

Demos

• Using EJB Handles
• Unit testing your EJBs with JUnit
• Implementing an EJB from business classes
• Implementing an EJB from business interfaces
• Bulk accessors and value objects
• Managing transactions
• Implementing a BMP Entity Bean

Exercises

The exercises are the backbone of this course. Throughout the week, we'll be incrementally building a simple but complete J2EE application. The application is a conference management system, something that can be used:

1. By conference managers, to create and edit a conference program
2. By speakers, to submit and edit presentation proposals
3. By attendees, to create their list of preferred presentations
4. By generic users, to browse the conference program

We'll spend about 40% of the time on practical exercises, which are complemented by the exercise guide. Full solutions to all exercises will also be provided.

Training material

• Print-out of the course slides
• CD with the exercise guide, solution code, software and related documentation

Hardware

We do not provide computers for the students. You should come to this seminar with your laptop, after having installed and tested the software listed below. If you want to bring this seminar in-house, you must provide the student machines as well.

Please note that we strongly encourage pair programming for the exercise sessions. If you are coming with a friend, or if you'll be attending the seminar with a colleague, you may share one machine between the two of you.

Software

We'll use open-source, freely available software for the entire seminar. There are good reasons for this:

1. Open-source software doesn't require any financial investment on your part, which you are probably not ready to make if you are evaluating or approaching this technology for the first time.
2. The open-source software we use doesn't come with any bells and whistles (a.k.a. "wizards" or code generation tools). This means that you are directly responsible for making all the pieces fit together, and you have to do it manually. Although this may not be desirable for production work, understanding how things work is exactly what you expect from a good course.
3. Commercial products do come with bells and whistles; that is, they often provide sophisticated development environments. Unfortunately, those environments have an implicit learning curve, and we cannot afford to spend much time during the seminar on any product-specific feature. We'll be focusing on the technology, and 95% of what you'll learn in this course you'll be able to apply to any commercial Application Server.

All the open-source tools we use have won wide acceptance in the community, with merits like ground-breaking implementation and elegant design, and are therefore quite robust and are often de facto standards.

Specifically, we'll use:

• jBoss as our EJB Container. jBoss is the leading open-source J2EE Application Server.
• Tomcat as our Servlet Container. Tomcat is part of the Apache/Jakarta project, and is also the reference implementation for Java Servlet Containers. We'll use the Tomcat implementation that comes bundled with jBoss.
• Ant, which can be thought of as "MAKE for Java." We'll use Ant to run build scripts during the exercise sessions.
• JUnit, a framework for Java unit testing, part of the XUnit familiy, which is now a de facto standard.
• XDoclet, a Java tool that will generate EJB source files, for example a deployment descriptor, out of special Javadoc tags that you put in your Bean implementation code.

The only two other things that you'll need are a Java2 Standard Edition platform, and a source code editor. Feel free to use your editor of choice, but we recommend something simple and yet flexible like UltraEdit (which has a free 45-day evaluation license).