Great JSP scripting elements and variables web hosting can be found at Alden JSP scripting elements and variables Web Site Hosting.

Java Server Pages (JSP) scripting elements and variables

Java Server Pages ..... Web Hosting featuring Apache, PHP, MySQL, PERL, servlets Java, JSP, Linux servers Fundraising Plans.
JSP scripting elements and variables
Standard scripting variables
The following scripting variables are always available:

* out – The JSPWriter used to write the data to the response stream.
* page – The servlet itself.
* pageContext – A PageContext instance that contains data associated with the whole page. A given HTML page may be passed among multiple JSPs.
* request – The HTTP request object.
* response – The HTTP response object.
* session – The HTTP session object that can be used to track information about a user from one request to another.

Scripting elements
There are three basic kinds of scripting elements that allow java code to be inserted directly into the servlet.

* A declaration tag places a variable definition inside the body of the java servlet class. Static data members may be defined as well.
<%! int serverInstanceVariable = 1; %>
* A scriptlet tag places the contained statements inside the _jspService() method of the java servlet class.
<% int localStackBasedVariable = 1; out.println(localStackBasedVariable); %>
* An expression tag places an expression to be evaluated inside the java servlet class. Expressions should not be terminated with a semi-colon.
<%= "expanded inline data " + 1 %>

Java Server Pages (JSP)

Great JSP web site hosting can be found at Alden JSP Web Site Hosting.


JSP or JavaServer Pages, known to some as the Java Scripting Preprocessor, is a Java technology that allows developers to dynamically generate HTML, XML or some other type of web page. The technology allows Java code and certain pre-defined actions to be embedded into static content.

The JSP syntax adds additional XML tags, called JSP actions, to be used to invoke built-in functionality. Additionally, the technology allows for the creation of JSP tag libraries that act as extensions to the standard HTML or XML tags. Tag libraries provide a platform independent way of extending the capabilities of a web server.


JSPs are compiled into Servlets by a JSP compiler. A JSP compiler may generate a servlet in Java code that is then compiled by the Java compiler, or it may generate byte code for the servlet directly. In either case, it is helpful to understand how the JSP compiler transforms the page into a Java servlet. For an example, see the following input, and its resulting generated Java servlet.


JSP and Servlets

Architecturally speaking, you can view JSP as a high-level abstraction of servlets that is implemented as an extension of the Servlet 2.1 API.

JSP Syntax A JavaServer Page may be broken down into the following pieces:


* static data such as HTML
* JSP directives such as the include directive
* JSP scripting elements and variables
* JSP actions
* custom tags


Static data

Static data is written out to the HTTP response exactly as it appears in the input file. Thus a valid JSP input would be a normal HTML page with no embedded java or actions. In that case, the same data would be sent in the response each and every time by the web server. Of course, the point of JSP is to allow dynamic data to be inserted into the static content.

JSP directives

JSP directives control how the JSP compiler generates the servlet. The following directives are available:


* include – The include directive informs the JSP compiler to include a complete file into the current file. It is as if the contents of the included file were pasted directly into the original file. This functionality is similar to the one provided by the C preprocessor.
<%@ include file="somefile.ext" %>
* page – There are several options to the page directive.
o import results in a java import statement being inserted into the resulting file
o contentType specifies the content that is generated. This should be used if HTML is not used or if the character set is not the default character set.
o errorPage indicates the page that will be shown if an exception occurs while processing the HTTP request.
o isErrorPage if set to true, it indicates that this is the error page.
o isThreadSafe indicates if the resulting servlet is thread safe.
+ <%@ page import="java.util.*" %> //example import
+ <%@ page contentType="text/html" %> //example contentType
+ <%@ page isErrorPage=false %> //example for non error page
+ <%@ page isThreadSafe=true %> //example for a thread safe JSP
+ Note: Only the "import" page directive can be used multiple times in the same JSP.

Great JSP web hosting can be found at Alden JSP Hosting.

JSP Actions

JSP actions are XML tags that invoke built-in web server functionality. The following actions are provided:

* jsp:include
Similar to a subroutine, the Java servlet temporarily hands the request and response off to the specified JavaServer Page. Control will then return to the current JSP, once the other JSP has finished. Using this, JSP code will be shared between two other JSPs, rather than duplicated.
* jsp:param
Can be used inside a jsp:include, jsp:forward or jsp:params block. Specifies a parameter that will be added to the request's current parameters.
* jsp:forward
Used to hand off the request and response to another JSP or servlet. Control will never return to the current JSP.
* jsp:plugin
Older versions of Netscape Navigator and Internet Explorer used different tags to embed an applet. This action generates the browser specific tag needed to include an applet.
* jsp:fallback
The content to show if the browser does not support applets.
* jsp:getProperty
Gets a property from the specified Java bean.
* jsp:setProperty
Sets a property in the specified Java bean.
* jsp:useBean
Creates or re-uses a Java bean available to the JSP page.

Great JSP web hosting can be found at Alden JSP Hosting.

Java Server Pages (JSP)
(JSP) A freely available specification for extending the Java Servlet API to generate dynamic web pages on a web server. The JSP specification was written by industry leaders as part of the Java development program.

JSP assists developers in creating HTML or XML pages that combine static (fixed) page templates with dynamic content. Separating the user interface from content generation allows page designers to change the page layout without having to rewrite program code. JSP was designed to be simpler than pure servlets or CGI scripting.

JSP uses XML-like tags and scripts written in Java to generate the page content. HTML or XML formatting tags are passed back to the client. Application logic can live on the server, e.g. in JavaBeans.

JSP is a cross-platform alternative to Microsoft's Active Server Pages, which only runs in IIS on Windows NT.

Applications written to the JSP specification can be run on compliant web servers, and web servers such as Apache, Netscape Enterprise Server, and Microsoft IIS that have had Java support added.