Active Server Pages (ASP) is Microsoft's first server-side script engine for dynamically-

generated web pages. It was initially marketed as an add-on to Internet Information Services
(IIS) via the Windows NT 4.0 Option Pack, but has been included as a free component of
Windows Server since the initial release of Windows 2000 Server.

Programming ASP websites is made possible by various built-in objects. Each object
corresponds to a group of frequently-used functions useful for creating dynamic web pages. In
ASP 2.0 there are six such built-in objects: Application, ASPError, Request, Response, Server,
and Session. Session, for example, is a cookie-based session object that maintains variables from
page to page. Web pages with the ".asp" file extension use ASP, although some Web sites
disguise their choice of scripting language for security purposes. The ".aspx" extension is not an
ASP page, but an ASP.NET page, another server-side scripting language from Microsoft, based
on a mixture of traditional ASP, and Microsoft's .NET technology.

Most ASP pages are written in VBScript, but any other Active Scripting engine can be selected
instead by using the @Language directive or the <script language="language"
runat="server"> syntax. JScript (Microsoft's implementation of ECMAScript) is the other
language that is usually available. PerlScript (a derivative of Perl) and others are available as
third-party installable Active Scripting engines.

Contents
[hide]

• 1 History
• 2 Versions
• 3 Sample usage
• 4 References

• 5 External links

[edit] History
Previously called dbWeb, and created by Aspect Software Engineering, ASP was one of the first
web application development environments that integrated web application execution directly
into the web server, 9 months after the release of NeXT's (now Apple) WebObjects. This was
done in order to achieve high performance compared to calling external executable programs or
CGI scripts which was the most popular method for writing web applications at the time it was
introduced. Today there are additional platforms for web application development that are more
common on other operating systems. Both JavaServer Pages and PHP are more commonly found
on webservers running non-Microsoft operating systems, with PHP currently being the more
common of the two. Also of note is ColdFusion, a popular Java technology running on several
platforms including Microsoft servers as well as other platforms.
Prior to Microsoft's release of ASP for IIS 3, programmers relied on IDC and HTX files
combined with ODBC drivers to display and manipulate dynamic data and pages running on IIS.
The basics of these file formats and structures were used, at least in part, in the implementation
of the early versions of ASP.

Halcyon InstantASP iASP and Chili!Soft ASP are 3rd party products that run ASP on platforms
other than the Microsoft Windows operating systems. Both alternatives to real ASP don't fully
emulate every feature, and may require additional components that traditional ASP has no issues
with, such as database connectivity. MS access database support is a particular issue on non
windows based systems.

iASP is able to use the VBScript and JScript languages unlike Chili!Soft ASP which uses
JScript. Microsoft's ASP can use both and has the potential to have other languages make use of
the scripting engine. iASP was written in Java, and as such will run any almost any operating
system. iASP appears be no longer available or at least hard to find.

Examples of other languages available are Perl and TCL, although they are not as widely known
or used for ASP scripting. There is an Apache Webserver mod that runs an ASP like Perl script
languge [1]

Chili!Soft was purchased by Sun Microsystems and later renamed "Sun ONE Active Server
Pages", then later renamed to "Sun Java System Active Server Pages". Chilisoft ASP was written
in C/C++ and is tied rather tightly to specific webserver versions. According to Sun "Sun Java
System Active Server Pages has entered its End Of Life". [2]

[edit] Versions
ASP has gone through three major releases:

• ASP version 1.0 (distributed with IIS 3.0) in December 1996

• ASP version 2.0 (distributed with IIS 4.0) in September 1997
• ASP version 3.0 (distributed with IIS 5.0) in November 2000

ASP 3.0 is currently available in IIS 6.0 on Windows Server 2003 and IIS 7.0 on Windows
Server 2008.

ASP.NET is often confused as the newest release of ASP, but the technologies are very different.
ASP.Net relies on the .Net Framework and is a compiled language, whereas ASP is strictly an
interpreted scripting language.

The move from ASP 2.0 to ASP 3.0 was a relatively modest one. One of the most important
additions was the Server.Execute methods, as well as the ASPError object.[3] Microsoft's What's
New in IIS 5.0 lists some additional changes.

There are solutions to run "Classic ASP" sites as standalone applications, such as ASPexplore, a
software package that runs Microsoft Active Server Pages offline.
[edit] Sample usage
Any scripting languages compatible with Microsoft's Active Scripting standard may be used in
ASP. The default scripting language (in classic ASP) is VBScript:

1. <html>
2. <body>

3. <% Response.Write "Hello World!" %>

4. </body>
5. </html>

Or in a simpler format

1. <html>
2. <body>

3. <%= "Hello World!" %>

4. </body>
5. </html>

The examples above print "Hello World!" into the body of an HTML document.

Here's how to connect to an Access Database

1. <%
2. Set oConn = Server.CreateObject("ADODB.Connection")
3. oConn.Open "DRIVER={Microsoft Access Driver
(*.mdb)}; DBQ=" & Server.MapPath("DB.mdb")
4. Set rsUsers = Server.CreateObject("ADODB.Recordset")
5. rsUsers.Open "SELECT * FROM Users", oConn
6. %>
JavaServer Pages
From Wikipedia, the free encyclopedia
Jump to: navigation, search

This article includes a list of references or external links, but its sources remain
unclear because it lacks inline citations. Please improve this article by
introducing more precise citations where appropriate. (November 2007)

This article or section may require restructuring to meet Wikipedia's

quality standards.
Please discuss this issue on the talk page. (November 2007)

JavaServer Pages (JSP) is a Java technology that allows software developers to dynamically
generate HTML, XML or other types of documents in response to a Web client request. The
technology allows Java code and certain pre-defined actions to be embedded into static content.

The JSP syntax adds additional XML-like 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 Java 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. JSPs can also be interpreted on-the-fly, reducing the time taken to reload
changes.

Contents
[hide]

• 1 JSP and Servlets

o 1.1 JSP syntax
o 1.2 JSP scripting elements and objects
 1.2.1 JSP implicit objects
 1.2.2 Scripting elements
o 1.3 JSP actions
 1.3.1 Examples of tags
 1.3.1.1 jsp:include
 1.3.1.2 jsp:forward
 1.3.1.3 jsp:plugin
o 1.4 JSP Tag Libraries
o 1.5 JSP Standard Tag Library (JSTL)
o 1.6 JSP Technology in the Java EE 5 Platform
• 2 Internationalization
 • 3 JSP 2.0
• 4 Model-view-controller paradigm
• 5 Example
• 6 See also
• 7 Further reading

• 8 External links

[edit] JSP and Servlets

Architecturally, JSP may be viewed as a high-level abstraction of servlets that is implemented as
an extension of the Servlet 2.1 API. Both servlets and JSPs were originally developed at Sun
Microsystems. Starting with version 1.2 of the JSP specification, JavaServer Pages have been
developed under the Java Community Process. JSR 53 defines both the JSP 1.2 and Servlet 2.3
specifications and JSR 152 defines the JSP 2.0 specification. As of May 2006 the JSP 2.1
specification has been released under JSR 245 as part of Java EE 5.

[edit] 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 with correct library

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. Included files generally have the extension "jspf" (for JSP
Fragment):

<%@ include file="somefile.jspf" %>

page

The page directive has several attributes.

import

Results in a Java import statement being inserted into the resulting file.

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.

errorPage

Indicates the page that will be shown if an exception occurs while processing
the HTTP request.

isErrorPage

If set to true, it indicates that this is the error page. Default value is false.

isThreadSafe

Indicates if the resulting servlet is thread safe.

autoFlush

To autoflush the contents.A value of true, the default, indicates that the
buffer should be flushed when it is full. A value of false, rarely used, indicates
that an exception should be thrown when the buffer overflows. A value of
false is illegal when also using buffer="none".

session

To maintain session. A value of true (the default) indicates that the

predefined variable session (of type HttpSession) should be bound to the
existing session if one exists, otherwise a new session should be created and
bound to it. A value of false indicates that no sessions will be used, and
attempts to access the variable session will result in errors at the time the JSP
page is translated into a servlet.

buffer

To set Buffer Size. The default is 8k and it is advisable that you increase it.

isELIgnored

Defines whether EL expressions are ignored when the JSP is translated.

language

Defines the scripting language used in scriptlets, expressions and

declarations. Right now, the only possible value is "java".

extends
 Defines the superclass of the class this JSP will become. You won't use this
unless you REALLY know what you're doing - it overrides the class hierarchy
provided by the Container.

info

Defines a String that gets put into the translated page, just so that you can
get it using the generated servlet's inherited getServletInfo() method.

pageEncoding

Defines the character encoding for the JSP. The default is "ISO-8859-1"(unless
the contentType attribute already defines a character encoding, or the page
uses XML document syntax).

<%@ 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 --%>
<%@ page session="true" %> <%-- example for using session binding --%>
<%@ page autoFlush="true" %> <%-- example for setting autoFlush --%>
<%@ page buffer="20kb" %> <%-- example for setting Buffer Size --%>
Note: Only the "import" page directive can be used multiple times in the
same JSP.

taglib

The taglib directive indicates that a JSP tag library is to be used. The directive
requires that a prefix be specified (much like a namespace in C++) and the
URI for the tag library description.

<%@ taglib prefix="myprefix" uri="taglib/mytag.tld" %>

[edit] JSP scripting elements and objects

[edit] JSP implicit objects

The following JSP implicit objects are exposed by the JSP container and can be referenced by
the programmer:

out

The JspWriter used to write the data to the response stream(output page).

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 HttpServletRequest object that provides HTTP request information.

response

The HttpServletResponse object that can be used to send data back to the
client.

session

The HttpSession object that can be used to track information about a user
from one request to another.

config

Provides servlet configuration data.

application

Data shared by all JSPs and servlets in the application.

exception

Exceptions not caught by application code.

[edit] 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. Also inner classes
should be defined here.

<%! int serverInstanceVariable = 1; %>

Declaration tags also allow methods to be defined.

<%!
/**
* Converts the Object into a string or if
* the Object is null, it returns the empty string.
*/
public String toStringOrBlank( Object obj ){
if(obj != null){
return obj.toString();
}
 return "";
}
%>

• 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 %>

• Also we can use the following tag to give comments in jsp:

<%-- give your comments here --%>

[edit] JSP actions

JSP actions are XML tags that invoke built-in web server functionality. They are executed at
runtime. Some are standard and some are custom (which are developed by Java developers). The
following list contains the standard ones:

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 multiple 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 JavaBean.

jsp:setProperty

Sets a property in the specified JavaBean.

jsp:useBean

Creates or re-uses a JavaBean available to the JSP page.

[edit] Examples of tags

[edit] jsp:include
<html>
<head></head>
<body>
<jsp:include page="mycommon.jsp" >
<jsp:param name="extraparam" value="myvalue" />
</jsp:include>
name:<%=request.getParameter("extraparam")%>
</body>
</html>

[edit] jsp:forward
<jsp:forward page="subpage.jsp" >
<jsp:param name="forwardedFrom" value="this.jsp" />
</jsp:forward>

In this forwarding example, the request is forwarded to "subpage.jsp". The request handling does
not return to this page.

[edit] jsp:plugin
<jsp:plugin type=applet height="100%" width="100%"
archive="myjarfile.jar,myotherjar.jar"
codebase="/applets"
code="com.foo.MyApplet" >
<jsp:params>
<jsp:param name="enableDebug" value="true" />
</jsp:params>
<jsp:fallback>
Your browser does not support applets.
</jsp:fallback>
</jsp:plugin>

The plugin example illustrates a <html> uniform way of embedding applets in a web page.
Before the advent of the <OBJECT> tag, there was no common way of embedding applets.
Currently, the jsp:plugin tag does not allow for dynamically called applets. For example,
jsp:params cannot be used with a charting applet that requires the data points to be passed in as
parameters unless the number of data points is constant. You cannot, for example, loop through a
ResultSet to create the jsp:param tags. Each jsp:param tag must be hand-coded. However, each
of those jsp:param tags can have a dynamic name and a dynamic value.

[edit] JSP Tag Libraries

In addition to the pre-defined JSP actions, developers may add their own custom actions using
the JSP Tag Extension API. Developers write a Java class that implements one of the Tag
interfaces and provide a tag library XML description file that specifies the tags and the java
classes that implement the tags.

Consider the following JSP.

<%@ taglib uri="mytaglib.tld" prefix="myprefix" %>

...
<myprefix:myaction> <%-- the start tag %>
...
</myprefix:myaction> <%-- the end tag %>
...

The JSP compiler will load the mytaglib.tld XML file and see that the tag 'myaction' is
implemented by the java class 'MyActionTag'. The first time the tag is used in the file, it will
create an instance of 'MyActionTag'. Then (and each additional time that the tag is used), it will
invoke the method doStartTag() when it encounters the starting tag. It looks at the result of the
start tag, and determines how to process the body of the tag. The body is the text between the
start tag and the end tag. The doStartTag() method may return one of the following:

SKIP_BODY

The body between the tag is not processed.

EVAL_BODY_INCLUDE

Evaluate the body of the tag.

EVAL_BODY_TAG

Evaluate the body of the tag and push the result onto stream (stored in the
body content property of the tag).

Note: If tag extends the BodyTagSupport class, the method doAfterBody() will be called when
the body has been processed just prior to calling the doEndTag(). This method is used to
implement looping constructs.

When it encounters the end tag, it invokes the doEndTag() method. The method may return one
of two values:

EVAL_PAGE
 This indicates that the rest of the JSP file should be processed.

SKIP_PAGE

This indicates that no further processing should be done. Control leaves the
JSP page. This is what is used for the forwarding action.

The myaction tag above would have an implementation class that looked like something below:

public class MyActionTag extends TagSupport {

//Releases all instance variables.
public void release() {...}

public MyActionTag() { ... }

//called for the start tag

public int doStartTag() { ... }

//called at the end tag

public int doEndTag(){ ... }
}

Add Body Tag description.

If you want to iterate the body a few times, then the java class (tag handler) implements
IterationTag interface. It returns EVAL_BODY_AGAIN - which means to invoke the body
again.

[edit] JSP Standard Tag Library (JSTL)

The JavaServer Pages Standard Tag Library (JSTL) is a component of the Java EE Web
application development platform. It extends the JSP specification by adding a tag library of JSP
tags for common tasks, such as XML data processing, conditional execution, loops and
internationalization.

[edit] JSP Technology in the Java EE 5 Platform

The focus of Java EE 5 has been ease of development by making use of Java language
annotations that were introduced by J2SE 5.0. JSP 2.1 supports this goal by defining annotations
for dependency injection on JSP tag handlers and context listeners.

Another key concern of the Java EE 5 specification has been the alignment of its webtier
technologies, namely JavaServer Pages (JSP), JavaServer Faces (JSF), and JavaServer Pages
Standard Tag Library (JSTL).

The outcome of this alignment effort has been the Unified Expression Language (EL), which
integrates the expression languages defined by JSP 2.0 and JSF 1.1.

The main key additions to the Unified EL that came out of the alignment work have been:
A pluggable API for resolving variable references into Java objects and for resolving the
properties applied to these Java objects, Support for deferred expressions, which may be
evaluated by a tag handler when needed, unlike their regular expression counterparts, which get
evaluated immediately when a page is executed and rendered, and Support for lvalue expression,
which appear on the left hand side of an assignment operation. When used as an lvalue, an EL
expression represents a reference to a data structure, for example: a JavaBeans property, that is
assigned some user input. The new Unified EL is defined in its own specification document,
which is delivered along with the JSP 2.1 specification.

Thanks to the Unified EL, JSTL tags, such as the JSTL iteration tags, can now be used with JSF
components in an intuitive way.

JSP 2.1 leverages the Servlet 2.5 specification for its web semantics

[edit] Internationalization
Internationalization in JSP is accomplished the same way as in a normal Java application, that is
by using resource bundles.

[edit] JSP 2.0

The new version of the JSP specification includes new features meant to improve programmer
productivity. Namely:

• An Expression Language (EL) which allows developers to create Velocity-style

templates (among other things).
• A faster/easier way to display parameter values.

Hello, ${param.visitor} <%-- same as: Hello, <

%=request.getParameter("visitor")%> --%>

• A clearer way to navigate nested beans

// consider some beans.

class Person {
String name;
// person nests an organization bean.
Organization organization;

public String getName() { return this.name; }

public Organization getOrganization() { return this.organization; }
}

class Organization {
String name;
public String getName() { return this.name; }
}
// then if an instance of Person was to be placed onto a request attribute
under the name "person"
<!-- the JSP would have -->
Hello, ${person.name}, of company ${person.organization.name}
<%-- second expression same as
<% Person p = (Person) request.getAttribute("person");
if (p != null) {
Organization o = p.getOrganization();
if (o != null) {
out.print(o.getName());
}
}
%>
--%>

[edit] Model-view-controller paradigm

Sun recommends that the Model-view-controller pattern be used with the JSP files in order to
split the presentation from request processing and computer data storage. Either regular servlets
or separate JSP files are used to process the request. After the request processing has finished,
control is passed to a JSP used only for creating the output. There are several platforms based on
Model-view-controller pattern for web tiers (such as Barracuda, Apache Struts or Spring MVC
framework).

[edit] Example
Regardless of whether the JSP compiler generates Java source code for a servlet or emits the byte
code directly, it is helpful to understand how the JSP compiler transforms the page into a Java
servlet. For example, consider the following input JSP and its resulting generated Java Servlet.

Input JSP

<%@ page errorPage="myerror.jsp" %>

<%@ page import="com.foo.bar" %>

<html>
<head>
<%! int serverInstanceVariable = 1;%>

<% int localStackBasedVariable = 1; %>

<table>
<tr><td><%= toStringOrBlank( "expanded inline data " + 1 ) %></td></tr>

Resulting servlet

package jsp_servlet;
import java.util.*;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
 import javax.servlet.jsp.tagext.*;

import com.foo.bar; //imported as a result of <%@ page import="com.foo.bar"

%>
import ...

class _myservlet implements javax.servlet.Servlet,

javax.servlet.jsp.HttpJspPage {
//inserted as a
//result of <%! int serverInstanceVariable = 1;%>
int serverInstanceVariable = 1;
...

public void _jspService( javax.servlet.http.HttpServletRequest request,

javax.servlet.http.HttpServletResponse response )
throws javax.servlet.ServletException,
java.io.IOException
{
javax.servlet.ServletConfig config = ...;//get the servlet config
Object page = this;
PageContext pageContext = ...;//get the page context for this request
javax.servlet.jsp.JspWriter out = pageContext.getOut();
HttpSession session = request.getSession( true );
try {
out.print( "<html>\r\n" );
out.print( "<head>\r\n" );
...
//from <% int localStackBasedVariable = 1; %>
int localStackBasedVariable = 1;
...
out.print( "<table>\r\n" );
out.print( " <tr><td>" );
//from <%= toStringOrBlank( "expanded inline data " + 1 ) %>
out.print( toStringOrBlank( "expanded inline data " + 1 ) );
out.print( " </td></tr>\r\n" );
...
} catch ( Exception _exception ) {
//clean up and redirect to error page in <%@ page
errorPage="myerror.jsp" %>
}
}
}