Jsp java что это

Custom tags (see Chapter 8, Custom Tags in JSP Pages) set a variable ( c:set ), iterate over a collection of locale names ( c:forEach ), and conditionally insert HTML text into the response ( c:if , c:choose , c:when , c:otherwise ).

jsp:setProperty is another standard element that sets the value of an object property.

A function ( f:equals ) tests the equality of an attribute and the current item of a collection. (A built-in == operator is usually used to test equality.)

Here is the JSP page:

To deploy the date application with NetBeans IDE, follow these steps:

Start the Application Server.

In NetBeans IDE, select File->Open Project.

In the Open Project dialog, navigate to:

Select the date folder.

Select the Open as Main Project check box.

Click Open Project.

In the Projects tab, right-click the date project, and select Undeploy and Deploy.

To deploy the date application with the Ant tool, follow these steps:

In a terminal window, go to tut-install /javaeetutorial5/examples/web/date/ .

Type ant . This command will spawn any necessary compilations, copy files to the tut-install /javaeetutorial5/examples/web/date/build/ directory, and create a WAR file.

Start the Application Server.

Type ant deploy .

To run the example, do the following:

Set the character encoding in your browser to UTF-8.

Open your browser to http://localhost:8080/date.

You will see a combo box whose entries are locales. Select a locale and click Get Date. You will see the date expressed in a manner appropriate for that locale.

Some of the characters might not display properly if you don’t have the appropriate language files installed on your machine. Consult the user guide or online help for your operating system to determine how you can install these language files.

The Example JSP Pages

To illustrate JSP technology, this chapter rewrites each servlet in the Duke’s Bookstore application introduced in The Example Servlets as a JSP page (see Table 5–1).

Enter the bookstore.

Create the bookstore banner.

Browse the books offered for sale.

Add a book to the shopping cart.

bookcatalog.jsp and bookdetails.jsp

Get detailed information on a specific book.

Display the shopping cart.

Remove one or more books from the shopping cart.

Buy the books in the shopping cart.

Receive an acknowledgment for the purchase.

The data for the bookstore application is still maintained in a database and is accessed through tut-install /javaeetutorial5/examples/web/bookstore2/src/java/com/sun/bookstore2/database/BookDBAO.java . However, the JSP pages access BookDBAO through the JavaBeans component tut-install /javaeetutorial5/examples/web/bookstore2/src/java/com/sun/bookstore2/database/BookDB.java . This class allows the JSP pages to use JSP elements designed to work with JavaBeans components (see JavaBeans Component Design Conventions).

The implementation of the database bean follows. The bean has two instance variables: the current book and the data access object.

This version of the Duke’s Bookstore application is organized along the Model-View-Controller (MVC) architecture. The MVC architecture is a widely used architectural approach for interactive applications that distributes functionality among application objects so as to minimize the degree of coupling between the objects. To achieve this, it divides applications into three layers: model, view, and controller. Each layer handles specific tasks and has responsibilities to the other layers:

The model represents business data, along with business logic or operations that govern access and modification of this business data. The model notifies views when it changes and lets the view query the model about its state. It also lets the controller access application functionality encapsulated by the model. In the Duke’s Bookstore application, the shopping cart and database access object contain the business logic for the application.

The view renders the contents of a model. It gets data from the model and specifies how that data should be presented. It updates data presentation when the model changes. A view also forwards user input to a controller. The Duke’s Bookstore JSP pages format the data stored in the session-scoped shopping cart and the page-scoped database bean.

The controller defines application behavior. It dispatches user requests and selects views for presentation. It interprets user inputs and maps them into actions to be performed by the model. In a web application, user inputs are HTTP GET and POST requests. A controller selects the next view to display based on the user interactions and the outcome of the model operations. In the Duke’s Bookstore application, the Dispatcher servlet is the controller. It examines the request URL, creates and initializes a session-scoped JavaBeans component (the shopping cart), and dispatches requests to view JSP pages.

When employed in a web application, the MVC architecture is often referred to as a Model-2 architecture. The bookstore example discussed in Chapter 4, Java Servlet Technology, which intermixes presentation and business logic, follows what is known as a Model-1 architecture. The Model-2 architecture is the recommended approach to designing web applications.

In addition, this version of the application uses several custom tags from the JavaServer Pages Standard Tag Library (JSTL), described in Chapter 7, JavaServer Pages Standard Tag Library:

c:if, c:choose, c:when, and c:otherwise for flow control

c:set for setting scoped variables

c:url for encoding URLs

fmt:message, fmt:formatNumber, and fmt:formatDate for providing locale-sensitive messages, numbers, and dates

Custom tags are the preferred mechanism for performing a wide variety of dynamic processing tasks, including accessing databases, using enterprise services such as email and directories, and implementing flow control. In earlier versions of JSP technology, such tasks were performed with JavaBeans components in conjunction with scripting elements (discussed in Chapter 9, Scripting in JSP Pages). Although still available in JSP 2.0 technology, scripting elements tend to make JSP pages more difficult to maintain because they mix presentation and logic, something that is discouraged in page design. Custom tags are introduced in Using Custom Tags and described in detail in Chapter 8, Custom Tags in JSP Pages.

Finally, this version of the example contains an applet to generate a dynamic digital clock in the banner. See Including an Applet for a description of the JSP element that generates HTML for downloading the applet.

To deploy and run the application using NetBeans IDE, follow these steps:

In NetBeans IDE, select File->Open Project.

In the Open Project dialog, navigate to:

Select the bookstore2 folder.

Select the Open as Main Project check box and the Open Required Projects check box.

Click Open Project.

In the Projects tab, right-click the bookstore2 project, and select Undeploy and Deploy.

To run the application, open the bookstore URL http://localhost:8080/bookstore2/books/bookstore.

To deploy and run the application using Ant, follow these steps:

In a terminal window, go to tut-install /javaeetutorial5/examples/web/bookstore2/ .

Type ant . This command will spawn any necessary compilations, copy files to the tut-install /javaeetutorial5/examples/web/bookstore2/build/ directory, and create a WAR file and copy it to the tut-install /javaeetutorial5/examples/web/bookstore2/dist/ directory.

Start the Application Server.

To deploy the example, type ant deploy . The deploy target outputs a URL for running the application. Ignore this URL, and instead use the one shown in the next step.

To run the application, open the bookstore URL http://localhost:8080/bookstore2/books/bookstore.

To learn how to configure the example, refer to the deployment descriptor (the web.xml file), which includes the following configurations:

A display-name element that specifies the name that tools use to identify the application.

A context-param element that specifies the JSTL resource bundle base name.

A listener element that identifies the ContextListener class used to create and remove the database access.

A servlet element that identifies the Dispatcher servlet instance.

A set of servlet-mapping elements that map Dispatcher to URL patterns for each of the JSP pages in the application.

Nested inside a jsp-config element are two jsp-property-group elements, which define the preludes and coda to be included in each page. See Setting Properties for Groups of JSP Pages for more information.

Figure 5–2 shows the bookcatalog.jsp page from the Duke’s Bookstore application. This page displays a list of all the books that are available for purchase.

Figure 5–2 Book Catalog

See Troubleshooting Duke’s Bookstore Database Problems for help with diagnosing common problems related to the database server. If the messages in your pages appear as strings of the form . Key . , the likely cause is that you have not provided the correct resource bundle base name as a context parameter.

The Life Cycle of a JSP Page

A JSP page services requests as a servlet. Thus, the life cycle and many of the capabilities of JSP pages (in particular the dynamic aspects) are determined by Java Servlet technology. You will notice that many sections in this chapter refer to classes and methods described in Chapter 4, Java Servlet Technology.

When a request is mapped to a JSP page, the web container first checks whether the JSP page’s servlet is older than the JSP page. If the servlet is older, the web container translates the JSP page into a servlet class and compiles the class. During development, one of the advantages of JSP pages over servlets is that the build process is performed automatically.

Translation and Compilation

During the translation phase each type of data in a JSP page is treated differently. Static data is transformed into code that will emit the data into the response stream. JSP elements are treated as follows:

Directives are used to control how the web container translates and executes the JSP page.

Scripting elements are inserted into the JSP page’s servlet class. See Chapter 9, Scripting in JSP Pages for details.

Expression language expressions are passed as parameters to calls to the JSP expression evaluator.

jsp:[set|get]Property elements are converted into method calls to JavaBeans components.

jsp:[include|forward]elements are converted into invocations of the Java Servlet API.

The jsp:plugin element is converted into browser-specific markup for activating an applet.

Custom tags are converted into calls to the tag handler that implements the custom tag.

In the Application Server, the source for the servlet created from a JSP page named pageName is in this file:

For example, the source for the index page (named index.jsp ) for the date localization example discussed at the beginning of the chapter would be named:

Both the translation and the compilation phases can yield errors that are observed only when the page is requested for the first time. If an error is encountered during either phase, the server will return JasperException and a message that includes the name of the JSP page and the line where the error occurred.

After the page has been translated and compiled, the JSP page’s servlet (for the most part) follows the servlet life cycle described in Servlet Life Cycle:

If an instance of the JSP page’s servlet does not exist, the container:

Loads the JSP page’s servlet class

Instantiates an instance of the servlet class

Initializes the servlet instance by calling the jspInit method

The container invokes the _jspService method, passing request and response objects.

If the container needs to remove the JSP page’s servlet, it calls the jspDestroy method.

Execution

You can control various JSP page execution parameters by using page directives. The directives that pertain to buffering output and handling errors are discussed here. Other directives are covered in the context of specific page-authoring tasks throughout the chapter.

Buffering

When a JSP page is executed, output written to the response object is automatically buffered. You can set the size of the buffer using the following page directive:

A larger buffer allows more content to be written before anything is actually sent back to the client, thus providing the JSP page with more time to set appropriate status codes and headers or to forward to another web resource. A smaller buffer decreases server memory load and allows the client to start receiving data more quickly.

Handling JSP Page Errors

Any number of exceptions can arise when a JSP page is executed. To specify that the web container should forward control to an error page if an exception occurs, include the following page directive at the beginning of your JSP page:

The Duke’s Bookstore application page tut-install /javaeetutorial5/examples/web/bookstore2/web/template/preludeErrorPage.jspf contains the directive:

The following page directive at the beginning of tut-install /javaeetutorial5/examples/web/bookstore2/web/error/errorpage.jsp indicates that it is serving as an error page:

This directive makes an object of type javax.servlet.jsp.ErrorData available to the error page so that you can retrieve, interpret, and possibly display information about the cause of the exception in the error page. You access the error data object in an EL (see Unified Expression Language) expression by way of the page context. Thus, $ retrieves the status code, and $ retrieves the exception. You can retrieve the cause of the exception using this expression: