jsp

JSP

JSP：java server pages,根本是一个简化的servlet设计，实现了在java当中使用HTML标签，是一种动态网页技术，和servlet一样是在服务器端执行的。

Jsp页面：以.jsp结尾的文件。允许在HTML代码中嵌入java代码来完成功能。

HTML：静态页面，写好后，页面结构几乎不能再更改了，采用一些方法也可以让页面有一些变化，动作，但是一刷新，页面又回到了原来的状态。

JSP：动态网页，页面的数据与结构以及状态，都可以借助java 代码去控制，比如创建对象，获取对象，调用方法，连接数据库等等，可以让网页根据实际情况与逻辑显示不同的效果。

Jsp中能写的内容包括HTML标签，css,javascript,java代码，EL表达式，引入并使用其他标签库，例如jutl标签库，Struts2标签库等。

浏览器可以直接运行html页面,但是不能直接运行jsp页面。jsp是运行在服务器端的,运行完之后,把动态生成的html页面再使用io流写回给浏览器,浏览器接收并且解析后再呈现出来效果。

一个jsp页面就是一个servlet，jsp页面第一次被访问的时候,会被tomcat服务器翻译成一个java类,这个java默认继承HttpJspBase类,而HttpJspBase类是HttpServlet的子类。

jsp页面被tomcat服务器编译成的java文件及其class文件保存在tomcat服务器里面的work目录中。

HttpJspBase:

 init(){ GenericServlet/重写

  super.init(servletConfig)

  重载1 jspInit(){}      //JspPage

  自定义重载2 _jspInit(){}

 }

 destroy() { GenericServlet/重写

     重载1 jspDestroy(); //JspPage

     自定义重载2 _jspDestroy();

    }

[service(ServletRequest)  HttpServlet继承]

service(HttpServletReq){ HttpServlet/重写

  _jspService(request, response);//                    HttpJspPage

    }

 

_jspService(){ 抽象方法;jsp继承后实现}

自定义JSP--tomcat服务器(servlet/jsp容器/引擎) 翻译--自定义JSP_jsp.java--自定义JSP_jsp.class

Servlet请求，执行对应的初始化，运行

自定义JSP_jsp.java extends HttpJspBase{

  public void _jspInit() { //空实现 }

 //重写初始化方法:jspInit(){}

  public void _jspDestroy() {

    //空实现

  }

  //重写销毁方法:jspDestroy()

  _jspService(  request, response){

  //实现

  把jsp页面中写的所有html标签内容，全部使用输出流输出

  }

}

继承结构:

JSP

|翻译

 JSP_jsp.java(_jspService,_jspInit,_jspDestory)

    |编译

 JSP_jsp.class

  |继承

 HttpJspBase(org.apache.jasper.runtime.)

 init(){super.init(); jspInit() _jspInit}

 destory(){ jspDestory() _jspDestory }

 service(){ _jspService()}

 _jspService: 抽象方法

   |继承               |实现

 HttpServlet                         HttpJspPage(_jspService)

   |继承               |继承

 GenericServlet                    JspPage(jspInit,jspDes)

   |实现               |继承

  Servlet                                             Servlet

4.jsp的生命周期

4.1 编译阶段：hello.jsp--->hello_jsp.java--->hello_jsp.class

4.2 初始化阶段:调用这个servlet对象中的init方法进行初始化

如果我们想给jsp进行自定义的初始化内容,只要在【jsp声明】<%!  %>中重写jspInit()方法。

4.3 执行阶段

客户端访问jsp页面的时候,服务器会调用其对应的servlet对象中的一个指定方法_jspService(request,response)就是在这个_jspService(request,response)方法中使用io流,把动态生成的html一行一行写给了浏览器.

注:本来是调用servlet对象中的service方法的,但是在HttpJspBase中重写的service方法中又调用了这个_jspService(request,response)方法.

4.4 销毁阶段

当服务器正常关闭的时候,jsp对应的servlet对象会被销毁,并且调用servlet中的destroy方法如果我们在jsp对应的servlet对象销毁时完成一些工作时,只要在jsp声明中重写jspDestroy()方法即可。

5.jsp语法

jsp的脚本元素 (3个):<%= %>,<% %>,<%! %>

jsp的指令元素(3个): <%@page 语言，编码，引用类，错误页面... %>  include  taglib

jsp的动作元素

Javabean:类，public,private,con..,getter,setter

<jsp:useBean >

<jsp:setProperty >

<jsp:getProperty>

<jsp:include >…..

5.1 jsp的脚本元素

第一种:表达式(expression)

形式:<%= %>

例如:<%="hello" %>

<%=1+1 %>

<%=s.getName() %>

将来翻译到java文件中的位置:

_jspService方法中的out.print(..)里面的参数.

例如上面那几个例子会翻译成

out.print("hello");

out.print(1+1);

out.print(s.getName());

所以System.out.println() (本质是out.print())这个方法的参数可以写什么,那么我们这个jsp页面中表达式里面就可以写什么.

注意:在jsp中的表达式里面不需要加;号。

第二种:脚本(scriptlet)

形式:<% ... %>或者

<%

....

%>

例如:

<%

Student s = new Student();

String name = "tom";

String username = s.getName();

List<String> list = new ArrayList<String>();

list.add("hello")

%>

将来翻译到java文件中的位置:

脚本中的代码将来会被直接翻译到_jspService这个方法中.

在一个普通的方法中我们可以写什么样的代码,那么在脚本中就可以写什么样的代码.

注意:在脚本中所写的代码,代码的最后是要加上;号的.因为我们在一个方法里面所写的每一句代码后面都是要加;号。在脚本声明的变量,我们是可以在表达式里面使用的,但是要注意要先声明变量再使用变量.只要查看脚本和表达式分别翻译到java文件中的位置,就可以很清楚的认识到这一点.

第三种:声明(declaration)

形式:<%!

.....

 %>

例如:

 <%!

private String name;

public String go(){

System.out.println("hello world "+name);

return "this is go()";

}

 %>

将来翻译到java文件中的位置:直接将声明中的代码翻译到java文件里面所定义的类中。所以我们直接可以在一个类中写什么,就可以在声明中写什么.(一般在声明中会去定义一些类中的成员变量或者方法)

注意:这里面的代码,定义变量的时候要加;号,定义方法的时候不用加;号,这是和我们写一个java类语法是一样的。

5.2 jsp的指令元素

jsp的指令是给jsp引擎看的,让jsp引擎在翻译jsp页面成java文件的时候,知道需要注意哪些地方的设置.比如页面中的编码、页面中脚本里面所用的编程语言、翻译的java文件中需要引入哪些其他包下的java类等等。

语法: <%@指令名字  属性="值" ..  %>

指令名字包含page include taglib三种

1）page指令:

//表示当前页面中的编程语言是java,目前这个属性值只能写java

language="java"

//在当前页面中要引入哪些包下的类.若有多个包要引入，可以写在一个import中，包名之间用,隔开。

import="java.util.HashMap"

import="java.util.HashMap,java.sql.Connection"

import="java.util.HashMap" import="java.util.Connection"

//设置jsp页面文件保存时候文件本身所用的编码

pageEncoding="UTF-8"

//设置服务器发送给客户端时的内容编码，即使用io把jsp页面内容一行一行的输出给浏览器的时候,使用什么编码向浏览器输出。

contentType="text/html; charset=UTF-8"

//设置jsp页面被翻译成java文件的时候,java文件中的类要继承那个父类.这个属性不用设置,jsp引擎会给它一个默认的父类去继承的（HttpServlet）.

extends=""

//如果a.jsp页面中设置了errorPage="b.jsp",那么a.jsp页面在运行的时候一旦出错,就会自动跳转到b.jsp里面.  /

errorPage=""

//如果一个页面中设置了isErrorPage="true",那么就表示这个页面是用来专门显示错误信息的页面.然后在这个页面中才能够使用到隐藏对象exception来显示出错误的信息.(需要使用jsp的内置对象)

isErrorPage="true"

2）include指令:

<%@include file="" %>

作用:在当前页面中使用include指令可以把另外一个页面的内容引入到当前页面。这儿使用“/”代表项目名下，主页面中的样式也都可以应用上。

一个页面包含/引入另外一个页面有俩种方式:静态包含 动态包含。

这个include指令就属于静态包含

静态包含特点:例如a.jsp页面中静态包含了b.jsp页面,那么在翻译期间,jsp引擎在翻译a.jsp成为一个a_jsp.java文件的时候,发现jsp页面中有include指令,这时候jsp引擎就会把被包含的页面b.jsp中内容原封不动的拿到a_jsp.java的jspService方法中相应位置,然后用io输出出去.

3）taglib指令:

作用:在当前jsp页面中引入一些特殊的标签库.比如jstl标签库、struts2标签库等等.

5.3 jsp的动作元素。

可以把java代码进行封装，为请求处理阶段提供信息，提高代码可读性。

1）javabean：javaBeans就是符合某种特定的规范的java类，是使用Java语言开发的一个可重用的组件，在JSP的开发中可以使用JavaBean减少重复代码，减少代码冗余，功能区分明确，提高了代码的可维护性。

javabean的设计原则：JavaBean本身就是一个类，属于Java的面向对象编程，只是需要满足以下特点:

1.1.类是公有类，即public

1.2.类中的属性（attribute）是私有的，即private(name)

1.3类中有无参的构造器

1.4类中的属性有符合规范的公有的访问入口（property），即getXxx，setXxx方法。(getName)

1.javaBean的存取.

<jsp:useBean id="s" class="com.briup.bean.Student"  scope="page"></jsp:useBean>

相当于使用代码初始化一个javabean实例:

<%

Student s = null;

s = (Student)pageContext.getAttribute("s");

if(s==null){

s = new Student();

pageContext.setAttribute("s",s);

}

   %>

2.给已经实例化的javaBean对象的属性赋值，一共有四种形式

2.1根据表单赋值全部匹配属性

<jsp:setProperty name="javaBean实例名" property="*"/>

2.2根据表单赋值property中填写的属性

<jsp:setProperty name="javaBean实例名" property="javaBean属性名"/>

2.3根据request中的参数设置

<jsp:setProperty name="javaBean实例名"  property="javaBean属性名" param="request中的参数名"/>

request的parameter中的值都可设置

2.4手动设置值

<jsp:setProperty name="s" property="name" value="tom" />

相当于代码:

<%

Student s = (Student)pageContext.getAttribute("s");

s.setName("tom");

%>

3.获取并输出javabean的属性值

<jsp:getProperty property="name" name="s"/>

相当于代码:

   <%

Student s = (Student)pageContext.getAttribute("s");

out.write(s.getName());

   %>    

2）页面跳转

<jsp:forward page="url"></jsp:forward>等同于request.getRequestDispaycher("url").forward(request,response)

 //跳转的同时还可以传参数

   <jsp:forward page="target.jsp?name=tom"></jsp:forward>

   或者

   <jsp:forward page="target.jsp">

   <jsp:param value="tom" name="name"/>

      </jsp:forward>

 参数传递到请求范围中，可以使用getParameter方法取值，若要设置编码，需要  在<jsp:forward>标签之前调用request.setCharacterEncoding("");

 3）这个动作元素专门是传参数使用的，通常与forward配合使用

   <jsp:param value="tom" name="name"/>

4）动态包含

   <jsp:include page="foot.jsp">

<jsp:param value="lisi" name="name"/>

   </jsp:include>

   注意不能使用url?name=tom这种方式传

动态包含特点:在把jsp文件翻译成java文件的期间,动态包含并不会去把被包含的页面原封不动的拿过来,而是会把动态包含这个标签翻译成一个方法的调用,将来运行页面调用到这个方法的时候才会去拿被包含页面的内容.同时还可以给动态包含的页面传参数.静态包含是不能传参数的。

include指令与jsp:include动作的区别:

语法格式：<%@ include %>           <jsp:include page="">   

发生时间：页面转换期间                请求期间

包含的内容：文件的实际内容           页面的输出

转换servlet：一个文件                  两个文件

编译时间：较慢，需要解析资源            较快

执行时间：较快                     较慢-每次必须调用

5）使用jsp的动作元素向浏览器输出一个标签

<jsp:element name="font">

<jsp:attribute name="color">blue</jsp:attribute>

<jsp:body>hello world</jsp:body>

</jsp:element>

这个效果相当于在页面代码中直接写上

<font color="blue">hello world</font>

或者:

<%

out.println("<font color='blue'>hello world</font>");

%>

一.jsp页面中的注释 comment

第一种:<!-- html/xml中的注释方式 -->

特点:1.用户在浏览器中右键查看源代码 [能] 看到这个注释。

2.在服务器端,这个jsp页面被翻译成的java文件中 [能] 看到这个注释.

第二种:<%--

       jsp中的注释方式(隐藏注释)

      --%>

特点:1.用户在浏览器中右键查看源代码 [不能] 看到这个注释。

2.在服务器端,这个jsp页面被翻译成的java中 [不能] 看到这个注释.

第三种:java中的注释方式,但是这种注释方式只能在jsp的脚本或者声明中使用。

//String name = "tom";

/*

int b = 40;

*/

 /**

int a = 20;

*/

特点:1.用户在浏览器中右键查看源代码 [不能] 看到这个注释。

2.在服务器端,这个jsp页面被翻译成的java中 [能] 看到这个注释.

二. 在jsp页面代码中可以直接使用的对象（九大内置对象）

只有在_jspService()方法中才能使用(因为他们都是在_jspService这个方法中默认声明出来的)。所以可以在jsp脚本和jsp表达式中使用

<%  脚本 %>       <%= 表达式 %>

一共有9个内置对象可以直接使用.

   类型                       名字

PageContext                 pageContext

HttpServletRequest             request

HttpSession               session

ServletContext                 application

Object                   page

HttpServletResponse            response

JspWriter                    out

ServletConfig                   config

Throwable                    exception（需要声明isErrorPage）

2.1page不是页面范围对象,它是Object类型的对象,表示当前这个页面本身.page指的是jsp页面翻译成的java类,服务器使用这个java类所创建的对象，即page对象代表jsp页面本身.

response 重定向

out 用于向浏览器输出内容的输出流.

config     

exception，这个对象其实我们并不能直接使用,需要相关设置后才能使用,可以算是一个隐藏对象.这个对象表示将来jsp页面运行出错的时候所抛出的异常对象。

2.2在jsp中可以动态获得项目的url。

JSTL标签库：JSP Standard Tag Library(JSTL)

把JSTL标签库（核心标签库）导入到某一个jsp页面中，使用jsp中的taglib指令:

%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

prefix="c"相当于给这个标签库起一个别名,将来在页面中就是用以c开头的标签来使用标签库中的标签。这个别名也可以叫其他的名字。

1）.迭代:<c:forEach>标签

begin=""默认值是0  end =""默认值是最后一个元素,一般的遍历只要写var和items来个属性即可。

名字     类型       描述

var       String      迭代参数的名字

items  任何支持的类型 将要迭代itmes的集合/数组

varStatus    String    迭代的状态，可以访问迭代的自身信息

items=""属性值是要遍历的集合

var=""  属性值是每次遍历到的对象用什么名字的变量去接收。

2）<c:out>标签:向页面输出内容,就像<%= ... >

<c:out value="hello"></c:out>

   <c:out value="${5+5}"></c:out>

3）<c:set>标签:向某一个范围对象中存放一个值。

<c:set var="name" value="zhangsan" scope="request"></c:set>

4）<c:remove>标签:从某个范围对象中把某个值给移除掉.

<c:remove var="name" scope="request"/>

5）<c:if>标签:条件判断

6）<c:catch>标签:处理产生错误的异常状况，并且将错误信息储存起来。

7）<c:redirect>标签重定向

8）<c:choose>标签

<c:when>标签

<c:otherwise>标签

格式化JSP页面日期显示

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>

<fmt:formatDate value="${member.startdate }" pattern="yyyy-MM-dd HH:mm:ss"/>

4.EL表达式

形式:${ }

作用:从一个范围里面取值或者从一个对象中取值并向页面输出值.