- 外文名
- Java Server Pages
- 本 质
- JSP
- 中文名
- JAVA服务器页面
-
2021-02-19 16:09:27
什么是jsp？
JSP全称Java Server Pages，是一种动态网页开发技术。它使用JSP标签在HTML网页中插入Java代码。标签通常以<%开头以%>结束。 JSP是一种Java servlet，主要用于实现Java web应用程序的用户界面部分。JSP通过网页表单获取用户输入数据、访问数据库及其他数据源，然后动态地创建网页。 JSP是Servlet的扩展，在没有JSP之前，就已经出现了Servlet技术。Servlet是利用输出流动态生成HTML页面，包括每一个HTML标签和每个在HTML页面中出现的内容。为什么使用jsp?
性能更加优越，JSP可以直接在HTML网页中动态嵌入元素而不需要单独引用CGI文件。 服务器调用的是已经编译好的JSP文件，而不像CGI/Perl那样必须先载入解释器和目标脚本。 JSP 基于Java Servlet API，因此，JSP拥有各种强大的企业级Java API。jsp处的位置
JSP处理流程
- 浏览器发送一个 HTTP 请求给服务器。
- Web 服务器识别出这是一个对 JSP 网页的请求，并且将该请求传递给 JSP 引擎。
- JSP 引擎从磁盘中载入 JSP 文件，然后将它们转化为 Servlet。
- JSP 引擎将 Servlet 编译成可执行类，并且将原始请求传递给 Servlet 引擎。
- Web 服务器的某组件将会调用 Servlet 引擎，然后载入并执行 Servlet 类。在执行过程中，Servlet 产生 HTML 格式的输出并将其内嵌于 HTTP response 中上交给 Web 服务器。
- Web 服务器以静态 HTML 网页的形式将 HTTP response 返回到浏览器中。
- Web 浏览器处理 HTTP response 中动态产生的HTML网页。
JSP生命周期
JSP生命周期就是从创建到销毁的整个过程，类似于servlet生命周期，区别在于JSP生命周期还包括将JSP文件编译成servlet.
-
JSP编译
当浏览器请求JSP页面时，JSP引擎会首先去检查是否需要编译这个文件。如果这个文件没有被编译过，或者在上次编译后被更改过，则编译这个JSP文件。
-
JSP初始化
容器载入JSP文件后，它会在为请求提供任何服务前调用jspInit()方法。如果您需要执行自定义的JSP初始化任务，重写jspInit()方法就行。
-
JSP执行
这一阶段描述了JSP生命周期中一切与请求相关的交互行为，直到被销毁。
当JSP网页完成初始化后，JSP引擎将会调用_jspService()方法。
void _jspService(HttpServletRequest request,HttpServletResponse response){ // Todo } -
JSP销毁
JSP生命周期的销毁阶段描述了当一个JSP网页从容器中被移除时所发生的一切。jspDestroy()方法在JSP中等价于servlet中的销毁方法。当您需要执行任何清理工作时复写jspDestroy()方法。
public void jspDestroy(){ //清理 } -
JSP生命周期代码测试：
<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>jsp生命周期</title> </head> <body> <%! //声明变量 private int initCnt = 0; private int serviceCnt = 0; private int destroyCnt = 0; %> <%! //初始化方法 public void jspInit(){ initCnt++; System.out.println("jspInit(): JSP被初始化了"+initCnt+"次"); } //销毁方法 public void jspDestroy(){ destroyCnt++; System.out.println("JSP被销毁了"+destroyCnt+"次"); } %> <% serviceCnt++; System.out.println("Jsp响应了"+serviceCnt+"次"); String initString="初始化次数 : "+initCnt; String serviceString="响应客户请求次数 : "+serviceCnt; String destroyString ="销毁次数 : "+destroyCnt; %> <h1>结果如下：</h1> <p><%= initString%></p> <p><%= serviceString%></p> <p><%= destroyString%></p> </body> </body> </html>结果如下：(Tomcat 9.0 + jdk1.8)
初始化次数 : 1
响应客户请求次数 : 1
销毁次数 : 0
jsp相关语法：
1.<% %>叫做脚本片段，其中写的内容会翻译在Servlet的Service方法中，显然我们可以在Service方法中定义局部变量或者调用其他方法，但是不能在Service中再定义其他的方法，也就是我们可以在<%%>中定义局部变量或者调用方法，但不能定义方法。在jsp页面可以有多个脚本片段，但是多个脚本片段之间要保证结构完整。 2.<%!%>称作声明，其中写的内容将来会直接翻译在Servlet类中，因为我们可以在类中定义方法和属性以及全局变量，所以我们可以在<%!%>中声明方法、属性、全局变量。 3.<%=%>称作jsp表达式，用于将已经声明的变量或者表达式输出到网页上面。 4.直接写在jsp页面<body></body>中的代码称作模板元素，将来会Servlet的Service方法out.write("___")中，作为输出内容。 编写与其等价的XML语句<jsp:scriptlet>代码片段</jsp:scriptlet>。 <%-- jsp注释 --%>注释内容不会被发送至浏览器甚至不会被编译 <!-- 注释 --> HTML注释，通过浏览器查看网页源代码时可以看见注释内容JSP指令
JSP指令用来设置与整个JSP页面相关的属性。
<%@ directive attribute="value" %> <%-- jsp指令语法格式 --%><%@ page …> 定义页面的依赖属性，比如脚本语言、error页面、缓存需求等等 <%@ include … %> 包含其他文件 <%@ taglib … %> 引入标签库的定义，可以是自定义标签 JSP行为
行为标签只有一种语法格式，它严格遵守XML标准：<jsp:action_name attribute=“value” />
JSP隐含对象
request对象
request对象是javax.servlet.http.HttpServletRequest 类的实例。每当客户端请求一个JSP页面时，JSP引擎就会制造一个新的request对象来代表这个请求。request对象提供了一系列方法来获取HTTP头信息，cookies，HTTP方法等等。
response对象
response对象是javax.servlet.http.HttpServletResponse类的实例。当服务器创建request对象时会同时创建用于响应这个客户端的response对象。
response对象也定义了处理HTTP头模块的接口。通过这个对象，开发者们可以添加新的cookies，时间戳，HTTP状态码等。
out对象
out对象是 javax.servlet.jsp.JspWriter 类的实例，用来在response对象中写入内容，用来输出boolean，char，int，double，String，object等类型数据。
application对象
application对象直接包装了servlet的ServletContext类的对象，是javax.servlet.ServletContext 类的实例。这个对象在JSP页面的整个生命周期中都代表着这个JSP页面。这个对象在JSP页面初始化时被创建，随着jspDestroy()方法的调用而被移除。通过向application中添加属性，则所有组成您web应用的JSP文件都能访问到这些属性。
pageContext 对象
pageContext对象是javax.servlet.jsp.PageContext 类的实例，用来代表整个JSP页面。
page对象
对象就是页面实例的引用。它可以被看做是整个JSP页面的代表。page 对象就是this对象的同义词。
HttpServletRequest类
request对象是javax.servlet.http.HttpServletRequest类的实例。每当客户端请求一个页面时，JSP引擎就会产生一个新的对象来代表这个请求。request对象提供了一系列方法来获取HTTP信息头，包括表单数据，cookies，HTTP方法等。
部分方法测试代码：
<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>Test Request Object</title> </head> <body> <h1>HttpServletRequest</h1> <p><% out.println("请求方式："+request.getMethod()); %>></p> <p><% out.println("编码方式："+request.getCharacterEncoding()); %>></p> <p><% out.println("request主体的MIME类型："+request.getContentType()); %>></p> <p><% out.println("与此request URL相关的路径："+request.getPathInfo()); %>></p> <p><% out.println("客户端的IP地址："+request.getRemoteAddr()); %>></p> <p><% out.println("request的URI："+request.getRequestURI()); %>></p> <p><% out.println("请求的servlet路径："+request.getServletPath()); %>></p> <p><% out.println("request是否使用了加密通道："+request.isSecure()); %>></p> <p><% out.println("request主体所包含的字节数："+request.getContentLength()); %>></p> <p><% out.println("服务器端口号："+request.getServerPort()); %>></p> </body> </body> </html>HttpServletRequest(输出)
请求方式：GET >
编码方式：null >
request主体的MIME类型：null >
与此request URL相关的路径：null >
客户端的IP地址：0:0:0:0:0:0:0:1 >
request的URI：/ServletTest/requestDemo.jsp >
请求的servlet路径：/requestDemo.jsp >
request是否使用了加密通道：false >
request主体所包含的字节数：-1 >
服务器端口号：8080 >
HttpServletResponse类
esponse 对象是 javax.servlet.http.HttpServletResponse 类的一个实例。就像服务器会创建request对象一样，它也会创建一个客户端响应。response对象定义了处理创建HTTP信息头的接口。通过使用这个对象，开发者们可以添加新的cookie或时间戳，还有HTTP状态码。
部分方法测试代码：
<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>Insert title here</title> </head> <body> <p>Response相关测试结果</p> <p><%out.println("BufferSize:"+response.getBufferSize()); %> <p><%out.println("CharacterEncoding:"+response.getCharacterEncoding()); %> <p><%out.println("ContentType:"+response.getContentType()); %> <p><%out.println("Status:"+response.getStatus()); %> <%Cookie cookie = new Cookie("name","wanglj");%> <br> <% response.addCookie(cookie); Cookie[] cookies = request.getCookies(); if(cookies != null){ for(Cookie cook:cookies){ out.println("name:"+cook.getName()); out.println("value:"+cook.getValue()); out.print("<br>"); } } %> </body> </body> </html>Response相关测试结果
BufferSize:8192
CharacterEncoding:utf-8
ContentType:text/html;charset=utf-8
Status:200
name:JSESSIONID value:CA89C2AD98730B319F7C6475462679A1
name:name value:wangljHTTP状态码
JSP表单处理
我们在浏览网页的时候，经常需要向服务器提交信息，并让后台程序处理。浏览器中使用 GET 和 POST 方法向服务器提交数据。
GET 方法
GET方法将请求的编码信息添加在网址后面，网址与编码信息通过"?"号分隔。GET方法是浏览器默认传递参数的方法，一些敏感信息，如密码等建议不使用GET方法。用get时，传输数据的大小有限制 （注意不是参数的个数有限制），最大为1024字节。
POST方法
一些敏感信息，如密码等我们可以通过POST方法传递，POST提交数据是隐式的。JSP使用getParameter()来获得传递的参数，getInputStream()方法用来处理客户端的二进制数据流的请求。
JSP 读取表单数据
- getParameter(): 使用 request.getParameter() 方法来获取表单参数的值。
- getParameterValues(): 获得如checkbox类（名字相同，但值有多个）的数据。 接收数组变量 ，如checkbox类型。
- **getParameterNames()😗*该方法可以取得所有变量的名称，该方法返回一个 Enumeration。
- **getInputStream()😗*调用此方法来读取来自客户端的二进制数据流。
JSP过滤器
JSP 和 Servlet 中的过滤器都是 Java 类。过滤器可以动态地拦截请求和响应，以变换或使用包含在请求或响应中的信息。
JSP过滤器作用：
- 在客户端的请求访问后端资源之前，拦截这些请求。
- 在服务器的响应发送回客户端之前，处理这些响应。
各种类型的过滤器
- 身份验证过滤器（Authentication Filters）
- 数据压缩过滤器（Data compression Filters）
- 加密过滤器（Encryption Filters）
- 触发资源访问事件过滤器
- 图像转换过滤器（Image Conversion Filters）
- 日志记录和审核过滤器（Logging and Auditing Filters）
- MIME-TYPE 链过滤器（MIME-TYPE Chain Filters）
- 标记化过滤器（Tokenizing Filters）
- XSL/T 过滤器（XSL/T Filters），转换 XML 内容
过滤器通过 Web 部署描述符（web.xml）中的 XML 标签来声明，然后映射到您的应用程序的部署描述符中的 Servlet 名称或 URL 模式。
JSP Cookie
使用 JSP 设置 cookie（三步）
//Cookie只有一个带参构造器 Cookie cookie = new Cookie("key","value");- 创建Cookie对象
- **设置有效期：**调用 setMaxAge() 函数表明 cookie 在多长时间（以秒为单位）内有效。
- **将 cookie 发送至 HTTP 响应头中：**调用 response.addCookie() 函数来向 HTTP 响应头中添加 cookie。
-
**getName()**返回 cookie 的名称，名称创建后将不能被修改。
-
**getValue()**获取cookie的值。
JSP文件上传
JSP 可以与 HTML form 标签一起使用，来允许用户上传文件到服务器。上传的文件可以是文本文件或图像文件或任何文档。
upload.jsp : 文件上传表单程序。
message.jsp : 上传成功后跳转页面。
UploadServlet.java : 上传处理的 Servlet。
需要引入的 jar 文件：cos.jar,commons-fileupload-1.3.2、commons-io-2.5.jar。(可在Apache下载)
upload.jsp
注意点:
- 表单 method 属性应该设置为 POST 方法，不能使用 GET 方法。
- 表单 enctype 属性应该设置为 multipart/form-data.
- 表单 action 属性应该设置为在后端服务器上处理文件上传的 Servlet 文件。下面的实例使用了 UploadServlet Servlet 来上传文件。
- @MultipartConfig //文件上传注解
代码:
<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>文件上传</title> </head> <body> <form method="POST" enctype="multipart/form-data" action="upser"> 文件: <input type="file" name="upfile"><br/> <br/> <input type="submit" value="上传"> </form> </body> </body> </html>message.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>文件上传结果</title> </head> <body> <center> <h2>成功</h2> </center> </body> </html>UploadServlet.java
package com.wanglj.servlet; import java.io.File; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.annotation.MultipartConfig; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.Part; @WebServlet("/upser") @MultipartConfig //文件上传 public class UploadServlet extends HttpServlet { private static final long serialVersionUID = 1L; @SuppressWarnings("deprecation") @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //处理中文 req.setCharacterEncoding("utf-8"); //文件上传 Part part = req.getPart("upfile"); //得到上传的文件名 String fileName = part.getSubmittedFileName(); //判断上传的文件是否为空 String path = getServletContext().getRealPath("/uplaod"); part.write(path+fileName); req.getRequestDispatcher("message.jsp").forward(req, resp); } }JSP日期处理
使用JSP最重要的优势之一，就是可以使用所有Java API.Date类是很常用的一个事件处理类。
Date类的两个构造器
Date( );//无参构造器 Date(long millisec);//带参构造器，参数表示从1970年1月1日凌晨至所要表示时间的毫秒数显示当前日期：
<%@page import="org.apache.jasper.tagplugins.jstl.core.Out"%> <%@page import="java.text.SimpleDateFormat"%> <%@page import="java.util.Date"%> <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>Index</title> </head> <body> <h1>显示当前时间日期</h1> <% Date date = new Date(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM--dd HH-mm-ss"); out.println("<h2 align=\"center\">" + sdf.format(date) + "</h2>"); %> </body> </body> </html>JSP页面重定向
当需要将文档移动到一个新的位置时，就需要使用JSP重定向了
重定向实例：
<%@page import="java.io.IOException"%> <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>JSP重定向测试</title> </head> <body> <% String baidu = new String("https://www.baidu.com"); //重定向到百度response.sendRedirect(location) try{ response.sendRedirect(baidu); System.out.print("重定向成功"); }catch(IOException e){ e.printStackTrace(); } %> <--下面方式同样效果--> <%--String site = "https://www.baidu.com" ; response.setStatus(response.SC_MOVED_TEMPORARILY); response.setHeader("Location", site); --%> </body> </body> </html>JSP自动刷新
public void setIntHeader(String header, int headerValue)，
这个方法通知浏览器在给定的时间后刷新，时间以秒为单位。
JSP自动刷新测试：
<%@page import="java.text.SimpleDateFormat"%> <%@page import="java.util.Date"%> <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>自动刷新实例</title> </head> <body> <h1> 自动刷新测试 </h1> <% //当前时间 Date date = new Date(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss"); out.println("当前时间："+sdf.format(date)); // 设置每隔5秒刷新一次 response.setIntHeader("Refresh", 5); %> </body> </body> </html>[1]:本文仅供个人学习记录使用，如果错误，欢迎提出，谢谢
更多相关内容 -
JSP
2020-11-19 14:46:23JSP全称为Java Server Pages，它指的就是java服务器端页面 我们可以理解为它就是一个特殊的页面，其中既可以指定定义html标签，又可以定义java代码，用于简化我们的书写 二、原理 画图说明 JSP本质上就是一个...展开全文- List item
一、概念
JSP全称为Java Server Pages，它指的就是java服务器端页面
我们可以理解为它就是一个特殊的页面，其中既可以指定定义html标签，又可以定义java代码，用于简化我们的书写二、原理
画图说明
JSP本质上就是一个Servlet
三、JSP指令
用于配置JSP页面，导入资源文件
格式：<%@ 指令名称 属性名1="属性值1 属性名2="属性值2 %>
例如<%@ page contentType="text/html;charset=UTF-8" language="java" %>分类
- page：配置JSP页面的
- include：页面包含的。导入页面的资源文件
- taglib：导入资源
1、page指令
（1）contentType：等同于response.setContentType():
① 用于设置响应体的mime类型以及字符集；
② 高级开发工具例如idea还可以自动设置当前jsp页面的编码（2）language：设置编写的脚本语言
（3）buffer：设置缓冲区的大小的属性
（4）import：导包属性
（5）errorPage：当前页面发生异常后，会自动跳转到指定的错误页面
（6）isErrorPage：标识当前页面是否是错误页面
① 如果值为true：那么标识为错误页面，就可以使用内置对象exception
② 如果值false：不能够使用内置对象exception2、include指令
top.jsp代码内容
index.jsp代码内容
显示效果为
3、taglib
用于导入资源这里不过多解释，后面解释
四、注释
1、html注释：
<！-- -->只能注释html代码片段
2、jsp注释
<%-- --%>可以所有
注意：
如果使用jsp注释的话响应体当中不会显示注释的内容，如果使用html注释的话响应体当中会有注释的显示
举例代码如下
响应体中的效果为
五、JSP的脚本
JSP定义Java代码的方式
1、<% 代码 %>
定义的Java代码，在service方法中。sevice方法中可以定义什么，该脚本就能定义什么
2、<%! 代码 %>
定义的是Java代码，在jsp转换后的java类中的成员变量的位置
3、<%= 代码 %>
定义的java代码，会输出到页面上。输出语句中能定义什么该脚本中就能定义什么
六、JSP内置对象
在jsp页面中不需要创建和获取就能直接拿来使用的对象就是内置对象
jsp一共有9个内置对象jsp内置对象变量名 Servlet中的真实类型 作用 pageContext PageContext 用于当前页面共享数据，还可以来获取其他八个内置对象 request HttpServletRequest 用于一次请求访问多个资源（通过转发实现） session HttpSession 用于一次会话的多个请求间共享数据 application ServletContext 多个用户间来共享数据 response HttpServletResponse 它就是响应对象 page Object 它就是当前页面（当前serclet）的对象 out JspWriter 它就是一个输出对象，将数据输出到页面上 config ServletConfig sercvlet的配置对象 exception Throwable 异常对象 黄色标红重点注意作用域
1、request
2、response
3、out
可以将数据输出到页面上，是一个字符输出流对象，他和我们的response.getWriter()类似
response.getWriter()方法和out.write()方法到的区别在tomcat服务器真正给客户端做出响应之前，会先找response缓冲区再找out缓冲区数据。所以response.getWrite()数据永远在out.write()之前
显示效果为
4、pageContext
用于当前页面共享数据
举例示范
显示到页面的结果就是
5、application
6、session
7、page
8、exception
9、config
-
jsp+mysql简单留言板实现
2015-05-06 14:48:09采用纯jsp页面+Mysql的方法实现功能 项目编码是gb2312，要转换格式的请自己装换，界面简洁，功能简单，实现容易，非常适合初学者 有助于加深初学者对jsp的理解和使用Mysql数据库 String DBDRIVER = ... -
JSP技术
2021-11-18 00:47:56一、JSP概述 二、JSP基本语法 三、JSP隐式对象 学习内容 一、JSP概述 1.1 什么是jsp: 它的英文全称 java server pages ,java服务端页面，它是建立在servlet规范基础上的动态网页开发技术。 java 服务端 页面： 在...展开全文学习目标
一、JSP概述
二、JSP基本语法
三、JSP隐式对象学习内容
一、JSP概述
1.1 什么是jsp:
它的英文全称 java server pages ,java服务端页面，它是建立在servlet规范基础上的动态网页开发技术。- java 服务端 页面： 在jsp上可以写java代码，也可以写html标记，它运行在服务器端。
- jsp = java + html + jsp自身的一些东西。
- 为什么会产生jsp技术：
因为在早期没有jsp时，需要servlet向页面写数据，比较麻烦，所以就产生了jsp技术，
jsp最大的特点：可以非常简单的书写页面html。
jsp其实它的本质是servlet： 可以看到jsp 继承了 HttpJspBase 继承 HttpServlet。
1.2 编写第一个jsp文件
jsp生成java文件，编译成class文件，存在tomcat服务器的work目录。
注意：修改jsp的默认编码格式：window---------->preferenes-----> 搜索 jsp -----> 选中编码 进行修改。
步骤：
1.创建JSP文件
2.命名文件
<%@page language=“java"contentType="text/html;charset=UTF-8"pageEncoding="UTF-8"%> <!DOCTYPE html> <html> <head> <metacharset="UTF-8"> <title>Insert title here</title> </head> <body> 大数据2005 yanmin <%response.getWriter().print("四川")；%> </body> </html>
1.3.jsp运行原理
JSP的运行原理WEB容器(Servlet引擎)接收到以.jsp为扩展名的URL的访问请求时，它将把该访问请求交给JSP引擎去处理。Tomcat 中的JSP引擎就是一个Servlet程序，它负责解释和执行JSP页面。二、JSP基本语法
2.1 JSP脚本元素
在jsp页面书写java的三种形式：
1.可以声明语句和方法
2.可以书写java代码段
3.可以书写表达式
2.2JSP声明语句
JSP的声明语句用于声明变量和方法，它以“<%“开始，以“%>” 结束，其语法格式如<%！
定义的变量或方法等
%>
在上述语法格式中，被声明的Java代码将被编译到Serlet的jsService(方法之外，即在JSP声明语句中定义的都是成员方法、成员变量、静态方法、静态变量、静态代码块等。在JSP声明语句中声明的方法在整个JSP页面内有效，但是在方法内定义的变量只在该方法内有效。当声明的方法被调用时，会为方法内定的变量分配内存，而调用结束后立刻会释放所占的内存。
在一个JSP页面中可以有多个JSP声明语句，单个声明中的Java语句可以是不完整的，但是多个声明组合后的结果必须是完整的Java语句。接下来，通过一个案例来演示JSP Scriptlets
和声明语句的使用。<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>Insert title here</title> </head> <body> int a=1; int b=2; %> <%! public String dashuju(){ String str="dashuju"; return str; } %> <% out.print(a+b);%> <br/> <% response.getWriter().print("yanmin");%> <br/> <% out.print(dashuju());%> <br/> <br/><br/><br/> <%=a+b %> <br/> <%=dashuju()%> </body> </html>2.3.JSP 指令
page指令、include指令、taglib指令（现在不讲）
page指令
page指令的用途是设置与jsp页面相关的信息，比如说设置jsp页面的编码，jsp页面的默认语言等
基本语法格式：<%@ page 属性=“属性值” 属性=“属性值” 属性=“属性值” %>
比如：<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>include指令：
在jsp页面通常会需要显示其它页面的信息，所以可以通过这个include指令把其它页面包含过来。
基本语法：<%@ include file=“被包含文件的url” %>
创建两个jsp页面： date.jsp页面<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%@page import="java.util.Date" %> <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>Insert title here</title> </head> <body> date.jsp页面用来输出当前时间 <%out.print(new Date().toLocaleString()); %>> </body> </html>
include.jsp页面<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>Insert title here</title> </head> <body> 我是include页面，下面是我包含进来的页面： <%@ include file="date.jsp" %> </body> </html>
三、JSP隐式对象
隐式对象概述
什么是隐式对象：在jsp页面里面，jsp提供了一些对象，不用咱们自己创建，可以直接使用的对象。
jsp常见的九大隐式对象：
request: HttpServletRequest,请求对象，它同时也是域对象，作用范围一次请求
response:HttpServletResponse,响应对象
session: HttpSession ,会话对象，它同时也是域对象，作用范围一次会话
application:ServletContext,上下文对象，它同时也是域对象，作用范围整个项目
config:ServletConfig,配置对象
out:JspWriter,其实和PrintWriter作用差不多。
page:Object ,代表当前jsp的页面对象
pageContext:PageContext ,jsp容器
exception:Throwable,异常对象，用来捕获异常信息。
只有当前jsp页面有isErrorPage="true"这个属性时，才能使用exception对象。
3.1out对象
在JSP页面中，经常需要向客户端发送文本内容，这时，可以使用out对象来实现。out对象是javax servlet.jsp.JspWriter类的实例对象，它的作用与ServletResponse.getWriter()方法返回的PrintWriter对象非常相似，都是用来向客户端发送文本形式的实体内容。不同的足，out对象的类型为JSpWriter, 它相当于一种带缓存 功能的PintWriteror接下来，通过一张图来描述JSP页面的out对象与Servlet引擎提供的缓冲区之间的工作关系
在chapter06项目的WebContent 目录下创建out.jsp文件。<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>Insert title here</title> </head> <body> <% out.print("first line <br/>"); response.getWriter().print("seconde line <br/>"); %> </body> </html>
3.2pageContext 对象
在JSP页面中，使用pageContext对象可以获取JSP的其他8个隐式对象。pageContext对象是javax. servlet.jsp PageContext类的实例对象，它代表当前JSP页面的运行环境，并提供了一系列用 于获取其他隐式对象的方法。pageContext 对象获取隐式对象的方法
结论：在pageContext域对象使用findAttribute方法获取值，进行了全域查找，
查找的范围：pageContext—>request----->session----->application
首先找域作用范围小的对象，如果有值获取到，停止向下查找，如果不存在对应的值，就继续向下寻找。
编写pageContext<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>Insert title here</title> </head> <body> <% HttpServletRequest req=(HttpServletRequest) pageContext.getRequest(); pageContext.setAttribute("dashuju11", "pagecontext",PageContext.PAGE_SCOPE); pageContext.setAttribute("dashuju22","REQUEST",pageContext.REQUEST_SCOPE); pageContext.setAttribute("dashuju33","SESSION",pageContext.SESSION_SCOPE); pageContext.setAttribute("dashuju","APPLICATION",PageContext.APPLICATION_SCOPE); %> <%=pageContext.findAttribute("dashuju") %> <hr/> <%=(String)req.getAttribute("dashuju") %> </body> </html>
3.3exception 对象
它是用来捕获异常信息的。
使用它通常会用到两个属性：
errorPage:属性对应的值，处理异常信息的页面，就是说在当前页面发生了异常，跳转到处理异常信息的页面
比如：<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" errorPage="error.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=UTF-8"> <title>Insert title here</title> </head> <body> <% int a=3; int b=0; %> 输出：<%=(a/b) %>
isErrorPage: 属性对应的值是true或者false,如果为true，在当前页面可以使用exception对象
比如：<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" 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> 输出异常信息： <%=exception.getMessage() %> </body> </html>
2020080605041
-
JSP的基本使用总结
2020-08-11 13:14:23JSP的使用 本文适合初学者学习JSP时参考，包括代码演示，相信初学者看完一定有所收获，本文可以学习...文章目录JSP的使用一、JSP的介绍与创建二、JSP的本质三、JSP的语法四、JSP中的常用脚本1. 声明脚本2. 表达式脚本3.展开全文JSP的使用
还可以看看博主的其他文章：
MySQL的时使用，看这篇就够了，传送地址：MySQL必知必会
Servlet服务器必知必会，传送地址：初学Servlet服务器，看这篇就够了文章目录
一、JSP的介绍与创建
- JSP的全称是Java Server Pages，即Java的服务器页面
- JSP的主要作用是代替Servlet程序回传HTML页面的数据
- web目录(或其他)右击 --> new --> JSP/JSPX --> 输入文件名 --> 选择JSP file创建
二、JSP的本质
JSP页面本质上是一个Servlet程序，第一次访问JSP页面时(运行Tomcat服务器后在浏览器地址栏输入路径)，Tomcat服务器会将此JSP页面翻译成为一个Java源文件，并对其进行编译成为.class字节码文件(一个.java，一个.class)，当打开.java文件时发现其中的内容是：
而HttpJspBase类直接继承于HttpServlet类，即JSP翻译出来的Java类间接继承于HttpServlet类，证明JSP页面是一个Servlet程序三、JSP的语法
JSP头部的page指令：
JSP头部的page指令可以修改JSP页面中的一些重要属性或行为
(以下属性均写在page指令中，默认page指令中没有出现的属性都采用默认值)：(1) contentType属性：表示JSP返回的数据类型是什么，即response.setContentType()的参数值
(2) language属性：表示JSP翻译之后是什么语言文件(目前只支持Java)
(3) pageEncoding属性：表示当前JSP文件本身的字符集(可在IDEA右下角看到)
(4) import属性：表示导包(导类)，与Java一致
(5) autoFlush属性：设置当out输出流缓冲区满了之后是否自动刷新缓冲区，默认值是true
(6) buffer属性：设置out缓冲区的大小，默认是8kb
注意：out缓冲区满了之后不能自动刷新的话会报错
(7) errorPage属性：设置当JSP页面运行出错时自动跳转到的页面(错误信息页面)的路径，这个 路径一般都是以斜杠打头，表示请求的地址是http://ip:port/工程路径/，对应代码web目录
(8) isErrorPage属性：设置当前JSP页面是否是错误信息页面，默认是false，如果是true可以 获取错误信息
(9) session属性：设置访问当前JSP页面时是否会创建HttpSession对象，默认值是true
(10) extends属性：设置JSP页面翻译出来的Java类默认继承谁注意：以上默认值除非有特殊需要，否则不建议修改
四、JSP中的常用脚本
1. 声明脚本
格式：<%! 声明Java代码 %>
作用：可以给JSP翻译出来的Java类定义属性、方法、静态代码块、内部类等
特点：不会在浏览器的页面上显示出来，仅存在于翻译后的Java类中代码演示：声明脚本的使用(此JSP文件在web目录下，名为First.jsp)
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <%@ page import="java.util.HashMap" %> <%@ page import="java.util.Map" %> <html> <head> <title>Title</title> </head> <body> <%--1.声明类属性--%> <%! private String name; private static Map<String, Object> map; %> <%--2.声明类方法--%> <%! public int sum() { return 12; } %> <%--3.声明静态代码块--%> <%! static { map = new HashMap<String, Object>(); map.put("key1", "value1"); } %> </body> </html>对应的翻译后的java源文件：
2. 表达式脚本
格式：<%=表达式 %>
作用：在浏览器的JSP页面上输出数据(只有此脚本可以在浏览器的页面上输出数据)
特点：
(1) 所有的表达式脚本都会被翻译到对应的Java类的_jspService()方法中，故表达式脚本可以 直接使用_jspService()方法参数中的对象
(2) 表达式脚本都会被编译后的Java类中的out.print()方法输出到浏览器页面上
(3) 表达式脚本中的表达式不能以分号结束代码演示：表达式脚本的使用(此JSP文件在web目录下，名为First.jsp)
<%=22 %> <br/> <%="可以输出字符串" %> <br/> <%=map %> <br/> <%--使用_jspService方法中的对象--%> <%=request.getParameter("username") %>启动Tomcat服务器后浏览器的运行结果：
对应的翻译后的Java源文件(在_jspService方法中)：
注意：-
write方法中的标签、转义字符自动识别为对应的
功能，不在页面输出，执行各自代表的功能 -
out的两个方法也在_jspService方法中，也都是java语言
-
只有print、write方法、表达式脚本中的内容才可在浏览器中显示，其余Java代码的sout在控制台输出
3. 代码脚本
格式：<% Java语句 %>
作用：在JSP页面中可以编写需要的Java代码
特点：
(1) 代码脚本翻译后都在_jspService方法中，故代码脚本可以直接使用此方法参数中的对象
(2) 可以由多个代码脚本块组合完成一个完整的Java语句
(3) 代码脚本还可以和表达式脚本一起组合使用，在JSP页面上输出数据代码演示：代码脚本的使用(此JSP文件在web目录下，名为First.jsp)
<%--1.if语句--%> <% int i = 1; if (i == 1) { System.out.println("我爱祖国！"); } else { System.out.println("我很爱祖国！"); } %> <br/> <%--2.for循环语句--%> <% for (int j = 0 ; j < 3; j++) { System.out.println("第" + j + "次循环"); } %> <br/> <%--3.使用_jspService方法参数中的对象--%> <% String username = request.getParameter("username"); System.out.println("username对应的值为：" + username); %>运行结果：
启动Tomcat服务器后在地址栏输入：http://localhost:8080/MyTest/First.jsp?username=Jaychou
在控制台显示：
对应的翻译后的Java源文件(在_jspService方法中)：
五、JSP三种注释
- HTML注释：
<!--HTML注释-->
HTML注释会被翻译到JSP文件对应的Java类的_jspService方法中，以out.write()输出到客户端，
write方法会自动识别标签，执行标签对应的功能，不会在浏览器的页面上输出注释 - Java注释：(1) //单行注释 (2)
/*多行注释*/
Java注释要写在声明脚本和代码脚本中才被认为是Java注释，会被翻译到JSP文件对应的Java类的_jspService方法中，在对应的Java类中也是注释 - JSP注释：<%- -这是JSP注释- -%>
JSP注释中的内容不会在JSP文件翻译后的Java类中出现，即注释中的内容没有任何功能
六、JSP九大内置对象
JSP的内置对象指的是Tomcat服务器将JSP页面翻译为Java类之后内部提供的九大对象：
(将page指令的isErrorPage属性写成true可以出现exception对象)
request：请求对象
response：响应对象
pageContext：JSP的上下文对象
session：会话对象
application：ServletContext对象
config：ServletConfig对象
out：JSP输出流对象
page：指向当前JSP的对象
exception：异常对象七、JSP四大域对象
域对象是指可以像Map一样存取数据的对象，四个域对象功能一样，只是对数据的存取范围不同代码演示1：四个域对象存取数据的范围的不同(在web目录下创建scope1.jsp)
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>scope1</title> </head> <body> <h1>scope1.jsp页面</h1> <% //向四个域对象中分别保存数据 pageContext.setAttribute("key", "pageContext"); request.setAttribute("key", "request"); session.setAttribute("key", "session"); application.setAttribute("key", "application"); %> <%-- <jsp:forward page=""></jsp:forward>是请求转发标签， page属性设置请求转发的路径 --%> <jsp:forward page="/scope2.jsp"></jsp:forward> </body>代码演示2：在web目录下创建scope2.jsp
<head> <title>Title</title> </head> <body> <h1>scope2.jsp页面</h1> <%-- JSP页面中不加任何标签直接输入的内容被write方法输出在浏览器的页面上 --%> pageContext域是否有值：<%=pageContext.getAttribute("key")%> <br> request域是否有值：<%=request.getAttribute("key")%> <br> session域是否有值：<%=session.getAttribute("key")%> <br> application域是否有值：<%=application.getAttribute("key")%> <br> </body>运行结果1：
运行结果2：
注意：若四个域对象在使用时范围都可满足要求，则使用的优先顺序是(范围从小到大)：
pageContext --> request --> session --> application八、JSP的out输出和response.getWriter输出的异同
- 相同点：response表示响应，用于给客户端(浏览器)返回内容
out同样也是用于给客户端(浏览器)输出内容 - 不同点：
- 注意：由于官方的代码中翻译后的Java代码底层都是使用out进行输出，故一般都使用out进行 输出，out又分为write方法和print方法：
(1) out.print()：会将任何内容转换成字符串后调用write方法输出
(2) out.write()：输出字符串没有问题，但输出int型时会将int转换成char输出，导致输出的并非是想要的数字而是数字对应的ASCII码
结论：JSP页面的代码脚本中任何要输出在浏览器的内容均使用out.print()方法
九、JSP的常用标签
1. 静态包含
(1)使用场景：
(2)使用方法：
<%@include file=“”%>
其中file属性设置要包含的JSP页面，以/打头，代表http://ip:port/工程路径/，对应web目录代码演示1：在web目录下创建body.jsp
<body> 头部信息 <br> 主体信息 <br> <%@include file="/foot.jsp"%> </body>代码演示2：在web目录下创建foot.jsp
<body> 页脚信息 <br> </body>运行结果：
(3)静态包含的特点：
①静态包含不会将被包含的JSP页面翻译成.java.class文件
②静态包含是把被包含的页面的代码拷贝到body.jsp对应的Java文件的对应位置执行输出2. 动态包含
(1)使用方法：
<jsp:include page=””></jsp:include>
其中page属性设置要包含的JSP页面，与静态包含一致(2)动态包含的特点：
①动态包含将被包含的JSP页面翻译成.java.class文件
②动态包含还可以传递参数
③动态包含底层使用如下代码调用被包含的JSP页面执行输出：
org.apache.jasper.runtime.JspRuntimeLibrary.include(request, response, “/foot.jsp”, out, false);代码演示1：在web目录下创建body.jsp
<body> 头部信息 <br> 主体信息 <br> <jsp:include page="/foot.jsp"> <jsp:param name="username" value="Jaychou"/> <jsp:param name="password" value="root"/> </jsp:include> </body>注意：
- 设置参数的标签要写在动态包含之中
- 出现Expecting “jsp:param” standard action with “name” and “value” attributes异常，两个原因：
①动态包含中未设置参数但没有把<jsp:include page=””></jsp:include>放在一行上
②动态包含中加了注释
代码演示2：在web目录下创建foot.jsp
<body> 页脚信息 <br> <%=request.getParameter("username")%> </body>运行结果：
(3)动态包含的底层原理：
十、ServletContextListener监听器
1. Listener监听器的介绍
(1) Listener监听器是JavaWeb的三大组件之一
(2) Listener监听器是JavaEE的规范(接口)
(3) Listener监听器的作用是监听某件事物的变化，然后通过回调函数反馈给程序做一些处理2. ServletContextListener监听器
ServletContextListener监听器可以监听ServletContext对象的创建和销毁(web工程启动时创建，停止时销毁)，监听到创建和销毁之后都会调用ServletContextListener监听器的方法进行反馈：
public interface ServletContextListener extends EventListener { //在ServletContext对象创建之后调用 public void contextInitialized(ServletContextEvent sce); //在ServletContext对象销毁之后调用 public void contextDestroyed(ServletContextEvent sce); }3. ServletContextListener监听器的使用步骤
(1) 编写一个类实现ServletContextListener接口
(2) 重写两个方法
(3) 在web.xml文件中配置监听器代码演示1：创建一个类
public class ListenerTest implements ServletContextListener { @Override public void contextInitialized(ServletContextEvent servletContextEvent) { System.out.println("ServletContext对象创建"); } @Override public void contextDestroyed(ServletContextEvent servletContextEvent) { System.out.println("ServletContext对象销毁"); } }代码演示2：在web.xml中配置
<listener> <!-- <listener-class>标签中写上述程序的全类名 --> <listener-class>com.qizegao.servlet.ListenerTest</listener-class> </listener>运行结果：
Tomcat服务器启动之后控制台输出ServletContext对象创建
Tomcat服务器停止之后控制台输出ServletContext对象销毁注意：
- 查看翻译后的Java源文件的方法：启动Tomcat服务器访问到JSP页面之后在控制台输出的信息的前端找到Using CATALINA_BASE中的路径，在硬盘中打开此目录，点击work --> Catalina --> localhost，找到对应的工程文件夹寻找即可
- 访问JSP页面其实是在执行对应的翻译后的Java代码的_jspService方法：翻译后的Java类中没有service方法，而是重写了父类的_jspService方法，这个方法会被父类的service方法调用
-
基于java的图书管理系统（jsp+mysql）
2017-07-02 21:21:04基于java的图书管理系统（jsp+mysql） -
jsp登陆界面模板
2014-05-20 11:32:55css登陆界面的样板，稍加修改就能使用，只是简单的模板，可以在此基础上继续增加是面板更加丰富 -
jsp密码修改页面
2014-05-10 12:41:50就是密码修改的提示页，使用者只需简单修改即可加到自己的项目中。 -
servlet和jsp学习指南
2015-07-18 21:45:28servlet和jsp学习指南 -
Jsp日期控件
2012-11-04 19:54:29Jsp日期控件 自己改的jsp页面弹出的日期选择 里面有例子！点击 下拉各种弹出！很全的 -
用户登录Demo(JSP+Servlet)
2015-09-12 10:52:08<> 失败：保存错误信息到request域，转发到login.jsp(login.jsp显示request域中的错误信息) <> 成功：保存用户信息到session域中，重定向到main.jsp页面，显示session域中的用户信息 > main.jsp：从session域获取... -
零基础学Java Web开发 jSP+Servlet+Struts +Spring+Hibernate+Ajax
2015-07-18 20:19:49零基础学Java Web开发 jSP+Servlet+Struts +Spring+Hibernate+Ajax零基础学Java Web开发 jSP+Servlet+Struts +Spring+Hibernate+Ajax零基础学Java Web开发 jSP+Servlet+Struts +Spring+Hibernate+Ajax零基础学Java ... -
2.《JSP应用开发案例教程》第1章 JSP概述
2021-10-09 14:49:44第1章 JSP概述 1.1 JSP简介 （1）JSP：Java Server Page是一种动态网页技术标准，是Java Web应用开发的主要技术之一，也是目前Web应用开发的主流技术之一。 （2）JSP类似于ASP、PHP，可在HTML文档(*.html、*.htm)中... -
jsp练习题
2020-03-23 15:05:141.在JSP中要使用user包中的User类，则以写法正确的是（ ） A：<jsp:useBean id="user" class=" user.User" scope="page" /> B：<jsp:useBean class="user.Use.class"/> C：<jsp:useBean name="user" ... -
JSP-课后答案
2020-11-23 23:44:13《JSP实用教程（第三版）》课后答案 第 1 章 JSP 1. 安装 Tomcat引擎的计算机需要事先安装 JDK 吗？ 答：需要 2. 怎样启动和关闭 Tomcat服务器 ? 答：bin 目录下使用 startup.bat启动 Tomcat服务器。bin 目录下... -
JSP程序设计教程课件及完整代码（郭真）
2014-02-26 11:26:10这是《JSP程序设计教程》郭真版本的。里面有第一章到第九章的PPT课件和第1到12章完整代码。 -
搞定J2EE核心技术与企业应用:Ajax,JSP,Struts2,Spring,Hibernate，完整扫描版
2014-03-19 17:50:51《搞定j2ee核心技术与企业应用：ajax，jsp，struts 2，spring，hibernate》是笔者在多年项目开发过程中的经验总结，它通过丰富的实例由浅入深、循序渐进地介绍了目前采用java进行web开发的各种框架的使用方法，从而... -
JSP木马,JSP大马
2011-04-08 16:43:52是目前最强大完整的JSP网站木马脚本（包含了一个JSP小马）。 -
【JSP入门】只知道HTML却不知道JSP？
2022-02-11 22:02:41JSP（全称Java Server Pages）是由 Sun Microsystems 公司倡导和许多公司参与共同创建的一种使软件开发者可以响应客户端请求，而==动态生成== HTML、XML 或其他格式文档的Web网页的技术标准。 -
JSP程序设计复习题库(客观题)
2020-11-14 15:36:251、下面哪一个不是JSP本身已加载的基本类？（B ） A、java.lang.* B、java.io.* C、javax.servlet.* D、javax.servlet.jsp.* 2、以下关于JavaBean的说法中，错误的是（B） A、JavaBean是基于JA V A语言的。 B、... -
Servlet JSP深入详解 基于Tomcat的Web开发
2015-07-17 09:22:25Servlet JSP深入详解 基于Tomcat的Web开发 -
JSP调用摄像头
2013-02-13 16:55:22JSP调用摄像头 MyEclipse导出 -
JavaWeb一JSP简介
2020-03-20 15:17:04本篇想谈谈为啥会出现JSP技术和简单的框架。JavaWeb中有两个地方挺难的，一个是JDBC相关的内容，另一个就是JSP与Servlet（JSP本质也是Servlet）。JDBC之所以让我感觉很难，在于JDBC是我接触的第一个“非Java类”形式... -
JSP项目155套-开发专题-大作业设计-毕业设计【建议在校生收藏】（保持更新）
2021-12-18 16:41:20运行环境: 最好是java jdk 1.8，我们在这个平台上运行的。...用了技术框架： HTML+CSS+JavaScript+jsp+mysql 所用的数据库： Mysql或SQL SQLSERVER 下载相应的数据库即可 毕业设计型 在线点播系统,(论文,ASP,J. -
精通Java Web整合开发(JSP+AJAX+Struts+Hibernate)(第2版)
2012-11-29 14:55:20书籍目录： 《精通java web整合开发(jsp+ajax+struts+hibernate)(第2版)》 第1篇 基 础 篇 第1章 java web应用开发技术选用策略 第2章 开发运行环境的安装与配置 2.1 安装与配置jdk 1.65 2.2 安装web服务器tomcat ... -
JSP是什么
2020-07-26 14:10:17一.JSP简介： JSP（全称JavaServer Pages），JSP将Java代码和特定变动内容嵌入到静态的页面中，实现以静态页面为模板，动态生成其中的部分内容。JSP文件在运行时会被其编译器转换成更原始的Servlet代码。JSP编译器... -
JSP相关练习题及答案（有详解）
2020-04-23 16:32:561.下列不是JSP隐含变量的是______。 A、request B、out C、context D、session 解析:JSP有九大隐含对象，out, request， response, config, session, application, page, pageContext, exception 我的答案：C 2.可以... -
什么是jsp？jsp的内置对象有哪些？
2019-05-15 09:44:28【什么是jsp？jsp的内置对象有哪些？】 每篇分享文从 【背景介绍】【知识剖析】【常见问题】【解决方案】【编码实战】【扩展思考】【更多讨论】【参考文献】 八个方面深度解析前端知识/技能，本篇分享的是： ... -
jsp是什么以及jsp运行原理
2021-03-26 14:38:34jsp是什么以及jsp运行原理 一.JSP的简单介绍 1. JSP(Java Server Pages)是由Sun Microsystems公司倡导、许多公司参与一起建立的一种动态网页技术标准。JSP技术有点类似ASP技术，它是在传统的网页HTML文件(.htm,.html...
