Java Web基础入门第二十一讲 JSP技术——什么是JSP？

最新推荐文章于 2023-05-17 16:26:36 发布
最新推荐文章于 2023-05-17 16:26:36 发布
阅读量2.5k 收藏 11
点赞数 3
分类专栏： Java Web基础入门 文章标签： Java-Web基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yerenyuan_pku/article/details/52003502
版权

什么是JSP？

JSP全称是Java Server Pages，它和Servle技术一样，都是SUN公司定义的一种用于开发动态Web资源的技术。JSP这门技术的最大的特点在于，写JSP就像在写HTML，但它相比HTML而言，HTML只能为用户提供静态数据，而JSP技术允许在页面中嵌套Java代码，为用户提供动态数据。相比Servlet而言，Servlet很难对数据进行排版，而JSP除了可以用Java代码产生动态数据的同时，也很容易对数据进行排版。
为什么JSP技术也是一种动态Web资源的开发技术呢？因为JSP技术允许在页面中嵌套Java代码，以产生动态数据，并且Web服务器在执行JSP时，Web服务器会传递Web开发相关的对象给JSP，JSP通过这些对象，可以与浏览器进行交互，所以JSP当然也是一种动态Web资源开发技术。这里，强调一个概念：对现在的用户而言，用户通过浏览器看到的东西都是网页。但我们程序员心里要清楚，开一个浏览器访问网页，这些网页有可能是一个HTML页面（即静态Web资源），也有可能是一个动态Web资源（即Servlet或JSP程序输出的)。

JSP最佳实践

什么是JSP最佳实践呢？通俗点讲，JSP最佳实践就是JSP技术在开发中该怎么去用。不管是JSP还是Servlet，虽然都可以用于开发动态Web资源。但由于这2门技术各自的特点，在长期的软件实践中，人们逐渐把Servlet作为Web应用中的控制器组件来使用，而把JSP技术作为数据显示模板来使用。其原因为，程序的数据通常要美化后再输出：

  1. 让JSP既用Java代码产生动态数据，又做美化会导致页面难以维护；
  2. 让Servlet既产生数据，又在里面嵌套HTML代码美化数据，同样也会导致程序可读性差，难以维护；
  3. 因此最好的办法就是根据这两门技术的特点，让它们各自负责各的，Servlet只负责响应请求产生数据，并把数据通过转发技术带给JSP，数据的显示由JSP来做。

JSP原理

Web服务器是如何调用并执行一个JSP页面的？

浏览器向服务器发请求，不管访问的是什么资源，其实都是在访问Servlet，所以当访问一个JSP页面时，其实也是在访问一个Servlet，服务器在执行JSP的时候，首先把JSP翻译成一个Servlet，所以我们访问JSP时，其实不是在访问JSP，而是在访问JSP翻译过后的那个Servlet。大家可以通过一个JSP快速入门案例——在JSP页面中输出当前时间，认识到这点。
首先编写如下一个名称为1.jsp的页面。

<%@page import="java.util.Date"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!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>JSP入门案例——输出当前时间</title>
</head>
<body>
	<font color="red">
		当前时间值：
		<%
			Date date = new Date();
			String time = date.toLocaleString();
			out.write(time);
		%>
	</font>
</body>
</html>

然后，我们通过浏览器访问1.jsp，服务器首先将1.jsp翻译成一个_1_jsp.class，在Tomcat服务器的work\Catalina\localhost\day08\org\apache\jsp目录下可以看到_1_jsp.class的源代码文件_1_jsp.java，如下图所示：
在这里插入图片描述
打开_1_jsp.java文件，内容如下：

/*
 * Generated by the Jasper component of Apache Tomcat
 * Version: Apache Tomcat/8.0.0
 * Generated at: 2019-04-15 14:03:14 UTC
 * Note: The last modified time of this file was set to
 *       the last modified time of the source file after
 *       generation to assist with modification tracking.
 */
package org.apache.jsp;

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

public final class _1_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("javax.servlet.http");
    _jspx_imports_packages.add("javax.servlet.jsp");
    _jspx_imports_classes = new java.util.HashSet<>();
    _jspx_imports_classes.add("java.util.Date");
  }

  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=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;

      out.write("\r\n");
      out.write("\r\n");
      out.write("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\r\n");
      out.write("<html>\r\n");
      out.write("<head>\r\n");
      out.write("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">\r\n");
      out.write("<title>JSP入门案例——输出当前时间</title>\r\n");
      out.write("</head>\r\n");
      out.write("<body>\r\n");
      out.write("\t<font color=\"red\">\r\n");
      out.write("\t\t当前时间值：\r\n");
      out.write("\t\t");

			Date date = new Date();
			String time = date.toLocaleString();
			out.write(time);
		
      out.write("\r\n");
      out.write("\t\t\r\n");
      out.write("\t\t");
      out.write(" <!-- 脚本表达式，它的作用就是用于向浏览器输出数据 -->\r\n");
      out.write("\t</font>\r\n");
      out.write("</body>\r\n");
      out.write("</html>");
    } 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);
    }
  }
}

我们可以看到，_1_jsp这个类是继承自org.apache.jasper.runtime.HttpJspBase这个类的，通过查看Tomcat服务器的源代码，可以知道在java\org\apache\jasper\runtime目录下存在HttpJspBase这个类的源代码文件，如下图所示：
在这里插入图片描述
我们可以看看HttpJspBase这个类的源代码，如下所示：

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.jasper.runtime;

import java.io.IOException;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.jsp.HttpJspPage;

import org.apache.jasper.compiler.Localizer;

/**
 * This is the super class of all JSP-generated servlets.
 *
 * @author Anil K. Vijendran
 */
public abstract class HttpJspBase extends HttpServlet implements HttpJspPage {

    private static final long serialVersionUID = 1L;

    protected HttpJspBase() {
    }

    @Override
    public final void init(ServletConfig config)
        throws ServletException
    {
        super.init(config);
        jspInit();
        _jspInit();
    }

    @Override
    public String getServletInfo() {
        return Localizer.getMessage("jsp.engine.info");
    }

    @Override
    public final void destroy() {
        jspDestroy();
        _jspDestroy();
    }

    /**
     * Entry point into service.
     */
    @Override
    public final void service(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException
    {
        _jspService(request, response);
    }

    @Override
    public void jspInit() {
    }

    public void _jspInit() {
    }

    @Override
    public void jspDestroy() {
    }

    protected void _jspDestroy() {
    }

    @Override
    public abstract void _jspService(HttpServletRequest request,
                                     HttpServletResponse response)
        throws ServletException, IOException;
}

HttpJspBase类是继承自HttpServlet的，所以HttpJspBase类是一个Servlet，而_1_jsp类又是继承自HttpJspBase类的，所以_1_jsp类也是一个Servlet，所以当浏览器访问服务器上的1.jsp页面时，其实就是在访问_1_jsp这个Servlet，_1_jsp这个Servlet使用_jspService这个方法处理请求。

JSP页面中的HTML排版标签是如何被发送到客户端的？

服务器接收到的这些数据：

<%@page import="java.util.Date"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!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>JSP入门案例——输出当前时间</title>
</head>
<body>
	<font color="red">
		当前时间值：
		<%
			Date date = new Date();
			String time = date.toLocaleString();
			out.write(time);
		%>
	</font>
</body>
</html>

都是在_1_jsp这个Servlet的_jspService方法中使用如下的代码输出给浏览器的：
在这里插入图片描述
在JSP中编写的Java代码和HTML代码都会被翻译到_jspService方法中去，并且在JSP中编写的Java代码会原封不动地翻译成Java代码，如：
在这里插入图片描述
而HTML代码则会翻译成使用out.write("<html标签>\r\n");的形式输出到浏览器。在JSP页面中编写的HTML排版标签都是以out.write("<html标签>\r\n");的形式输出到浏览器，浏览器拿到HTML代码后才能够解析执行HTML代码。

JSP页面中的Java代码服务器是如何执行的？

在JSP中编写的Java代码会被翻译到_jspService方法中去，当执行_jspService方法处理请求时，就会执行在JSP中编写的Java代码了，所以JSP页面中的Java代码服务器是通过调用_jspService方法处理请求时执行的。

Web服务器在调用JSP时，会给JSP提供一些什么Java对象？

查看_jspService方法可以看到，Web服务器在调用JSP时，会给JSP提供如下的8个java对象：

  • javax.servlet.http.HttpServletRequest request
  • javax.servlet.http.HttpServletResponse response
  • javax.servlet.jsp.PageContext pageContext
  • javax.servlet.http.HttpSession session
  • javax.servlet.ServletContext application
  • javax.servlet.ServletConfig config
  • javax.servlet.jsp.JspWriter out
  • java.lang.Object page(即代表this)

其中page对象，request和response已经完成了实例化，而其它5个没有实例化的对象通过下面的方式实例化：
在这里插入图片描述
这8个Java对象在JSP页面中是可以直接使用的。

Tomcat服务器的执行流程

在这里插入图片描述
第一次执行：

  1. 客户端通过计算机连接服务器，因为请求是动态的，所以所有的请求交给WEB容器来处理；
  2. 在容器中找到需要执行的*.jsp文件；
  3. 之后*.jsp文件通过转换变为*.java文件；
  4. *.java文件经过编译后，形成*.class文件；
  5. 最终服务器要执行形成的*.class文件。

第二次执行：

  • 因为已经存在了*.class文件，所以不再需要转换和编译的过程。

修改后执行：

  • 源文件已经被修改过了，所以需要重新转换，重新编译。

JSP基础语法

任何语言都有自己的语法，Java有，JSP虽然是在Java上的一种应用，但是依然有其自己扩充的语法，而且在JSP中，所有的Java语句都可以使用。

JSP模版元素

JSP页面中的HTML内容称之为JSP模版元素。JSP模版元素定义了网页的基本骨架，即定义了页面的结构和外观。

JSP脚本表达式

JSP脚本表达式（expression）用于将程序数据输出到客户端。其语法为<%= 变量或表达式 %>。例如，输出当前系统时间。

当前时间值：
<%
	Date date = new Date();
	String time = date.toLocaleString();
%>

<%=time %> <!-- 脚本表达式，它的作用就是用于向浏览器输出数据 -->

JSP引擎在翻译脚本表达式时，会将程序数据转成字符串，然后在相应位置用out.print(…)将数据输给客户端。温馨提示：JSP脚本表达式中的变量或表达式后面不能有分号（;）。

JSP脚本片断

JSP脚本片断（scriptlet）用于在JSP页面中编写多行Java代码。其语法为：

<% 
    多行Java代码 
%>

温馨提示，在<% %>中可以定义变量、编写语句，但不能定义方法。例如，在scriptlet中定义变量、编写语句。

<%
    int sum = 0; // 声明变量

    // 编写语句
    for(int i=1;i<=100;i++) {
        sum+=i;
    }

    out.print("<h1>sum="+sum+"</h1>");
%>

注意事项：

  • JSP脚本片断中只能出现Java代码，不能出现其它模板元素， JSP引擎在翻译JSP页面时，会将JSP脚本片断中的Java代码原封不动地放到Servlet的_jspService方法中；

  • JSP脚本片断中的Java代码必须严格遵循Java语法，例如，每一条执行语句后面必须用分号（;）结束；

  • 在一个JSP页面中可以有多个脚本片断，在两个或多个脚本片断之间可以嵌入文本、HTML标记和其他JSP元素。例如：

    <%
    int x = 1;
%>

<p>这是JSP页面文本</p>

<%
    out.print(x);
%>

  • 多个脚本片断中的代码可以相互访问，犹如将所有的代码放在一对<%%>之中的情况。如：out.println(x)；

  • 单个脚本片断中的Java语句可以是不完整的，但是，多个脚本片断组合后的结果必须是完整的Java语句，例如：

    <%
    for(int i=0;i<9;i++) 
    {
%>
    aaaaaaaaaaaaaaaaaaa
<%
    }
%>

JSP声明

JSP页面中编写的所有代码，默认会翻译到Servlet的_jspService方法中，而JSP声明中的Java代码会被翻译到_jspService方法的外面。其语法为：

<%！ 
    java代码
%>

所以，JSP声明可用于定义JSP页面转换成的Servlet程序的静态代码块、成员变量和方法(怎么让JSP拥有自己的方法)。多个静态代码块、变量和函数可以定义在一个JSP声明中，也可以分别单独定义在多个JSP声明中。JSP隐式对象的作用范围仅限于Servlet的_jspService方法，所以在JSP声明中不能使用这些隐式对象。JSP声明案例如下：

<%!
    static 
    { 
        System.out.println("loading Servlet!"); 
    }
    private int globalVar = 0;
    public void jspInit()
    {
        System.out.println("initializing jsp!");
    }
%>
<%!
    public void jspDestroy()
    {
        System.out.println("destroying jsp!");
    }
%>

此时jspInit()方法和jspDestroy()方法会覆盖掉Servlet中_jspInit()方法和_jspDestroy()方法。

JSP注释

在JSP中，注释有两大类：

  1. 显式注释：直接使用HTML风格的注释：<!-- 注释内容 -->；
  2. 隐式注释：直接使用Java的注释：//、/*……*/。

JSP也有自己的注释：<%-- 注释内容 --%>。那么这三种注释该怎么用呢？

<!-- 这个注释可以看见 -->

<%
    // Java中的单行注释

    /*
        Java中的多行注释
    */
%>

<%-- JSP自己的注释 --%>

这三种注释的区别：HTML的注释在浏览器中查看源文件的时候是可以看得到的，而Java注释和JSP注释在浏览器中查看源文件时是看不到注释的内容的，这就是这三种注释的区别。即JSP引擎在将JSP页面翻译成Servlet程序时，忽略JSP页面中被注释的内容。

李阿昀
关注
专栏目录
JSP技术
m0_55689562的博客
11-18 1万+
学习目标 一、JSP概述 二、JSP基本语法 三、JSP隐式对象 学习内容 一、JSP概述 1.1 什么是jsp: 它的英文全称 java server pages ,java服务端页面，它是建立在servlet规范基础上的动态网页开发技术。 java 服务端 页面： 在jsp上可以写java代码，也可以写html标记，它运行在服务器端。 jsp = java + html + jsp自身的一些东西。 为什么会产生jsp技术： 因为在早期没有jsp时，需要servlet向页面写数据，比较麻烦，所以就产生了
Java Web基础入门第三十三讲 JSP技术——JSP简单标签开发
李阿昀的博客
08-07 3071
简单标签(SimpleTag)由于传统标签使用三个标签接口来完成不同的功能，显得过于繁琐，不利于标签技术的推广， SUN公司为降低标签技术的学习难度，在JSP 2.0中定义了一个更为简单、便于编写和调用的SimpleTag接口来实现标签的功能。 实现SimpleTag接口的标签通常称为简单标签。简单标签共定义了5个方法： setJspContext方法 setParent和getParent方
JSP技术介绍
09-03
关于学习JSP技术的一些介绍入门，关于学习JSP技术的一些介绍入门关于学习JSP技术的一些介绍入门，关于学习JSP技术的一些介绍入门
Javaweb —— JSP技术
求学之路的苦行僧
09-17 1748
JSP 简介 1.1什么是Java Server Pages? JSP全称Java Server Pages，是一种动态网页开发技术。它使用JSP标签在HTML网页中插入Java代码。标签通常以<%开头以%>结束。 JSP是一种Java servlet，主要用于实现Java web应用程序的用户界面部分。网页开发者们通过结合HTML代码、XHTML代码、XML元素以及嵌入JSP操作和命...
什么是JSP技术?
cfx1299748113的博客
09-15 6429
JSP是一种运行在服务器端的脚本语言，是用来开发动态网页的技术，它是JAVA Web 程序开发的重要技术。本章介绍JSP技术的相关概念以及如何开发JSP程序，主要内容包括JSP技术简介、JSP的处理过程、JSP语法、JSP的内置对象、每种对象的使用方法和使用技巧，以及简单web应用程序的开发设计。
Java Web基础入门第三十二讲 JSP技术——JSP传统标签开发
李阿昀的博客
08-07 1803
标签技术的API标签技术的API类继承关系标签API简单介绍JspTag接口JspTag接口是所有自定义标签的父接口，它是JSP2.0中新定义的一个标记接口，没有任何属性和方法。JspTag接口有Tag和SimpleTag两个直接子接口，JSP2.0以前的版本中只有Tag接口，所以把实现Tag接口的自定义标签也叫做传统标签，把实现SimpleTag接口的自定义标签叫做简单标签。Tag接口Tag接口是
Java Web基础入门第三十六讲 JSP技术——EL表达式
李阿昀的博客
08-17 1475
EL表达式简介EL全名为Expression Language。EL主要作用： 获取数据 EL表达式主要用于替换JSP页面中的脚本表达式，以从各种类型的web域 中检索java对象、获取数据。(某个web域中的对象，访问javabean的属性、访问list集合、访问map集合、访问数组) 执行运算 利用EL表达式可以在JSP页面中执行一些基本的关系运算、逻辑运算和算术运算，以在JSP页面中完成
Java Web基础入门第六十五讲 文件上传——文件上传概述
李阿昀的博客
09-01 2828
在Web应用系统开发中，文件上传和下载功能是非常常用的功能，今天来讲一下JavaWeb中的文件上传和下载功能的实现。文件上传概述实现web开发中的文件上传功能，需完成如下二步操作： 在web页面中添加上传输入项。 在servlet中读取上传文件的数据，并保存到本地硬盘中。 那如何在web页面中添加上传输入项呢？ 我们可以这样回答：<input type=“file”>标签用于在web页面中添加文件
Java_Web快速入门——全十讲
03-11
### Java Web 快速入门全十讲知识点梳理 #### 一、Java Web 技术概述与环境搭建 ##### 1. Java 与 Java Web 的关系 - **Java 的三大平台**：JavaSE（标准版）、JavaEE（企业版）与 JavaME（微小版）。 - **Java ...
jsp技术简介
12-21
JSP（Java Server Pages）技术是由Sun公司发布的用于开发动态Web应用的一项技术。它以其简单易学、跨平台的特性，在众多动态Web应用程序设计语言中异军突起，在短短几年中已经形成了一套完整的规范，并广泛地应用于电子商务等各个领域中。在国内，JSP现在也得到了比较广泛的重视，得到了很好的发展，越来越多的动态网站开始采用JSP技术。本章就对JSP及其相关技术进行简单的介绍。
jsp技术
二月鸟
05-25 322
JavaEE 项目的三层架构 介绍 jsp 的全换是 java server pages。Java 的服务器页面。 sp 的主要作用代替 Servlet 程序回传 html 页面的数据。 因为 Servlet 程序回传 html 页面数据是一件非常繁锁的事情。开发成本和维护成本都极高。 jsp实质是 Servlet 程序 jsp 头部的 page 指令 jsp 的 page 指令可以修改 jsp 页面中一些重要的属性，或者行为。 <%@ page contentType=“text/html;cha
JSP技术基础
m0_52049033的博客
04-11 1784
JSP技术简介
关于JSP技术总结
进击的ITgo
02-12 1149
开篇之前：     jsp技术产生的背景是为了克服servlet技术的不足，因其无法在页面中嵌入java代码。但其缺点是生成的html页面比较繁琐。1．jsp脚本和注释jsp脚本：1）&lt;%java代码%&gt; ----- 内部的java代码翻译到service方法的内部2）&lt;%=java变量或表达式&gt; ----- 会被翻译成service方法内部out.print()或out....
JavaWeb——JSP技术
ZikM的博客
06-14 347
1. 什么是 jsp ，它有什么用? jsp 的全称是 java server pages。Java 的服务器页面。 jsp 的主要作用是代替 Servlet 程序回传 html 页面的数据。 因为 Servlet 程序回传 html 页面数据是一件非常繁锁的事情。开发成本和维护成本都极高。 2.jsp 的本质是什么。 jsp 页面本质上是一个 Servlet 程序。 当我们第一次访问 jsp 页面的时候。Tomcat 服务器会帮我们把 jsp 页面翻译成为一个 java 源文件。并且对它进行编译成为
JSP技术概述
最新发布
qq_51074048的博客
05-17 411
1、page，他只在当前页面有效，也就是用户请求的页面有效，当当前页面关闭或转到其他页面时，page对象将在响应回馈给客户端后释放2、request，他在当前请求中有效，request可以通过方法实现页面中的信息传递，也可以通过forward()方法进行页面间的跳转，需要注意的是request是转发不是重定向，转发相对于浏览器来说是透明的，也就是无论页面如何跳转，地址栏上显示的依旧是最初的地址3、session，他在当前回话中有效。............
JSP介绍
热门推荐
Zxy_zzz的博客
05-19 1万+
目录 一、JSP入门 二、JSP 运行原理 1、JSP 技术特点 2、JSP 与 Servlet 区别 三、JSP 的使用 1、JSP 的三种原始标签 2、JSP 原始标签的使用 3、JSP 的指令标签 4、JSP 三大指令 四、JSP 的内置对象 request常用的方法： response常用的方法 session session常用方法 五、JSP四大作用域对象 一、JSP入门 1、JSP技术介绍 为什么会出现JSP（Java Server Pages）技术..
JAVA-WEB开发入门：21天学习指南
"21天学通JAVA-WEB开发电子书主要涵盖了如何在Windows环境下搭建JAVA Web开发的基础环境，包括安装JDK、Tomcat服务器以及Eclipse与MyEclipse插件的配置。书中强调了掌握这些基础知识对于后续学习的重要性。" 在深入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

李阿昀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值