category table

1. In the Services window (Ctrl-5; ⌘-5 on Mac), right-click the category table ( ) node and choose View Data. The SQL editor opens and displays with a GUI representation of the category table in the lower region. Note that the table is empty, as no data has yet been added.
   
   Also, note that the native SQL query used to generate the GUI representation is displayed in the upper region of the editor: 'select * from category'.
2. Delete 'select * from category' and enter the following SQL statement:

   INSERT INTO `category` (`name`) VALUES ('dairy'),('meats'),('bakery'),('fruit & veg');

   This statement inserts four new records, each with a unique entry for the 'name' column. Because the id column was specified as AUTO_INCREMENT when you created the schema, you do not need to worry about supplying a value.
3. Click the Run SQL ( ) button in the editor's toolbar. The SQL statement is executed.
4. To confirm that the data has been added, run the 'select * from category' query again. To do so, you can use the SQL History window. Click the SQL History ( ) button in the editor's toolbar and double-click the 'select * from category' entry. The SQL History window lists all SQL statements that you recently executed in the IDE.

Watch the screencast below to see how you can follow the above steps. When typing in the editor, be sure to take advantage of the IDE's code completion and suggestion facilities.

product table

1. Right-click the product table ( ) node and choose Execute Command. Choosing the Execute Command menu option in the Services window opens the SQL editor in the IDE.
2. Copy and paste the following INSERT statements into the editor.

   --
   -- Sample data for table `product`
   --
   
   INSERT INTO `product` (`name`, price, description, category_id) VALUES ('milk', 1.70, 'semi skimmed (1L)', 1);
   INSERT INTO `product` (`name`, price, description, category_id) VALUES ('cheese', 2.39, 'mild cheddar (330g)', 1);
   INSERT INTO `product` (`name`, price, description, category_id) VALUES ('butter', 1.09, 'unsalted (250g)', 1);
   INSERT INTO `product` (`name`, price, description, category_id) VALUES ('free range eggs', 1.76, 'medium-sized (6 eggs)', 1);
   
   INSERT INTO `product` (`name`, price, description, category_id) VALUES ('organic meat patties', 2.29, 'rolled in fresh herbs<br>2 patties (250g)', 2);
   INSERT INTO `product` (`name`, price, description, category_id) VALUES ('parma ham', 3.49, 'matured, organic (70g)', 2);
   INSERT INTO `product` (`name`, price, description, category_id) VALUES ('chicken leg', 2.59, 'free range (250g)', 2);
   INSERT INTO `product` (`name`, price, description, category_id) VALUES ('sausages', 3.55, 'reduced fat, pork<br>3 sausages (350g)', 2);
   
   INSERT INTO `product` (`name`, price, description, category_id) VALUES ('sunflower seed loaf', 1.89, '600g', 3);
   INSERT INTO `product` (`name`, price, description, category_id) VALUES ('sesame seed bagel', 1.19, '4 bagels', 3);
   INSERT INTO `product` (`name`, price, description, category_id) VALUES ('pumpkin seed bun', 1.15, '4 buns', 3);
   INSERT INTO `product` (`name`, price, description, category_id) VALUES ('chocolate cookies', 2.39, 'contain peanuts<br>(3 cookies)', 3);
   
   INSERT INTO `product` (`name`, price, description, category_id) VALUES ('corn on the cob', 1.59, '2 pieces', 4);
   INSERT INTO `product` (`name`, price, description, category_id) VALUES ('red currants', 2.49, '150g', 4);
   INSERT INTO `product` (`name`, price, description, category_id) VALUES ('broccoli', 1.29, '500g', 4);
   INSERT INTO `product` (`name`, price, description, category_id) VALUES ('seedless watermelon', 1.49, '250g', 4);
   

   Examine the above code and note the following points:
   • By examining the affablebean schema generation script, you'll note that the product table contains a non-nullable, automatically incremental primary key. Whenever you insert a new record into the table (and don't explicitly set the value of the primary key), the SQL engine sets it for you. Also, note that the product table's last_update column applies CURRENT_TIMESTAMP as its default value. The SQL engine will therefore provide the current date and time for this field when a record is created.
     
     Looking at this another way, if you were to create an INSERT statement that didn't indicate which columns would be affected by the insertion action, you would need to account for all columns. In this case, you could enter a NULL value to enable the SQL engine to automatically handle fields that have default values specified. For example, the following statement elicits the same result as the first line of the above code:

     INSERT INTO `product` VALUES (NULL, 'milk', 1.70, 'semi skimmed (1L)', NULL, 1);

     After running the statement, you'll see that the record contains an automatically incremented primary key, and the last_update column lists the current date and time.
   • The value for the final column, 'category_id', must correspond to a value contained in the category table's id column. Because you have already added four records to the category table, the product records you are inserting reference one of these four records. If you try to insert a product record that references a category_id that doesn't exist, a foreign key constraint fails.
3. Click the Run SQL ( ) button in the editor's toolbar.
   
   

   Note: View the Output window (Ctrl-4; ⌘-4 on Mac) to see a log file containing results of the execution.

4. Right-click the product table ( ) node and choose View Data. You can see 16 new records listed in the table.
   
   

   NetBeans GUI Support for Database Tables

   In the Services window, when you right-click a table ( ) node and choose View Data, the IDE displays a visual representation of the table and the data it contains (as depicted in the image above). You can also use this GUI support to add, modify, and delete table data.

   • Add new records: To add new records, click the Insert Record ( ) button. An Insert Records dialog window displays, enabling you to enter new records. When you click OK, the new data is committed to the database, and the GUI representation of the table is automatically updated.
     
     

     Click the Show SQL button within the dialog window to view the SQL statement(s) that will be applied upon initiating the action.

   • Modify records: You can make edits to existing records by double-clicking directly in table cells and modifying field entries. Modified entries display as green text. When you are finished editing data, click the Commit Record ( ) button to commit changes to the actual database. (Similarly, click the Cancel Edits ( ) button to cancel any edits you have made.
   • Delete individual records: Click a row in the table, then click the Delete Selected Record ( ) button. You can also delete multiple rows simultaneously by holding Ctrl (⌘ on Mac) while clicking to select rows.
   • Delete all records: Deleting all records within a table is referred to as 'truncating' the table. Click the Truncate Table ( ) button to delete all records contained in the displayed table.

   If the displayed data needs to be resynchronized with the actual database, you can click the Refresh Records ( ) button. Note that much of the above-described functionality can also be accessed from the right-click menu within the GUI editor.

Pinging the Connection Pool

1. Ensure that the GlassFish server is already running. In the Services window (Ctrl-5; ⌘-5 on Mac), expand the Servers node. Note the small green arrow next to the GlassFish icon ( ).
   
   (If the server is not running, right-click the server node and choose Start.)
2. Right-click the server node and choose View Admin Console. The GlassFish Administration Console opens in a browser.
3. Log into the administration console. The default username / password is: admin / adminadmin.
4. In the console's tree on the left, expand the Resources > JDBC > Connection Pools nodes, then click AffableBeanPool. In the main window, the Edit Connection Pool interface displays for the selected connection pool.
5. Click the Ping button. If the ping succeeds, the GlassFish server has a working connection to the affablebean database on the MySQL server.
   
   (If the ping fails, see suggestions in the Troubleshooting section below.)

Creating a Resource Reference to the Data Source

1. In the Projects window, expand the Configuration Files folder and double-click web.xml. A graphical interface for the file displays in the IDE's main window.
2. Click the References tab located along the top of the editor. Expand the Resource References heading, then click Add. The Add Resource Reference dialog opens.
3. Enter the following details into the dialog:
   • Resource Name: jdbc/affablebean
   • Resource Type: javax.sql.DataSource
   • Authentication: Container
   • Sharing Scope: Shareable
   • Description: (Optional) Connects to database for AffableBean application
   
4. Click OK. The new resource is added under the Resource References heading.
   
   To verify that the resource is now added to the web.xml file, click the XML tab located along the top of the editor. Notice that the following <resource-ref> tags are now included:

   <resource-ref>
       <description>Connects to database for AffableBean application</description>
       <res-ref-name>jdbc/affablebean</res-ref-name>
       <res-type>javax.sql.DataSource</res-type>
       <res-auth>Container</res-auth>
       <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>

Querying the Database from a JSP Page

1. Create a new JSP page to test the data source. Click the New File ( ) button. (Alternatively, press Ctrl-N; ⌘-N on Mac.)
2. Select the Web category, then select the JSP file type and click Next.
3. Enter 'testDataSource' as the file name. In the Folder field, type in 'test'.
   
   

   The project does not yet have a folder named 'test' within the Web Pages location (i.e., within the web folder). By entering 'test' into the Folder field, you have the IDE create the folder upon completing the wizard.

4. Click finish. The IDE generates a new testDataSource.jsp file, and places it into the new test folder within the project.
5. In the new testDataSource.jsp file, in the editor, place your cursor at the end of the line containing the <h1> tags (line 17). Press Return, then press Ctrl-Space to invoke code suggestions. Choose DB Report from the list of options.
   
   

   If line numbers do not display, right-click in the left margin of the editor and choose Show Line Numbers.

6. In the Insert DB Report dialog, specify the data source and modify the SQL query to be executed:
   • Data Source: jdbc/affablebean
   • Query Statement: SELECT * FROM category, product WHERE category.id = product.category_id
   
7. Click OK. The dialog adds the taglib directives for the JSTL core and sql libraries to the top of the file:

   <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
   <%@taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql"%>

   The dialog also generates template code to display the query results in an HTML table:

   <sql:query var="result" dataSource="jdbc/affablebean">
       SELECT * FROM category, product
       WHERE category.id = product.category_id
   </sql:query>
   
   <table border="1">
       <!-- column headers -->
       <tr>
           <c:forEach var="columnName" items="${result.columnNames}">
               <th><c:out value="${columnName}"/></th>
           </c:forEach>
       </tr>
       <!-- column data -->
       <c:forEach var="row" items="${result.rowsByIndex}">
           <tr>
               <c:forEach var="column" items="${row}">
                   <td><c:out value="${column}"/></td>
               </c:forEach>
           </tr>
       </c:forEach>
   </table>

8. Before running the file in a browser, make sure you have enabled the JDBC driver deployment option in NetBeans' GlassFish support. Choose Tools > Servers to open the Servers window. In the left column, select the GlassFish server you are deploying to. In the main column, ensure that the 'Enable JDBC Driver Deployment' option is selected, then click Close.
   
   For Java applications that connect to a database, the server requires a JDBC driver to be able to create a communication bridge between the SQL and Java languages. In the case of MySQL, you use the Connector/J JDBC driver. Ordinarily you would need to manually place the driver JAR file into the server's lib directory. With the 'Enable JDBC Driver Deployment' option selected, the server performs a check to see whether a driver is needed, and if so, the IDE deploys the driver to the server.
9. Right-click in the editor and choose Run File (Shift-F6; fn-Shift-F6 on Mac). The testDataSource.jsp file is compiled into a servlet, deployed to the server, then runs in a browser.
10. Open the Output window (Ctrl-4; ⌘-4 on Mac) and click the 'AffableBean (run)' tab. The output indicates that the driver JAR file (mysql-connector-java-5.1.6-bin.jar) is deployed.
    
11. Examine testDataSource.jsp in the browser. You see an HTML table listing data contained in the category and product tables.
    
    (If you receive a server error, see suggestions in the Troubleshooting section below.)

${initParam.productImagePath}broccoli.png

${initParam.productImagePath}${product.name}.png

index page

1. In the Projects window, double-click the index.jsp node to open it in the editor. (If already opened, press Ctrl-Tab to select it in the editor.)
2. At the top of the file, before the first <div> tag, place your cursor on a blank line, then type 'db' and press Ctrl-Space. In the code-completion pop-up window that displays, choose DB Query.
   
3. In the Insert DB Query dialog, enter the following details:
   • Variable Name: categories
   • Scope: page
   • Data Source: jdbc/affablebean
   • Query Statement: SELECT * FROM category
   
4. Click OK. The dialog generates an SQL query using JSTL <sql:query> tags. Also, note that the required reference to the sql taglib directive has been automatically inserted at the top of the page. (Changes displayed in bold.)

   <%@taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql"%>
   <%--
       Document   : index
       Created on : Sep 5, 2009, 4:32:42 PM
       Author     : nbuser
   --%>
   
   <sql:query var="categories" dataSource="jdbc/affablebean">
       SELECT * FROM category
   </sql:query>
   
               <div id="indexLeftColumn">
                   <div id="welcomeText">
                       <p>[ welcome text ]</p>
                       

   The SQL query creates a result set which is stored in the categories variable. You can then access the result set using EL syntax, e.g., ${categories} (demonstrated below).
5. Place your cursor at the end of '<div id="indexRightColumn">' (line 22), hit return, type 'jstl' then press Ctrl-Space and choose JSTL For Each.
   
6. In the Insert JSTL For Each dialog, enter the following details:
   • Collection: ${categories.rows}
   • Current Item of the Iteration: category
   
7. Click OK. The dialog sets up syntax for a JSTL forEach loop using <c:forEach> tags. Also, note that the required reference to the core taglib directive has been automatically inserted at the top of the page. (Changes displayed in bold.)

   <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
   <%@taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql"%>
   
       ...
   
       <div id="indexRightColumn">
           <c:forEach var="category" items="categories.rows">
           </c:forEach>
           <div class="categoryBox">

   
   

   If you are wondering what 'rows' refers to in the generated code, recall that the categories variable represents a result set. More specifically, categories refers to an object that implements the javax.servlet.jsp.jstl.sql.Result interface. This object provides properties for accessing the rows, column names, and size of the query’s result set. When using dot notation as in the above example, 'categories.rows' is translated in Java to 'categories.getRows()'.

8. Integrate the <c:forEach> tags into the page. You can nest the <div class="categoryBox"> tags within the forEach loop so that HTML markup is generated for each of the four categories. Use EL syntax to extract the category table's id and name column values for each of the four records. Make sure to delete the other <div class="categoryBox"> tags which exist outside the forEach loop. When you finish, the complete index.jsp file will look as follows. (<c:forEach> tags and contents are displayed in bold.)

   <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
   <%@taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql"%>
   <%--
       Document   : index
       Created on : Sep 5, 2009, 4:32:42 PM
       Author     : nbuser
   --%>
   
   <sql:query var="categories" dataSource="jdbc/affablebean">
       SELECT * FROM category
   </sql:query>
   
               <div id="indexLeftColumn">
                   <div id="welcomeText">
                       <p>[ welcome text ]</p>
   
                       <!-- test to access context parameters -->
                       categoryImagePath: ${initParam.categoryImagePath}
                       productImagePath: ${initParam.productImagePath}
                   </div>
               </div>
   
               <div id="indexRightColumn">
                   <c:forEach var="category" items="${categories.rows}">
                       <div class="categoryBox">
                           <a href="category?${category.id}">
   
                               <span class="categoryLabelText">${category.name}</span>
   
                               <img src="${initParam.categoryImagePath}${category.name}.jpg"
                                    alt="${category.name}">
                           </a>
                       </div>
                   </c:forEach>
               </div>

9. Click the Run Project ( ) button. The project's index page opens in the browser, and you see the names and images of the four categories.
   
10. Click any of the four images in the browser. The category page displays.
    
    To understand how linking takes place between the index and category pages, reexamine the HTML anchor tags within the forEach loop:

    <a href="category?${category.id}">

    When a user clicks the image link in the browser, a request for 'category' is sent to the application's context root on the server. In your development environment, the URL is:

    http://localhost:8080/AffableBean/category

    which can be explained as follows:
    • http://localhost:8080: The default location of the GlassFish server on your computer
    • /AffableBean: The context root of your deployed application
    • /category: The path to the request
    Recall that in Preparing the Page Views and Controller Servlet, you mapped a request for '/category' to the ControllerServlet. Currently, the ControllerServlet internally forwards the request to /WEB-INF/view/category.jsp, which is why the category page displays upon clicking an image link.
    
    

    You can verify the application's context root by expanding the Configuration Files node in the Projects window, and opening the sun-web.xml file. The sun-web.xml file is a deployment descriptor specific to GlassFish.

    
    Also, note that a question mark (?) and category ID are appended to the requested URL.

    <a href="category?${category.id}">

    This forms the query string. As is demonstrated in the next section, you can apply (pageContext.request.queryString} to extract the value of the query string from the request. You can then use the category ID from the query string to determine which category details need to be included in the response.

category page

Three aspects of the category page need to be handled dynamically. The left column must indicate which category is selected, the table heading must display the name of the selected category, and the table must list product details pertaining to the selected category. In order to implement these aspects using JSTL, you can follow a simple, 2-step pattern:

1. Retrieve data from the database using the JSTL sql tag library.
2. Display the data using the JSTL core library and EL syntax.

Tackle each of the three tasks individually.

Display selected category in left column

1. In the Projects window, double-click the category.jsp node to open it in the editor. (If already opened, press Ctrl-Tab to select it in the editor.)
2. Add the following SQL query to the top of the file.

   <sql:query var="categories" dataSource="jdbc/affablebean">
       SELECT * FROM category
   </sql:query>

   Either use the Insert DB Query dialog as described above, or use the editor's code suggestion and completion facilities by pressing Ctrl-Space while typing.
3. Between the <div id="categoryLeftColumn"> tags, replace the existing static placeholder content with the following <c:forEach> loop.

   <div id="categoryLeftColumn">
   
       <c:forEach var="category" items="${categories.rows}">
   
           <c:choose>
               <c:when test="${category.id == pageContext.request.queryString}">
                   <div class="categoryButton" id="selectedCategory">
                       <span class="categoryText">
                           ${category.name}
                       </span>
                   </div>
               </c:when>
               <c:otherwise>
                   <a href="category?${category.id}" class="categoryButton">
                       <div class="categoryText">
                           ${category.name}
                       </div>
                   </a>
               </c:otherwise>
           </c:choose>
   
       </c:forEach>
   
   </div>

   In the above snippet, you access the request's query string using 'pageContext.request.queryString'. pageContext is another implicit object defined by the JSP Expression Language. The EL expression uses the PageContext to access the current request (an HttpServletRequest object). From HttpServletRequest, the getQueryString() method is called to obtain the value of the request's query string.
4. Make sure to add the JSTL core and sql taglib directives to the top of the page. (This is done automatically when using the editor's code suggestion and completion facilities.)

   <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
   <%@taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql"%>

5. Run the project. In the browser, navigate to the category page and click the category buttons in the left column. Each time you click, the page refreshes highlighting the selected category.
   
   Also, note that the ID of the selected category is displayed in the page's URL. (In the above image, the bakery category is selected, and '3' is appended to the URL in the browser's navigation toolbar.)
   
   

   Your servlet container (i.e., GlassFish) converts JSP pages into servlets before running them as part of a project. You can view the generated servlet for a JSP page by right-clicking the page node in the Projects window and choosing View Servlet. Of course, you first need to run the project so that the servlet is generated. Taking the index.jsp file as an example, when you choose View Servlet, the IDE displays a read-only copy of the generated servlet, index_jsp.java, in the editor. The servlet exists on the server at: <gf-install-dir>/glassfish/domains/domain1/generated/jsp/AffableBean/org/apache/jsp/index_jsp.java.

Display title heading above product table

1. Add the following SQL query to the top of the file, underneath the query you just implemented. (New query is shown in bold.)

   <sql:query var="categories" dataSource="jdbc/affablebean">
       SELECT * FROM category
   </sql:query>
   
   <sql:query var="selectedCategory" dataSource="jdbc/affablebean">
       SELECT name FROM category WHERE id = ?
       <sql:param value="${pageContext.request.queryString}"/>
   </sql:query>

2. Use JSP EL syntax to extract the category name from the query and display it in the page. Make the following change to the <p id="categoryTitle"> element. (Displayed in bold.)

   <p id="categoryTitle">${selectedCategory.rows[0].name}</p>

   Since the result from the selectedCategory query contains only one item (i.e., user can select only one category), you can retrieve the first row of the result set using 'selectedCategory.rows[0]'. If a user selects the 'meats' category for example, the returned expression would be '{name=meats}'. You could then access the category name with '${selectedCategory.rows[0].name}'.
3. Save (Ctrl-S; ⌘-S on Mac) changes made to the file.
4. Return to the browser and refresh the category page. The name of the selected category now displays above the product table.
   
   

   Note: As demonstrated in this and the previous step, you do not need to explicitly recompile, deploy, and run the project with each change to your code base. The IDE provides a Deploy on on Save feature, which is enabled for Java web projects by default. To verify that the feature is activated, right-click your project node in the Projects window and choose Properties. In the Project Properties window, click the Run category and examine the 'Deploy on Save' option.

Display product details within the table

1. Add the following SQL query to the top of the file, underneath the previous queries you implemented. (New query is shown in bold.)

   <sql:query var="categories" dataSource="jdbc/affablebean">
       SELECT * FROM category
   </sql:query>
   
   <sql:query var="selectedCategory" dataSource="jdbc/affablebean">
       SELECT name FROM category WHERE id = ?
       <sql:param value="${pageContext.request.queryString}"/>
   </sql:query>
   
   <sql:query var="categoryProducts" dataSource="jdbc/affablebean">
       SELECT * FROM product WHERE category_id = ?
       <sql:param value="${pageContext.request.queryString}"/>
   </sql:query>

2. Between the <table id="productTable"> tags, replace the existing static table row placeholders (<tr> tags) with the following <c:forEach> loop. (Changes are displayed in bold.)

   <table id="productTable">
   
       <c:forEach var="product" items="${categoryProducts.rows}" varStatus="iter">
   
           <tr class="${((iter.index % 2) == 0) ? 'lightBlue' : 'white'}">
               <td>
                   <img src="${initParam.productImagePath}${product.name}.png"
                       alt="${product.name}">
               </td>
               <td>
                   ${product.name}
                   <br>
                   <span class="smallText">${product.description}</span>
               </td>
               <td>
                   &euro; ${product.price} / unit
               </td>
               <td>
                   <form action="addToCart" method="post">
                       <input type="hidden"
                              name="productId"
                              value="${product.id}">
                       <input type="submit"
                              value="add to cart">
                   </form>
               </td>
           </tr>
   
       </c:forEach>
   
   </table>

   Note that in the above snippet an EL expression is used to determine the background color for table rows:

   class="${((iter.index % 2) == 0) ? 'lightBlue' : 'white'}"

   The API documentation for the <c:forEach> tag indicates that the varStatus attribute represents an object that implements the LoopTagStatus interface. Therefore, iter.index retrieves the index of the current round of the iteration. Continuing with the expression, (iter.index % 2) == 0) evaluates the remainder when iter.index is divided by 2, and returns a boolean value based on the outcome. Finally, an EL conditional operator (? :) is used to set the returned value to 'lightBlue' if true, 'white' otherwise.
   
   

   For a description of JSP Expression Language operators, see the Java EE 5 Tutorial: JavaServer Pages Technology > Unified Expression Language > Operators.

3. Save (Ctrl-S; ⌘-S on Mac) changes made to the file.
4. Return to the browser and refresh the category page. Product details now display within the table for the selected category.
   

You have now completed this tutorial unit. In it, you explored how to connect your application to the database by setting up a connection pool and data source on the server, then referenced the data source from the application. You also created several context parameters, and learned how to access them from JSP pages. Finally, you implemented JSTL tags into the application's web pages in order to dynamically retrieve and display database data.

You can download and examine snapshot 3 if you'd like to compare your work with the solution project. The solution project contains enhancements to the HTML markup and stylesheet in order to properly display all provided images. It also provides welcome page text, and a basic implementation for the page footer.

NetBeans Resources

• Connecting to a MySQL Database
• Introduction to Developing Web Applications
• Creating a Simple Web Application Using a MySQL Database
• Screencast: Database Support in NetBeans IDE

MySQL Resources

• The MySQL Community Librarian
• MySQL 5.1 Reference Manual
• MySQL and Java
• MySQL Forums

JSP & EL Resources

• Product Page: JavaServer Pages Technology
• Specification Download: JSR 245: JSP and EL 2.2 Maintenance Release
• API Documentation: JavaServer Pages 2.1 API Documentation
• Supporting Documentation: Java EE 5 Tutorial - Chapter 5: JavaServer Pages Technology
• Syntax Reference: JavaServer Pages 2.0 Syntax Reference
• Official Forum: Web Tier APIs - JavaServer Pages (JSP) and JSTL

JSTL Resources

• Product Page: JavaServer Pages Standard Tag Library
• Specification Download: JSR 52: JSTL 1.2 Maintenance Release
• Implementation Download: GlassFish JSTL Project Download
• Tag Library Documentation: JSTL 1.1 Tag Reference
• API Documentation: JSTL 1.1 API Reference

Technical Articles & Reference Cards

• Developing Web Applications With JavaServer Pages 2.0
• Web Tier to Go With Java EE 5: Summary of New Features in JSP 2.1 Technology
• Unified Expression Language
• Practical JSTL, Part 1
• A JSTL primer, Part 4: Accessing SQL and XML content
• JavaServer Pages v2.0 Syntax Card
• Essential JSP Expression Language Reference Card
• The Java Tutorials: JDBC Database Access
• Database Programming with JDBC and Java, Second Edition
• Essential JSP Expression Language Reference Card
• The JNDI Tutorial