JavaServer Pages. 3rd Edition

Spis treści ebooka

• JavaServer Pages, 3rd Edition
  • SPECIAL OFFER: Upgrade this ebook with OReilly
  • A Note Regarding Supplemental Files
  • Preface
    • Whats in This Book
    • Readers of the Second Edition
    • Audience
      • What You Need to Know
    • Organization
      • Part I, JSP Application Basics
      • Part II, JSP Application Development
      • Part III, JSP in J2EE and JSP Component Development
      • Part IV, Appendixes
    • About the Examples
    • Conventions Used in This Book
    • How to Contact Us
    • Acknowledgments for First Edition
    • Acknowledgments for Second Edition
    • Acknowledgments for Third Edition
  • I. JSP Application Basics
    • 1. Introducing JavaServer Pages
      • 1.1. What Is JavaServer Pages?
      • 1.2. Why Use JSP?
        • 1.2.1. Embedding Dynamic Elements in HTML Pages
        • 1.2.2. Compilation
        • 1.2.3. Using the Right Person for Each Task
        • 1.2.4. Integration with Enterprise Java APIs
        • 1.2.5. Other Solutions
          • 1.2.5.1. Active Server Pages (ASP)
          • 1.2.5.2. PHP
          • 1.2.5.3. ColdFusion
          • 1.2.5.4. Java servlet template engines
        • 1.2.6. The JSP Advantage
      • 1.3. What You Need to Get Started
    • 2. HTTP and Servlet Basics
      • 2.1. The HTTP Request/Response Model
        • 2.1.1. Requests in Detail
        • 2.1.2. Responses in Detail
        • 2.1.3. Request Parameters
        • 2.1.4. Request Methods
      • 2.2. Servlets
        • 2.2.1. Advantages over Other Server-Side Technologies
        • 2.2.2. Servlet Containers
        • 2.2.3. Servlet Contexts and Web Applications
    • 3. JSP Overview
      • 3.1. The Problem with Servlets
      • 3.2. The Anatomy of a JSP Page
      • 3.3. JSP Processing
        • 3.3.1. JSP Elements
          • 3.3.1.1. Directive elements
          • 3.3.1.2. Standard action elements
          • 3.3.1.3. Custom action elements and the JSP Standard Tag Library
          • 3.3.1.4. Scripting elements
          • 3.3.1.5. Expression Language expressions
          • 3.3.1.6. JavaBeans components
      • 3.4. JSP Application Design with MVC
    • 4. Setting Up the JSP Environment
      • 4.1. Installing the Java Software Development Kit
      • 4.2. Installing the Tomcat Server
        • 4.2.1. Windows Platforms
        • 4.2.2. Unix Platforms (Including Linux and Mac OS X)
      • 4.3. Testing Tomcat
      • 4.4. Installing the Book Examples
      • 4.5. Example Web Application Overview
  • II. JSP Application Development
    • 5. Generating Dynamic Content
      • 5.1. Creating a JSP Page
      • 5.2. Installing a JSP Page
      • 5.3. Running a JSP Page
      • 5.4. Using JSP Directive Elements
        • 5.4.1. JSP Comments
      • 5.5. Using Template Text
      • 5.6. Using JSP Action Elements
        • 5.6.1. JSP Standard Tag Library
        • 5.6.2. The JSP Expression Language
    • 6. Using JavaBeans Components in JSP Pages
      • 6.1. What Is a Bean?
      • 6.2. Declaring a Bean in a JSP Page
      • 6.3. Reading Bean Properties
        • 6.3.1. Using the <jsp:getProperty> Action
        • 6.3.2. Using the JSP Expression Language
        • 6.3.3. Including Images with JSP
      • 6.4. Setting Bean Properties
        • 6.4.1. Using the <jsp:setProperty> Action
        • 6.4.2. Using the JSTL <c:set> Action
        • 6.4.3. Automatic Type Conversions
    • 7. Using Custom Tag Libraries and the JSP Standard Tag Library
      • 7.1. What Is a Custom Tag Library?
      • 7.2. Installing a Custom Tag Library
      • 7.3. Declaring a Custom Tag Library
        • 7.3.1. Identifying a Custom Tag Library in a JSP 1.1 Container
      • 7.4. Using Actions from a Tag Library
        • 7.4.1. Setting Action Attribute Values
        • 7.4.2. The JSP Standard Tag Library
        • 7.4.3. Using Beans or Custom Actions
    • 8. Processing Input and Output
      • 8.1. Reading Request Parameter Values
        • 8.1.1. Accessing Parameter Values with JSTL Actions
        • 8.1.2. Accessing Other Request Data
        • 8.1.3. Capturing Parameter Values Using a Bean
      • 8.2. Validating User Input
        • 8.2.1. Validating User Input Using JSTL Actions
        • 8.2.2. Validating User Input Using a Bean
      • 8.3. Formatting HTML Output
    • 9. Error Handling and Debugging
      • 9.1. Dealing with Syntax Errors
        • 9.1.1. Element Syntax Errors
        • 9.1.2. Expression Language Syntax Errors
      • 9.2. Debugging a JSP Application
      • 9.3. Dealing with Runtime Errors
        • 9.3.1. Catching Exceptions
    • 10. Sharing Data Between JSP Pages, Requests, and Users
      • 10.1. Passing Control and Data Between Pages
        • 10.1.1. Passing Control from One Page to Another
        • 10.1.2. Passing Data from One Page to Another
        • 10.1.3. All Together Now
      • 10.2. Sharing Session and Application Data
        • 10.2.1. Session Tracking Explained
        • 10.2.2. Counting Page Hits
        • 10.2.3. URL Rewriting
      • 10.3. Online Shopping
        • 10.3.1. Number Formatting
        • 10.3.2. Using a Request Parameter as an Index
        • 10.3.3. Redirect Versus Forward
      • 10.4. Memory Usage Considerations
    • 11. Developing Custom Tag Libraries as Tag Files
      • 11.1. Creating and Using a Tag File
      • 11.2. Accessing Attribute Values
        • 11.2.1. Using Undeclared Attributes
      • 11.3. Processing the Action Body
      • 11.4. Processing Fragment Attributes
      • 11.5. Exposing Data to the Calling Page Through Variables
      • 11.6. Aborting the Page Processing
      • 11.7. Packaging Tag Files for Easy Reuse
    • 12. Accessing a Database
      • 12.1. Accessing a Database from a JSP Page
        • 12.1.1. Application Architecture Example
        • 12.1.2. Table Example
        • 12.1.3. The DataSource Interface and JDBC Drivers
        • 12.1.4. Reading and Storing Information in a Database
          • 12.1.4.1. Reading database information
          • 12.1.4.2. Inserting database information
          • 12.1.4.3. Updating database information
        • 12.1.5. Generating HTML from a Query Result
        • 12.1.6. Searching for Rows Based on Partial Information
        • 12.1.7. Deleting Database Information
        • 12.1.8. Displaying Database Data over Multiple Pages
          • 12.1.8.1. Setting an upper limit for the result size
          • 12.1.8.2. Getting a limited number of rows at a time
          • 12.1.8.3. Run a query once and display the result over multiple pages
      • 12.2. Validating Complex Input Without a Bean
      • 12.3. Using Transactions
      • 12.4. Application-Specific Database Actions
    • 13. Authentication and Personalization
      • 13.1. Container-Provided Authentication
        • 13.1.1. Authenticating Users
        • 13.1.2. Controlling Access to Web Resources
      • 13.2. Application-Controlled Authentication
        • 13.2.1. A Table for Personalized Information
        • 13.2.2. Logging In
          • 13.2.2.1. Using cookies to remember the username and password
        • 13.2.3. Authentication Using a Database
          • 13.2.3.1. Creating the validation object
          • 13.2.3.2. Setting and deleting cookies
          • 13.2.3.3. Redirect to the application page
        • 13.2.4. Checking for a Valid Session
          • 13.2.4.1. Providing personalized content
        • 13.2.5. Updating the User Profile
        • 13.2.6. Logging Out
      • 13.3. Other Security Concerns
    • 14. Internationalization
      • 14.1. How Java Supports Internationalization and Localization
        • 14.1.1. The Locale Class
        • 14.1.2. Formatting Numbers and Dates
        • 14.1.3. Using Localized Text
      • 14.2. Generating Localized Output
        • 14.2.1. Using One Page for Multiple Locales
        • 14.2.2. Using a Separate Page per Locale
      • 14.3. A Brief History of Bits
      • 14.4. Handling Localized Input
        • 14.4.1. Dealing with Non-Western European Input
    • 15. Working with XML Data
      • 15.1. Generating an XML Response
      • 15.2. Transforming XML into HTML
      • 15.3. Transforming XML into a Device-Dependent Format
      • 15.4. Processing XML Data
        • 15.4.1. Caching Data
        • 15.4.2. Parsing XML Data
        • 15.4.3. Accessing XML Data Using XPath Expressions
    • 16. Using Scripting Elements
      • 16.1. Using page Directive Scripting Attributes
      • 16.2. Implicit JSP Scripting Objects
      • 16.3. Using Scriptlets
      • 16.4. Using Expressions
      • 16.5. Using Declarations
        • 16.5.1. jspInit() and jspDestroy( )
      • 16.6. Mixing Action Elements and Scripting Elements
        • 16.6.1. Using an Expression Element to Set an Attribute
        • 16.6.2. Accessing Scoped Variables in Scripting Code
      • 16.7. Dealing with Scripting Syntax Errors
        • 16.7.1. Scripting Syntax Error Examples
    • 17. Bits and Pieces
      • 17.1. Buffering
      • 17.2. Including Page Segments
      • 17.3. Global Configuration Options
        • 17.3.1. Declaring a File as a JSP Page
        • 17.3.2. Controlling the Interpretation of EL Expressions
        • 17.3.3. Controlling the Use of Scripting Elements
        • 17.3.4. Specifying the File Encoding
        • 17.3.5. Specifying Automatically Included Files
        • 17.3.6. Declaring Files as JSP Documents
      • 17.4. Mixing Client-Side and Server-Side Code
        • 17.4.1. Generating JavaScript Code
          • 17.4.1.1. Using server-side data in JavaScript code
        • 17.4.2. Using Java Applets
      • 17.5. Precompiling JSP Pages
      • 17.6. Preventing Caching of JSP Pages
      • 17.7. Writing JSP Pages as XML Documents
        • 17.7.1. Identifying a JSP Document
        • 17.7.2. Custom Tag Library Declarations
        • 17.7.3. Generating a DOCTYPE Declaration
        • 17.7.4. XML Syntax for JSP Directives and Scripting Elements
        • 17.7.5. Generating Elements Dynamically
        • 17.7.6. Encoding Non-XML Data and Special Characters
        • 17.7.7. Using the <jsp:root> Element
        • 17.7.8. XML Declaration Generation
      • 17.8. How URIs Are Interpreted
  • III. JSP in J2EE and JSP Component Development
    • 18. Web Application Models
      • 18.1. The Java 2 Enterprise Edition Model
      • 18.2. The MVC Design Model
        • 18.2.1. Using Only JSP
        • 18.2.2. Using Servlets and JSP
        • 18.2.3. Using Servlets, JSP, and EJB
      • 18.3. Scalability
        • 18.3.1. Preparing for Distributed Deployment
    • 19. Combining JSP and Servlets
      • 19.1. Servlets, Filters, and Listeners
        • 19.1.1. Servlet Lifecycle
        • 19.1.2. Compiling and Installing a Servlet
        • 19.1.3. Reading a Request
        • 19.1.4. Generating a Response
        • 19.1.5. Using Filters and Listeners
          • 19.1.5.1. Filters
          • 19.1.5.2. Listeners
        • 19.1.6. Sharing Data Between the Component Types
      • 19.2. Picking the Right Component Type for Each Task
      • 19.3. Initializing Shared Resources Using a Listener
      • 19.4. Access Control Using a Filter
      • 19.5. Centralized Request Processing Using a Servlet
        • 19.5.1. Struts Request Processing Overview
        • 19.5.2. Mapping Application Requests to the Servlet
        • 19.5.3. Dispatching Requests to an Action Class
        • 19.5.4. Implementing the Action Classes
        • 19.5.5. Processing Requests
        • 19.5.6. Calling the Controller Servlet from JSP Pages
      • 19.6. Using a Common JSP Error Page
    • 20. Developing JavaBeans Components for JSP
      • 20.1. Beans as JSP Components
        • 20.1.1. JavaBeans Naming Conventions
          • 20.1.1.1. Handling session events
          • 20.1.1.2. Using a package name for a bean class
        • 20.1.2. Compiling and Installing a Bean
      • 20.2. JSP Bean Examples
        • 20.2.1. Value Beans
        • 20.2.2. Utility Beans
        • 20.2.3. Multithreading Considerations
      • 20.3. Unexpected <jsp:setProperty> Behavior
    • 21. Developing Custom Tag Libraries Using Java
      • 21.1. Developing Simple Tag Handlers
        • 21.1.1. Accessing Context Information
        • 21.1.2. Aborting the Page Processing
        • 21.1.3. Processing the Action Body as an Executable Fragment
          • 21.1.3.1. Conditional and iterating processing
          • 21.1.3.2. Processing the action body
        • 21.1.4. Processing Fragment Attributes
        • 21.1.5. Handling Exceptions
      • 21.2. Developing Classic Tag Handlers
        • 21.2.1. Developing a Basic Action
        • 21.2.2. Developing an Iterating Action
        • 21.2.3. Processing the Action Body
          • 21.2.3.1. Dealing with empty elements
        • 21.2.4. Handling Exceptions
        • 21.2.5. The Classic Tag Handler Lifecycle and What It Means to You
          • 21.2.5.1. Providing default values for optional attributes
          • 21.2.5.2. Resetting per-invocation state
          • 21.2.5.3. Keeping expensive resources for the lifetime of the tag handler instance
      • 21.3. Developing Tag Library Functions
      • 21.4. Creating the Tag Library Descriptor
        • 21.4.1. General Library Elements
        • 21.4.2. Validator and Listener Elements
        • 21.4.3. Tag Elements
          • 21.4.3.1. General tag elements
          • 21.4.3.2. Variable elements
          • 21.4.3.3. Attribute elements
          • 21.4.3.4. Dynamic attributes element
          • 21.4.3.5. Example element
        • 21.4.4. Tag File Elements
        • 21.4.5. Function Elements
        • 21.4.6. Differences Between a JSP 1.2 and a JSP 2.0 TLD
        • 21.4.7. Differences Between a JSP 1.1 and a JSP 1.2 TLD
      • 21.5. Packaging and Installing a Tag Library
        • 21.5.1. Making the Tag Library Files Available to the Container
        • 21.5.2. Identifying the Tag Library in a JSP Page
        • 21.5.3. Packaging Multiple Libraries in One JAR File
    • 22. Advanced Custom Tag Library Features
      • 22.1. Developing Cooperating Actions
        • 22.1.1. Using Explicit Parent-Child Cooperation
        • 22.1.2. Using Implicit Cooperation Through Variables
          • 22.1.2.1. Creating a scripting variable
          • 22.1.2.2. Using a TagExtraInfo subclass to declare a variable
        • 22.1.3. Supporting Undeclared Attributes
      • 22.2. Validating Syntax
        • 22.2.1. Validation Based on the TLD
        • 22.2.2. Using a TagLibraryValidator
        • 22.2.3. Using a TagExtraInfo Class for Validation
      • 22.3. Using a Listener in a Tag Library
      • 22.4. Dynamic Attribute Values and Types
        • 22.4.1. Conversions Performed by the Container
        • 22.4.2. Using a PropertyEditor for Conversion
    • 23. Integrating Custom Code with JSTL
      • 23.1. Setting and Using Configuration Variables
      • 23.2. Integrating Custom Conditional Actions
      • 23.3. Integrating Custom Iteration Actions
        • 23.3.1. Implementing a Custom Iteration Action
        • 23.3.2. Interacting with an Iteration Action
      • 23.4. Integrating Custom I18N Actions
      • 23.5. Integrating Custom Database Actions
      • 23.6. Using JSTL Tag Library Validators
    • 24. Database Access Strategies
      • 24.1. JDBC Basics
      • 24.2. Using Connections and Connection Pools
        • 24.2.1. Using a JDBC 2.0 Optional Package Connection Pool
        • 24.2.2. Making a JDBC 1.0 Connection Pool Behave as a JDBC 2.0 Connection Pool
      • 24.3. Making a Connection Pool Available to Application Components
        • 24.3.1. Using an Application Scope Variable
        • 24.3.2. Using JNDI
      • 24.4. Using a Generic Database Bean
      • 24.5. Developing Application-Specific Database Components
  • IV. Appendixes
    • A. JSP Elements Reference
      • A.1. Directive Elements
        • Attribute Directive
        • Include Directive
        • Page Directive
        • Taglib Directive
        • Tag Directive
        • Variable Directive
      • A.2. Scripting Elements
        • Declaration
        • Expression
        • Scriptlet
      • A.3. Action Elements
        • <jsp:attribute>
        • <jsp:body>
        • <jsp:doBody>
        • <jsp:element>
        • <jsp:fallback>
        • <jsp:forward>
        • <jsp:getProperty>
        • <jsp:include>
        • <jsp:invoke>
        • <jsp:output>
        • <jsp:param>
        • <jsp:params>
        • <jsp:plugin>
        • <jsp:root>
        • <jsp:setProperty>
        • <jsp:text>
        • <jsp:useBean>
      • A.4. Custom actions
      • A.5. Comments
      • A.6. Escape Characters
    • B. JSTL Actions and API Reference
      • B.1. JSTL Library URIs and Default Prefixes
      • B.2. Core Library Actions
        • <c:catch>
        • <c:choose>
        • <c:forEach>
        • <c:forTokens>
        • <c:if>
        • <c:import>
        • <c:otherwise>
        • <c:out>
        • <c:param>
        • <c:redirect>
        • <c:remove>
        • <c:set>
        • <c:url>
        • <c:when>
      • B.3. Internationalization and Formatting Actions
        • <fmt:bundle>
        • <fmt:formatDate>
        • <fmt:formatNumber>
        • <fmt:message>
        • <fmt:param>
        • <fmt:parseDate>
        • <fmt:parseNumber>
        • <fmt:requestEncoding>
        • <fmt:setBundle>
        • <fmt:setLocale>
        • <fmt:setTimeZone>
        • <fmt:timeZone>
      • B.4. Database Access Actions
        • <sql:dateParam>
        • <sql:param>
        • <sql:query>
        • <sql:setDataSource>
        • <sql:transaction>
        • <sql:update>
      • B.5. XML Processing Actions
        • <x:choose>
        • <x:forEach>
        • <x:if>
        • <x:otherwise>
        • <x:out>
        • <x:param>
        • <x:parse>
        • <x:set>
        • <x:transform>
        • <x:when>
      • B.6. EL Functions
        • fn:contains
        • fn:containsIgnoreCase
        • fn:endsWith
        • fn:escapeXml
        • fn:indexOf
        • fn:join
        • fn:length
        • fn:replace
        • fn:split
        • fn:startsWith
        • fn:substring
        • fn:substringAfter
        • fn:substringBefore
        • fn:toLowerCase
        • fn:toUpperCase
        • fn:trim
      • B.7. Support and Utility Types
        • ConditionalTagSupport
        • LocaleSupport
        • LocalizationContext
        • LoopTag
        • LoopTagStatus
        • LoopTagSupport
        • Result
        • ResultSupport
        • SQLExecutionTag
      • B.8. Configuration Settings
        • Data Source
        • Fallback Locale
        • Locale
        • Localization Context
        • Max Rows
        • Time Zone
    • C. JSP Expression Language Reference
      • C.1. Syntax
        • C.1.1. Literals
        • C.1.2. Keywords and Reserved Words
      • C.2. Variables
        • C.2.1. Implicit Variables
      • C.3. Data Types
        • C.3.1. Coercion Rules
      • C.4. Expressions and Operators
        • C.4.1. Operand Coercing Rules
          • C.4.1.1. Property and array accessor operators
          • C.4.1.2. Arithmetic operators
          • C.4.1.3. Relational operators
          • C.4.1.4. Logical operators
          • C.4.1.5. Empty operator
    • D. JSP API Reference
      • D.1. Implicit Variables
        • application
        • config
        • exception
        • out
        • page
        • pageContext
        • request
        • response
        • session
      • D.2. Other Servlet Types Accessible Through Implicit Variables
        • Cookie
        • RequestDispatcher
      • D.3. Tag Handler Types
        • BodyContent
        • BodyTag
        • BodyTagSupport
        • DynamicAttributes
        • IterationTag
        • JspContext
        • JspFragment
        • JspTag
        • SimpleTag
        • SimpleTagSupport
        • Tag
        • TagAdapter
        • TagSupport
        • TryCatchFinally
      • D.4. Translation Time Types
        • FunctionInfo
        • PageData
        • TagAttributeInfo
        • TagData
        • TagExtraInfo
        • TagFileInfo
        • TagInfo
        • TagLibraryInfo
        • TagLibraryValidator
        • TagVariableInfo
        • ValidationMessage
        • VariableInfo
      • D.5. Other JSP Types
        • ErrorData
        • HttpJspPage
        • JspEngineInfo
        • JspException
        • JspFactory
        • JspPage
        • JspTagException
        • SkipPageException
      • D.6. Expression Language Types
        • ELException
        • ELParseException
        • Expression
        • ExpressionEvaluator
        • FunctionMapper
        • VariableResolver
    • E. Book Example Custom Actions and API Reference
      • E.1. Generic Custom Actions
        • <ora:addCookie>
        • <ora:calendar>
        • <ora:debug>
        • <ora:fileWrite>
        • <ora:ifUserInRole>
        • <ora:ifValidEmailAddr>
        • <ora:invalidateSession>
        • <ora:menuItem>
        • <ora:noCache>
        • <ora:setHeader>
      • E.2. Generic Utility Classes
        • ConnectionPool
        • ConnectionWrapper
        • CookieUtils
        • DataSourceFactory
        • DataSourceWrapper
        • StringFormat
        • SQLCommandBean
    • F. Web Application Structure and Deployment Descriptor Reference
      • F.1. Web Application File Structure
        • F.1.1. Placing Java Class Files in the Right Directory
      • F.2. Web Application Deployment Descriptor
        • Reference Section
          • <description>, <display>, and <icon>
        • Reference Section
          • <distributable>
        • Reference Section
          • <context-param>
        • Reference Section
          • <filter>
        • Reference Section
          • <filter-mapping>
        • Reference Section
          • <listener>
        • Reference Section
          • <servlet>
        • Reference Section
          • <servlet-mapping>
        • Reference Section
          • <session-config>
        • Reference Section
          • <mime-mapping>
        • Reference Section
          • <welcome-file-list>
        • Reference Section
          • <error-page>
        • Reference Section
          • <jsp-config>
        • Reference Section
          • <resource-env-ref>
        • Reference Section
          • <resource-ref>
        • Reference Section
          • <security-constraint>
        • Reference Section
          • <login-config>
        • Reference Section
          • <security-role>
        • Reference Section
          • <locale-encoding-mapping-list>
        • Reference Section
          • <env-entry>
        • Reference Section
          • <ejb-ref>
        • Reference Section
          • <ejb-local-ref>
        • Reference Section
          • <service-ref>
        • Reference Section
          • <message-destination-ref>
        • Reference Section
          • <message-destination>
        • F.2.1. Example Application Deployment Descriptor
      • F.3. Creating a WAR File
  • About the Author
  • Colophon
  • SPECIAL OFFER: Upgrade this ebook with OReilly

pokaż cały spis treści

ukryj recenzje