Introduction... xxxi. Chapter 1: Java EE 6: An Overview... 1

Transcription

1 Introduction... xxxi Chapter 1: Java EE 6: An Overview... 1 Evolution of Java... 2 Starting with Java... 4 Java Programming Language... 4 Java Runtime Environment... 4 Java Virtual Machine... 5 Java Platform... 5 Exploring Enterprise Architecture Types... 6 The Single-Tier Architecture... 6 The 2-Tier Architecture... 6 The 3-Tier Architecture... 8 The n-tier Architecture... 9 Objectives of Enterprise Applications Exploring the Features of the Java EE Platform Platform Independence Managed Objects Reusability Modularity Easier Development Simplified EJB Enhanced Web Services Support for Web Exploring the New Features of the Java EE 6 Platform Exploring the Java EE 6 Platform The Runtime Infrastructure The Java EE 6 APIs Exploring the Architecture of Java EE

2 Describing Java EE 6 Containers Container Types Java EE 6 Container Architecture Developing Java EE 6 Applications Probable Java EE Application Architectures Application Development and Deployment Roles Application Development Process Listing the Compatible Products for the Java EE Platform Introducing Web Servers Introducing Application Servers The WebLogic Application Server The WebSphere Application Server The JBoss Application Server The Glassfish Application Server Java Database Connectivity Java Servlet JavaServer Pages JavaServer Faces JavaMail Enterprise JavaBeans Hibernate Seam Java EE Connector Architecture Web Services Struts Spring JAAS AJAX Summary Quick Revise Chapter 2: Web Applications and Java EE Exploring the HTTP Protocol Describing HTTP Requests Describing the HTTP Responses Introducing Web Applications Describing Components of a Web Application Describing Structure /Modules of Web Applications Describing Web Containers vi

3 Exploring Web Architecture Models Describing the Model-1 Architecture Describing the Model-2 Architecture Exploring the MVC Architecture Describing the Model Component Describing the View Component Describing the Controller Component Summary Quick Revise Chapter 3: Working with JDBC Introducing JDBC Components of JDBC JDBC Specification JDBC Architecture Exploring JDBC Drivers Describing the Type-1 Driver Describing the Type-2 Driver (Java to Native API) Describing the Type-3 Driver (Java to Network Protocol/All Java Driver) Describing the Type-4 Driver (Java to Database Protocol) Exploring the Features of JDBC Additional Features of JDBC New Features in JDBC Describing JDBC APIs The java.sql Package The javax.sql Package Exploring Major Classes and Interfaces The DriverManager Class The Driver Interface The Connection Interface The Statement Interface Exploring JDBC Processes with the java.sql Package Understanding Basic JDBC Steps Creating a Simple JDBC Application Working with the PreparedStatement Interface Working with the CallableStatement Interface Working with ResultSets Working with Batch Updates Describing SQL 99 Data Types vii

4 Exploring JDBC Processes with the javax.sql Package Using DataSource to Make a Connection Exploring Connection Pooling Using RowSet Objects Working with Transactions ACID Properties Types of Transactions Transaction Management Summary Quick Revise Chapter 4: Working with Servlets Exploring the Features of Java Servlet Servlet A Request and Response Model Servlet and Environment State Security Features HTML-Aware Servlets HTTP-Specific Servlets Performance Features Tier Applications Web Publishing System Exploring New Features in Servlet Exploring the Servlet API Describing the javax.servlet Package Exploring the javax.servlet.http Package Explaining the Servlet Life Cycle The init() Method The service() Method The destroy() Method Understanding Servlet Configuration Creating a Sample Servlet Exploring Directory Structure Configuring the Servlet Packaging, Deploying and Running the Web Application Creating a Servlet by using Annotation Working with ServletConfig and ServletContext Objects Working with the HttpServletRequest and HttpServletResponse Interfaces Using the HttpServletRequest Interface Using the HttpServletResponse Interface viii

5 Exploring Request Delegation and Request Scope Implementing Servlet Collaboration Collaboration through the System Properties List Collaboration through a Shared Object Collaboration through Inheritance Summary Quick Revise Chapter 5: Handling Sessions in Servlets Describing a Session Introducing Session Tracking Exploring the Session Tracking Mechanisms Using Cookies Using Hidden Form Fields Implementing URL Rewriting Using Secure Socket Layer Using the Java Servlet API for Session Tracking History of Session Tracking Session Creation and Tracking Creating Login Application using Session Tracking Exploring the Directory Structure of Login Application Building the Front-End Creating and Managing a Session Configuring the Login Application Running the Login Application Summary Quick Revise Chapter 6: Implementing Event Handling and Wrappers in Servlets Introducing Events Introducing Event Handling Working with the Types of Servlet Events Implementing the Servlet Context Level Events Implementing the Servlet Session Level Events Developing the onlineshop Web Application Creating the JavaBeans for the onlineshop Web Application Creating the CartContextListener Class Building the Front-end of the onlineshop Web Application Introducing Wrappers ix

6 Exploring the Need for Wrappers Exploring the Types of Wrapper Classes Working with Wrappers Creating the Home HTML Page Creating the WrapperTestServlet.java File Creating the TestServlet.java File Creating the MyRequestWrapper.java File Creating the MyResponseWrapper.java File Creating the web.xml File Packaging, Deploying, and Running the wrapper Web Application Summary Quick Revise Chapter 7: Working with JavaServer Pages (JSP) x Introducing JSP Technology Exploring New Features of JSP Listing Advantages of JSP over Java Servlet Exploring the Architecture of a JSP Page The JSP Model I Architecture The JSP Model II Architecture Describing the Life Cycle of a JSP Page The Page Translation Stage The Compilation Stage The Loading & Initialization Stage The Request Handling Stage The Destroying Stage Working with JSP Basic Tags and Implicit Objects Exploring Scripting Tags Exploring Implicit Objects Explaining Directive Tags Working with Action Tags in JSP Exploring Action Tags Declaring a Bean in a JSP Page Exploring the JSP Unified EL Understanding the Basic Syntax of using EL Classifying EL Expressions Describing Tag Attribute Types Resolving EL Expressions Describing EL Operators

7 Describing EL Objects Using Functions with EL Summary Quick Revise Chapter 8: Implementing JSP Tag Extensions Exploring the Elements of Tag Extensions The TLD File The taglib Directive The Tag Handler Exploring the Tag Extension API The Tag Extension Interfaces The Tag Extension Classes Working with Classic Tag Handlers Exploring the Life Cycle of Classic Tag Handlers Implementing Classic Tags Working with Simple Tag Handlers Exploring the Life Cycle of Simple Tag Handlers Implementing Simple Tag Handler Working with JSP Fragments Creating a JSP Fragment Invoking a JSP Fragment Exploring the JspFragment Class Working with Tag Files Handling Dynamic Attributes in Tag Files Exporting Variables from a Tag File to a JSP Page Using Attributes to Provide Names for Variables Invoking JSP Fragments from Tag Files Summary Quick Revise Chapter 9: Implementing JavaServer Pages Standard Tag Library Introducing JSTL Explaining the Features of JSTL Exploring the Tag Libraries in JSTL Working with the Core Tag Library Exploring the Tags in the Core Tag Library Using the Core Tag Library in the coretagapp Application Working with the XML Tag Library xi

8 Exploring the Tags of the XML Tag Library Using the XML Tag Library in the XMLTagApp Application Working with the Internationalization Tag Library Exploring the Tags of the Internationalization Tag Library Using the Internationalization Tag Library in Web Applications Working with the SQL Tag Library Exploring Tags of the SQL Tag Library Using the SQL Tag Library in the SqlTagApp Application Working with the Functions Tag Library Exploring the Functions Available in the Functions Tag Library Using the JSTL Functions in the JSTLFunctionApp Application Summary Quick Revise Chapter 10: Implementing Filters Exploring the Need of Filters Exploring the Working of Filters Exploring Filter API The Filter Interface The FilterConfig Interface The FilterChain Interface Configuring a Filter Configuring Filters Using Deployment Descriptor Configuring Filters Using Annotations Creating a Web Application Using Filters Using Deployment Descriptor to Configure a Filter Exploring the Directory Structure of FilterApp Application Using Annotations to Configure a Filter Creating a Servlet to Test the Filter Using Initializing Parameter in Filters Creating the MsgFilter Filter Creating a JSP Page to Test the Filter Configuring the Filter Testing a Filter Manipulating Responses Creating the ServletOutputStreamFilter Class Creating the MyGenericResponseWrapper Class Creating the Filter Creating the Servlet to Test the Filter xii

9 Configuring the Filter Testing the FilterPrePost Filter Discussing Issues in Using Threads with Filters Summary Quick Revise Chapter 11: Working with JavaServer Faces Introducing JSF Explaning the Features of JSF Exploring the JSF Architecture Describing JSF Elements UI Component Renderer Validators Backing Beans Converters Events and Listeners Message Navigation Exploring the JSF Request Processing Life Cycle The Restore View Phase The Apply Request Values Phase The Process Validations Phase The Update Model Values Phase The Invoke Application Phase The Render Response Phase Exploring JSF Tag Libraries JSF HTML Tags JSF Core Tags JSF Standard UI Components Command Components Data Component Form Component Image Component Input Component Message and Messages Component Output Component Parameter Component Checkbox Component xiii

10 SelectItem and SelectItems Component SelectMany and SelectOne Component ViewRoot Component Working with Backing Beans Using the Backing Bean Method as an Event Handler Using Backing Bean Method as Validator Managing Backing Beans JSF Input Validation Using Validator Method Using Validators JSF Type Conversion Standard JSF Converters Creating Custom Converters Handling Page Navigation in JSF Describing Internationalization Support in JSF Configuring Supported Locales Creating Resource Bundles Accessing Localized Messages from Resource Bundle Configuring JSF Applications Setting web.xml Setting the faces-config.xml File Developing a JSF Application Setting Development Environment Creating JSF Pages Creating the Employee Backing Bean String getemployees() String addnew() String update() String deleteemployee() String getdetail() void getemployee(actionevent) Managing Employee Bean Creating the EmployeeDB Class Creating the Validator Class Configuring a JSF Application Enabling JSF Servlet in the web.xml File Navigation Rules Defined in the faces-config.xml File Supporting Internationalization xiv

11 Exploring the Directory Structure of the Application Running the KogentPro Application Displaying All Employees Getting Employee Detail Adding New Employee Editing Employee Detail Deleting Employee Summary Quick Revise Chapter 12: Understanding JavaMail Introducing JavaMail Exploring the Protocols MIME Establishing Communication between an Client and Server Exploring the JavaMail Architecture Exploring the JavaMail API The Session Class The Authenticator Class The Message Class The MimeMessage Class The Part Interface The Multipart Class The ContentType Class The MimeBodyPart Class The PreencodedMimeBodyPart Class The MimeUtility Class The InternetHeader Class The ParameterList Class The QuotaAwareStore Interface The Resource Class The Quota Class The SharedFileInputStream Class The SharedByteArrayInputStream Class The ByteArrayDataSource Class The Address Class The Store Class The Folder Class The Transport Class xv

12 Working with JavaMail Sending Mails Reading Mails Summary Quick Revise Chapter 13: Working with EJB Understanding EJB 3 Fundamentals Why EJB 3? EJB 3 Architecture and Concepts Features of EJB Classifying EJBs Introducing Session Beans Conversational State State Management of a Bean The Stateless Session Beans The Stateful Session Beans Stateless versus Stateful Session Beans Implementing Session Beans Exploring Business Interface Exploring Bean Class Working with a Stateless Session Bean Working with a Stateful Session Bean Introducing the MDB Characteristics of the MDB Structure of the MDB Life Cycle of the MDB Implementing the MDB Implementing the MessageDrivenBean and MessageListener Interfaces Implementing Business Logic inside the onmessage() Method Creating a Sample MDB Application Packaging, Deploying, and Running the Application Managing Transactions in Java EE Applications Exploring Transaction Properties Exploring Transaction Model Explaining Distributed Transactions Implementing Transaction Management in EJB Explaining Bean-Managed Transactions Explaining Container-Managed Transactions xvi

13 Explaining EJB 3 Timer Services Different Types of Timers Strengths and Limitations of EJB Timer Services Timer Service API Implementing EJB 3 Timer Service Creating Timer Objects Canceling a Timer Object Expiring the Timer Object Exploring EJB 3 Interceptors Specifying Interceptors Exploring the Life Cycle of Interceptors Working with the Interceptor Class Applying Interceptors through XML Disabling Interceptors Using the Business Method Interceptors Using the Life Cycle Callback Methods Specifying Default Interceptor Methods Exploring the Life Cycle Callback Methods in an Interceptor Class Annotation Annotation Annotation Annotation Exploring the Life Cycle Callback Interceptor Methods in an MDB Exploring the Life Cycle Callback Interceptor Methods in a Session Bean Summary Quick Revise Chapter 14: Implementing Entities and Java Persistence API Understanding Java Persistence and EntityManager API Introducing Entities Specifying Annotation Specifying Annotation Specifying Annotation Specifying Annotation Specifying Annotation Specifying Annotation Exploring Entity and Session Beans Describing When To Use Entity Beans Describing an Entity Class xvii

14 Describing the Life Cycle of Entity Entity Listeners and Callbacks Packaging a Persistence Unit Obtaining an EntityManager Interacting with an EntityManager Understanding Entity Relationship Types The One-to-One Relationship The One-to-Many Relationship The Many-to-One Relationship The Many-to-Many Relationship Mapping Collection-Based Relationships Understanding Entity Inheritance Single Table Per Class Hierarchy Separate Table Per Subclass Single Table Per Concrete Entity Class Understanding JPQL JPQL Functions JPQL Statements The SELECT Clause The FROM Clause The WHERE Clause The ORDER BY Clause Conditional Expressions Query API Developing Sample Application Exploring the Directory Structure Creating the Web Module Configuring Connection Pool and JDBC Resource Summary Quick Revise Chapter 15: Implementing Java Persistence Using Hibernate Introducing Hibernate Why Hibernate? What is New in Hibernate 3.5? Exploring the Architecture of Hibernate Noteworthy Interfaces of Hibernate The Hibernate Cache Architecture Downloading Hibernate xviii

15 Exploring HQL Need of HQL HQL Syntax Understanding Hibernate O/R Mapping Working with Hibernate Setting up the Development Environment Creating Database Table Writing Hibernate Configuration File, JavaBean, and Hibernate Mapping File Implementing O/R Mapping with Hibernate Developing a JavaBean Developing Hibernate Configuration File Developing Hibernate Mapping File Creating the EmployeeData.java File Developing Controller Component Developing View Components Creating the web.xml File Exploring Directory Structure Running the Application Summary Quick Revise Chapter 16: Implementing JBoss Seam Listing the Features of the Seam Framework Working with the Seam Framework Understanding Contexts Working with Seam Components Using Annotations Implementing BPM and Page Flow in Seam Stateless Navigation Model Stateful Navigation Model Using jpdl Pageflows Configuring JBoss Seam Configuring JSF in Seam Configuring EJB components in Seam Creating a Jboss Seam Application Creating an EJB Component Creating Views Creating Resources Packaging and Deploying the Seam Application xix

16 Running the Application Summary Quick Revise Chapter 17: Java EE Connector Architecture Describing the Key Concepts of the JCA Enterprise Information Systems Resource Manager Resource Adapter Managed Environment Non-Managed Environment Connection of an Application Client with a Resource Manager System Contracts Common Client Interface Describing the Life Cycle Management of a Resource Adapter Bootstrapping a Resource Adapter Instance Understanding a ManagedConnectionFactory JavaBean and Outbound Communication Understanding an ActivationSpec JavaBean and Inbound Communication Managing the Life Cycle of a Resource Adapter Exploring Workflow Management Listing the Advantages of Workflow Management Describing the Work Management Model Describing the Work Interface Describing the ExecutionContext Class Describing the WorkListener Interface Describing the WorkEvent Class Describing the WorkAdapter Class Exploring the Differences between JDBC and JCA Exploring the Inbound Communication Model Discussing a Scenario using Inbound Communication Exploring Message Inflow from EIS to Resource Adapter Exploring the Message Inflow to Message Endpoints Exploring Activation Specifications (JavaBean) Exploring Administered Objects Understanding EJB Invocation Understanding the CCI API The ConnectionFactory Interface The ConnectionSpec Interface The Connection Interface xx

17 The Interaction Interface The InteractionSpec Interface The LocalTransaction Interface Exploring JCA Exceptions The Application Exception The System Exception Packaging and Deploying a Resource Adapter Understanding Directory Structure of a Resource Adapter Packaging Considerations Packaging a Resource Adapter Deploying a Resource Adapter Explaining the Deployment Descriptor for a Resource Adapter Explaining the Role of Parties Involved in Deployment of a Resource Adapter Summary Quick Revise Chapter 18: Java EE Design Patterns Describing the Java EE Application Architecture Introducing a Design Pattern Discussing the Role of Design Patterns Exploring Types of Patterns The Front Controller Pattern The Composite View Pattern The Composite Entity Pattern The Intercepting Filter Pattern The Transfer Object Pattern The Session Facade Pattern The Service Locator Pattern The Data Access Object Pattern The View Helper Pattern The Dispatcher View Pattern The Service To Worker Pattern Summary Quick Revise Chapter 19: Implementing SOA using Java Web Services Overview of SOA Describing the SOA Environment The Core Layer xxi

18 The Platform Layer The Quality of Services Layer Overview of JWS Role of WSDL, SOAP, and Java/XML Mapping in SOA Role of WSDL in SOA Role of SOAP in SOA Role of Java/XML Mapping in SOA Exploring the JAX-WS 2.2 Specification The Invocation Sub-Specification Category The Serialization Sub-Specification Category The Deployment Sub-Specification Category Exploring the JAXB 2.2 Specification Mapping Annotations Binding Runtime Framework Implementing Validation Exploring Marshal Event Callbacks Exploring Partial Binding Exploring Binary Data Encoding Exploring JAXB Binding Language Explaining Portability Exploring the WSEE 1.3 Specification Port Component Servlet Endpoints EJB Endpoints Simple Packaging Handler Programming Model Exploring the WS-Metadata 2.2 Specification WSDL Mapping Annotations SOAP Binding Annotations Handler Annotations Service Implementation Bean Start From WSDL and Java Automatic Deployment Describing the SAAJ 1.3 Specification Working with SAAJ and DOM APIs Creating a Simple SOAP Message Accessing the different Message Parts of a SOAP Message Adding Content to the SOAPBody Object xxii

19 Sending a Message Retrieving the Content of a Message Adding Content to the Header Element Creating and Adding Attachments Retrieving Attachments Describing the JAXR Specification JAXR Architecture JAXR Client JAXR Provider Exploring the StAX 1.0 Specification StAX APIs StAX Factory Classes Using the JAX-WS 2.2 Specification Invoking Web Services by using JAX-WS Proxies Implementing JAX-WS WSDL to Java Mapping Marshalling and Unmarshalling Method Calls to SEI Invoking a Web Service using a Proxy Using the JAXB 2.2 Specification Binding between XML Schema and Java Classes Customizing JAXB Binding Exploring an Example of JAXB 2.2 Java/XML Binding Implementing Type Mappings with JAXB Implementing Type Mappings with JAXB 2.2 Annotations Using the WSEE and WS-Metadata Specifications Deployment using a Servlet Endpoint Deployment using an EJB Endpoint Deployment without Deployment Descriptors Deployment with Deployment Descriptor Implementing the SAAJ Specification Implementing the JAXR Specification Setting up a Connection Querying a Registry Manipulating Registry Objects Implementing the StAX Specification Reading XML Streams Writing XML Streams Reading an XML File using the Cursor API Reading an XML File using the Event Iterator API xxiii

20 Writing an XML File using the Cursor API Summary Quick Revise Chapter 20: Working with Struts Introducing Struts Explaining MVC 2 Design Pattern for Struts The Need for Struts Processing Request in Struts Exploring Relation between WebWork 2 and Struts Describing Struts 2 Architecture Exploring Struts 2 Configuration Files Explaining Zero Configuration Applications Exploring Struts 2 Annotations Understanding Actions in Struts Action Classes POJO as Action Implementing Actions in Struts Dependency Injection and Inversion of Control The ApplicationAware Interface The ParameterAware Interface The ServletRequestAware Interface The ServletResponseAware Interface The SessionAware Interface Preprocessing with Interceptors What are Interceptors? Interceptors as RequestProcessor How to Configure Interceptors? Stacking of Interceptors Bundled Interceptors Writing Interceptors OGNL Support in Struts Syntax of OGNL Using OGNL in Struts Implementing Struts 2 Tags Generic Tags UI Tags Controlling Results in Struts What is Result? xxiv

21 Types of Results Configuring Results Configuring Result Types Performing Validation in Struts XWork Validation framework Bundled Validators Registering Validators Defining Validation Rules Custom Validators Short-circuiting Validators Validation Annotation ConversionErrorFieldValidator Annotation Validating Stuts2App Application Internationalizing Struts 2 Applications Describing Internationalization and Localization Global Resource Bundle Implementing Plugins in Struts Struts 2 Bundled Plugins Tiles Plugin Integrating Struts 2 with Hibernate Setting the MySQL Database and Table Configuring Hibernate Developing Struts Hibernate Plugin Summary Quick Revise Chapter 21: Working with Spring Introducing Features of the Spring Framework What s New in Spring Exploring the Spring Framework Architecture Explaining the Spring Core Module Explaining the Spring AOP Module Explaining the Spring ORM Module Explaining the Spring Web MVC Module Explaining the Spring Web Flow Module Explaining the Spring DAO Module Explaining the Spring Application Context Module Exploring Dependency Injection and Inversion of Control xxv

22 Explaining DI Explaining IoC Container Exploring AOP with Spring Describing the AOP Concepts Explaining Types of Advices Spring AOP Capabilities and Its Goals Managing Transactions Need of Transaction Management Support Spring Transaction Abstraction Resource Synchronization with Transactions Declarative Transaction Management Programmatic Transaction Management Choosing between Programmatic and Declarative Transaction Managements Application Server-Specific Integration Exploring Spring Form Tag Library Classifying the Types of Tags Exploring Spring s Web MVC Framework Key Features of Spring Web MVC The DispatcherServlet Class Controllers Handler Mappings Views and View Resolvers Implementing Spring Web MVC Framework Creating the Controller Creating the Views Creating the Spring Configuration File Creating the Web Configuration File Exploring the Directory Structure Running the Application Testing Spring Applications The Unit Testing The Integration Testing Integrating Spring with Hibernate Integrating Struts 2 with Spring Configuring Spring in a Struts 2 Application Summary Quick Revise xxvi

23 Chapter 22: Securing Java EE 6 Applications Introducing Security in Java EE Authentication Protection Domain Exploring Security Mechanisms Application Layer Security Transport Layer Security Message Layer Security Implementing Security on an Application Server Realm User Group Role Securing Enterprise Beans Using the Programmatic Security Approach Using Security Identity Securing Application Clients Implementing Security in Web Applications Using JAAS Using Authentication Mechanisms Implementing Security Describing Declarative Security Implementing Programmatic Security Summary Quick Revise Chapter 23: People Management Solutions Software Requirements SDLC of the Project Requirement Analysis Software Design Database Design Development Testing Implementation and Maintenance Summary xxvii

24 Chapter 23: Section A: Developing the Login Module Designing Login User Interface Creating the people_user_login Servlet Creating the UserLoginDBObj Class Creating the UserLoginDBMethods Class Creating the people_default.jsp File Directory Structure of the Project Login and Navigating to Home Page Changing Password Chapter 23: Section B: Developing the Profile Management Module Implementing Logic with Servlet Creating the people_employee Servlet Creating the EmployeeObj Class Creating the EmployeeDBMethods Class Creating the GenerateId Class Creating Views Creating the employee_insert JSP Page Creating the employee_search JSP Page Creating the employee_edit JSP Page Creating the employee_list JSP Page Creating the employee_profile JSP Page Chapter 23: Section C: Developing the Recruitment Module Registering a New Applicant Creating the people_applicant Servlet Creating the ApplicantDBObj Class Creating the ApplicantDBMethods Class Creating the GenerateId Class Creating an Interface for Applicant Registration Conducting Rounds of Test Creating the applicant_test_dtl Servlet Designing JSP Views Working of the Recruitment Module Chapter 23: Section D: Developing the Attendance Management Module Creating the time_management Servlet Creating the Classes in the com.timemanagement Package Creating JSP Views xxviii

25 Creating the employee_daily_attendance JSP Page Creating the employee_daily_attendance_summary JSP Page Chapter 23: Section E: Developing the Leave Management Module Creating the leave_management Servlet Creating the LeaveRequest Class Creating the LeaveMgmtBeanMethods Class Creating the GenerateId Class Designing JSP Views Creating the leave_request JSP Page Creating the leave_request_edit JSP Page Creating the leave_request_reject JSP Page Creating the leave_request_list JSP Page Chapter 23: Section F: Developing the Payroll Module Updating Salary Statement Creating people_payroll Servlet Creating the EmpSal Class Creating the EmployeeAgreement Class Creating the PayrollBeanMethods Class Designing JSP Views Creating the employee_agreement JSP Page Creating the employee_agreement_edit JSP Page Creating the salary_search.jsp File Creating the salary_slip JSP Page Appendix A: AJAX Appendix B: Installing Java EE 6 SDK Appendix C: Working with NetBeans IDE Appendix D: Implementing Internationalization Appendix E: Working with Facelets Appendix F: Working with JMS Glossary Index What s on the CD-ROM xxix

26 Appendices on the CD Appendix A: RMI-IIOP Appendix B: Understanding Directory Services and JNDI Appendix C: XML Appendix D: Unified Modeling Language (UML) xxx