JSP Java Server Pages - PowerPoint PPT Presentation

About This Presentation
Title:

JSP Java Server Pages

Description:

Easy access to request, session and context data. Easy manipulation of the ... The code is inserted verbatim into the service method, according to the location ... – PowerPoint PPT presentation

Number of Views:354
Avg rating:3.0/5.0
Slides: 106
Provided by: Ben5152
Category:

less

Transcript and Presenter's Notes

Title: JSP Java Server Pages


1
JSP Java Server Pages
  • Representation and Management of Data on the
    Internet

2
Introduction
3
What is JSP Good For?
  • Servlets allow us to write dynamic Web pages
  • Easy access to request, session and context data
  • Easy manipulation of the response (cookies, etc.)
  • And lots more...
  • It is not convenient to write and maintain long
    static HTML using Servlets
  • out.println("lth1gtBla Blalt/h1gt" "bla bla bla
    bla" "lots more here...")

4
JSP Idea
  • Use HTML for most of the page
  • Write Servlet code directly in the HTML page,
    marked with special tags
  • The server automatically translates a JSP page to
    a Servlet class and the latter is actually
    invoked
  • In Tomcat 5.0 you can find the generated Servlet
    code under CATALINA_BASE/work/

5
Relationships
  • Servlets HTML code is printed from Java code
  • JSP Java code is embedded in HTML code

Java
HTML
Java
HTML
6
Example
  • ltHTMLgt
  • ltHEADgt
  • ltTITLEgtHello Worldlt/TITLEgt
  • lt/HEADgt
  • ltBODYgt
  • ltH2gtltIgtlt new java.util.Date() gtlt/Igtlt/H2gt
  • ltH1gtHello Worldlt/H1gt
  • lt/BODYgt
  • lt/HTMLgt

Tomcat 5.0 Generated Servlet
7
(No Transcript)
8
JSP Limitations and Advantages
  • JSP can only do what a Servlet can do
  • Easier to write and maintain HTML
  • Easier to separate HTML from code
  • Can use a "reverse engineering technique" create
    static HTML and then replace static data with
    Java code

9
Basic JSP Elements
10
Elements in a JSP file
  • HTML code lthtml-taggtcontentlt/html-taggt
  • HTML comment lt!-- comment --gt
  • JSP Comment lt-- comment --gt
  • Expressions lt expression gt
  • Scriptlets lt code gt
  • Declarations lt! code gt
  • Directives lt_at_ directive attribute"value" gt
  • Actions discussed later

11
JSP Expressions
  • A JSP expression is used to insert Java values
    directly into the output
  • It has the form lt expression gt , where
    expression can be a Java object, a numerical
    expression, a method call that returns a value,
    etc...
  • For example
  • lt new java.util.Date() gt
  • lt "Hello"" World" gt
  • lt (int)(100Math.random()) gt

12
JSP Expressions
  • A JSP Expression is evaluated
  • The result is converted to a string
  • The string is inserted into the page
  • This evaluation is performed at runtime (when the
    page is requested), and thus has full access to
    information about the request, the session, etc...

13
Expression Translation
ltH1gtA Random Numberlt/H1gt lt Math.random() gt
14
Predefined Variables (Implicit Objects)
  • The following predefined variables can be used
  • request the HttpServletRequest
  • response the HttpServletResponse
  • session the HttpSession associated with the
    request
  • out the PrintWriter (a buffered version of type
    JspWriter) used to fill the response content
  • application The ServletContext
  • These variables and more will be discussed in
    details

15
ltHTMLgt ltHEADgt ltTITLEgtJSP Expressionslt/TITLEgtlt/H
EADgt ltBODYgt ltH2gtJSP Expressionslt/H2gt ltULgt
ltLIgtCurrent time lt new java.util.Date()
gt ltLIgtYour hostname lt request.getRemoteHo
st() gt ltLIgtYour session ID lt
session.getId() gt ltLIgtThe
ltCODEgttestParamlt/CODEgt form parameter lt
request.getParameter("testParam") gt lt/ULgt
lt/BODYgt lt/HTMLgt
16
(No Transcript)
17
(No Transcript)
18
JSP Scriplets
  • JSP scriptlets let you insert arbitrary code into
    the Servlet service method ( _jspService )
  • Scriptlets have the form lt Java Code gt
  • The code is inserted verbatim into the service
    method, according to the location of the scriplet
  • Scriptlets have access to the same automatically
    defined variables as expressions

19
Scriptlet Translation
lt foo() gt lt bar() gt
public void _jspService(HttpServletRequest
request,
HttpServletResponse response) throws
ServletException, IOException ... response.set
ContentType("text/html") ... out.print(foo())
bar() ...
20
An Interesting Example
  • Scriptlets don't have to be complete code blocks

lt if (Math.random() lt 0.5) gt You ltBgtwonlt/Bgt
the game! lt else gt You ltBgtlostlt/Bgt the
game! lt gt
if (Math.random() lt 0.5) out.write("You
ltBgtwonlt/Bgt the game!") else
out.write("You ltBgtlostlt/Bgt the game!")
21
JSP Declarations
  • A JSP declaration lets you define methods or
    members that get inserted into the Servlet class
    (outside of all methods)
  • It has the following form
  • lt! Java Code gt
  • For example
  • lt! private int someField 5 gt
  • lt! private void someMethod(...) ... gt
  • It is usually of better design to define methods
    in a separate Java class...

22
Declaration Example
  • Print the number of times the current page has
    been requested since the server booted (or the
    Servlet class was changed and reloaded)

lt! private int accessCount 0 gt lt! private
synchronized int incAccess() return
accessCount gt ltH1gtAccesses to page since
server reboot lt incAccess() gt lt/H1gt
23
(No Transcript)
24
(No Transcript)
25
  • public class serviceCount_jsp extends...
    implements... throws...
  • private int accessCount 0
  • private synchronized int incAccess()
  • return accessCount
  • public void _jspService(HttpServletRequest
    request,
  • HttpServletResponse
    response)
  • throws ServletException, IOException
  • ...
  • ...
  • out.write("ltH1gtAccesses to page since
    server reboot ")
  • out.print(incAccess())
  • ... ...

26
jspInit and jspDestroy
  • In JSP pages, like regular Servlets, sometimes
    want to use init and destroy
  • It is illegal to use JSP declarations to override
    init or destroy, since they (usually) are already
    implemented by the generated Servlet
  • Instead, override the methods jspInit and
    jspDestroy
  • The generated servlet is guaranteed to call these
    methods from init and destroy respectively
  • The standard versions of jspInit and jspDestroy
    are empty (placeholders for you to override)

27
JSP Directives
  • A JSP directive affects the structure of the
    Servlet class that is generated from the JSP page
  • It usually has the following form
  • lt_at_ directive attribute"value" gt
  • Multiple attribute settings for a single
    directive can be combined
  • lt_at_ directive attribute1"value1" ...
    attributeN"valueN" gt
  • Two types discussed in this section page and
    include

28
page-Directive Attributes
  • import attribute A comma separated list of
    classes/packages to import
  • lt_at_ page import"java.util., java.io." gt
  • contentType attribute Sets the MIME-Type of the
    resulting document (default is text/html)
  • lt_at_ page contentType"text/plain" gt
  • Note that instead of using the contentType
    attribute, you can write
  • lt response.setContentType("text/plain") gt

29
More page-Directive Attributes
  • session"truefalse" - use a session?
  • buffer"sizekbnone"
  • Specifies the content-buffer size (out)
  • errorPage"url "
  • Defines a JSP page that handles uncaught
    exceptions
  • The page in url must have true in the
    page-directive
  • isErrorPage"truefalse"
  • The variable exception holds the exception thrown
    by the calling JSP

30
showTableA.jsp
ltHTMLgt ltHEADgt ltTITLEgtReading From
Databaselt/TITLEgtlt/HEADgt ltBODYgt lt_at_ page
import"java.sql." gt lt_at_ page
errorPage"errorPage.jsp" gt lt
Class.forName("oracle.jdbc.driver.OracleDriver")
Connection con DriverManager.getConnection("
jdbcoraclethin" "snoopy/snoopy_at_sol41521
stud") Statement stmt con.createStatement()
ResultSet rs stmt.executeQuery("Select
from a") ResultSetMetaData md
rs.getMetaData() int col md.getColumnCount()
gt
31
ltTABLE border"2"gt lt while (rs.next())
gt ltTRgt lt for (int i 1 i lt col i)
gt ltTDgtlt rs.getString(i) gtlt/TDgt lt
gt lt/TRgt lt gt lt/TABLEgt lt/BODYgt lt/HTMLgt
32
errorPage.jsp
ltHTMLgt ltHEADgt ltTITLEgtReading From
Databaselt/TITLEgtlt/HEADgt ltBODYgt lt_at_ page
isErrorPage"true" gt lth1gtOops. There was an
error when you accessed the database.
lt/h1gt lth2gtHere is the stack trace lt/h2gt ltfont
color"red"gt ltpregt lt exception.printStackTrace(ne
w PrintWriter(out)) gt lt/pregtlt/fontgt lt/BODYgt lt/HT
MLgt
33
Table A exists!
34
Table A does not exist!
35
The include Directive
  • This directive lets you include files at the time
    the JSP page is translated into a Servlet
  • The directive looks like this
  • lt_at_ include file"url" gt
  • JSP content can affect main page
  • In Tomcat 5.x, generated Servlet is updated when
    included files change (unlike old versions...)

36
ltHTMLgt ltHEADgt ltTITLEgtIncluding
JSPlt/TITLEgtlt/HEADgt ltBODYgt Here is an interesting
page.ltbrgtltbrgt Bla, Bla, Bla, Bla.
ltbrgtltbrgtltbrgt lt_at_ include file"AccessCount.jsp"
gt lt/BODYgt lt/HTMLgt
BlaBla.jsp
lthrgt Page Created for Dbi Course. Email us lta
href"mailtodbi_at_cs.huji.ac.il"gtherelt/agt. ltbrgt lt!
private int accessCount 0 gt Accesses to
page since server reboot lt accessCount gt
AccessCount.jsp
37
(No Transcript)
38
  • out.write("ltHTMLgt \r\n")
  • out.write("ltHEADgt ltTITLEgtIncluding
    JSPlt/TITLEgtlt/HEADgt\r\n")
  • out.write("ltBODYgt\r\n")
  • out.write("Here is an interesting
    page.ltbrgtltbrgt\r\n")
  • out.write("Bla, Bla, Bla, Bla.
    ltbrgtltbrgtltbrgt\r\n")
  • out.write("\r\n")
  • out.write("lthrgt\r\n")
  • out.write("Page Created for Dbi Course.
    Email us \r\n")
  • out.write("lta href\"mailtodbi_at_cs.huji.ac.i
    l\"gtherelt/agt.\r\n")
  • out.write("ltbrgt\r\n")
  • out.write(" \r\n")
  • out.write("Accesses to page since server
    reboot \r\n")
  • out.print( accessCount )
  • out.write("\r\n")
  • out.write("lt/BODYgt\r\n")
  • out.write("lt/HTMLgt ")

39
Writing JSP in XML(and vice versa)
  • We can replace the JSP tags with XML tags that
    represent
  • Expressions
  • Scriptlets
  • Declarations
  • Directives

40
(No Transcript)
41
  • lt?xml version"1.0" encoding"UTF-8"?gt
  • ltjsproot xmlnsjsp"http//java.sun.com/JSP/Page"
    version"2.0"gt
  • ltnumbersgt
  • ltjspscriptletgt for(int i1 ilt10 i)
    lt/jspscriptletgt
  • ltnumbergt
  • ltjspexpressiongt i lt/jspexpressiongt
  • lt/numbergt
  • ltjspscriptletgt lt/jspscriptletgt
  • lt/numbersgt
  • lt/jsprootgt

42
(No Transcript)
43
Variables in JSP
44
Implicit Objects
  • As seen before, some useful variables, like
    request and session are predefined
  • These variables are called implicit objects
  • Implicit objects are defined in the scope of the
    service method
  • Can these be used in JSP declarations?
  • Implicit objects are part of the JSP
    specifications

45
The objects request and response
  • request and response are the HttpServletRequest
    and HttpServletResponse arguments of the service
    method
  • Using these objects, you can
  • Read request parameters
  • Set response headers
  • etc. (everything we learned in Servlet lectures)

46
The object out
  • This is the Writer used to add write output into
    the response body
  • This object implements the interface JspWriter,
    which supports auto-flush
  • Recall that you can adjust the buffer size, or
    turn buffering off, through use of the buffer
    attribute of the page directive

47
The object page
  • Simply a synonym for (Object)this
  • page is not very useful in JSP pages
  • It was created as a placeholder for the time when
    the scripting language could be something other
    than Java

48
The object pageContext
  • pageContext is a new object introduced by JSP
  • This object encapsulates use of server-specific
    features (e.g. higher performance JspWriters)
  • Access server-specific features through this
    class rather than directly, so your code will
    conform to JSP spec. and not be server dependent
  • This object is also used to store page-scoped
    Java Beans (discussed later)

49
The object session
  • This is the HttpSession object associated with
    the request
  • If the session attribute in the page directive is
    turned off (lt_at_ page session"false" gt) then
    this object is not available
  • Recall that a session is created by default

50
The object config
  • This is the ServletConfig of the page, as
    received in the init() method
  • Remember Contains Servlet specific
    initialization parameters
  • Later, we will study how initialization
    parameters are passed to JSP pages in Tomcat
  • You can get the ServletContext from config

51
The object application
  • This is the ServletContext as obtained via
    getServletConfig().getContext()
  • Remember
  • The ServletContext is shared by all
    Web-application Servlets (including ones
    generated from JSP)
  • Getting and setting attributes is with
    getAttribute and setAttribute of ServletContext
  • You can use this object to get application-wide
    initialization parameters

52
Review Variable Scope
53
Review Variable Scope
54
Review Variable Scope
55
Review Variable Scope
56
Servlet Package and Helper Classes
  • The generated Servlet has a named package
  • In Tomcat, this package is org.apache.jsp
  • In Java, you cannot use classes from the default
    package (i.e. with no package declaration) from a
    named package!
  • Therefore, helper classes used by JSP pages must
    have a named package

57
JSP Actions
58
Actions
  • JSP actions use constructs in XML syntax to
    control the behavior of the Servlet engine
  • Using actions, you can
  • dynamically insert a resource content
  • forward the user to another page
  • reuse Java Beans and custom tags - briefly
    discussed later

59
The forward Action
  • jspforward - Forwards the requester to a new
    resource
  • ltjspforward page"relativeURLlt expression
    gt"gt
  • ltjspparam name"parameterName"  
  • value"parameterValue lt expression gt" /gt
  • lt/jspforwardgt
  • This action is translated to an invocation of the
    RequestDispatcher

60
The include Action
  • jspinclude - Include a resource content at run
    time
  • ltjspinclude page"relativeURLlt expression
    gt"
  • flush"true false" gt    
  • ltjspparam name"parameterName"
  • value"parameterValue lt expression
    gt" /gt
  • lt/jspincludegt
  • This action is also translated to an invocation
    of the RequestDispatcher

61
include Directive vs. Action
  • When a file is included using the include
    directive, the file itself is included verbatim
    into the JSP code, prior to the Servlet
    generation
  • When a resource is included using the include
    action, the generated Servlet uses the dispatcher
    to include its content at runtime
  • Question using which of the latter options can
    the included element change the HTTP headers or
    status?

62
JSP Life Cycle
63
JSP Life Cycle
  • The following table describes the life cycle of
    JSP generated Servlet in details

64
JSP Life Cycle
Written by Marty Hall. Core Servlets JSP book
www.coreservlets.com
65
JSP Translation
  • When the JSP file is modified, JSP is translated
    into a Servlet
  • Application need not be reloaded when JSP file is
    modified
  • In Tomcat 5.0, translation is done even if
    included files (through the include directive)
    are modified
  • Server does not generate the Servlet class after
    startup, if the latter already exists
  • Generated Servlet acts just like any other Servlet

66
init() and destroy()
  • init() of the generated Servlet is called every
    time the Servlet class is loaded into memory and
    instantiated
  • destroy() of the generated Servlet is called
    every time the generated Servlet is removed
  • The latter two happen even if the reason is
    modification of the JSP file

67
Thread Synchronization
  • After the Servlet is generated, one instance of
    it services requests in different threads, just
    like any other Servlet
  • In particular, the service method (_jspService)
    may be executed by several concurrent threads
  • Thus, like Servlets, JSP code should deal with
    concurrency

68
JSP in Tomcat 5.0
69
Tomcat 5.0 Generated Servlet
  • ltHTMLgt
  • ltHEADgt
  • ltTITLEgtHello Worldlt/TITLEgt
  • lt/HEADgt
  • ltBODYgt
  • ltH2gtltIgtlt new java.util.Date() gtlt/Igtlt/H2gt
  • ltH1gtHello Worldlt/H1gt
  • lt/BODYgt
  • lt/HTMLgt

Tomcat 5.0 Generated Servlet
70
Generated Servlet Hierarchy(Tomcat 5.0
Implementation)
71
Implementation vs. Specification
  • JSP files should conform to JSP specifications
    and be container independent
  • For example, JSP files that assume extension of
    HttpServlet will compile and run correctly under
    Tomcat, but may fail to compile under other
    containers
  • The implicit object pageContext exists for this
    reason

72
JSP Initial Parameters
  • Like Servlets, initial parameters can be passed
    to JSP files using the ltservletgt element of the
    application configuration file web.xml
  • Use the sub-element ltjsp-filegt instead of the
    sub-element ltservlet-classgt
  • A ltservlet-mappinggt is also needed
  • Use the JSP file as the lturl-patterngt

73
  • ltweb-appgt
  • ltcontext-paramgt
  • ltparam-namegtdbLoginlt/param-namegt
  • ltparam-valuegtsnoopylt/param-valuegt
  • lt/context-paramgt
  • ltcontext-paramgt
  • ltparam-namegtdbPasswordlt/param-namegt
  • ltparam-valuegtsnoopasslt/param-valuegt
  • lt/context-paramgt

74
  • ltservletgt
  • ltservlet-namegtParamPagelt/servlet-namegt
  • ltjsp-filegt/paramPage.jsplt/jsp-filegt
  • ltinit-paramgt
  • ltparam-namegttableNamelt/param-namegt
  • ltparam-valuegtuserslt/param-valuegt
  • lt/init-paramgt
  • lt/servletgt
  • ltservlet-mappinggt
  • ltservlet-namegtParamPagelt/servlet-namegt
  • lturl-patterngt/initParam.jsplt/url-patterngt
  • lt/servlet-mappinggt
  • lt/web-appgt

75
ltHTMLgt ltHEADgtltTITLEgtJSP initial
parameterslt/TITLEgtlt/HEADgt ltBODYgt
ltH1gtHellolt/H1gt ltH2gtI should use the table
ltIgtlt config.getInitParameter("tableName"
) gtlt/Igt.lt/H2gt ltH2gtTo access the Database, I
should use the login ltIgtlt
application.getInitParameter("dbLogin") gtlt/Igt
and the password ltIgtlt
application.getInitParameter("dbPassword")
gtlt/Igt.lt/H2gt lt/BODYgt lt/HTMLgt
76
(No Transcript)
77
Appendix 1Java Beans in JSP
78
Motivation
  • Software components (e.g. objects, data
    structures, primitives) are extensively used in
    Web applications
  • For example
  • Service local variables
  • Attributes forwarded in requests
  • Session attributes, like users information
  • Application attributes, like access counters

79
Motivation
  • Standard actions are used to manipulate
    components declaration, reading from the
    suitable context, setting of new values
    (according to input parameters), storing inside
    the suitable context, etc.
  • Java Beans provide a specification for automatic
    handling and manipulation of software components
    in JSP (and other technologies...)

80
Java Beans The Idea
  • Wrap your data, in a standard fashion, inside a
    Java class (Java Bean)
  • Use special JSP actions to access and manipulate
    the bean
  • Use special action attributes to specify the
    properties of the bean, like its scope

81
Example 1 Access Counter
  • In the following example, we use a Bean to
    maintain an access counter for requests to the
    pages

82
(No Transcript)
83
(No Transcript)
84
  • package dbi
  • public class CounterBean
  • private int counter
  • public CounterBean() counter 0
  • public int getCounter() return counter
  • public void setCounter(int i) counter i
  • public void increment() counter

Bean must reside in a package
Bean is created by an empty constructor
getCounter and setCounter define the property
counter
other methods can be used
85
pageA.jsp
ltjspuseBean id"accessCounter"
class"dbi.CounterBean" scope"application"/gt lt
accessCounter.increment() gt ltH1gtWelcome to Page
Alt/H1gt ltH2gtAccesses to this application
ltjspgetProperty name"accessCounter"
property"counter"/gtlt/H2gt ltA HREF"pageB.jsp"gtPa
ge Blt/agt
invokes getCounter()
86
pageB.jsp
ltjspuseBean id"accessCounter"
class"dbi.CounterBean" scope"application"/gt lt
accessCounter.increment() gt ltH1gtWelcome to Page
Blt/H1gt ltH2gtAccesses to this application
ltjspgetProperty name"accessCounter"
property"counter"/gtlt/H2gt ltA HREF"pageA.jsp"gtPa
ge Alt/agt
87
Example 2 Session Data
  • In the following example, we use a Bean in order
    to keep a user's details throughout the session

88
(No Transcript)
89
(No Transcript)
90
(No Transcript)
91
  • package dbi
  • public class UserInfoBean
  • private String firstName
  • private String lastName
  • public UserInfoBean() firstName lastName
    null
  • public String getFirstName() return firstName
  • public String getLastName() return lastName
  • public void setFirstName(String string)
    firstName string
  • public void setLastName(String string) lastName
    string

92
infoForm.html
ltHTMLgt ltHEADgtltTITLEgtUser Infolt/TITLEgtlt/HEADgt
ltBODYgtltH1gtFill in your detailslt/H1gt ltFORM
ACTION"infoA.jsp"gt Your First Name ltINPUT
TYPE"text" NAME"firstName"gt ltBRgt Your
Last Name ltINPUT TYPE"text" NAME"lastName"gt
ltBRgt ltINPUT TYPE"submit"gt
lt/FORMgt lt/BODYgt lt/HTMLgt
93
infoA.jsp
Match parameters to corresponding properties
ltjspuseBean id"userInfo" class"dbi.UserInfoBe
an" scope"session"/gt ltjspsetProperty
name"userInfo" property""/gt ltH1gt
ltjspgetProperty name"userInfo"
property"firstName"/gt ltjspgetProperty
name"userInfo" property"lastName"/gt,
lt/H1gt ltH1gtHave a nice session!lt/H1gt ltA
HREF"infoB.jsp"gtUser Info Blt/agt
94
infoB.jsp
ltjspuseBean id"userInfo" class"dbi.UserInfoBe
an" scope"session"/gt ltjspsetProperty
name"userInfo" property""/gt ltH1gt
ltjspgetProperty name"userInfo"
property"firstName"/gt ltjspgetProperty
name"userInfo" property"lastName"/gt,
lt/H1gt ltH1gtHave a nice session!lt/H1gt ltA
HREF"infoA.jsp"gtUser Info Alt/agt
95
Advantages of Java Beans
  • Easy and standard management of data
  • Automatic management of bean sharing and lots
    more
  • Good programming style
  • Allow standard but not direct access to members
  • You can add code to the setters and getters (e.g.
    constraint checks) without changing the client
    code
  • You can change the internal representation of the
    data without changing the client code
  • Increase of separation between business logic
    (written by programmers) and HTML (written by GUI
    artists)

96
Appendix 2Custom JSP Tags
97
Custom JSP Tags
  • JSP code may use custom tags - tags that are
    defined and implemented by the programmer
  • The programmer defines how each of the custom
    tags is translated into Java code
  • There are two methods to define custom tags
  • Tag libraries - used in old versions of JSP
  • Tag files - much simpler, introduced in JSP 2.0

98
Tag Libraries
  • A tag library consists of
  • Tag handlers - Java classes that define how each
    of the new tags is translated into Java code
  • A TLD (Tag Library Descriptor) file, which is an
    XML file that defines the structure and the
    implementing class of each tag

99
A Simple TagLib Example
DateTag.java
  • package dbi
  • import javax.servlet.jsp.JspException
  • import javax.servlet.jsp.tagext.SimpleTagSupport
  • import java.io.IOException
  • public class DateTag extends SimpleTagSupport
  • public void doTag() throws JspException,
    IOException
  • getJspContext().getOut().print(new
    java.util.Date())

100
lt?xml version"1.0" encoding"ISO-8859-1"
?gt lttaglib version"2.0"gt lttlib-versiongt1.0lt/tli
b-versiongt lttaggt ltnamegtdatelt/namegt
lttagclassgtdbi.DateTaglt/tagclassgt
ltbody-contentgtemptylt/body-contentgt
lt/taggt lt/taglibgt
dbi-taglib.tld
lt_at_ taglib prefix"dbitag" uri"/WEB-INF/tags/d
bi-taglib.tld" gt lthtmlgtltbodygt lth1gtHello. The
time is ltdbitagdate/gtlt/h1gt lt/bodygtlt/htmlgt
taglibuse.jsp
101
(No Transcript)
102
Tag Files
  • The new version of JSP (2.0) provides an
    extremely simplified way of defining tags
  • The idea for each custom tag, write a tag file
    tagName.tag that implements the tag translation
    using JSP code
  • This way, the programmer can avoid creating tag
    handlers and TLD files

103
The Simplified Example
lt new java.util.Date() gt
date.tag
lt_at_ taglib prefix"dbitag" tagdir"/WEB-INF/tags/"
gt lthtmlgtltbodygt lth1gtHello. The time is
ltdbitagdate/gtlt/h1gt lt/bodygtlt/htmlgt
taguse.jsp
104
(No Transcript)
105
Other Capabilities of Custom Tags
  • Attributes
  • You can define the possible attributes of the
    Tags
  • These can be accessed during the Tag translation
  • Tag Body
  • Tag translation may choose to ignore, include or
    change the tag body
Write a Comment
User Comments (0)
About PowerShow.com