Java Web基础 --- Jsp 综述(上)

摘要：

　　J2EE是一套规范，而Servlet/Jsp是J2EE规范的一部分，是Tomcat的主要实现部分。在最初的应用实践中，当用户向指定Servlet发送请求时，Servlet利用输出流动态生成HTML页面，这导致Servlet开发效率极为低下。JSP技术通过实现普通静态HTML和动态部分混合编码，使得逻辑内容与外观相分离，大大简化了表示层的实现，提高了开发效率。本文以JSP的本质是Servlet为主线，结合JSP转译后所得的Servlet，详细探讨了JSP的原理、执行过程、脚本元素、编译指令和动作指令，并给出了JSP使用的常见注意事项。

一. J2EE, Tomcat 和 Web Application

1、J2EE 与 Tomcat

　　J2EE 是由 SUN 公司开发的一套企业级应用规范。所谓规范(Specification)指的是一系列接口，不包含具体实现，我们可以通过 J2EE Specification APIs (以 J2EE 6 为例) 来了解该规范。 J2EE 主要由十三种核心技术规范组成，这些规范包括：

  • JDBC (Java Database Connectivity)；
  • JNDI (Java Name and Directory Interface)；
  • EJB (Enterprise Javabean)；
  • RMI (Remote Method Invoke)；
  • Java IDL (Interface Definition Language)；
  • JSP (Java Server Pages)；
  • Servlet；
  • XML (Extensible Markup Language)；
  • JMS (Java Message Service)；
  • JTA (java transaction Architecture)；
  • JTS (java transaction Service API)；
  • JavaMail；
  • JAF (JavaBean Activation FrameWork).

    　　基于 J2EE 规范，各个公司可以根据自己的产品实现相应的接口，例如，JBOSS 和 GLASSFISH 就是常见的 J2EE 实现。特别需要注意的是， Tomcat 是一个 Servlet 容器，实现了 J2EE 中的 Servlet/JSP 规范 (位于 Tomcat 的 lib 目录下的 jsp-api.jar 和 servlet-api.jar)，所以 Jsp 和 Servlet 只要按 SUN 发布的规范进行开发和部署就能直接在 Tomcat 中运行。但是 Tomcat 没有实现 EJB 等规范，也就是说，Tomcat 并不是一个 EJB 容器，所以 Tomcat 不是一个完整的 J2EE 实现。通常，若一个 WEB服务器 想要支持 J2EE， 那么它必须要实现这个规范。

    　　总的来说，J2EE 是一套规范，而 Tomcat 实现了其中的一部分规范；Servlet/Jsp 是 J2EE 规范的一部分，是 Tomcat 的主要实现部分。


2、Web Application

　　符合 J2EE 规范的 Web Application 实际上是一个目录，如下图所示。classes 和 lib 两个文件夹都适用于保存 Web应用 所需的Java类文件，区别是 classes 保存单个 *.class 文件；而 lib 保存打包后的 jar 文件。

　　　　　　　　　　　　　　

二. JSP 原理

1、JSP 简介

　　JSP (Java Server Pages) 是由 Sun 公司倡导、多家公司参与一起建立的一种动态网页技术标准。JSP 文件（*.jsp）实际上是在传统的网页HTML文件（*.htm，*.html）中插入Java程序段（Scriptlet）和 JSP标记（tag）所形成的。

　　JSP 的本质是 Servlet。当用户向指定 Servlet 发送请求时，Servlet 利用输出流动态生成 HTML 页面。由于一个 HTML 页面往往包括大量的 HTML标签、静态文本和格式等，导致 Servlet开发效率极为低下。如下图所示，JSP 的出现弥补了这种不足，它通过实现普通静态HTML和动态部分混合编码，使得逻辑内容与外观相分离，大大简化了表示层的实现。实际上，在静态的HTML页面中嵌入动态Java脚本即可完成JSP的开发。JSP并没有增加任何本质上不能用Servlet实现的功能，但是在JSP中编写静态HTML更加方便，因为不必再用println语句来输出每一行HTML代码。

　　　　　　　　　　　　


2、JSP 的执行过程

　　当用户访问一个JSP页面时，容器对JSP页面的处理通常可分为两个时期：转译时期（Translation Time）和 请求时期（Request Time）。在转译时期，JSP网页被转译成Servlet类，然后被编译成class文件；在请求时期，容器加载编译后的 Servlet类，并把响应结果返回至客户端，整个流程可分为三个步骤，流程图如下：

　　　　　　　　　　　　　　　

(1). 当客户第一次请求JSP页面时，JSP引擎会通过预处理把JSP文件中的静态数据（HTML文本）和动态数据（Java脚本）全部转换为Java代码。转换原则非常直观：对于HTML文本只是简单的用 out.println() 方法包裹起来，而对于Java脚本只是保留或做简单的处理；

(2). JSP引擎把生成的.java文件编译成Servlet类文件（.class）。对于Tomcat服务器而言，生成的类文件默认的情况下存放在\work目录；

(3). 编译后的class对象被加载到容器中，并根据用户的请求生成HTML格式的响应页面。


1) 转译时期

　　为了更好地了解JSP的转译过程和转换原则，我们以下面这个JSP文件为例进行说明。

<%@ page language="java" import="java.util.*" pageEncoding="GB18030"%>

<%-- JSP脚本 --%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    <title>Success</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
    <!--
    <link rel="stylesheet" type="text/css" href="styles.css">
    -->
  </head>
  <body>
    Welcome! </br>
    <%! private String declaration = "我是JSP声明..." ;%>
    <%=declaration %>
    <%-- 我是JSP注释... --%>
  </body>
</html>

　　JSP引擎会把JSP文件中的静态数据（HTML文本）和动态数据（Java脚本）转换为如下Java代码：

public final class welcome_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent {

  // 动态部分： 通过 JSP 声明所声明的变量转化为成员变量
  private String declaration = "我是JSP声明..." ;
  private static java.util.List _jspx_dependants;

  public Object getDependants() {
    return _jspx_dependants;
  }

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

    //JSP 内置对象
    JspFactory _jspxFactory = null;
    PageContext pageContext = null;
    HttpSession session = null;
    ServletContext application = null;
    ServletConfig config = null;
    JspWriter out = null;
    Object page = this;
    JspWriter _jspx_out = null;
    PageContext _jspx_page_context = null;

    try {       // JSP异常处理机制
      _jspxFactory = JspFactory.getDefaultFactory();
      response.setContentType("text/html;charset=GB18030");
      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‘);

      // 动态部分： JSP脚本直接转换为Java代码
      String path = request.getContextPath();
      String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";

      // 静态部分： 页面输出流输出静态HTML
      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>Success</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("    Welcome! </br>\r\n");
      out.write("  \t");
      out.write("\r\n");
      out.write("  \t");
      // 动态部分： JSP 输出表达式转换为 out.print()
      out.print(declaration );
      out.write(‘\r‘);
      out.write(‘\n‘);
      out.write(‘   ‘);
      out.write("\r\n");
      out.write("  </body>\r\n");
      out.write("</html>\r\n");
    } catch (Throwable t) {
      if (!(t instanceof SkipPageException)){
        out = _jspx_out;
        if (out != null && out.getBufferSize() != 0)
          out.clearBuffer();
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
      }
    } finally {
      if (_jspxFactory != null) _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}

　　结合以上示例，关于JSP本质和转移准则，我们可以得出以下几点结论：

  • org.apache.jasper.runtime.HttpJspBase 继承自 javax.servlet.http.HttpServlet，因此 JSP 的本质是 Servlet；
  • JSP 页面的静态部分(HTML内容)在 _jspService 方法中由页面输出流进行输出；
  • JSP引擎在处理 JSP 页面的动态部分时，会将JSP声明的变量/方法转换为类的成员变量/方法；将JSP脚本按原顺序插入到_jspService 方法中；将JSP输出表达式转换为 out.print() 进行输出；将JSP注释进行忽略。

2) 请求时期

　　在请求时期，容器加载编译后的 Servlet类，并把响应结果返回至客户端。特别地，如果JSP页面已经被转换为Servlet且该Servlet被编译进而被加载（在第一次被请求时），这样再次请求此JSP页面时，将感觉不到延迟。


三. JSP 基本语法与脚本元素

　　JSP 的脚本元素(Scripting Element)包含三个部分：Scriptlet、Expression(表达式) 和 Declaration(声明)。

Scriptlet 元素
Scriptlet 中可以包含有效的程序片段，可以包含多个语句、方法调用、变量和表达式等，只要是合乎Java本身的标准语法即可。通常主要的程序也是写在这里，Scriptlet是以 <% 为开始， %> 为结尾。特别需要注意的是：在编译JSP时，编译器在_jspService()方法中只是简单地不做修改地在对应位置包含Scriptlet的内容。因此，在 Scriptlet 中声明的变量是局部变量。
<%@ page language="java" import="java.util.*" contentType="text/html; charset=utf-8" pageEncoding="utf-8" errorPage="exception.jsp"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>test</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
  </head>
  <body>
    <% for(int i =0; i < 7; i++){
        out.print("<font size=‘" + i + "‘>");
    %>
    地球</br></font> <!-- 会打印七遍“地球”-->
    <%}%>
  </body>
</html>
Expression 元素
JSP 提供了一种简单方法访问可用的Java变量和Java表达式，并生成页面HTML字符串。Expression 元素是以 <%= 为开始，%> 为结尾的，其中内容包含一段合法Java的表达式。
Declaration 元素

Declaration元素用于声明在页面中初始化的变量、方法和类，特别需要注意以下几点：

  • 编译JSP时，Scriptlet 中定义的变量是_jspService()方法的局部变量，而使用 Declaration 所声明的变量为全局变量；
  • 每一个Declaration声明仅在一个页面中有效，如果要在每个页面都用到一些共同的声明，最好把它们写成一个单独的JSP网页，然后用<%@include%>或元素包含进来；
  • Declaration元素必须是完整的Java语句，以分号结尾，并且不能产生任何输出。

　　此外，JSP注释 的格式为 <%– –%>，与 HTML注释 (<!– –>)的区别在于： JSP注释不会输出到客户端。


四. JSP 的三个编译指令

　　JSP指令负责发送消息到JSP引擎，不包含业务逻辑，不修改out流，只是告诉JSP引擎JSP页面应该如何编译。JSP指令的作用范围仅限于包含指令本身的JSP页面。JSP编译指令有三种类型：page指令、include指令和taglib指令，其语法如下：

　　　　<%@directive attribute=”attribute value”%>


1、page 指令

　　Page指令定义了一些属性，通知关于JSP页面一般设置的Servlet引擎的属性。对于page指令，有几点需要注意：

  • 可以在一个页面中引用多个 Page指令，但是除了import属性能多次使用之外，其他的属性都只能用一次；
  • Page指令 可以放在JSP文件的任何地方，但是为了JSP程序的可读性及养成好的编程习惯，最好还是放在JSP文件的顶部；
  • Page 指令的 errorPage属性 和 isErrorPage属性 共同组成了JSP 的异常机制，因此 JSP 可以不用像Java那样处理异常，即使是checked异常。前者用于设置该jsp页面出现异常时所要转到的页面，如果没设定，容器将使用当前的页面显示错误信息；后者用于设置该jsp页面是否作为错误显示页面，默认是false，如果设置为true，容器则会在当前页面生成一个 exception 内置对象。

2、include 指令

　　include指令指出所编译的JSP页面要包含的文件名(以相对URL形式)，实质上是页面的静态导入（复制），甚至它会把目标页面的其他编译指令也包含进来（动态include则不会），所以被包括的文件内容会成为当前JSP页面的一部分。需要注意的是，通过include指令包含的文件的操作会在转译时期完成，即将所包含的页面以页面输出流的形式添加到原JSP页面中，如下所示。

<%@ page language="java" import="java.util.*" pageEncoding="utf-8" errorPage=""%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>My JSP ‘include.jsp‘ starting page</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
  </head>
  <body>
    This is my JSP page. <br>
  </body>
  <%@ include file="test.jsp"%>
</html>

　　使用include编译指令所包含的JSP文件被转译成如下的java片断：

      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("    <title>test</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("  </head>\r\n");
      out.write("  \r\n");
      out.write("  <body>\r\n");
      out.write("  \t");
      for(int i =0; i < 7; i++){
        out.println("<font size=‘" + i + "‘>");
        out.write("\r\n");
        out.write("  \t地球</br></font>\r\n");
        out.write("    ");
      }
      out.write("\r\n");

五. JSP 的七个动作指令

　　JSP的动作指令与编译指令不同，编译指令是通知 Servlet 引擎的消息，而动作指令只是运行时的动作。编译指令在将JSP编译成Servlet时起作用；而动作指令通常可以替换成JSP脚本，它只是JSP脚本的标准化写法。现将这七个动作指令按使用方式分为两组( 动作指令 jsp:plugin 暂不细表)：

  • jsp:forward，jsp:include，jsp:param；
  • jsp:useBean，jsp:setProperty，jsp:getProperty；
forward 指令
执行页面转向，将请求的处理转发到下一个页面。使用 forward 指令进行请求转发时，其并不会重新向新页面发送请求，而只是采用新页面来对用户生成响应。也就是说，请求依然是一次请求，所以不会丢失请求参数，而且用户的请求地址也不会发生改变。此外，在使用forward 指令转发请求时可以增加额外的请求参数，格式如下：
    <jsp:forward page="{relativeURL | <%=expression%>}">
        <jsp:param value="***" name="***"/>
    </jsp:forward>

　　forward 指令被转译为Servlet时，会在其对应处添加以下代码片段：

    if (true) {
        _jspx_page_context.forward("所forward的页面地址" + (("所forward的页面地址").indexOf(‘?‘)>0? ‘&‘: ‘?‘) + org.apache.jasper.runtime.JspRuntimeLibrary.URLEncode("额外参数名", request.getCharacterEncoding())+ "=" + org.apache.jasper.runtime.JspRuntimeLibrary.URLEncode("对应参数值", request.getCharacterEncoding()));
        return;    // 不执行该指令后面的内容
      }

　　结合以上说明，我们可以得出以下几个结论：

  • forward指令 使用同一个request；
  • forward后的语句不会继续发送给客户端；
  • 服务器内部转换 (转发的路径必须是同一个web容器下的url)；
  • 可以传递额外的参数。
include 指令
用于动态引入一个JSP页面，但它不会导入被include页面的编译指令，仅仅将被导入页面的body内容插入本页面。此外，在使用forward 指令转发请求时可以增加额外的请求参数，格式如下：
    <jsp:include page="{relativeURL | <%=expression%>}">
        <jsp:param value="***" name="***"/>
    </jsp:include>

　　include 指令被转译为Servlet时，会在其对应处添加以下代码片段：

org.apache.jasper.runtime.JspRuntimeLibrary.include(request, response, "被导入页面的地址" + (("被导入页面的地址").indexOf(‘?‘)>0? ‘&‘: ‘?‘) + org.apache.jasper.runtime.JspRuntimeLibrary.URLEncode("额外参数名", request.getCharacterEncoding())+ "=" + org.apache.jasper.runtime.JspRuntimeLibrary.URLEncode("对应参数值", request.getCharacterEncoding()), out, false);

　　从以上代码片段我们可以看出，动态导入只是使用一个include()方法来插入目标页面的内容，而不是将目标页面完全融入当前页面中。因此，静态导入和动态导入有如下三点区别：

  • 静态导入是被导入页面的代码完全融入；而动态导入则在Servlet中使用include方法引入被导入页面内容；
  • 静态导入会导入被导入页面的编译指令；而动态导入只是插入被导入页面的body内容；
  • 动态导入还可以增加额外的参数。
useBean、setProperty、getProperty 指令
useBean 指令用于在JSP页面中初始化一个Java对象；setProperty 指令用于为 JavaBean 实例的属性设置值；getProperty 指令用于输出 JavaBean 实例的属性值。格式分别如下：
<jsp:useBean id="name" class="classname" scope="page | request | session | application"/>
<jsp:setProperty name="BeanName" property="propertyName" value="value"/>
<jsp:getProperty name="BeanName" property="propertyName"/>

　　useBean、setProperty、getProperty 指令在使用上是并列的（不是嵌套的），形式如下：

    <jsp:useBean id="p" class="com.tju.rico.bean.Person" scope="application"/>
    <jsp:setProperty property="name" name="p" value="rico"/>
    <jsp:getProperty property="name" name="p"/></br>

　　形如上面的jsp代码被转译为Servlet时，会在其对应处添加以下代码片段：

// useBean 指令的转译
com.tju.rico.bean.Person p = null;
synchronized (application) {    // 共享资源的序列化访问
    p = (com.tju.rico.bean.Person) _jspx_page_context.getAttribute("p", PageContext.APPLICATION_SCOPE);
    if (p == null){
        p = new com.tju.rico.bean.Person();
        _jspx_page_context.setAttribute("p", p, PageContext.APPLICATION_SCOPE);
    }
}

//内部调用了JavaBean的 setter
org.apache.jasper.runtime.JspRuntimeLibrary.introspecthelper(_jspx_page_context.findAttribute("p"), "name", "rico", null, null, false);

//调用了JavaBean的 getter
out.write(org.apache.jasper.runtime.JspRuntimeLibrary.toString((((com.tju.rico.bean.Person)_jspx_page_context.findAttribute("p")).getName())));

　　结合以上说明，我们可以在JSP中使用定义好的Bean，但是 Bean 必须具有以下特点：

  • Bean类应该没有任何公共实例变量多态（Bean中可以不定义属性，但必须提供对应的 getter/setter），也就是说，不允许直接访问实例变量，变量名称首字母必需小写；
  • 必须要有一个不带参数的构造器。在JSP元素创建Bean时会调用空构造器 (JSP创建bean的时候使用不带参数的构造器)；
  • 通过getter/setter方法来读/写变量的值，并且将对应的变量首字母改成大写。
param 指令
param 指令用于设置参数值，并且该指令不能单独使用。常与 jsp:include、jsp:forward 指令联合使用。

六. 注意事项

1、JSP中 out.write()、out.print() 和 out.println()的区别

　out对象的类型是JspWriter，而JspWriter继承了java.io.Writer类。上述三个方法区别如下：

  • print/println方法是子类JspWriter中定义的方法，write 是 父类Writer中定义的方法；
  • print/println方法可将各种类型的数据转换成字符串的形式进行输出，而write方法只能输出字符、字符数组和字符串等与字符相关的数据；
  • JspWriter类型的out对象使用print方法和write方法都可以输出字符串，但是，如果字符串对象的值为null时，print方法将输出内容为“null”的字符串，而write方法则是抛出NullPointerException异常；
  • println方法与print/write相比，只会多输出一个空格。

2、JSP/Servlet中的四种编码方式的作用与区别

　　关于这块内容的介绍详见我的博文《JSP中文乱码问题终极解决方案(上)》。


　　关于JSP更多的介绍，特别是内置对象等内容见我的下一篇博客《Java Web基础 — Jsp 综述(下)》。

　　关于JSP中文乱码更多的介绍，包括 JSP的执行过程与编码设定、页面乱码、参数乱码、表单乱码、源文件乱码 等知识，见我的另外两篇博客：《JSP中文乱码问题终极解决方案(上)》 和 《JSP中文乱码问题终极解决方案(下)》。

　　

引用

《轻量级 JavaEE 企业应用实战(第四版)》

JSP中out.write()和out.print()的区别

JSP中文乱码问题终极解决方案

关于JSP页面中的pageEncoding和contentType两种属性的区别

JSP中System.out.println()与out.println()区别

JSP技术

时间： 2024-10-03 21:54:35

Java Web基础 --- Jsp 综述(上)的相关文章

Java Web基础 --- Jsp 综述(下)

摘要: JSP脚本中包含九个内置对象,它们都是Servlet-API接口的实例,并且JSP规范对它们进行了默认初始化.本文首先通过一个JSP实例来认识JSP内置对象的实质,紧接着以基于请求/响应架构应用的运行机制为背景,引出JSP/Servlet的通信方式与内置对象的作用域,并对每个内置对象的常见用法进行深入介绍和总结. 一. JSP 九大内置对象概述及相关概念说明 JSP脚本中包含九个内置对象,这九个内置对象都是 Servlet API 接口的实例,并且JSP规范对它们进行了默认初始化(由 J

Java Web基础 --- Servlet 综述(实践篇)

摘要: 伴随 J2EE 6一起发布的Servlet 3.0规范是Servlet规范历史上最重要的变革之一,它的许多新的特性都极大的简化了 Java Web 应用的开发.本文从一个简单的 Servlet 例子开始,说明了如何开发.配置一个 Servlet.此外,还重点叙述了Servlet的一些新特性,包括Servlet 异步处理.Servlet 非阻塞IO 以及 Servlet 文件上传等内容,以便我们对Servlet有一个更全面的了解. 本篇主要介绍 Servlet 实践方面的知识,更多关注于S

Java Web基础 --- Servlet 综述(理论篇)

摘要: Web 技术成为当今主流的互联网 Web 应用技术之一,而 Servlet 是 Java Web 技术的核心基础.本文首先从请求/响应架构应用的大背景谈起 Servlet 的由来,明确 Servlet 的产生动机,并揭示了 Servlet 的本质以及其在标准MVC模式中所扮演的角色.紧接着,给出了 Servlet族的继承结构,并对族内的接口和抽象类作了进一步的介绍,并给出开发一个Servlet程序的常用做法.在此基础上,我们图文并茂地介绍了 Servlet 的生命周期与执行流程,清晰展现

Java Web 基础 --- Filter 综述

摘要: 伴随J2EE一起发布的Servlet规范中还包括一个重要的组件--过滤器(Filter).过滤器可以认为是Servlet的一种加强版,它主要用于对用户请求进行预处理以及对服务器响应进行后处理,是个典型的处理链.Servlet规范使用了三个接口对过滤器进行了抽象,即Filter是对具体过滤器的抽象,FilterChain是基于AOP理念对责任链方面的抽象,FilterConfig则是对Filter配置的抽象.本文概述了Filter的提出动机.工作原理.使用流程和应用实例,并指出Java W

Java web基础总结八之—— jsp基础

Java web基础总结八之-- jsp基础 一．什么是jsp? JSP是Java ServerPages的缩写,它和servlet一样,都是用于开发动态web资源的技术.在servlet中拼凑输出html代码时,非常麻烦.而JSP的最大的特点在于,写jsp就像在写html,但是html只能为用户提供静态数据,而Jsp技术允许在页面中嵌套java代码,开发动态资源. 现在随着前端越来越重要,很多的公司都会采取前后端分离的开发模式.即后端只提供返回json等格式的接口,而前端开发人员则通过对后端接

Java Web基础(HTML、Servlet/JSP)

要成为牛逼的JavaWeb程序员, Java Web的基础非常重要,现在有各种成熟的设计框架例如JQuery.Spring.Struts.Mybatis,将Java Web基础的复杂且通用的逻辑进行封装,减少了程序员的代码量,提高了编码效率,但是这些框架非常不利于我们了解Java Web底层如何运作,甚至不知道HTML(HyperText MarkupLanguage).HTTP(HyperText Transfer Protocol).URL(Uniform Resource Locator)

java web 程序---jsp连接mysql数据库的实例基础+表格显示

<%@ page language="java" import="java.util.*,java.sql.*" pageEncoding="gb2312"%> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <body> <center>JSP连接mysql数据库</

Java web基础总结九之—— jsp标签

Java web基础总结九之-- jsp标签 JSP标签也称之为Jsp Action,在前面讲过,jsp的设计目的就是作为表现层.我们希望JSP页面仅用作数据显示模块,不要嵌套任何java代码引入任何业务逻辑,但在实际开发中不引入一点业务逻辑是不可能的,但引入业务逻辑会导致页面出现难看java代码.jsp的标签就是为了解决这个问题.所以jsp页面中也内置了一些标签(这些标签叫做jsp标签),开发人员使用这些标签可以完成页面的一些业务逻辑.我们也可以开发自定义标签,使jsp页面不出现一行java代

Java web基础总结十之—— jsp EL表达式

Java web基础总结十之-- jsp EL表达式 一．EL表达式简介 EL 是Expression Language的缩写.在jsp中有很大的作用,EL主要有以下一些作用:获取数据,替换JSP页面中的脚本表达式,以从各种类型的web域中检索java对象.获取数据.还可以执行运算,利用EL表达式可以在JSP页面中执行一些基本的关系运算.逻辑运算和算术运算,以在JSP页面中完成一些简单的逻辑运算,例如 ${user==null}.还可以获取web开发常用的jsp的隐式对象,利用这些隐式对象,we