JSP

JSP(Java Server Page)

1.jsp与servlet的关系

JSP简单的说就是HTML+JAVA代码，文件后缀为.jsp的文件。

servlet：servlet可以被认为是服务器端的applet。servlet被Web服务器加载和执行，就如同applet被浏览器加载和执行一样。servlet从客户端(通过Web服务器)接收请求，执行某种作业，然后返回结果。

JSP和Servlet是JavaEE的重要基础，看起来JSP和Servlet是两个完全不同的东西，但是JSP其实就是Servlet的一种形式，JSP最终需要被编译成Servlet;

JSP页面必须部署到web容器中才能够访问，因为单单的JSP页面时没有用处的;必须要转换成Servlet才能够使用;

JSP是面向对象的,因为最后会变成Servlet,而Servlet是一个类

而用户访问JSP页面看到的输出，是Servlet输出流的结果;

JSP可以不处理异常，因为如果产生异常有两种处理方法：

1.在浏览器页面显示;

2.跳转到errorPage;

当第一次访问某个JSP文件时，web服务器会将JSP文件转换成Servlet,再由Servlet提供输出流将HTML输出给客户.因此客户接触的只是HTML而已，而JSP的处理过程都是在服务器完成的;

注意：每个Servlet类的对象在容器中只有一个，因此每个客户访问的同一个JSP页面都是一个Servlet对象;

假设有null.jsp文件,此文件内容为空，如下所示：

View Code

    <%@ page contentType="text/html;charset=utf-8" pageEncoding="utf-8" info="This is a JSP " %>  
    <html>  
        <body>  
        </body>  
    </html>

tomcat的\work\Catalina\localhost\项目名\org\apache\jsp会生成null_jsp.java和null_jsp.class，null_jsp.java的代码如下：

View Code

    package org.apache.jsp;  
      
    import javax.servlet.*;  
    import javax.servlet.http.*;  
    import javax.servlet.jsp.*;  
      
      
    //HttpJspBase是Servlet的子类  
    /* 
    此类主要有三个方法组成： 
    1.init();   初始化 
    2.destroy(): 销毁 
    3.service();  接收客户端请求并处理 
    */  
      
      
    public final class null_jsp extends org.apache.jasper.runtime.HttpJspBase  
        implements org.apache.jasper.runtime.JspSourceDependent {  
      
      public String getServletInfo() {  
        return "This is a JSP ";  
      }  
      
      private static final JspFactory _jspxFactory = JspFactory.getDefaultFactory();  
      
      private static java.util.List<String> _jspx_dependants;  
      
      private javax.el.ExpressionFactory _el_expressionfactory;  
      private org.apache.tomcat.InstanceManager _jsp_instancemanager;  
      
      public java.util.List<String> getDependants() {  
        return _jspx_dependants;  
      }  
      
      public void _jspInit() {  
        _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();  
        _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());  
      }  
      
      public void _jspDestroy() {  
      }  
      
      public void _jspService(final HttpServletRequest request, final HttpServletResponse response)  
            throws java.io.IOException, ServletException {  
    //生成JSP内置对象  
        final PageContext pageContext;  
        HttpSession session = null;  
        final ServletContext application;  
        final ServletConfig config;  
        JspWriter out = null;  
        final Object page = this;  
        JspWriter _jspx_out = null;  
        PageContext _jspx_page_context = null;  
      
      
        try {  
          response.setContentType("text/html;charset=utf-8");  
          pageContext = _jspxFactory.getPageContext(this, request, response,  
                    null, true, 8192, true);  
          _jspx_page_context = pageContext;  
          application = pageContext.getServletContext();  
          config = pageContext.getServletConfig();  
          session = pageContext.getSession();  
          out = pageContext.getOut();  
          _jspx_out = out;  
    //输出JSP页面中的显示  
          out.write("\r\n");  
          out.write("<html>\r\n");  
          out.write("\t<body>\r\n");  
          out.write("\r\n");  
          out.write("\t</body>\r\n");  
          out.write("</html>");  
        } catch (Throwable t) {  
          if (!(t instanceof SkipPageException)){  
            out = _jspx_out;  
            if (out != null && out.getBufferSize() != 0)  
              try { out.clearBuffer(); } catch (java.io.IOException e) {}  
            if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);  
          }  
        } finally {  
          _jspxFactory.releasePageContext(_jspx_page_context);  
        }  
      }  
    }

从以上代码就可以很清晰地看出JSP和Servlet的关系了,JSP编写的<%%> <%=%> 和 html代码都是在_jspService函数中实现;

而<%! %>中的代码作为Servlet类的成员变量和成员方法;

JSP内置对象就是在这个文件中被创建的。

2.注释：

一种语言都会有注释，而这里JSP有两种类型的注释，用户能够查看网页源代码，看见显式注释，而看不见隐式注释。

(1)显式注释： （注释html代码的）
(2)隐式注释：//隐式注释 /*隐式注释*/ (注释java代码的 ) <%--隐式注释 --%>（注释jstl标签用的）

3.编译指令

编译指令模板：<%@ 指令 %>

1.page指令

page指令放在jsp文件的最上方，描述一些信息，以<%@ page 属性="值"%>的形式出现;

属性能够有：

(1)contentType：网页的内容类型，即MIME类型，通常为 contentType="text/html";里面还能设定字符集，经常为 contentType="text/html;charset=GBK";

(2)language：表示脚本所用语言，目前只能为 language="java";

(3)pageEncoding：表示页面的编码方式，通常为 pageEncoding="GBK";

2.include指令

<%@ include file="filename"%>

这是静态包含，即将被包含的文件融入成为一个文件，也就是将你的index.jsp中所有代码原封不动的放到xx.jsp中这条语句所在的位置，和你直接将上面这段代码写到xx.jsp中是一样的效果；

因此从tomcat生成的java文件中可以看出。

<jsp:include page="filename"/>

而动态包含则是调用了include函数将一个文件包含进来，而不是融为一体；

举例：有a.jsp、b.jsp、c.jsp，在a.jsp中动态包含b.jsp、c.jsp意味着编译生成class文件，然后再包含在一起。

动态包含还能够传递参数，注意，是包含页面--->被包含页面，即包含界面的参数传给被包含界面，a界面的参数传给b,c界面形如：

<jsp:include page = "demo.jsp"/>

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

<jsp:param name="age" value="20"/>

</jsp:include>

被包含页通过request.getParameter()接收。

4、客户端跳转和服务器跳转：

Sendredirect（重定向）	Forward（转发）
是不同的request	虽然是不同的对象，但是，可以取到上一个页面的内容
send后的语句会继续执行，除非return	forward后的语句不会继续发送给客户端
速度慢	速度快
需要到客户端的往返，可以转到任何页面，	服务器内部转换，
地址栏有变化，客户端在变化	地址栏没有变化,是服务器内部在变
可以传参数，直接写在url后面	可以传参数
/代表的是http://127.0.0.1/ <%response.sendRedirect("/test/ServletToJSP");%> <form action="/test/ServletToJSP"> <a href="/test/ServletToJSP">test</a>	/代表的是http://127.0.0.1/test this.getServletContext().getRequestDispatcher ("/servlet_jsp/ServletUseJsp.jsp") .forward(req, resp); 并且只能以/开头
常用	常用

list可包含相同数据（遍历集合内元素时使用）
ArrayList 可变大小，随机访问和遍历元素时效率高
LinkedList 添加头条新闻标题，删除末条新闻标题
set不可包含相同数据时使用
Map通过某一个值查找另一个值时使用

jsp内置对象
   out
   request
   response
   session
   application

5.JSP生命周期

1.web容器读取web.xml中的配置信息；

2.当客户发出jsp请求时，JSP翻译成Servlet，并编译成class文件；

3.容器加载Servlet；

4.容器实例化Servlet，并调用jspInit()方法；

5.容器创建Servlet线程，调用Service方法；

6.调用destroy()；

http://blog.csdn.net/xiazdong/article/details/6845857

posted on 2011-11-29 21:41 lovebeauty 阅读(968) 评论(0) 编辑收藏举报

刷新页面返回顶部

lovebeauty

JSP