Basic Principles of JSPs
|
|
|
- Wilfred Richards
- 7 years ago
- Views:
Transcription
1 ch05 10/18/02 2:44 PM Page ch05 10/18/02 2:44 PM Page IN THIS CHAPTER LISTING 5.1 A Simple JSP Chapter 4, Basic Principles of Servlets, introduced you to simple Web applications using servlets. Although very useful for writing dynamic server-side code, servlets suffer from some disadvantages. In particular, coding complex HTML pages is somewhat tedious and error prone (due to the need to pepper the code with out.println() statements), and a servlet developer has to take on the dual roles of developer of application logic and designer of Web pages. JavaServer Pages (JSPs) were designed to address these disadvantages. In this chapter, you will study the JSP syntax and the translate-compile life cycle used to generate a servlet that services the HTTP using the information in the JSP Web page. What Is a JSP? A JSP is just a servlet by another name and is used in the same way to generate dynamic HTML pages. Unlike a servlet, which you deploy as a Java class, a JSP is deployed in a textual form similar to a simple HTML page. When the JSP is first accessed, it is translated into a Java class and compiled. The JSP then services HTTP s like any other servlet. A JSP consists of a mix of HTML elements and special JSP elements. You use the JSP elements, among other things, to embed Java code in the HTML. For example, Listing 5.1 shows a simple JSP that prints out the current date. The special JSP scripting element <%=... %> is used to introduce the Java code. What Is a JSP? Deploying a JSP in Tomcat Elements of a JSP Page Currency Converter JSP Using JavaBeans in a JSP The Currency Converter JSP Using a JavaBean The JSP Life Cycle JSPs and the Deployment Descriptor File <HEAD> <TITLE>Date JSP</TITLE> </HEAD> Today s date is <%= new java.util.date() %> Before examining JSP elements in more detail, you will see what Tomcat does when this JSP is deployed. Deploying a JSP in Tomcat Deploying a JSP is very simple. There are only a couple of rules: JSPs are stored in their textual form in the application directory. A JSP must have a.jsp suffix. So, to deploy the JSP in Listing 5.1: 1. Create a new Web application directory in Tomcat s webapps directory; call it basic-jsp. 2. Create a subdirectory called WEB-INF in the basic-jsp directory. 3. Copy Listing 5.1 into a file called date.jsp in this application directory. 4. Stop and restart Tomcat so it recognizes the new Web application. Access the JSP using the URL If there are no errors, you will see a screen similar to the one in Figure 5.1. For this simple example, it is unlikely that you experienced any problems, but a more complex JSP might have generated some errors. The next section on the JSP translate-compile cycle will explain how to handle these errors. If you do not find the answer to your problem there, Chapter 6, Troubleshooting Servlets and JSPs, covers the subject in far greater detail ch05 10/18/02 2:44 PM Page ch05 10/18/02 2:44 PM Page 80 Deploying a JSP in Tomcat In complex applications, you do not need to set up the environment for the JSP. Page parameters do not have to be passed to the JSP. It simplifies the creation of automatic JSP compilation scripts. Client HTTP Request FIGURE 5.1 date.jsp displayed using Netscape 6. Tomcat JSP Translate Compile Cycle HTTP Response Catalina Container First Page Access Unlike the servlets covered in Chapter 4, JSPs are not compiled before deployment. Actually, it is possible to compile JSPs and deploy them in exactly the same way as servlets, JSP Servlet Class File _jspservice() JSP File but this is not normally done and will not be covered. The JSP file is stored in its textual form in the Web application. When a client first s the page, Tomcat (or more correctly the Jasper JSP container) automatically initiates the translate-compile cycle illustrated in Figure 5.2. This diagram assumes the translation and compilations are both successful. Later in this chapter we discuss how to fix any failures in this cycle. The JSP is first translated into Java source code, and if there are no translation errors, it is then compiled into a servlet class file. The translation and compilation obviously causes an initial delay for the first access. If all is well, the JSP will be displayed, but if the translation or compilation fails, the client will be presented with an HTTP 500 Internal Server Error accompanied by an error message from Jasper and a Java compiler stack trace. To prevent end users from seeing this, you should always force the translation and compilation of your JSP by making the first page yourself. Jasper Jasper Compiler Translator Generated Java Code FIGURE 5.2 The Tomcat JSP translate-compile cycle. If the translate-compile cycle fails, the client will receive the Tomcat error as normal. Figure 5.3 shows the how errors are handled in the translate-compile cycle. [FOUND SERVLET] [URL NOT [FOUND JSP] FOUND] Tomcat implements a mechanism for performing the translate-compile cycle without displaying the JSP. This is achieved by appending the special query string?jsp_precompile=true to the URL. This parameter is not passed to the JSP. Instead, it is taken as an instruction for Jasper to translate and compile the JSP. Even if the compilation is successful the JSP is not displayed. This has several advantages: client translate report [FAIL] [OK] exception & stack trace [FAIL] compile [OK] build response run FIGURE 5.3 Error handling during the JSP translate-compile cycle.
2 ch05 10/18/02 2:44 PM Page ch05 10/18/02 2:44 PM Page 82 Deploying a JSP in Tomcat Fixing JSP Errors If the translation fails, Tomcat will report the error in the browser window with a reference to the line in the original JSP where the error occurred. It should then be a simple matter to correct the error and redeploy the JSP. If there are no translation errors, Tomcat generates a Java source code file for the JSP. The default location for this file is in a Web application directory under <CATALINA_HOME>/work/<host>/. Tomcat then compiles this Java file. If an error occurs during compilation, the error message might be more vague. For example: An error occurred between lines: 7 and 17 in the jsp file: /example.jsp Fortunately, this is always followed by a reference to the translated source code file. Here the error is on line 77 of the translated file: Generated servlet error: D:\Apache Tomcat 4.0\work\localhost\basic-jsp\example$jsp.java:77: Class org.apache.jsp. Currency not found. Currency dollars = Currency.getInstance(Locale.US); ^ 1 error, 1 warning From this you will often be able to identify the Java problem, but if not, you can view the generated Java file to get a more complete picture. Listing 5.2 shows the file generated for the simple date.jsp in Listing 5.1. As you can see, lines from the original JSP are included as comments. LISTING 5.2 Generated Servlet Code for date.jsp package org.apache.jsp; import javax.servlet.*; import javax.servlet.http.*; import javax.servlet.jsp.*; import org.apache.jasper.runtime.*; public class date$jsp extends HttpJspBase { static { public date$jsp( ) { LISTING 5.2 Continued public final void _jspx_init() throws org.apache.jasper.runtime.jspexception { public void _jspservice(httpservletrequest, HttpServletResponse response) throws java.io.ioexception, ServletException { JspFactory _jspxfactory = null; PageContext pagecontext = null; HttpSession session = null; ServletContext application = null; ServletConfig config = null; JspWriter out = null; Object page = this; String _value = null; if (_jspx_inited == false) { synchronized (this) { if (_jspx_inited == false) { _jspx_init(); _jspx_inited = true; _jspxfactory = JspFactory.getDefaultFactory(); response.setcontenttype( text/html;charset=iso ); pagecontext = _jspxfactory.getpagecontext(this,, response,, true, 8192, true); application = pagecontext.getservletcontext(); config = pagecontext.getservletconfig(); session = pagecontext.getsession(); out = pagecontext.getout(); // HTML // begin [file= /date.jsp ;from=(0,0);to=(6,28)] out.write( \r\n <HEAD>\r\n <TITLE>Date JSP</TITLE>\r\n </HEAD>\r\n \r\n \r\n Today s date is ); private static boolean _jspx_inited = false; ch05 10/18/02 2:44 PM Page ch05 10/18/02 2:44 PM Page 84 Deploying a JSP in Tomcat LISTING 5.2 Continued // begin [file= /date.jsp ;from=(6,31);to=(6,53)] out.print( new java.util.date() ); // HTML // begin [file= /date.jsp ;from=(6,55);to=(10,0)] out.write( \r\n \r\n \r\n\r\n ); catch (Throwable t) { if (out!= null && out.getbuffersize()!= 0) out.clearbuffer(); if (pagecontext!= null) pagecontext.handlepageexception(t); finally { if (_jspxfactory!= null) _ jspxfactory.releasepagecontext(pagecontext); There are also a number of implicitly declared objects that are available for use in JSPs. These are listed in Table 5.1. TABLE 5.1 JSP Implicit Objects JSP Name Java Servlet Object javax.servlet.http.httpservletrequest response javax.servlet.http.httpservletresponse config javax.servlet.servletconfig pagecontext javax.servlet.jsp.pagecontext session javax.servlet.http.httpsession application javax.servlet.servletcontext out javax.servlet.jsp.jspwriter page java.lang.object (in the Java code on the JSP, this is a synonym for the this object) exception java.lang.throwable (available only if the JSP is designated an error page) We will discuss the use of each of these objects in some detail in Chapter 7, The Web Application Environment. CAUTION This generated file will be overwritten when the JSP is next accessed, so fix the error in the original JSP and not in this generated file. The Compiled JSP Class The Java code you write in your JSP is placed in a Java class with a name supplied by Tomcat. The majority of the code is placed in a method called _jspservice(), which has the following signature: public void _jspservice(httpservletrequest, HttpServletResponse response) throws ServletException, java.io.ioexception; Tomcat imports the following packages into the translated Java class, so there is no need to include these in your JSP: Let s now turn our attention to the elements that make up a JSP page. Elements of a JSP Page As you saw in Listing 5.1, a JSP element is embedded in otherwise static HTML. Similar to HTML all JSP elements are enclosed in open and close angle brackets (< >). Unlike HTML (but like XML), all JSP elements are case sensitive. JSP elements are distinguished from HTML tags by beginning with either <% or <jsp:. Although the standard JSP syntax is similar to XML, it does not completely conform to the XML syntax rules. The JSP 1.2 specification defines an alternative XML syntax for JSPs and uses the term JSP document to refer to a JSP that is a well-formed XML document. A JSP document has a number of advantages, but as yet it is not in common use. This book uses the standard JSP syntax. javax.servlet.* javax.servlet.http.* javax.servlet.jsp.* org.apache.jasper.runtime.*
3 ch05 10/18/02 2:44 PM Page ch05 10/18/02 2:44 PM Page 86 Elements of a JSP Page There are three basic JSP element types: Directives Scripting elements Action elements Each of these elements is discussed in turn in the following sections. JSP Directives Directives have the following syntax: <%@ directive { attr= value * %> They provide information used to control the translation of the JSP into Java code. There are three directives: include taglib page The include Directive The include directive is used, as the name suggests, to bring in static content from another file. The following example shows how to add a copyright notice to the JSP: <%@ include file= copyright.html %> This directive is acted on at translate time, and the file is subjected to the Tomcat translate-compile cycle. The taglib Directive The taglib directive is used to introduce a tag library to the JSP. Tag libraries are a convenient way of encapsulating code and extending the functionality of JSP tags. Tag libraries are covered in detail in Chapter 10, Custom Tags and TagLibs, and Chapter 11, JSP Expression Language and JSTL Page Directives Page directives are used to define properties for the page together with any files incorporated via the include directive. Table 5.2 provides a list of the common page directives (for others see the JSP specification) with examples of how they are used. TABLE 5.2 Common JSP Page Directives Directive Example Effect buffer <%@ page buffer= 8kb %> Set the output buffer size. A value of none indicates that the output is not buffered. The default is buffered. autoflush <%@ page autoflush= false %> Specifies whether the output buffer should be automatically flushed when it is full. The default is true. contenttype <%@ page contenttype= text/ Defines the MIME type and char plain;iso acter encoding for the response. MIME type text/html and character encoding ISO are the defaults. errorpage <%@ page errorpage= /error/messedup.jsp The client will be redirected to the specified URL when an exception occurs that is not caught by the current page. iserrorpage <%@ page iserrorpage= true %> Indicates whether this page is the target URL for an errorpage directive. If true, an implicit scripting java.lang.exception object called exception is defined. import <%@ page import= java.math.* A comma-separated list of package names to be imported for this JSP. The following are imported by default and do not need to be specified in the JSP: java.lang.* javax.servlet.* javax.servlet.jsp.* javax.servlet.http.* org.apache.jasper.runtime.* isthreadsafe <%@ page isthreadsafe= false %> If set to true, this page can be run multithreaded. This is the default, so you should ensure access to shared objects is synchronized. session <%@ page session= false %> Set to true if the page is to participate in an HTTP session. This is the default ch05 10/18/02 2:44 PM Page ch05 10/18/02 2:44 PM Page 88 Elements of a JSP Page Listing 5.3 shows the date.jsp with page directives to import the java.util package and construct the response using a Central European character set. (The use of page directives is covered in greater detail in Chapter 7.) LISTING 5.3 date.jsp with Page Directives <%@ page import= java.util.* contenttype= text/html;iso %> <HEAD> <TITLE>Date JSP</TITLE> </HEAD> Today s date is <%= new Date() %> JSP Action Elements The final JSP element type is an action element. The JSP specification defines some standard actions, three of which are concerned with support for JavaBeans. You can also create your own custom actions with the use of tag libraries. Action elements conform to XML/Namespace syntax with a start tag, an optional body, and an end tag. The JSP specification reserves the special <jsp: suffix for standard actions. Action elements associated with JavaBeans are covered later in this chapter, whereas the other remaining action elements are covered in Chapter 7. You will now rewrite the Currency Converter example as a JSP. Currency Converter JSP Listing 5.4 shows the Currency Converter servlet from Chapter 4, rewritten as a JSP. LISTING 5.4 currency-converter.jsp JSP Scripting Elements Scripting elements come in the three forms described in Table 5.3. TABLE 5.3 JSP Scripting Elements Scripting Element Example Description Declarations <%! String msg= Hello ; %> Declarations of variables or methods, each one separated by semicolons. Variables declared this way are declared in the class itself and not inside the _jspservice() method. Scriptlets <% int i = 42; Elements that contain Java code answer = select[i];%> fragments. These are added to the _jspservice() method. Expressions <%= msg %> JSP expressions are statements that are evaluated, the result cast into a String and placed on the JSP page. <%@ page import= java.io.* %> <%@ page import= java.util.* %> <%@ page import= java.text.* %> <%! private static final double EXCHANGE_RATE = 0.613; %> <% Currency dollars = Currency.getInstance(Locale.US); Currency pounds = Currency.getInstance(Locale.UK); String amount =.getparameter( amount ); NumberFormat nf = NumberFormat.getInstance(); double newvalue = nf.parse(amount).doublevalue(); poundvalue *= EXCHANGE_RATE ; nf.setmaximumfractiondigits(pounds.getdefaultfractiondigits()); nf.setminimumfractiondigits(pounds.getdefaultfractiondigits()); %> CAUTION Declarations and scriptlets contain normal Java code and require semicolons. Expressions are embedded in out.print() statements and should not be terminated with a semicolon. Misplacing semicolons is a common source of JSP compilation errors. <HEAD><TITLE>Currency Conversion JSP</TITLE></HEAD> <%= dollars.getsymbol(locale.us) %> <%= amount %> = <%= pounds.getsymbol(locale.uk) %> <%= nf.format(poundvalue) %> We will cover the use of each of these scripting elements later in this chapter.
4 ch05 10/18/02 2:44 PM Page ch05 10/18/02 2:44 PM Page 90 Currency Converter JSP LISTING 5.4 Continued Using JavaBeans in a JSP The use of implicit object declarations, JSP expressions, and scripting elements goes a long way to simplify and encapsulate the Java code, but the amount of code in a JSP can be reduced further using JavaBeans. <% catch (ParseException e) { out.println ( Bad number format ); %> As you can see, the majority of the code is encapsulated in two scriptlets, and the HTML formatting is both more obvious and more concise. JSP expressions have been used to output the dollar amount and the converted pound value. Deploy (copy) this JSP to the webapps/basic-jsp directory. Either call this JSP directly, providing the amount as a parameter to the URL, like this: Or edit the currency-form.html file from Chapter 4 to call the new JSP as shown in Listing 5.5. Copy this form to webapps/basic-jsp directory. LISTING 5.5 Currency Converter HTML Form Accessing a JSP <HEAD><TITLE>Currency Form</TITLE></HEAD> <FORM METHOD=GET ACTION= currency-converter.jsp > <H1>Simple Currency Converter</H1> <P>Use this form to convert US Dollars to UK Pounds Sterling</P> Type in the amount to be converted in the box <INPUT TYPE=TEXT NAME= amount > <INPUT TYPE=SUBMIT> </FORM> JavaBeans are self-contained, reusable software components that must be written to conform to a particular design convention (called an idiom). The convention is A JavaBean class must have a no argument constructor (this is what you get by default). A JavaBean can provide properties that allow customization of the bean. For each property, you should define a getter method to retrieve the property and a setter method to modify it. A getter method cannot have any parameters and must return an object of the type of the property. A setter method must take a single parameter of the type of the property and return a void. Let s look at a JavaBean written for the Currency Converter application. Currency Converter Using a JavaBean Adding a JavaBean to the Currency Converter application involves the following steps: 1. Create a CurrencyConverterBean class. 2. Add methods to set and get the US dollar amount. 3. Add a method to get the converted UK pound value. Listing 5.6 shows the code for the CurrencyConverterBean class. For the sake of simplicity, the code to output the currency symbols is included in the getter methods. You might want to split this out into discrete methods. From the simple currency converter example shown in Listing 5.4 you can start to see how, with JSPs, it is possible to separate the roles of HTML designer from Java programmer. With the use of JavaBeans, this separation can be made greater as discussed in the next section ch05 10/18/02 2:44 PM Page ch05 10/18/02 2:44 PM Page 92 Using JavaBeans in a JSP LISTING 5.6 package converters; CurrencyConverterBean Because the default no argument JavaBean constructor is not used, it has been omitted. import java.util.*; import java.text.*; public class CurrencyConverterBean { private static final double EXCHANGE_RATE = 0.613; private Currency dollars = Currency.getInstance(Locale.US); private Currency pounds = Currency.getInstance(Locale.UK); private NumberFormat nf = NumberFormat.getInstance(); private String amount; public void setamount (String amount){ this.amount = amount; Support for JavaBeans is provided in JSPs with the use of the three standard action elements <jsp:usebean>, <jsp:setproperty>, and <jsp:getproperty>. Each of these will now be covered in turn. Using a JavaBean JavaBeans are defined in a JSP using the standard action element <jsp:usebean>, as follows: <jsp:usebean id= <bean name> class= <bean class> scope= <scope> > An example is <jsp:usebean id= converter class= converters.currencyconverterbean scope= page /> public String getamount () { return dollars.getsymbol(locale.us) + amount; This tag creates an instance of the CurrencyConverterBean class and associates it with the id attribute converter for use in the entire JSP page, as defined by the scope attribute. public String getpoundvalue(){ double newvalue = nf.parse(amount).doublevalue(); newvalue *= EXCHANGE_RATE ; nf.setmaximumfractiondigits(pounds.getdefaultfractiondigits()); nf.setminimumfractiondigits(pounds.getdefaultfractiondigits()); return pounds.getsymbol(locale.uk) + nf.format(newvalue); catch (ParseException e) { return ( Bad number format ); Other values for the scope attribute are as follows: <jsp:usebean> Scope Attribute JavaBean Is in Scope For page Only this page This page and any page the is forwarded to session The duration of the session application All components in the Web application Because the scope of JavaBeans can extend beyond the page, they are a useful way of passing information between s. Getting and Setting Bean Properties You retrieve JavaBean properties using the standard element <jsp:getproperty>, as shown in the following example:
5 <jsp:getproperty name= converter property= amount /> ch05 10/18/02 2:44 PM Page ch05 10/18/02 2:44 PM Page 94 Using JavaBeans in a JSP The name attribute corresponds to the id attribute defined in the <jsp:usebean> element. The value of the property is converted to a string and placed in the output stream. Alternatively, you can access a JavaBean property inside a scriptlet using its getter method. For example: The Currency Converter JSP Using a JavaBean Listing 5.7 shows the new Currency Converter JSP using the JavaBean standard actions. As you can see the JSP is now extremely straightforward. All the Java code has been transferred to the JavaBean. Although this is obviously a very simple example it still demonstrates the principle of role separation very well. The Java programmer writes the JavaBean that encapsulates all the business logic. The HTML designer then uses the JSP actions to display the JavaBean properties at the appropriate place on the JSP page. <%= converters.currencyconverterbean.getamount() %> LISTING 5.7 date.jsp Utilizing a JavaBean You set a JavaBean Property using the <jsp:setproperty> element. For example, use the following to set the amount in the CurrencyConverterBean to the value 3: <jsp:setproperty name= converter property= amount value= 3 /> An alternative form of the <jsp:setproperty> element can be used to set a JavaBean property to the value of a parameter. The following sets the property amount to the value passed as a parameter also called amount: <jsp:setproperty name= date property= amount param= amount /> Using this form you can omit the param attribute when the parameter name is the same as the property name. The following also sets the property amount to the value passed as the parameter called amount: <jsp:setproperty name= date property= amount /> <jsp:usebean id= converter class= converters.currencyconverterbean scope= page > <jsp:setproperty name= converter property= amount /> </jsp:usebean> <HEAD><TITLE>Currency Conversion JSP</TITLE></HEAD> <jsp:getproperty name= converter property= amount /> = <jsp:getproperty name= converter property= poundvalue /> Before completing this introduction to JSPs, you need to briefly cover two more topics: the JSP life cycle and the use of the deployment descriptor file with JSPs. Initializing JavaBeans It is usual to set a bean s properties inside the body of the <jsp:usebean> element as follows: <jsp:usebean id= date class= Date scope= page > <jsp:setproperty name= date property= timezone value= GMT /> </jsp:usebean> This idiom reinforces the fact that the bean must be initialized before it is used. The JSP Life Cycle JSPs have the same init-service-destroy life cycle as servlets. The only difference is that you should use the jspinit() and jspdestroy() methods from the JSP interface instead of init() and destroy() from the servlet interface. When the first is delivered to a JSP page, Tomcat calls the jspinit() method, if there is one, to initialize resources. Similarly, Tomcat invokes the jspdestroy() method to reclaim these resources when Tomcat is shut down or the JSP is replaced. TIP Put the jspinit() and jspdestroy() methods in a JSP declaration ch05 10/18/02 2:44 PM Page ch05 10/18/02 2:44 PM Page 96 JSPs and the Deployment Descriptor File JSPs and the Deployment Descriptor File So far in this chapter, we have not discussed the deployment descriptor because none of the examples have needed one. Because JSPs are just servlets, there are no special deployment descriptor elements for them; the only difference lies in how you map a servlet name to a JSP. In Chapter 4, you saw that a <servlet> element in the web.xml file associates a name with a servlet class using the <servlet-class> element. A JSP uses the <jsp-file> element instead of the <servlet-class> element as follows: <jsp-file>/currency-converter.jsp</jsp-file > As with ordinary servlets, you can hide the implementation details of your Web application by using <servlet-mapping> elements for your JSPs. You can use the web.xml file shown in Listing 5.8 to ensure that the date.jsp JSP can be accessed via a wide range of URLs. LISTING 5.8 Deployment Descriptor for a JSP <!DOCTYPE web-app PUBLIC -//Sun Microsystems, Inc.//DTD Web Application 2.3//EN > LISTING 5.8 Continued <url-pattern>*.jsp</url-pattern> </servlet-mapping> </web-app> If this JSP is deployed in an application called basic-jsp, it can be accessed using any of the following URLs: Servlet mapping was discussed in Chapter 4. Return to the appropriate section in Chapter 4 if you need to refresh your memory on how servlet mapping works. Other web.xml elements, such as initialization parameters, can be accessed from within JSP scriptlets either using the normal servlet API objects or one of the implicit JSP variables shown in Table 5.1. <web-app> <display-name>currency Converter</display-name> <description> This is a simple web application with an HTML form passing a single parameter to a JSP. </description> <servlet> <jsp-file>/currency-converter.jsp </jsp-file> </servlet> <servlet-mapping> <url-pattern>/convert</url-pattern> </servlet-mapping> <servlet-mapping> Summary This chapter has provided an introduction to JSPs. You now know that a JSP is a servlet written using HTML and special JSP elements. JSPs have several advantages over servlets: Not only do JSPs simplify the coding of complex HTML documents, but they also allow the roles of Java programmer and HTML designer to be separated. Servlets and JSPs are not only written differently, but there are also differences in the way they are deployed. Unlike servlets that you compile and deploy as a Java class, a JSP is deployed in its original textual-document form. When the JSP is accessed for the first time, Tomcat detects this fact and subjects the JSP to a translation and compilation cycle. The time taken for this translate-compile cycle causes a significant delay in the display of the JSP for the first access. Precompiling the JSP as it is deployed can eliminate this delay. The use of JavaBeans to encapsulate the Java code in an accompanying bean class helps simplify JSPs even further by moving most if not all of the Java code into the JavaBean class. This concludes the introduction to JSPs. Chapter 6 covers troubleshooting your applications. Chapter 7 tackles more advanced servlet and JSP topics.
Pure server-side Web Applications with Java, JSP. Application Servers: the Essential Tool of Server-Side Programming. Install and Check Tomcat
Pure server-side Web Applications with Java, JSP Discussion of networklevel http requests and responses Using the Java programming language (Java servlets and JSPs) Key lesson: The role of application
Class Focus: Web Applications that provide Dynamic Content
Class Focus: Web Applications that provide Dynamic Content We will learn how to build server-side applications that interact with their users and provide dynamic content Using the Java programming language
JSP Java Server Pages
JSP - Java Server Pages JSP Java Server Pages JSP - Java Server Pages Characteristics: A way to create dynamic web pages, Server side processing, Based on Java Technology, Large library base Platform independence
2.8. Session management
2.8. Session management Juan M. Gimeno, Josep M. Ribó January, 2008 Session management. Contents Motivation Hidden fields URL rewriting Cookies Session management with the Servlet/JSP API Examples Scopes
Server-Side Web Development JSP. Today. Web Servers. Static HTML Directives. Actions Comments Tag Libraries Implicit Objects. Apache.
1 Pages () Lecture #4 2007 Pages () 2 Pages () 3 Pages () Serves resources via HTTP Can be anything that serves data via HTTP Usually a dedicated machine running web server software Can contain modules
Introduction to J2EE Web Technologies
Introduction to J2EE Web Technologies Kyle Brown Senior Technical Staff Member IBM WebSphere Services RTP, NC brownkyl@us.ibm.com Overview What is J2EE? What are Servlets? What are JSP's? How do you use
Web Container Components Servlet JSP Tag Libraries
Web Application Development, Best Practices by Jeff Zhuk, JavaSchool.com ITS, Inc. dean@javaschool.com Web Container Components Servlet JSP Tag Libraries Servlet Standard Java class to handle an HTTP request
Complete Java Web Development
Complete Java Web Development JAVA-WD Rev 11.14 4 days Description Complete Java Web Development is a crash course in developing cutting edge Web applications using the latest Java EE 6 technologies from
Controlling Web Application Behavior
2006 Marty Hall Controlling Web Application Behavior The Deployment Descriptor: web.xml JSP, Servlet, Struts, JSF, AJAX, & Java 5 Training: http://courses.coreservlets.com J2EE Books from Sun Press: http://www.coreservlets.com
Building Web Applications, Servlets, JSP and JDBC
Building Web Applications, Servlets, JSP and JDBC Overview Java 2 Enterprise Edition (JEE) is a powerful platform for building web applications. The JEE platform offers all the advantages of developing
Exam Prep. Sun Certified Web Component Developer (SCWCD) for J2EE Platform
Exam Prep Sun Certified Web Component Developer (SCWCD) for J2EE Platform Core Servlets & JSP book: www.coreservlets.com More Servlets & JSP book: www.moreservlets.com Servlet and JSP Training Courses:
Java Server Pages Tutorial
Java Server Pages Tutorial JAVA SERVER PAGES TUTORIAL by tutorialspoint.com tutorialspoint.com ABOUT THE TUTORIAL JSP Tutorial Java Server Pages (JSP) is a server-side programming technology that enables
Web Programming: Announcements. Sara Sprenkle August 3, 2006. August 3, 2006. Assignment 6 due today Project 2 due next Wednesday Review XML
Web Programming: Java Servlets and JSPs Sara Sprenkle Announcements Assignment 6 due today Project 2 due next Wednesday Review XML Sara Sprenkle - CISC370 2 1 Web Programming Client Network Server Web
ACM Crossroads Student Magazine The ACM's First Electronic Publication
Page 1 of 8 ACM Crossroads Student Magazine The ACM's First Electronic Publication Crossroads Home Join the ACM! Search Crossroads crossroads@acm.org ACM / Crossroads / Columns / Connector / An Introduction
Services. Custom Tag Libraries. Today. Web Development. Role-Based. Development. Code Reuse. Tag Libraries Custom Tags. Tag Lifecycle.
JSP, and JSP, and 1 JSP, and Custom Lecture #6 2008 2 JSP, and JSP, and interfaces viewed as user interfaces methodologies derived from software development done in roles and teams role assignments based
DTS Web Developers Guide
Apelon, Inc. Suite 202, 100 Danbury Road Ridgefield, CT 06877 Phone: (203) 431-2530 Fax: (203) 431-2523 www.apelon.com Apelon Distributed Terminology System (DTS) DTS Web Developers Guide Table of Contents
Development. with NetBeans 5.0. A Quick Start in Basic Web and Struts Applications. Geertjan Wielenga
Web Development with NetBeans 5.0 Quick Start in Basic Web and Struts pplications Geertjan Wielenga Web Development with NetBeans 5 This tutorial takes you through the basics of using NetBeans IDE 5.0
Ch-03 Web Applications
Ch-03 Web Applications 1. What is ServletContext? a. ServletContext is an interface that defines a set of methods that helps us to communicate with the servlet container. There is one context per "web
CONTROLLING WEB APPLICATION BEHAVIOR WITH
CONTROLLING WEB APPLICATION BEHAVIOR WITH WEB.XML Chapter Topics in This Chapter Customizing URLs Turning off default URLs Initializing servlets and JSP pages Preloading servlets and JSP pages Declaring
Glassfish, JAVA EE, Servlets, JSP, EJB
Glassfish, JAVA EE, Servlets, JSP, EJB Java platform A Java platform comprises the JVM together with supporting class libraries. Java 2 Standard Edition (J2SE) (1999) provides core libraries for data structures,
SSC - Web development Model-View-Controller for Java web application development
SSC - Web development Model-View-Controller for Java web application development Shan He School for Computational Science University of Birmingham Module 06-19321: SSC Outline Outline of Topics Java Server
JSP. Common patterns
JSP Common patterns Common JSP patterns Page-centric (client-server) CLIENT JSP or Servlet CLIENT Enterprise JavaBeans SERVER DB Common JSP patterns Page-centric 1 (client-server) Page View request response
In this chapter, we lay the foundation for all our further discussions. We start
01 Struts.qxd 7/30/02 10:23 PM Page 1 CHAPTER 1 Introducing the Jakarta Struts Project and Its Supporting Components In this chapter, we lay the foundation for all our further discussions. We start by
Web Application Programmer's Guide
Web Application Programmer's Guide JOnAS Team ( Florent BENOIT) - March 2009 - Copyright OW2 consortium 2008-2009 This work is licensed under the Creative Commons Attribution-ShareAlike License. To view
Java EE Introduction, Content. Component Architecture: Why and How Java EE: Enterprise Java
Java EE Introduction, Content Component Architecture: Why and How Java EE: Enterprise Java The Three-Tier Model The three -tier architecture allows to maintain state information, to improve performance,
www.virtualians.pk CS506 Web Design and Development Solved Online Quiz No. 01 www.virtualians.pk
CS506 Web Design and Development Solved Online Quiz No. 01 Which of the following is a general purpose container? JFrame Dialog JPanel JApplet Which of the following package needs to be import while handling
PA165 - Lab session - Web Presentation Layer
PA165 - Lab session - Web Presentation Layer Author: Martin Kuba Goal Experiment with basic building blocks of Java server side web technology servlets, filters, context listeners,
Hello World Portlet Rendered with JSP for WebSphere Portal Version 4.1
1 of 11 16.10.2002 11:41 Hello World Portlet Rendered with JSP for WebSphere Portal Version 4.1 Table of Contents Creating the directory structure Creating the Java code Compiling the code Creating the
Java Technologies. Lecture X. Valdas Rapševičius. Vilnius University Faculty of Mathematics and Informatics 2012.12.31
Preparation of the material was supported by the project Increasing Internationality in Study Programs of the Department of Computer Science II, project number VP1 2.2 ŠMM-07-K-02-070, funded by The European
How To Understand The Architecture Of Java 2Ee, J2Ee, And J2E (Java) In A Wordpress Blog Post
Understanding Architecture and Framework of J2EE using Web Application Devadrita Dey Sarkar,Anavi jaiswal, Ankur Saxena Amity University,UTTAR PRADESH Sector-125, Noida, UP-201303, India Abstract: This
SCWCD EXAM STUDY KIT JAVA WEB COMPONENT DEVELOPER CERTIFICATION SCE 310-081 SECOND EDITION. Hanumant Deshmukh Jignesh Malavia Matthew Scarpino MANNING
SCE 310-081 SCWCD EXAM STUDY KIT SECOND EDITION JAVA WEB COMPONENT DEVELOPER CERTIFICATION Hanumant Deshmukh Jignesh Malavia Matthew Scarpino MANNING SCWCD Study Kit Second Edition by Matthew Scarpino
Java Servlet Tutorial. Java Servlet Tutorial
Java Servlet Tutorial i Java Servlet Tutorial Java Servlet Tutorial ii Contents 1 Introduction 1 1.1 Servlet Process.................................................... 1 1.2 Merits.........................................................
Web Application Architecture (based J2EE 1.4 Tutorial)
Web Application Architecture (based J2EE 1.4 Tutorial) 1 Disclaimer & Acknowledgments Even though Sang Shin is a full-time employee of Sun Microsystems, the contents here are created as his own personal
Announcements. Comments on project proposals will go out by email in next couple of days...
Announcements Comments on project proposals will go out by email in next couple of days... 3-Tier Using TP Monitor client application TP monitor interface (API, presentation, authentication) transaction
CHAPTER 9: SERVLET AND JSP FILTERS
Taken from More Servlets and JavaServer Pages by Marty Hall. Published by Prentice Hall PTR. For personal use only; do not redistribute. For a complete online version of the book, please see http://pdf.moreservlets.com/.
Outline. CS 112 Introduction to Programming. Recap: HTML/CSS/Javascript. Admin. Outline
Outline CS 112 Introduction to Programming Web Programming: Backend (server side) Programming with Servlet, JSP q Admin and recap q Server-side web programming overview q Servlet programming q Java servlet
PowerTier Web Development Tools 4
4 PowerTier Web Development Tools 4 This chapter describes the process of developing J2EE applications with Web components, and introduces the PowerTier tools you use at each stage of the development process.
Oracle WebLogic Server
Oracle WebLogic Server Developing Web Applications, Servlets, and JSPs for Oracle WebLogic Server 10g Release 3 (10.3) July 2008 Oracle WebLogic Server Developing Web Applications, Servlets, and JSPs for
Agenda. Summary of Previous Session. Application Servers G22.3033-011. Session 3 - Main Theme Page-Based Application Servers (Part II)
Application Servers G22.3033-011 Session 3 - Main Theme Page-Based Application Servers (Part II) Dr. Jean-Claude Franchitti New York University Computer Science Department Courant Institute of Mathematical
Servlets. Based on Notes by Dave Hollinger & Ethan Cerami Also, the Online Java Tutorial by Sun
Servlets Based on Notes by Dave Hollinger & Ethan Cerami Also, the Online Java Tutorial by Sun 1 What is a Servlet? A Servlet is a Java program that extends the capabilities of servers. Inherently multi-threaded.
Creating Java EE Applications and Servlets with IntelliJ IDEA
Creating Java EE Applications and Servlets with IntelliJ IDEA In this tutorial you will: 1. Create IntelliJ IDEA project for Java EE application 2. Create Servlet 3. Deploy the application to JBoss server
Course Name: Course in JSP Course Code: P5
Course Name: Course in JSP Course Code: P5 Address: Sh No BSH 1,2,3 Almedia residency, Xetia Waddo Duler Mapusa Goa E-mail Id: ITKP@3i-infotech.com Tel: (0832) 2465556 (0832) 6454066 Course Code: P5 3i
Java Server Pages and Java Beans
Java Server Pages and Java Beans Java server pages (JSP) and Java beans work together to create a web application. Java server pages are html pages that also contain regular Java code, which is included
Form Handling. Server-side Web Development and Programming. Form Handling. Server Page Model. Form data appended to request string
Form Handling Server-side Web Development and Programming Lecture 3: Introduction to Java Server Pages Form data appended to request string
Developing a J2EE Application. Web Auction. Gerald Mo
Developing a J2EE Application Web Auction Gerald Mo A dissertation submitted in partial fulfillment of the requirements for the degree of Master of Science in Computer Science in the University of Wales
If you wanted multiple screens, there was no way for data to be accumulated or stored
Handling State in Web Applications Jeff Offutt http://www.cs.gmu.edu/~offutt/ SWE 642 Software Engineering for the World Wide Web sources: Professional Java Server Programming, Patzer, Wrox Web Technologies:
Java Application Developer Certificate Program Competencies
Java Application Developer Certificate Program Competencies After completing the following units, you will be able to: Basic Programming Logic Explain the steps involved in the program development cycle
Building a Multi-Threaded Web Server
Building a Multi-Threaded Web Server In this lab we will develop a Web server in two steps. In the end, you will have built a multi-threaded Web server that is capable of processing multiple simultaneous
Java Web Programming. Student Workbook
Student Workbook Java Web Programming Mike Naseef, Jamie Romero, and Rick Sussenbach Published by ITCourseware, LLC., 7245 South Havana Street, Suite 100, Centennial, CO 80112 Editors: Danielle Hopkins
An Overview of Java. overview-1
An Overview of Java overview-1 Contents What is Java Major Java features Java virtual machine Java programming language Java class libraries (API) GUI Support in Java Networking and Threads in Java overview-2
Java 2 Web Developer Certification Study Guide Natalie Levi
SYBEX Index Java 2 Web Developer Certification Study Guide Natalie Levi Index Copyright 2002 SYBEX Inc., 1151 Marina Village Parkway, Alameda, CA 94501. World rights reserved. No part of this publication
An introduction to creating JSF applications in Rational Application Developer Version 8.0
An introduction to creating JSF applications in Rational Application Developer Version 8.0 September 2010 Copyright IBM Corporation 2010. 1 Overview Although you can use several Web technologies to create
Supplement IV.E: Tutorial for Tomcat. For Introduction to Java Programming By Y. Daniel Liang
Supplement IV.E: Tutorial for Tomcat For Introduction to Java Programming By Y. Daniel Liang This supplement covers the following topics: Obtaining and Installing Tomcat Starting and Stopping Tomcat Choosing
2. Follow the installation directions and install the server on ccc
Installing a Web Server 1. Install a sample web server, which supports Servlets/JSPs. A light weight web server is Apache Tomcat server. You can get the server from http://tomcat.apache.org/ 2. Follow
Getting Started Guide. Version 1.8
Getting Started Guide Version 1.8 Copyright Copyright 2005-2009. ICEsoft Technologies, Inc. All rights reserved. The content in this guide is protected under copyright law even if it is not distributed
Developing XML Solutions with JavaServer Pages Technology
Developing XML Solutions with JavaServer Pages Technology XML (extensible Markup Language) is a set of syntax rules and guidelines for defining text-based markup languages. XML languages have a number
Web Service Development Using CXF. - Praveen Kumar Jayaram
Web Service Development Using CXF - Praveen Kumar Jayaram Introduction to WS Web Service define a standard way of integrating systems using XML, SOAP, WSDL and UDDI open standards over an internet protocol
TABLE OF CONTENTS...2 INTRODUCTION...3 APPLETS AND APPLICATIONS...3 JAVABEANS...4 EXCEPTION HANDLING...5 JAVA DATABASE CONNECTIVITY (JDBC)...
Advanced Features Trenton Computer Festival May 1 sstt & 2 n d,, 2004 Michael P.. Redlich Senior Research Technician ExxonMobil Research & Engineering michael..p..redlich@exxonmobil..com Table of Contents
An introduction to web programming with Java
Chapter 1 An introduction to web programming with Java Objectives Knowledge Objectives (continued) The first page of a shopping cart application The second page of a shopping cart application Components
Building and Using Web Services With JDeveloper 11g
Building and Using Web Services With JDeveloper 11g Purpose In this tutorial, you create a series of simple web service scenarios in JDeveloper. This is intended as a light introduction to some of the
7 Web Databases. Access to Web Databases: Servlets, Applets. Java Server Pages PHP, PEAR. Languages: Java, PHP, Python,...
7 Web Databases Access to Web Databases: Servlets, Applets Java Server Pages PHP, PEAR Languages: Java, PHP, Python,... Prof. Dr. Dietmar Seipel 837 7.1 Access to Web Databases by Servlets Java Servlets
CSc31800: Internet Programming, CS-CCNY, Spring 2004 Jinzhong Niu May 9, 2004. Java Servlets
CSc31800: Internet Programming, CS-CCNY, Spring 2004 Jinzhong Niu May 9, 2004 Java Servlets I have presented a Java servlet example before to give you a sense of what a servlet looks like. From the example,
Web Applications. For live Java training, please see training courses at
2009 Marty Hall Using and Deploying Web Applications Originals of Slides and Source Code for Examples: http://courses.coreservlets.com/course-materials/msajsp.html Customized Java EE Training: http://courses.coreservlets.com/
Outline. Lecture 9: Java Servlet and JSP. Servlet API. HTTP Servlet Basics
Lecture 9: Java Servlet and JSP Wendy Liu CSC309F Fall 2007 Outline HTTP Servlet Basics Servlet Lifecycle Request and Response Session Management JavaServer Pages (JSP) 1 2 HTTP Servlet Basics Current
Web Presentation Layer Architecture
Chapter 4 Web Presentation Layer Architecture In this chapter we provide a discussion of important current approaches to web interface programming based on the Model 2 architecture [59]. From the results
Simplify Your Web App Development Using the Spring MVC Framework
1 of 10 24/8/2008 23:07 http://www.devx.com Printed from http://www.devx.com/java/article/22134/1954 Simplify Your Web App Development Using the Spring MVC Framework Struts is in fairly widespread use
Getting Started with Web Applications
3 Getting Started with Web Applications A web application is a dynamic extension of a web or application server. There are two types of web applications: Presentation-oriented: A presentation-oriented
Tomcat 5 New Features
Tomcat 5 New Features ApacheCon US 2003 Session MO10 11/17/2003 16:00-17:00 Craig R. McClanahan Senior Staff Engineer Sun Microsystems, Inc. Slides: http://www.apache.org/~craigmcc/ Agenda Introduction
Java 7 Recipes. Freddy Guime. vk» (,\['«** g!p#« Carl Dea. Josh Juneau. John O'Conner
1 vk» Java 7 Recipes (,\['«** - < g!p#«josh Juneau Carl Dea Freddy Guime John O'Conner Contents J Contents at a Glance About the Authors About the Technical Reviewers Acknowledgments Introduction iv xvi
Web Frameworks and WebWork
Web Frameworks and WebWork Problem area Mixing application logic and markup is bad practise Harder to change and maintain Error prone Harder to re-use public void doget( HttpServletRequest request, HttpServletResponse
Java Server Pages (JSP)
Java Server Pages (JSP) What is JSP JSP simply puts Java inside HTML pages. You can take any existing HTML page and change its extension to ".jsp" instead of ".html". Scripting elements are used to provide
Java Server Pages combined with servlets in action. Generals. Java Servlets
Java Server Pages combined with servlets in action We want to create a small web application (library), that illustrates the usage of JavaServer Pages combined with Java Servlets. We use the JavaServer
Java Servlet and JSP Programming. Structure and Deployment China Jiliang University
Java Web Programming in Java Java Servlet and JSP Programming Structure and Deployment China Jiliang University Servlet/JSP Exercise - Rules On the following pages you will find the rules and conventions
A Meeting Room Scheduling Problem
A Scheduling Problem Objective Engineering, Inc. 699 Windsong Trail Austin, Texas 78746 512-328-9658 FAX: 512-328-9661 ooinfo@oeng.com http://www.oeng.com Objective Engineering, Inc., 1999-2007. Photocopying,
Web Applications. Originals of Slides and Source Code for Examples: http://courses.coreservlets.com/course-materials/msajsp.html
2009 Marty Hall Using and Deploying Web Applications Originals of Slides and Source Code for Examples: http://courses.coreservlets.com/course-materials/msajsp.html Customized Java EE Training: http://courses.coreservlets.com/
The Sun Certified Associate for the Java Platform, Standard Edition, Exam Version 1.0
The following applies to all exams: Once exam vouchers are purchased you have up to one year from the date of purchase to use it. Each voucher is valid for one exam and may only be used at an Authorized
}w!"#$%&'()+,-./012345 Model-View-Controller. and. Struts 2
Model-View-Controller and Struts 2 Problem area Mixing application logic and markup is bad practise Harder to change and maintain Error prone Harder to re-use public void doget( HttpServletRequest request,
Web Service Caching Using Command Cache
Web Service Caching Using Command Cache Introduction Caching can be done at Server Side or Client Side. This article focuses on server side caching of web services using command cache. This article will
Java 2 Web Developer Certification Study Guide Natalie Levi
SYBEX Sample Chapter Java 2 Web Developer Certification Study Guide Natalie Levi Chapter 8: Thread-Safe Servlets Copyright 2002 SYBEX Inc., 1151 Marina Village Parkway, Alameda, CA 94501. World rights
WIRIS quizzes web services Getting started with PHP and Java
WIRIS quizzes web services Getting started with PHP and Java Document Release: 1.3 2011 march, Maths for More www.wiris.com Summary This document provides client examples for PHP and Java. Contents WIRIS
Performance Monitoring API for Java Enterprise Applications
Performance Monitoring API for Java Enterprise Applications Purpose Perfmon4j has been successfully deployed in hundreds of production java systems over the last 5 years. It has proven to be a highly successful
In this chapter the concept of Servlets, not the entire Servlet specification, is
falkner.ch2.qxd 8/21/03 4:57 PM Page 31 Chapter 2 Java Servlets In this chapter the concept of Servlets, not the entire Servlet specification, is explained; consider this an introduction to the Servlet
Web Application Developer s Guide
Web Application Developer s Guide VERSION 8 Borland JBuilder Borland Software Corporation 100 Enterprise Way, Scotts Valley, CA 95066-3249 www.borland.com Refer to the file deploy.html located in the redist
Arjun V. Bala Page 20
12) Explain Servlet life cycle & importance of context object. (May-13,Jan-13,Jun-12,Nov-11) Servlet Life Cycle: Servlets follow a three-phase life cycle, namely initialization, service, and destruction.
Servlet and JSP Filters
2009 Marty Hall Servlet and JSP Filters Originals of Slides and Source Code for Examples: http://courses.coreservlets.com/course-materials/msajsp.html Customized Java EE Training: http://courses.coreservlets.com/
Web Applications and Struts 2
Web Applications and Struts 2 Problem area Problem area Separation of application logic and markup Easier to change and maintain Easier to re use Less error prone Access to functionality to solve routine
Java 2 Web Developer Certification Study Guide Natalie Levi; Philip Heller
SYBEX Index Java 2 Web Developer Certification Study Guide Natalie Levi; Philip Heller Index Copyright 2002 SYBEX Inc., 1151 Marina Village Parkway, Alameda, CA 94501. World rights reserved. No part of
Configure a SOAScheduler for a composite in SOA Suite 11g. By Robert Baumgartner, Senior Solution Architect ORACLE
Configure a SOAScheduler for a composite in SOA Suite 11g By Robert Baumgartner, Senior Solution Architect ORACLE November 2010 Scheduler for the Oracle SOA Suite 11g: SOAScheduler Page 1 Prerequisite
CrownPeak Java Web Hosting. Version 0.20
CrownPeak Java Web Hosting Version 0.20 2014 CrownPeak Technology, Inc. All rights reserved. No part of this document may be reproduced or transmitted in any form or by any means, electronic or mechanical,
Principles and Techniques of DBMS 5 Servlet
Principles and Techniques of DBMS 5 Servlet Haopeng Chen REliable, INtelligentand Scalable Systems Group (REINS) Shanghai Jiao Tong University Shanghai, China http://reins.se.sjtu.edu.cn/~chenhp e- mail:
Fundamentals of Java Programming
Fundamentals of Java Programming This document is exclusive property of Cisco Systems, Inc. Permission is granted to print and copy this document for non-commercial distribution and exclusive use by instructors
15-415 Database Applications Recitation 10. Project 3: CMUQFlix CMUQ s Movies Recommendation System
15-415 Database Applications Recitation 10 Project 3: CMUQFlix CMUQ s Movies Recommendation System Project Objective 1. Set up a front-end website with PostgreSQL back-end 2. Allow users to login, like
JBoss Portlet Container. User Guide. Release 2.0
JBoss Portlet Container User Guide Release 2.0 1. Introduction.. 1 1.1. Motivation.. 1 1.2. Audience 1 1.3. Simple Portal: showcasing JBoss Portlet Container.. 1 1.4. Resources. 1 2. Installation. 3 2.1.
Java Servlet 3.0. Rajiv Mordani Spec Lead
Java Servlet 3.0 Rajiv Mordani Spec Lead 1 Overview JCP Java Servlet 3.0 API JSR 315 20 members > Good mix of representation from major Java EE vendors, web container developers and web framework authors
CS506- Web Design and Development Solved Subjective From Final term Papers. Final term FALL(Feb 2012) CS506- Web Design and Development
Solved Subjective From Final term Papers JULY 05,2012 MC100401285 Moaaz.pk@gmail.com Mc100401285@vu.edu.pk PSMD01 Final term FALL(Feb 2012) Write 2 Characteristics of Expression Language. (2 Mark) Answer:-
Web Development in Java
Web Development in Java Detailed Course Brochure @All Rights Reserved. Techcanvass, 265, Powai Plaza, Hiranandani Garden, Powai, Mumbai www.techcanvass.com Tel: +91 22 40155175 Mob: 773 877 3108 P a g
Core Java+ J2EE+Struts+Hibernate+Spring
Core Java+ J2EE+Struts+Hibernate+Spring Java technology is a portfolio of products that are based on the power of networks and the idea that the same software should run on many different kinds of systems
Web. Services. Web Technologies. Today. Web. Technologies. Internet WWW. Protocols TCP/IP HTTP. Apache. Next Time. Lecture #3 2008 3 Apache.
JSP, and JSP, and JSP, and 1 2 Lecture #3 2008 3 JSP, and JSP, and Markup & presentation (HTML, XHTML, CSS etc) Data storage & access (JDBC, XML etc) Network & application protocols (, etc) Programming
Usability. Usability
Objectives Review Usability Web Application Characteristics Review Servlets Deployment Sessions, Cookies Usability Trunk Test Harder than you probably thought Your answers didn t always agree Important