JSP技术

最新推荐文章于 2021-11-10 15:27:19 发布
最新推荐文章于 2021-11-10 15:27:19 发布
阅读量544 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/strong_yu/article/details/54943924
版权

Jsp页面就是一个Servlet，其运行在jsp容器中

Jsp的运行过程:

1.转换成Servlet类，转换有无，消息将发送到客户端

2.转换成功,运行Servlet类

这也就是为什么添加一个新的JSP页面不需要重启Tomact的原因

如果再次请求jsp页面，则会判断该jsp页面有没更改过，如果没有更改过，则会直接执行内存总存在的Servlet，否则，转换—>编译—>执行

JSP的API主要有如下:

javax.servlet.jsp                        jsp的核心类库
javax.servlet.jsp.el                   EL表达式
javax.servlet.jsp.tagex             定制标签的类库

API网址:https://tomcat.apache.org/tomcat-5.5-doc/jspapi/

转化成的servlet代码如下:

package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import java.util.*;

public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent,
                 org.apache.jasper.runtime.JspSourceImports {

  private static final javax.servlet.jsp.JspFactory _jspxFactory =
          javax.servlet.jsp.JspFactory.getDefaultFactory();

  private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;

  private static final java.util.Set<java.lang.String> _jspx_imports_packages;

  private static final java.util.Set<java.lang.String> _jspx_imports_classes;

  static {
    _jspx_imports_packages = new java.util.HashSet<>();
    _jspx_imports_packages.add("javax.servlet");
    _jspx_imports_packages.add("java.util");
    _jspx_imports_packages.add("javax.servlet.jsp");
    _jspx_imports_packages.add("javax.servlet.http");
    _jspx_imports_classes = null;
  }

  private volatile javax.el.ExpressionFactory _el_expressionfactory;
  private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;

  public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
    return _jspx_dependants;
  }

  public java.util.Set<java.lang.String> getPackageImports() {
    return _jspx_imports_packages;
  }

  public java.util.Set<java.lang.String> getClassImports() {
    return _jspx_imports_classes;
  }

  public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
    if (_el_expressionfactory == null) {
      synchronized (this) {
        if (_el_expressionfactory == null) {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
        }
      }
    }
    return _el_expressionfactory;
  }

  public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
    if (_jsp_instancemanager == null) {
      synchronized (this) {
        if (_jsp_instancemanager == null) {
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      }
    }
    return _jsp_instancemanager;
  }

  public void _jspInit() {
  }

  public void _jspDestroy() {
  }

  public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
        throws java.io.IOException, javax.servlet.ServletException {

final java.lang.String _jspx_method = request.getMethod();
if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method) && !javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {
response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSPs only permit GET POST or HEAD");
return;
}

    final javax.servlet.jsp.PageContext pageContext;
    javax.servlet.http.HttpSession session = null;
    final javax.servlet.ServletContext application;
    final javax.servlet.ServletConfig config;
    javax.servlet.jsp.JspWriter out = null;
    final java.lang.Object page = this;
    javax.servlet.jsp.JspWriter _jspx_out = null;
    javax.servlet.jsp.PageContext _jspx_page_context = null;


    try {
      response.setContentType("text/html;charset=ISO-8859-1");
      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;

      out.write('\r');
      out.write('\n');

String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";

      out.write("\r\n");
      out.write("\r\n");
      out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\r\n");
      out.write("<html>\r\n");
      out.write("  <head>\r\n");
      out.write("    <base href=\"");
      out.print(basePath);
      out.write("\">\r\n");
      out.write("    \r\n");
      out.write("    <title>My JSP 'index.jsp' starting page</title>\r\n");
      out.write("\t<meta http-equiv=\"pragma\" content=\"no-cache\">\r\n");
      out.write("\t<meta http-equiv=\"cache-control\" content=\"no-cache\">\r\n");
      out.write("\t<meta http-equiv=\"expires\" content=\"0\">    \r\n");
      out.write("\t<meta http-equiv=\"keywords\" content=\"keyword1,keyword2,keyword3\">\r\n");
      out.write("\t<meta http-equiv=\"description\" content=\"This is my page\">\r\n");
      out.write("\t<!--\r\n");
      out.write("\t<link rel=\"stylesheet\" type=\"text/css\" href=\"styles.css\">\r\n");
      out.write("\t-->\r\n");
      out.write("  </head>\r\n");
      out.write("  \r\n");
      out.write("  <body>\r\n");
      out.write("    This is my JSP page. <br>\r\n");
      out.write("  </body>\r\n");
      out.write("</html>\r\n");
    } catch (java.lang.Throwable t) {
      if (!(t instanceof javax.servlet.jsp.SkipPageException)){
        out = _jspx_out;
        if (out != null && out.getBufferSize() != 0)
          try {
            if (response.isCommitted()) {
              out.flush();
            } else {
              out.clearBuffer();
            }
          } catch (java.io.IOException e) {}
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
        else throw new ServletException(t);
      }
    } finally {
      _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}

可以看到,其主体是在_jspService方法中,而_jspService是doService调用的,也就是一个Servlet的调用。

if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method) && !javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {
response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSPs only permit GET POST or HEAD");

也可以从中看到，其请求方式只能是get和post的原因.


注释

jsp注释使用<%-- --%>,该注释不会发送到浏览器，而html/xml<!--  -->这种注释会发送到html


隐式对象



我们在jsp页面使用的request对象的都是其通过pageContext得到的


指令:

表示其将jsp页面怎么转换成servlet

page指令:

<%@ page attribute="value" ...%>

例如:添加其java类库

<%@page import="java.text.DateFormat" %>

include指令:

把另一个jsp页面中的内容放入当前页面中

<%@ include file="url" %>      该url如果以/开头,就是绝对路径，否则是相对路径，一般和当前页面在同一个文件夹下

 

脚本元素

a.scriptlet:java代码块，以<%开头，%>结束

 <% DateFormatdateFormat=DateFormat.getDateInstance(DateFormat.LONG);

       String s=dateFormat.format(new Date());

      out.println(s);

      %>

对于第一个scriptlet中定义的变量，在第二个中可以使用

b.表达式

其运算结果会被添加到out.print中,以<%开头，%>结束

<%=Calendar.getInstance().getTime()%>

注意:不需要分号

c.声明

声明在jsp页面中使用的变量和方法，使用<%!%>包起来

声明如下:

 <%! StringgetStr(){

           return "Str";

        } %>

调用:

 <%=getStr()%>

 

动作:

a.useBean

创建一个与java对象相关的脚本对象，就是创建一个java对象

例子:

<jsp:useBean id="today"class="java.util.Date"></jsp:useBean>

调用:

<%=today %>

转换成的servlet代码如下，可以看到使一个java对象变量

java.util.Date today = null;

      today =(java.util.Date) _jspx_page_context.getAttribute("today",javax.servlet.jsp.PageContext.PAGE_SCOPE);

      if (today ==null){

        today = newjava.util.Date();

       _jspx_page_context.setAttribute("today", today,javax.servlet.jsp.PageContext.PAGE_SCOPE);

      }

     out.print(today );

b.setProperty和getProperty

<!-- 先创建一个Java对象 -->

    <jsp:useBeanid="product" class="studyservlet.Product"scope="page"></jsp:useBean>

    <!-- 这个对象的这个属性设置值,property表示其那个属性，name表示其那个对象 ,value表示其设置的值 -->

    <jsp:setPropertyproperty="name" name="product" value="jsp"/>

    <!--得到这个对象的值  -->

    FormfirstName:<jsp:getProperty property="name"name="product"/>

注意:类必须有一个默认的构造器，负责会报错

c.include

<jsp:include page="includefile.jsp">
    <jsp:param value="how are you" name="text"/>
    </jsp:include>

前面学习的时候也有一个include指令，那么这两个有什么区别了

(1)include指令:在jsp转换成servlet时产生，  include动作发生在请求的时候

(2)在使用include指令时，文件资源扩展名不作要求，在使用include动作时，其扩展名必须为jsp,如果扩展名是jspf,则会当做静态文件进行处理.

 org.apache.jasper.runtime.JspRuntimeLibrary.include(request, response, "includefile.jsp" + "?" + org.apache.jasper.runtime.JspRuntimeLibrary.URLEncode("text", request.getCharacterEncoding())+ "=" + org.apache.jasper.runtime.JspRuntimeLibrary.URLEncode("how are you", request.getCharacterEncoding()), out, false);

从上面转换成的servlet也可以看到,其include是一个请求

d.forward

<jsp:forward page="includefile.jsp">
    <jsp:param value="forward" name="forward"/>
    </jsp:forward>

前面学习指令的时候，我们也学习了include，那么和include动作有什么区别了

1.include指令是发生在jsp转换成servlet的时候，而include动作是在请求的时候

2.当include是指令时，其文件的扩展名任意，但是include是动作时，其扩展名必须是jsp作为扩展名,如果扩展名是jspf，则会当做静态资源.


错误处理:

自定义异常页面

<%@ page isErrorPage="true" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
xaxaxaxasx
 <% out.println(exception.toString()); %>
</body>
</html>

其它页面捕获该异常页面 

<%@page errorPage="errorHandle.jsp" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
<%Integer.parseInt("adsa"); %>
</body>
</html>




strong_yu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Jsp技术
hyp520520的博客
10-31 2002
JSP的运行机制、JSP脚本元素、JSP指令元素、JSP动作元素、JSP九大内置对象JSP的运行机制、JSP脚本元素、JSP指令元素、JSP动作元素、JSP九大内置对象
JSP详解，看这一篇就够了（含示例）
最新发布
2301_79858914的博客
05-29 2970
动作标签为开发者提供了一种方便的方式来控制和管理 JSP 页面的行为。通过使用动作标签，可以轻松地包含其他页面、转发请求、创建 JavaBean 实例、传递参数等，从而使得页面的逻辑更加清晰、易于维护。JSP隐式对象是JSP的重要组成部分，它们提供了对请求、响应、会话、应用上下文等各种Web资源的直接访问，极大地简化了Web应用程序的开发。了解和熟练使用这些隐式对象，是掌握JSP开发的重要一步。JSP是Java Web开发的重要组成部分，适用于创建动态网页。
JaveWeb-07JSP技术
Lily
11-10 174
JSP与Servlet的异同 JSP:是运行在服务器的页面 Servlet: 是运行在服务器的java代码 (有关系)(页面的展示) (html+Java代码) 静态的网页: 前后端交互比较麻烦 动态的页面: 是可以写html标签 :但是比较麻烦，html 与java代码混合，所有说不使用servle写网页 jsp属于一个特殊的servlet index_jsp extends org.apache.jasper.runtime.HttpJspBase HttpJspBase是HttpServle
第五课 JSP技术
iseeiconquer的专栏
09-19 1034
5.1 JSP简介　　JSP（JavaServer Pages）是一种基于Java的脚本技术。在JSP 的众多优点之中，其中之一是它能将 HTML 编码从 Web 页面的业务逻辑中有效地分离出来。用 JSP 访问可重用的组件，如 Servlet、JavaBean 和基于 Java 的 Web 应用程序。JSP 还支持在 Web 页面中直接嵌入 Java 代码。可用两种方法访问 JSP 文件：浏览器
JSP技术大全
09-02
很全的jsp技术介绍，全都在这。看了不后悔。
JSP技术介绍
09-03
关于学习JSP技术的一些介绍入门，关于学习JSP技术的一些介绍入门关于学习JSP技术的一些介绍入门，关于学习JSP技术的一些介绍入门
JSP技术简介
01-08
一、 JSP 技术概述 在 Sun 正式发布 JSP(JavaServer Pages) 之后，这种新的 Web 应用开发技术很快引起了人们的关注。 JSP 为创建高度动态的 Web 应用提供了一个独特的开发环境。按照 Sun 的说法， JSP 能够适应市场...
JSP技术演示文稿.rar_jsp技术
09-21
**JSP技术详解** JSP（JavaServer Pages）是Java平台上的动态网页技术，由Sun Microsystems在1999年推出，旨在简化Web应用程序的开发。JSP技术结合了HTML和Java代码，允许开发者在静态内容中嵌入动态数据处理，从而...
JSP技术文档
10-02
JSP技术资料 ，文档内是PDF格式文件，包含JSP基础，Servlet基础，EL表达式语言，Cookie的使用，会话，请求转发，MVC框架，使用JDBC进行数据访问，用hibernate持久层访问数据库，Struts与SERVLETJSP，JSP与Spring框架...
Javaweb —— JSP技术
求学之路的苦行僧
09-17 1737
JSP 简介 1.1什么是Java Server Pages? JSP全称Java Server Pages，是一种动态网页开发技术。它使用JSP标签在HTML网页中插入Java代码。标签通常以<%开头以%>结束。 JSP是一种Java servlet，主要用于实现Java web应用程序的用户界面部分。网页开发者们通过结合HTML代码、XHTML代码、XML元素以及嵌入JSP操作和命...
JSP技术详解与应用
JSP技术的主要特点包括： 1. **跨平台性**：由于JSP基于Java技术，所以JSP应用可以在任何支持Java的平台上运行，如Linux、Windows或其他操作系统。 2. **浏览器兼容性**：JSP生成的是HTML文本，因此，无论用户使用何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值