JSP source code runs on the web server via JSP Servlet Engine. JSP files are HTML files with special Tags

Transcription

1 JSP : Java Server Pages It is a server side scripting language. JSP are normal HTML with Java code pieces embedded in them. A JSP compiler is used to generate a Servlet from the JSP page. JavaServer Pages enables the development of dynamic web sites and it is based on Java language. Introduction to Jsp To allow server side development JSP was developed by Sun Microsystem. Typical different clients connecting via the Internet to a Web server. e.g. a well popular Apache Web server is execute on Unix platform. C and Perl are languages which used on web servers to provide dynamic content. Most languages including Visualbasic,Delphi,C and Java could be used to write application that provided dynamic content using data from database requests. These were known as CGI server side applications. Microsoft developed ASP to allow HTML developers to easily provide dynamic content supported as standard by Microsoft free Web Server called Internet Information Server (IIS). A comparison of ASP and JSP will be given in section below. JSP source code runs on the web server via JSP Servlet Engine. JSP files are HTML files with special Tags containing Java source code that provide the dynamic content. Why we used JSP? JSP allow developer to quickly produce web sites and applications in an open and standard way and it is easy to learn. JSP is Java based an object-oriented language and offers a robust platform for web development Reason to use JSP: Reusability of Components by using Javabeans and EJB. Multi platform Platform-Independent So you are never depend on one vendor or platform. HTML and graphics displayed on the web browser are the presentation layer and the Java code (JSP) on the server is classed as the implementation. 1

2 Due to the separation of presentation and implementation,web designers work only on the presentation and Java developers concentrate on implementing the application. Comparison of JSP with ASP,ASP.NET and Servlet Comparison with ASP JSP and ASP provide fairly similar functionality. Both allow embedded code in an HTML page,session variables and database access and manipulation. ASP is mostly found on Microsoft platform but JSP can operate on any platform that conforms to the J2EE specification. JSP allow reusubility of component by using Javabeans and EJBs but ASP provides the use of COM / ActiveX controls. Comparison with ASP.NET ASP.NET is based on the Microsoft.NET framework. By using.net framework you developed application with different programming language like Visual Basic,C# and JavaScript. JSP and Java still has the advantage that it is supported on many different platforms and the Java community has many years of experience in designing and developing Enterprise quality scalable applications. ASP.NET is quite an improvement over the old ASP code. Comparison with Servlets A Servlet is a Java class that provides special server side service. It is tough to write HTML code in Servlets. In Servlets you need to have lots of println statements to create HTML. JSP pages are converted to Servlets so actually can do the same thing as old Java Servlets. JSP architecture JSP are built by SUN Microsystem servlet technology. JSP tag contain Java code and its file extension is.jsp The JSP engine parses the.jsp and create a Java servlet source file. Then it compile the source file into a class file,this is done first time only therefore JSP is probably slower when first time it is accessed.after this compiled servlet is executed and is therefore return faster. 2

3 Steps for JSP request: When the user goes to a JSP page web browser makes the request via internet. JSP request gets sent to the Web server. Web server recognises the.jsp file and passes the JSP file to the JSP Servlet Engine. If the JSP file has been called the first time,the JSP file is parsed,otherwise Servlet is instantiated. The next step is to generate a special Servlet from the JSP file. All the HTML required is converted to println statements. The Servlet source code is compiled into a class. The Servlet is instantiated,calling the init and service methods. HTML from the Servlet output is sent via the Internet. HTML results are displayed on the user's web browser 3

4 JSP environment To Set JSP environment For setting the JSP environment you should have a JDK(Java Development Kit). Setting up the JSP Download the latest JDK from the following URL: Install through the setup. One of the main problems of new Java developers have is setting the PATH and CLASSPATH. For Windows 95/98/ME you edit the AUTOEXEC.BAT file with the new PATH and CLASSPATH set the path and reboot your machine. For Windows 2000/XP you edit the environment variables. (Control Panel -> System -> Environment Variables). Read the installation instructions properly as it may change with future releases. What you do is add the location of java's bin folder to the Path variable and the classes you want in the CLASSPATH variable 4

5 To Download the JSP environment Download JSP environment from the web. The preferred option is to download the Tomcat. Tomcat is a free open source JSP and Servlet engine,developed by Apache. Instructions to download Tomcat are given below. For Tomcat setup To download Tomcat (current version 5.),go to the following URL: Unzip the file into a directory and set an environment variable TOMCAT_HOME to your main Tomcat directory: For example, set TOMCAT_HOME=c:\tomcat To start the server change to the tomcat\bin directory and type: startup Open a web browser and in the address box type: - this displays the example page. 5

6 Place any new JSP files in the "webapps" directory under your installed Tomcat directory. For example,to run "first.jsp" file,copy the file into the "webapps/root" directory and then open a browser to the address: This will show you the executed JSP file. First JSP JSP simply place Java inside the HTML pages You can change HTML page extension to ".jsp" instead of ".html"extension. How to create simple JSP page <html> <head> <title>my first JSP page </title> </head> <body> <%@ page language="java" %> <% out.println("hello World"); %> </body> </html> Type the above code into a text file. Name the file helloworld.jsp. Place it in correct directory on your JSP web server and call it via your browser. Notice that when page reload in the browser, it comes up with the current time. The character sequence <%= and %> enclose Java expression, which are evaluated at run time. Scriptlets JSP allow you to write block of Java code inside the JSP You do this by placing your Java code between <% and %> character (just like expressions, but without the = sign at the start of the sequence.) This block of code is known as a "scriptlet". By itself, a scriptlet doesn't contribute any HTML (as we will see down below.) A scriptlet contains Java code that is executed every time the JSP is invoked. Here is a modified version of our JSP, adding in a scriptlet. <HTML> <BODY> 6

7 <% // This is a scriptlet. Notice that the "date" // variable we declare here is available in the // embedded expression later on. System.out.println( "Evaluating date now" ); java.util.date date = new java.util.date(); %> Hello! The time is now <%= date %> </BODY> </HTML> When above example execute, you will notice the output from the "System.out.println" on the server log. This is a convenient way to do simple debugging. By itself a scriptlet does not generate HTML. If a scriptlet want to generate HTML, it can use a variable called "out". This variable does not need to be declared. It is already predefined for scriptlet, along with some other variables. The following example shows how the scriptlet can generate HTML output. <HTML> <BODY> <% // This scriptlet declares and initializes "date" System.out.println( "Evaluating date now" ); java.util.date date = new java.util.date(); %> Hello! The time is now <% // This scriptlet generates HTML output out.println( String.valueOf( date )); %> </BODY> </HTML> Here we generate HTML directly by printing to the "out" variable. 7

8 Request & Response Keyword A "request" is a server-side processing which refers to the transaction between a browser and the server. When someone enters a URL, the browser sends a "request" to the server for that URL, and shows returned data. As a part of this "request", various data is available, including the file the browser wants from the server, and if the request is coming from pressing a SUBMIT button, the information the user has entered in the form fields. The JSP "request" variable is used to obtain information from the request as sent by the browser. For instance, you can find out the name of the client's host (if available, otherwise the IP address will be returned.) Let us modify the code as shown: <HTML> <BODY> <% // This scriptlet declares and initializes "date" System.out.println( "Evaluating date now" ); java.util.date date = new java.util.date(); %> Hello! The time is now <% out.println( date ); out.println( "<BR>Your machine's address is " ); out.println( request.getremotehost()); %> </BODY> </HTML> A similar variable is "response". This can be used to affect the response being sent to the browser. For instance, you can call response.sendredirect( anotherurl ); to send a response to the browser that it should load a different URL. This response will actualy goes all the way to the browser. The browser will then send a different request, to "anotherurl". Using JSP tags Declaration tag Expression tag Directive tag Scriptlet tag 8

9 Action tag Declaration tag Declaration tag ( <%! %> ) It allows the developer to declare variables or methods. Start with <%! and End with %> Code placed inside this tag must end in a semicolon ( ; ). Declarations do not generate output so are used with JSP expressions or scriptlets. For Example, <%! private int counter = 0 ; private String get Account ( int accountno) ; %> Expression tag Expression tag ( <%= %>) Expression tag allow the developer to embed any Java expression and is short for out.println(). A semicolon ( ; ) does not appear at the end of the code inside the tag. e.g.to show the current date and time. Date : <%= new java.util.date() %> Directive tag Direcitve tag ( <%@ directive...>) A JSP directive gives special information about the page to JSP Engine. Three main types of directives are: 1) page - processing information for this page. 2) Include - files to be included. 3) Tag library - tag library to be used in this page. 9

10 Directives do not produce any visible output when the page is requested but change the way the JSP Engine processes the page. e.g.,you can make session data unavailable to a page by setting a page directive (session) to false. 1.Page Directive This directive has 11 optional attributes that provide the JSP Engine with special processing information. The 11 different attributes with a brief description is decribe in table given below: Language Extends import session buffer autoflush isthreadsafe info Which language the file uses. Superclass used by the JSP engine for the translated Servlet. Import all the classes in a java package into the current JSP page. This allows the JSP page to use other java classes. oes the page make use of sessions. By default all JSP pages have session data available. There are performance benefits to switching session to false. Controls the use of buffered output for a JSP page. Default is 8kb Flush output buffer when full. Can the generated Servlet deal with multiple requests? If true a new thread is started so requests are handled simultaneously. Developer uses info attribute to add information/document for a page. Typically used to add author,version,copyright and date info. <%@ page language = "java" %> <%@ page extends = "com.taglib... %> <%@ page import = "java.util.*" %> Default is set to true. <%@ page buffer = "none" %> <%@ page autoflush = "true" %> <%@ page info = "visualbuilder.com test page,copyright " %> errorpage Different page to deal with errors. Must be URL to error page. <%@ page errorpage = "/error/error.jsp" %> IsErrorPage This flag is set to true to make a JSP page a special Error Page. This page has access to the implicit object exception (see later). 10

11 contenttype Set the mime type and character set of the JSP. 2. Include directive It allows a JSP developer to include contents of a file inside another. Typically include files are used for navigation,headers,tables and footers that are common to multiple pages. Two examples of using include files: This includes the html from privacy.html found in the include directory into the current jsp page. <%@ include file = "include/privacy.html" %> or to include a naviagation menu (jsp file) found in the current directory <%@ include file = "navigation.jsp" %> 3. Tag Lib directive A tag lib is a collection of custom tag that can be used by the page <%@ taglib uri = "tag library URI" prefix = "tag Prefix" %> Custom tag were introduced in JSP 1.1 and allow JSP developer to hide complex server side code from web designers Scriptlet tag Scriptlet tag ( <%... %> ) Between <% and %> tags,any valid Java code is called a Scriptlet. This code can access any variable or bean declared. For example,to print a variable. <% String username = "visualbuilder" ; out.println ( username ) ; %> Action tag There are three main roles of action tag : 1) It enable the use of server side Javabeans 11

12 2) It transfer control between pages 3) Browser independent support for applets. Javabeans A Javabeans is a special type of class that has a number of methods. The JSP page can call these method so can leave most of the code in these Javabeans. For example,if you wanted to make a feedback form that automatically sent out an . By having a JSP page with a form,when the visitor presses the submit button this send the details to a Javabean that sends out the . This way there would be no code in the JSP page dealing with sending s (JavaMail API) and your Javabeans could be used in another page(promotingreuse). To use a Javabeans in a JSP page use the following syntax: <jsp : usebean id = "..." scope = "application" class = "com..." /> The following is a list of Javabean scopes: page - valid until page completes. request - bean instance lasts for the client request session - bean lasts for the client session. application - bean instance created and lasts until application ends. Creating your second JSP page JSP Sessions Creating your second JSP page The different tags which we have learnt are using here. This example will declare two variables; one string used to stored the name of a website and an integer called counter that displays the number of times the page has been accessed. There is also a private method declared to increment the counter. The website name and counter value are displayed. <HTML> <HEAD> <!-- Example2 --> <TITLE> JSP loop</title> </HEAD> <BODY> 12

13 <font face=verdana color=darkblue> JSP loop <BR> <BR> <%! public String writethis(int x) { String mytext=""; for (int i = 1; i < x; i ) mytext = mytext "<font size=" i " color=darkred face=verdana>visualbuilder JSP Tutorial</font><br>" ; return mytext; } %> This is a loop example from the <br> <%= writethis(8) %> </font> </BODY> </HTML> JSP Sessions On any typical web site, a visitor might visit several pages and perform several interactions. If you are programming the site, it is very helpful to be able to associate some data with each visitor. For this purpose, "session"s can be used in JSP. A session is an object associated with a visitor. Data can be put in the session and retrieved from it, much like a Hashtable. A different set of data is kept for each visitor to the site. Here is a set of pages that put a user's name in the session, and display it elsewhere. Try out installing and using these. First we have a form, let us call it GetName.html <HTML> <BODY> <FORM METHOD=POST ACTION="SaveName.jsp"> What's your name? <INPUT TYPE=TEXT NAME=username SIZE=20> 13

14 <P><INPUT TYPE=SUBMIT> </FORM> </BODY> </HTML> The target of the form is "SaveName.jsp", which saves the user's name in the session. Note the variable "session". This is another variable that is normally made available in JSPs, just like out and request variables. (In directive, you can indicate that you do not need sessions, in which case the "session" variable will not be made available.) <% String name = request.getparameter( "username" ); session.setattribute( "thename", name ); %> <HTML> <BODY> <A HREF="NextPage.jsp">Continue</A> </BODY> </HTML> The SaveName.jsp saves the user's name in the session, and puts a link to another page, NextPage.jsp. NextPage.jsp shows how to retrieve the saved name. <HTML> <BODY> Hello, <%= session.getattribute( "thename" ) %> </BODY> </HTML> If you bring up two different browsers (not different windows of the same browser), or run two browsers from two different machines, you can put one name in one browser and another name in another browser, and both names will be kept track of. 14

15 The session is kept around until a timeout period. Then it is assumed the user is no longer visiting the site, and the session is discarded. Implicit Objects Implicit objects are a set of Java objects that the JSP Container makes available to developers in each page. These objects may be accessed as built-in variables via scripting elements and can also be accessed programmatically by JavaBeans and Servlets. Overview Implicit objects will be automatically instantiated under specific variable names. Furthermore,each object must adhere to a specific Java class or interface definition. We have already met one of these objects already - the out object in which we used the println() method to add text to the output stream. Object Class or Interface Description page jsp.httpjsppage Page's servlet instance config ServletConfig Servlet configuration information pagecontext jsp.pagecontext Provides access to all the namespaces associated with a JSP page and access to several page attributes request response http.httpservletrequest Data included with the HTTP Request http.httpservletresponse HTTP Response data, e.g. cookies out jsp.jspwriter Output stream for page context session http.httpsession User specific session data application ServletContext Data shared by all application pages 15

16 The first three are rarely used. The application, session and request implicit objects have the additional ability to hold arbitrary values. By setting and getting attribute values these objects are able to share information between several JSP pages. JSP Create Form Beans and Form processing Forms are a very common method of interactions in web sites. JSP makes easy forms processing. To Create Form Here we show how to create and process an html form. Code below you save as a file name myform.jsp Go to myform.jsp in your browser and open it. It won't do anything yet. <html> <head> <!-- Example4 --> <title>visualbuilder.com</title> </head> <body> <form action="myformconfirm.jsp" method="post"> Enter in a website name:<br> <input type="text" name="website"><br> <input type="submit" name="submit"> </form> </body> </html> Processing a Form Code written here which process the html form your just created. Copy the code below and place in a file named: myformconfirm.jsp Go to myform.jsp Fill in some details and submit the form You should see the results of your submission <html> <head> <!-- Example4 --> 16

17 <title>visualbuilder.com</title> </head> <body> <font size=3> Your info has been received: <br><br> <% String sname = request.getparameter("website"); out.print(sname); %> </font> </body> </html> Beans and Form Processing The standard way of handling JSP forms is to define a "bean". This is not a full Java bean. You just need to define a class that has a field corresponding to each field in the form. The class fields must have "setters" that match the names of the form fields. For instance, let us modify GetName.html to also collect address and age. The new version of GetName.html is <HTML> <BODY> <FORM METHOD=POST ACTION="SaveName.jsp"> What's your name? <INPUT TYPE=TEXT NAME=username SIZE=20><BR> What's your address? <INPUT TYPE=TEXT NAME= SIZE=20><BR> What's your age? <INPUT TYPE=TEXT NAME=age SIZE=4> <P><INPUT TYPE=SUBMIT> </FORM> </BODY> </HTML> To collect data, we define a Java class with fields "username", " " and "age" and we provide setter methods "setusername", "set " and "setage", as shown. A "setter" method is a method that 17

18 starts with "set" followed by the name of the field. The first character of the field name is upper-cased. So if the field is " ", its "setter" method will be "set ". Getter methods are defined similarly, with "get" instead of "set". Note that the setters & getters method must be public. package user; public class UserData { String username; String ; int age; public void setusername( String value ) { username = value; } public void set ( String value ) { = value; } public void setage( int value ) { age = value; } public String getusername() { return username; } public String get () { return ; } public int getage() { return age; } } The method names must be exactly as shown below. Once you have defined the class, compile it and make sure it is available in the web-server's classpath. The server may also define special folders where you can place bean classes, e.g. with Blazix you can place them in the "classes" folder. If you have to change the classpath, the web-server would need to be stopped and restarted if it is already running. Note that we are using the package name user, therefore the file UserData.class must be placed in a folder named user under the classpath entry. Now let us change "SaveName.jsp" to use a bean to collect the data. <jsp:usebean id="user" class="user.userdata" scope="session"/> <jsp:setproperty name="user" property="*"/> 18

19 <HTML> <BODY> <A HREF="NextPage.jsp">Continue</A> </BODY> </HTML> Now we have to add the jsp:usebean tag and the jsp:setproperty tag! The usebean tag will look for an instance of the "user.userdata" in the session. If the instance is already there, it will update the old instance. Otherwise,it will create a new instance of user.userdata (the instance of the user.userdata is called a bean), and put it in the session. The setproperty tag will automatically collect the input data, match names against the bean method names, and place the data in the bean! Let us modify NextPage.jsp to retrieve the data from bean.. <jsp:usebean id="user" class="user.userdata" scope="session"/> <HTML> <BODY> You entered<br> Name: <%= user.getusername() %><BR> <%= user.get () %><BR> Age: <%= user.getage() %><BR> </BODY> </HTML> Notice that the same usebean tags is repeated. The bean is available as the variable named "user" of class "user.userdata". The data entered by the user is all collected in the bean. We do not actually need the "SaveName.jsp", the target of GetName.html could have been NextPage.jsp, and the data would still be available the same way as long as we added a jsp:setproperty tag. But in the next tutorial, we will actually use SaveName.jsp as an error handler that automatically forwards the request to NextPage.jsp, or asks the user to correct the erroneous data. JSP Summary In our tutorial with JSP we've gotten an idea of what JSP is good for, and how it's used. We've seen that JSP gives us the power of Java on the Web server, which is an incomparable asset. 19

20 We have also taken a look at where JSP came from, and how it developed. We've seen that as the Web has evolved, Java has been a part of the picture first with applets, then servlets, and now JSP. Applets were nice, but limited; servlets are very powerful but complex. JSP gives us the best of both worlds: They're both very powerful (they're converted to servlets before they're run) and easy to write. You've also installed the Tomcat server and gotten it running, and built the development environment (Java, Tomcat, browser, and an editor) you'll be using in the coming days. We've also developed and run our first JSP. Instead of having to write everything in Java, we were able to simply insert the Java we wanted into an HTML page. That's the whole genius of JSP you use an HTML backbone and just add the Java you need. As we've also seen, JSP offers a whole set of built-in objects, which means we can get away with even less Java because we don't have to create those objects ourselves. We also took a look at the JSP syntax in overview here some of which might not have made a great deal of sense yet. (But don't worry, that's why this is Day 1 it's all coming up in depth in the next days.) And that's it we've started our in-depth guided tour of JSP, and built the foundation we'll need in the coming days. Tomorrow, you'll see more details, such as how to work with data and operators in JSP, and you'll start writing some real code. 20