Web学习笔记

Web应用程序是一种基于互联网的软件应用程序，它通过浏览器来提供服务和功能。用户可以使用Web应用程序在互联网上执行各种任务，如购物、社交、学习、工作等。这些应用程序通常使用Web技术（例如HTML、CSS、JavaScript等）来构建，并在Web服务器上运行。

Web应用程序的运行逻辑：

用户发出请求： 用户在浏览器中输入Web应用程序的网址（URL）或者通过点击链接、按钮等与Web应用程序进行交互。这些请求通常是HTTP请求。

Web服务器接收请求： 用户的请求到达Web服务器，服务器收到请求后开始处理。

应用程序逻辑处理： Web服务器将请求传递给Web应用程序，应用程序进行逻辑处理。这可能包括从数据库中获取数据、处理用户输入、生成动态内容等。

生成响应： 应用程序根据请求处理的结果生成一个HTTP响应。这个响应包含了要在用户浏览器上显示的内容，通常是HTML、CSS、JavaScript和其他资源。

发送响应： 生成的HTTP响应发送回到用户的浏览器。

浏览器渲染： 用户的浏览器接收到响应后，开始解析和渲染HTML、CSS和JavaScript，将内容显示在用户的屏幕上。

用户与应用程序交互： 用户可以在浏览器中与Web应用程序的页面进行交互，例如填写表单、点击按钮、触发事件等。

再次请求： 如果用户在应用程序上执行了操作，可能会产生新的请求，重复上述步骤。

网络顺序：

Web应用程序的运行涉及多个设备和网络层级，按照一般顺序为：

客户端（Client）： 用户使用的设备，如计算机、手机、平板电脑等，装有浏览器用于访问Web应用程序。

本地网络： 用户的设备连接到本地网络，如家庭Wi-Fi或公司局域网。

互联网： 本地网络通过互联网连接到Web服务器，互联网是连接全球网络的基础设施。

Web服务器： 接收并处理用户请求的服务器，运行Web应用程序。

应用程序服务器： 对于复杂的Web应用程序，可能涉及应用程序服务器来处理业务逻辑。

数据库服务器： Web应用程序通常需要从数据库中获取或存储数据，数据库服务器用于管理和存储数据。

在这个网络顺序中，数据和请求通过互联网在不同的服务器之间传递，直到最终在用户的浏览器上显示出来。Web应用程序的运行涉及多个环节的协调与交互，这样的设计使得Web应用程序具有高度的可扩展性和灵活性。

[TOC]

1.架构

B/S架构

当谈到BS架构（Browser-Server架构）的Web应用程序时，我们可以用一个简单的比喻来帮助新手理解。想象一下您正在参加一场虚拟咖啡馆会议：

浏览器（Browser）： 就像您自己坐在电脑前的浏览器，它是您与Web应用程序交互的窗口。您可以在浏览器中输入网址、点击链接或按钮，就像在虚拟咖啡馆会议中发言、举手或参与讨论一样。
服务器（Server）： 咖啡馆的服务员就像服务器，他们接收您的需求并提供所需的服务。在BS架构中，服务器是一个强大的计算机，它储存了Web应用程序的所有信息和逻辑。当您在浏览器中发出请求时，服务器会处理您的请求并提供相应的内容，就像服务员会为您提供咖啡、点心和其他所需的东西一样。
交互过程： 当您在浏览器中输入网址并按下回车时，这就像您走进咖啡馆并坐下。您告诉服务员您的需求，服务员将您的请求带到厨房（服务器处理请求），然后返回您所需的咖啡和点心（服务器响应请求）。您通过浏览器看到的内容，就像您在桌子上看到的咖啡和点心一样。
分离性： 就像在虚拟咖啡馆会议中，您不需要亲自去厨房，只需与服务员交互，BS架构将前端（浏览器）和后端（服务器）分开。这种分离性使得开发人员可以独立地设计、构建和维护这两部分，从而使整个系统更加有序和灵活。

总的来说，BS架构的Web应用程序就像您在虚拟咖啡馆与服务员进行交互一样。您使用浏览器发送请求，服务器处理并返回响应，这种分离性和交互方式使得Web应用程序变得高效、灵活且易于维护。

C/S架构

2.Tomcat

当谈到Tomcat时，它是一个非常流行的Java Servlet容器和JavaServer Pages（JSP）容器，它允许您在Web服务器上运行Java Web应用程序。以下是Tomcat的一些主要特点，以便新手更容易理解：

1. 什么是Servlet和JSP：

Servlet是Java编写的服务器端程序，用于处理客户端请求并生成动态内容。
JSP是JavaServer Pages的缩写，它是一种将Java代码嵌入HTML页面的技术，用于生成动态Web内容。

2. Tomcat是什么：

Tomcat是Apache软件基金会的一个开源项目，它是一个Servlet容器，也称为Web容器。它的主要作用是运行Servlet和JSP，将这些动态内容转换成HTML并发送给客户端浏览器。

3. 轻量级：

Tomcat是一个相对轻量级的Web服务器，适合用于小到中等规模的应用程序。

4. 独立性：

Tomcat是一个独立的Web服务器，您可以将其与其他Web服务器（如Apache HTTP Server）结合使用，或者将其作为独立的Web服务器运行。

5. 容易配置：

Tomcat具有简单且易于理解的配置。大多数情况下，您只需对默认配置进行少量修改即可开始运行Web应用程序。

6. 内置开发支持：

Tomcat内置了一个方便的开发模式，它允许您在不重启服务器的情况下进行应用程序的修改和调试。

7. 易于部署：

将Java Web应用程序部署到Tomcat中通常很简单。只需将您的WAR（Web ARchive）文件放在指定的目录中，Tomcat将自动将其解压并启动您的应用程序。

8. 支持多个协议：

Tomcat支持HTTP和HTTPS协议，并可以通过配置支持其他协议，如AJP（Apache JServ Protocol）。

9. 健壮性：

Tomcat在运行Java Web应用程序时表现良好，并且对于处理并发请求和大量用户非常可靠。

总之，Tomcat是Java Web开发的重要组成部分，它为Java开发人员提供了一个快速、可靠且易于使用的平台，用于构建和运行动态的Java Web应用程序。对于新手来说，了解Tomcat的这些基本特点将有助于更好地理解它在Java Web开发中的作用和价值。

Tomcat目录

当您使用Tomcat作为您的Java Web应用程序的服务器时，了解Tomcat的目录结构对于新手是非常重要的。这里我会简要介绍Tomcat的主要目录，以帮助您更容易理解：

bin目录：
- 这个目录包含了可执行文件，如启动和停止Tomcat服务器的脚本。在Windows系统中，您会找到startup.bat用于启动Tomcat，shutdown.bat用于停止Tomcat。在类Unix系统中，对应的文件分别是startup.sh和shutdown.sh。
conf目录：
- 这个目录包含了Tomcat的配置文件。其中最重要的文件是server.xml，它定义了Tomcat服务器的配置信息，如端口号、虚拟主机设置等。此外，还有其他一些配置文件，如web.xml用于配置Web应用程序的设置，tomcat-users.xml用于定义Tomcat管理员的登录信息等。
lib目录：
- 该目录包含Tomcat服务器运行所需的Java类库（JAR文件）。这些类库是Tomcat运行的核心组件，包括Servlet和JSP的实现以及其他支持文件。
logs目录：
- Tomcat在运行时会将各种日志文件保存在这个目录中。这些日志文件包含了服务器的访问日志、错误日志和其他重要的运行时信息，对于故障排查和性能监测非常有用。
webapps目录：
- 这个目录是您放置Web应用程序的地方。每个放在这个目录下的文件夹都会被Tomcat当作一个独立的Web应用程序来部署和运行。例如，如果您的应用程序是myapp.war，将其放在webapps目录下，Tomcat将自动将其解压并启动您的应用程序。
work目录：
- Tomcat在运行时将生成临时文件和缓存文件，并将它们存储在这个目录中。这些临时文件通常是编译后的Servlet类文件和JSP文件，以及其他缓存数据。
temp目录：
- 临时文件目录。Tomcat在运行时会在这个目录中创建临时文件，并在不再需要时自动删除。
logs目录：
- Tomcat的日志目录。Tomcat会将服务器运行过程中的日志信息保存在这个目录中，包括访问日志、错误日志等。

请注意，Tomcat的目录结构可能会因版本而异，但通常以上述目录为基础。了解Tomcat的目录结构有助于您更好地管理和理解Tomcat服务器以及您的Java Web应用程序的部署和运行。

3.JSP

JSP介绍

当谈到JSP（JavaServer Pages），可以将其想象成一种用于在Web应用程序中创建动态内容的技术。JSP允许您在HTML页面中嵌入Java代码，以便在服务器端生成动态内容，然后将其发送到用户的浏览器。

JSP的主要特点和工作原理：

动态内容生成： JSP允许您将Java代码嵌入到HTML中，从而能够在服务器上动态生成内容。这意味着您可以根据用户请求、数据库数据或其他条件来生成不同的页面内容。
易于学习： 对于熟悉HTML和Java的开发人员来说，学习JSP相对容易。您只需要在HTML中插入少量的Java代码，就可以在页面中实现复杂的逻辑和功能。
与Servlet结合： JSP实际上是基于Servlet技术的，它被转化为Java Servlet并在服务器端运行。这使得JSP可以与Java类、库和框架无缝结合，实现更强大的功能。
分离逻辑和视图： JSP鼓励将Java代码和HTML内容分开，这有助于更好地组织代码，使代码更易于维护和理解。
标签库： JSP标签库（Tag Library）提供了许多预定义的标签，用于执行常见的任务，如循环、条件语句等。这些标签可以简化页面开发过程。
隐式对象： JSP提供了一组隐式对象，可以直接在JSP页面中使用，如请求对象、响应对象、会话对象等，以便更方便地访问和操作Web应用程序的不同方面。

JSP的工作流程：

客户端发出请求： 用户在浏览器中输入URL或点击链接，向Web服务器发出请求。
Web服务器接收请求： Web服务器接收到请求，将其传递给处理JSP的Servlet引擎。
JSP转化为Servlet： JSP文件被Servlet引擎编译成一个Java Servlet。这个Servlet包含了JSP页面中的Java代码和动态内容生成逻辑。
生成动态内容： 编译后的Servlet执行JSP页面中的Java代码，生成动态内容。这可能涉及从数据库获取数据、处理用户输入等。
生成响应： Servlet生成一个包含动态内容的HTTP响应，然后将其发送回给Web服务器。
Web服务器发送响应： Web服务器将生成的响应发送回用户的浏览器。
浏览器渲染： 浏览器接收响应，解析HTML和动态内容，然后在用户的屏幕上渲染出完整的页面。

总之，JSP是一种强大的技术，允许开发人员在HTML中嵌入Java代码，以便在服务器上生成动态内容。这使得Web应用程序可以根据用户的需求和其他条件提供个性化和实时的体验。

JSP工作原理

JSP（JavaServer Pages）的工作原理涉及到以下几个主要步骤：

JSP文件创建和部署： 开发人员编写JSP文件，这些文件包含HTML标记和嵌入在其中的Java代码片段。JSP文件必须部署到Web服务器中，通常与其他Web资源（例如HTML、CSS、JavaScript、Servlet等）一起组成Web应用程序。
JSP的编译： 当Web服务器启动时或者第一次请求JSP页面时，JSP引擎（容器）将对JSP文件进行编译。编译将JSP文件转换为一个Java Servlet。该Servlet类会继承自javax.servlet.jsp.HttpJspBase，并包含在JSP页面中嵌入的Java代码。
Servlet的初始化： 当Servlet被编译后，容器将创建该Servlet的一个实例，并调用其init()方法，进行一些初始化设置。
HTTP请求处理： 当用户在浏览器中请求JSP页面时，Web服务器将创建一个HTTP请求对象，并将其传递给JSP Servlet实例。
JSP代码执行： Servlet实例处理HTTP请求，执行JSP页面中嵌入的Java代码。这些Java代码可能包含条件语句、循环、数据库查询等。在执行过程中，Servlet可以访问一系列隐式对象（如request、response、session等），用于处理客户端发送的请求和生成响应。
动态内容生成： 在JSP代码的执行过程中，Servlet可以根据请求、数据库数据或其他条件来生成动态内容。生成的内容通常是在HTML标记中嵌入的，用于构建最终要发送到浏览器的响应。
HTTP响应生成： Servlet执行完JSP页面中的Java代码后，它将生成一个HTTP响应，其中包含了动态生成的内容。
HTTP响应发送： Servlet将生成的HTTP响应发送回Web服务器。
浏览器渲染： Web服务器将响应传递给用户的浏览器，浏览器解析HTML和动态内容，并将其显示在用户的屏幕上。

需要注意的是，一旦JSP文件被编译成Servlet并生成响应，JSP本身在整个过程中不再直接参与。每次请求JSP页面时，Servlet引擎都会重新处理该JSP，以确保动态内容生成和个性化的效果。

通过这种方式，JSP允许开发人员在HTML中嵌入Java代码，实现更加灵活和动态的Web应用程序。同时，与Java Servlet结合，JSP可以更高效地生成动态内容并响应客户端请求。

JSP基础代码

当你开始学习JSP时，以下是一些基础代码示例，帮助你理解JSP的工作原理和语法。我们将从简单的JSP页面开始，逐步介绍如何嵌入Java代码和显示动态内容。

1. 创建基本的JSP页面：

<!-- index.jsp -->
<!DOCTYPE html>
<html>
<head>
<title>My First JSP Page</title>
</head>
<body>
<h1>Hello, World!</h1>
</body>
</html>

解释：

这是一个简单的HTML页面，其中包含一个h1标签显示”Hello, World!”。
保存该文件为index.jsp，并将其放置在Web应用程序的合适位置，例如在WebContent目录下。

2. 在JSP中嵌入Java代码：

<!-- greet.jsp -->
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<!DOCTYPE html>
<html>
<head>
<title>Greeting Page</title>
</head>
<body>
<%
String name = "John"; // Java代码段，定义一个名为name的字符串变量
out.println("Hello, " + name); // Java代码段，输出动态内容
%>
</body>
</html>

解释：

<%@ page %>指令用于定义页面的属性和配置信息。在这里，我们指定使用Java语言，并且输出的字符编码为UTF-8。
在<body>标签中，我们使用<% %>标签将Java代码嵌入到JSP页面中。
在这个例子中，我们定义了一个名为name的字符串变量，并使用out.println()函数输出”Hello, John”。这样，我们在浏览器中访问该页面时，将看到”Hello, John”被显示出来。

3. 使用JSP隐式对象：

JSP提供了一组隐式对象，您无需声明即可在JSP页面中直接使用。以下是一些常用的隐式对象：

<!-- implicit\_objects.jsp -->
<!DOCTYPE html>
<html>
<head>
<title>Implicit Objects</title>
</head>
<body>
<h1>User Information</h1>
<p>Username: <%= request.getParameter("username") %></p>
<p>IP Address: <%= request.getRemoteAddr() %></p>
<p>Session ID: <%= session.getId() %></p>
</body>
</html>

解释：

request：代表客户端的请求，可以用于获取请求参数等信息。
session：代表用户的会话，可以用于跟踪用户状态和共享数据。

注意：在实际开发中，为了更好地分离逻辑和视图，应该尽量避免在JSP中嵌入过多的Java代码。应该将业务逻辑封装在JavaBean、Servlet或其他后端组件中，并在JSP中调用这些组件，以提高代码的可维护性和复用性。

这些基础的JSP代码示例应该能帮助您开始学习JSP，并逐渐了解如何在JSP中嵌入Java代码和生成动态内容。继续学习JSP和相关的Web开发技术，您将能够构建更复杂和功能丰富的Web应用程序。

JSP关于out.print报红解决办法

虽然可以正常使用，但是却有报红，这是因为lib包和Tomcat的lib没有正确被识别导致的，需要手动识别添加

首先在WEB-INF里建立lib包然后导入在Tomcat-lib里的jaspic-api and servlet-api 导入后在文件-项目结构-模块-你的项目-依赖-Tomcat（没有就点击加号添加）

最后重启项目

JSP实例演示1

<%@ page import="java.util.Date" %>
<%@ page import="java.text.SimpleDateFormat" %><%-- Created by IntelliJ IDEA. --%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title></title>
</head>
<body>
web项目启动成功
<%
Date date = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
String format = simpleDateFormat.format(date);
out.print(format);
String[] fruits = {"Apple", "Banana", "Orange", "Grapes", "Mango"};
%>
<%=format%>
</body>
</html>

4.JSP核心内置对象

基础介绍

request：代表客户端的请求。它可以用来获取客户端发送的数据，比如表单数据、URL 参数等。
response：代表服务器的响应。你可以使用它来发送数据回客户端，比如生成 HTML 内容。
out：这个对象用于输出内容到客户端。你可以使用它将文本、HTML、XML 等内容发送给浏览器。
session：用于在不同请求之间保存用户的会话数据。可以用来存储用户登录信息、购物车内容等。
application：代表整个 web 应用程序的上下文。可以在不同的页面之间共享数据。
pageContext：代表 JSP 页面的上下文信息。可以用来获取其他内置对象。
config：包含 JSP 页面的配置信息，比如初始化参数。
page：指向当前的 JSP 页面本身，可以用来调用自身的方法。
exception：在发生异常时，包含了异常对象的信息。

你可以根据需要，使用这些内置对象来处理不同的任务和数据。记得根据每个内置对象的特点和用途做出相应的笔记。如果需要更详细的信息，可以查阅 JSP 官方文档或其他相关资料。

使用格式

request：假设你有一个简单的登录表单，用户通过输入用户名和密码提交登录请求。在 JSP 页面中，你可以使用 request.getParameter("username") 和 request.getParameter("password") 来获取用户输入的用户名和密码。
response：如果你想向客户端发送一个简单的 “Hello World” 消息，可以使用 response.getWriter().println("Hello World"); 将该消息输出到客户端。
out：你可以使用 out.println("这是输出到浏览器的内容"); 将指定的文本内容输出到客户端的浏览器。
session：假设用户登录后，你想在不同页面之间保持用户的登录状态。你可以使用 session.setAttribute("username", "user123"); 将用户的用户名存储在会话中，在其他页面中通过 session.getAttribute("username"); 获取该值。
application：如果你想在整个 web 应用程序中共享某个值，比如一个全局配置，你可以使用 application.setAttribute("key", value); 存储数据，并在其他页面中通过 application.getAttribute("key"); 获取该值。
pageContext：在 JSP 页面中，你可以使用 pageContext.getRequest() 获取请求对象，或者使用 pageContext.getServletContext() 获取 servlet 上下文对象。
config：如果在 web.xml 配置文件中设置了一个初始化参数，你可以在 JSP 页面中使用 config.getInitParameter("paramName"); 获取该参数的值。
page：你可以在 JSP 页面中使用 <% pageContext.forward("otherPage.jsp"); %> 来调用 otherPage.jsp 页面的内容。
exception：在 JSP 页面中，如果发生异常，你可以使用 exception.printStackTrace(); 输出异常堆栈信息。

from表格提交与接收

<%-- Created by IntelliJ IDEA. --%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>from表单提交</title>
</head>
<body>
<form method="post" action="indexController.jsp">
<in>
商品评价
<input type="radio" value="五星" name="level">五星
<input type="radio" value="四星" name="level">四星
<input type="radio" value="三星" name="level" checked>三星
</p>
<p>
<textarea name="info" rows="4" cols="12"></textarea>
</p>
<p>
配送评价
<input type="checkbox" value="配送快" name="send">配送快</input>
<input type="checkbox" value="配送快" name="send">配送好</input>
<input type="checkbox" value="配送快" name="send">服务态度好</input>
</p>
<p><input type="submit"> <input type="reset"></p>
</form>
</body>
</html>

<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2023/8/7
Time: 14:47
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>接受from</title>
</head>
<body>
<%
//设置乱码
request.setCharacterEncoding("utf-8");
String level = request.getParameter("level");
String info = request.getParameter("info");
out.print(level);
out.print(info);
String[] sends = request.getParameterValues("send");
for (String send:sends){
out.print(send);
}
%>
</body>
</html>

转发和重定向的区别

重定向（Redirect）和转发（Forward）是在 web 应用程序中用于页面跳转的两种不同技术，它们有以下区别：

1. 目标地址不同：

重定向：将请求发送到一个完全不同的 URL 地址。客户端会发起新的请求，并且浏览器地址栏会显示新的 URL。
转发：将请求转发给同一 web 服务器上的另一个资源（如 JSP、Servlet）。客户端不知道发生了转发，URL 地址保持不变。

2. 流程：

重定向：是两次请求-响应过程。首先，客户端发送一个请求给服务器，服务器返回一个响应来重定向到另一个 URL，客户端再次发送请求到该新的 URL。
转发：是一次请求-响应过程。客户端发送请求给服务器，服务器直接将请求转发给另一个资源进行处理，然后返回响应给客户端。

3. 数据传递：

重定向：不同请求之间的数据传递需要使用 URL 参数、Cookie 或者会话（Session）。
转发：可以在服务器端通过请求对象传递数据给目标资源，使用 request.setAttribute()，目标资源可以通过请求对象获取数据。

4. 地址栏变化：

重定向：会导致浏览器地址栏显示新的 URL，因为发生了新的请求和响应。
转发：浏览器地址栏 URL 不会改变，因为是在服务器端内部处理的转发。

5. 应用场景：

重定向：适合用于不同 web 应用程序之间的跳转，或者在处理 POST 请求后防止表单重复提交。
转发：适合用于在同一 web 应用程序内部的页面跳转和共享数据。

在选择重定向或转发时，需要考虑这两者之间的差异以及适用的具体情况。重定向更适合用于不同资源或应用程序之间的跳转，而转发更适合用于在同一应用程序内部进行页面跳转和数据传递。

1	<% request.getRequestDispatcher("home.jsp").forward(request,response); %>

重定向

1	<% response.sendRedirect("home.jsp"); %>

在这种情况如何传参把特定参数给跳转的页

1	<% response.sendRedirect("home.jsp" + username); %>

5.session对象

Session 对象

介绍

session对象是在 web 应用程序中用于在不同请求之间存储和共享用户数据的一种机制。每个用户的 session 对象在用户访问 web 应用程序时都会被创建，它可以在用户的整个会话期间保存数据，直到用户关闭浏览器或会话超时。

特点

session 对象是基于用户的，每个用户都会有自己的 session。
通过 session 对象，可以在不同的页面和请求之间共享数据，无需每次都通过 URL 参数或表单字段传递数据。

使用方法

创建 session 对象：在 JSP 页面或 Servlet 中，可以通过 request.getSession() 方法获取当前用户的 session 对象。如果 session 对象不存在，则会创建一个新的 session。
存储数据：使用 session.setAttribute("key", value) 方法可以将数据存储在 session 对象中。key 是用来标识数据的名称，value 是实际的数据。
获取数据：通过 session.getAttribute("key") 方法可以获取之前存储在 session 中的数据。
删除数据：可以使用 session.removeAttribute("key") 方法从 session 对象中删除指定的数据。
**销毁 session**：通常，session 会在用户关闭浏览器后自动销毁，或者根据配置的超时时间进行销毁。也可以使用 session.invalidate() 方法手动销毁当前用户的 session。

示例

假设你正在开发一个在线购物网站：

用户登录后，可以将用户的用户名存储在 session 对象中，以便在其他页面显示欢迎信息。
用户在浏览商品时，将选中的商品信息存储在 session 对象中的购物车中，以便用户在不同页面之间保持购物车内容。
用户结账时，从 session 对象中获取购物车中的商品信息，进行订单处理。

通过使用 session 对象，你可以在用户的整个会话期间持久化保存用户的状态和数据，实现更好的用户体验。

记得根据需要，将上述内容调整为你的笔记规范，帮助你更好地理解和记忆 session 对象的用法。

`session` 常用方法介绍与举例

1. `setAttribute(String name, Object value)`

作用：将数据存储在 session 对象中。
参数：
- name：用于标识数据的名称。
- value：实际的数据。

示例：在登录成功后，将用户的用户名存储在 session 中。

1 2	String username = "user123"; session.setAttribute("username", username);

2. `getAttribute(String name)`

作用：从 session 对象中获取之前存储的数据。
参数：name：要获取的数据的名称。

示例：在其他页面中获取之前存储的用户名。

1	String storedUsername = (String) session.getAttribute("username");

3. `removeAttribute(String name)`

作用：从 session 对象中删除指定名称的数据。
参数：name：要删除的数据的名称。

示例：在用户退出登录时，清除存储的用户名。

1	session.removeAttribute("username");

4. `invalidate()`

作用：手动销毁当前用户的 session 对象，清除其中的所有数据。

示例：用户注销或会话过期时，调用该方法销毁 session。

1	session.invalidate();

5. `getId()`

作用：获取当前 session 的唯一标识符。

示例：用于记录日志或跟踪用户会话。

1	String sessionID = session.getId();

6. `getCreationTime()`

作用：获取 session 对象创建的时间。

示例：用于跟踪会话的开始时间。

1	long creationTime = session.getCreationTime();

7. `getLastAccessedTime()`

作用：获取用户上次访问 session 对象的时间。

示例：用于判断用户是否活跃。

1	long lastAccessedTime = session.getLastAccessedTime();

通过上述常用方法，你可以在 session 对象中存储、获取、删除数据，管理用户会话，以及追踪用户活动。这些方法能够帮助你更好地利用 session 来维护用户状态和数据。

JSP连接数据库模板

<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2023/8/7
Time: 17:01
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>数据库读取输出</title>
</head>
<body>
<%@ page import="java.sql.\*" %>
<%
// 声明数据库连接信息
String jdbcUrl = "jdbc:mysql://localhost:3306/zhuanzhuandb?serverTimezone=GMT-8"; // 数据库的连接 URL
String username = "root"; // 数据库用户名
String password = "123"; // 数据库密码
try {
// 加载MySQL驱动程序
Class.forName("com.mysql.cj.jdbc.Driver");
// 建立数据库连接
Connection connection = DriverManager.getConnection(jdbcUrl, username, password);
// 创建并执行查询
Statement statement = connection.createStatement();
String sql = "SELECT ROW\_NUMBER() OVER (ORDER BY addTime) AS row\_num, id, name, price, addTime FROM goods WHERE isOnSell = 1 LIMIT 1 , 5";
ResultSet resultSet = statement.executeQuery(sql);
out.println("\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_" + "<br>");
out.println( "序号" + "\t" + "好物编号" + "\t" + "姓名" + "\t" + "价格" + "\t" + "上架时间"+ "<br>");
out.println("\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_"+ "<br>");
try {
while (resultSet.next()){
int x = resultSet.getInt(1);
int id = resultSet.getInt(2);
String name = resultSet.getString(3);
int price = resultSet.getInt(4);
String Date = resultSet.getString(5);
out.println(x + "\t" + "\t" + id + "\t" + name + "\t" + price + "\t" + Date+ "<br>");
}
System.out.println("\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_"+ "<br>");
} catch (Exception e) {
e.printStackTrace();
}
// 关闭资源
resultSet.close();
statement.close();
connection.close();
} catch (ClassNotFoundException e) {
out.println("MySQL驱动程序未找到： " + e.getMessage());
} catch (SQLException e) {
out.println("数据库连接错误： " + e.getMessage());
}
%>
</body>
</html>

7.JSP数据访问

include

在JSP中，<%@ include %> 指令用于将一个文件的内容嵌入到另一个文件中，从而在页面上进行代码重用。这种技术被称为”包含”（include），它可以在编译时或运行时将指定的文件内容合并到当前的JSP页面中。

包含可以帮助减少代码的冗余，提高代码的可维护性，并允许在多个页面中共享相同的代码片段。有两种主要的包含方式：

静态包含（Static Include）：
1
2
3
<%@ include file="header.jsp" %>

<%@ include file="footer.jsp" %>
静态包含在JSP页面的编译阶段将被合并到当前页面，作为页面的一部分。在生成的servlet代码中，被包含的内容就像直接写在包含指令的位置一样。
动态包含（Dynamic Include）：
1
2
3
<jsp:include page="header.jsp" />

<jsp:include page="footer.jsp" />
动态包含在运行时通过JSP引擎实现，允许根据条件或用户请求来包含特定的内容。包含的内容在页面每次请求时都会被执行和合并。

无论是静态包含还是动态包含，都可以用来引入头部、尾部、导航栏或其他在多个页面中重复的部分。需要注意的是，包含操作只是将文件的内容嵌入到页面中，而不会改变上下文中的变量或对象作用域。

application

Application 对象介绍

在 JavaServer Pages (JSP) 中，application 对象是一个全局的 Servlet 上下文对象，代表整个 Web 应用程序的范围。它允许在不同的会话和请求之间共享数据，并且在整个应用程序的生命周期内保持持久性。application 对象的数据在所有用户之间共享，适合存储全局配置、共享资源等信息。

方法	描述
`setAttribute(String name, Object value)`	将一个数据对象存储在 `application` 对象中。
`getAttribute(String name)`	通过名称从 `application` 对象中获取之前存储的数据对象。
`removeAttribute(String name)`	从 `application` 对象中移除特定名称的数据对象。
`getInitParameter(String name)`	获取应用程序的初始化参数，这些参数在 `web.xml` 文件中配置。
`getInitParameterNames()`	获取应用程序的所有初始化参数的名称。
`getServletContextName()`	获取当前 Servlet 上下文的名称。
`getResource(String path)`	获取与给定路径关联的 URL 对象，用于访问 Web 应用中的资源。
`getResourceAsStream(String path)`	获取与给定路径关联的输入流，用于读取 Web 应用中的资源。
`getRequestDispatcher(String path)`	获取一个请求分派器，用于将请求转发给其他资源。
`log(String message)`	在服务器日志中记录一条消息。
`log(String message, Throwable throwable)`	在服务器日志中记录一条消息及其相关的异常信息。

常用的 application 对象方法0

**setAttribute(String name, Object value)**：用于将一个数据对象存储在 application 对象中。可以通过名称访问存储的对象。

示例：
1
2
3
<%
application.setAttribute("companyName", "MyCorp Inc.");
%>
**getAttribute(String name)**：通过名称从 application 对象中获取之前存储的数据对象。

示例：
1
2
3
<%
String companyName = (String) application.getAttribute("companyName");
%>
**removeAttribute(String name)**：从 application 对象中移除特定名称的数据对象。

示例：
1
2
3
<%
application.removeAttribute("companyName");
%>
**getInitParameter(String name)**：获取应用程序的初始化参数，这些参数在 web.xml 文件中配置。

示例：
1
2
3
<%
String databaseURL = application.getInitParameter("databaseURL");
%>
**getServletContextName()**：获取当前 Servlet 上下文的名称。

示例：
1
2
3
<%
String contextName = application.getServletContextName();
%>

JSP作用域介绍

JSP 提供了四种不同的对象作用域，它们分别是页面作用域（Page Scope）、请求作用域（Request Scope）、会话作用域（Session Scope）和应用程序作用域（Application Scope）。这些作用域具有不同的范围和大小，适用于不同的数据共享需求。

页面作用域（Page Scope）：

范围：仅在单个 JSP 页面中有效。
大小：最小，只在当前页面内共享数据。
适用场景：适合存储和传递仅在页面上使用的临时数据。

请求作用域（Request Scope）：

范围：在同一次 HTTP 请求中有效，对于处理该请求的所有 JSP 页面和 Servlet 可见。
大小：适中，适合在同一次请求的多个页面之间共享数据。
适用场景：在请求处理过程中传递数据，如表单提交后的数据传递。

会话作用域（Session Scope）：

范围：在整个用户会话期间有效，跨多个请求和页面。
大小：较大，适用于在整个用户会话中保持状态和数据。
适用场景：存储用户登录状态、用户首选项、购物车等会话级别的数据。

应用程序作用域（Application Scope）：

范围：在整个 Web 应用程序生命周期内有效，对所有用户和请求可见。
大小：最大，适用于全局配置、共享资源等数据。
适用场景：存储全局设置、共享的数据库连接池等全局级别的数据。

选择适当的作用域取决于数据的生命周期和共享范围。更小的作用域可以提高数据隔离和安全性，但可能需要更多的数据传递工作。更大的作用域可以简化数据共享，但需要注意可能的并发问题和资源消耗。根据具体需求合理选择作用域是很重要的。

JavaBean

8.Serviet

Servlet创建、配置和调用

package com.bdqn.web;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import java.io.IOException;
@WebServlet("/HelloServiet")
public class HelloServiet extends HttpServlet {
public HelloServiet() {
}
@Override
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
System.out.println("Web运行");
}
@Override
public void destroy() {
System.out.println("销毁");
}
@Override
public void init() throws ServletException {
System.out.println("初始化");
}
}

创建Servlet

在Java Web应用程序中，创建一个Servlet可以通过以下步骤完成：

创建Java类: 创建一个类，继承自javax.servlet.http.HttpServlet。例如：

java复制代码import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class MyServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
// 在这里编写处理GET请求的代码
}
}

配置Servlet

要使Servlet在Web应用程序中运行，需要对其进行配置：

web.xml配置（传统方式）：在WEB-INF文件夹下的web.xml文件中添加Servlet的配置信息。示例：

xml复制代码<servlet>
<servlet-name>MyServlet</servlet-name>
<servlet-class>com.example.MyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>MyServlet</servlet-name>
<url-pattern>/myservlet</url-pattern>
</servlet-mapping>

注解配置：在Servlet类上使用注解进行配置。示例：

java复制代码import javax.servlet.annotation.WebServlet;
@WebServlet("/myservlet")
public class MyServlet extends HttpServlet {
// doGet 方法和其他代码
}

调用Servlet

一旦Servlet已创建并配置，您可以通过浏览器或其他HTTP客户端来调用它：

在浏览器中输入URL：http://localhost:8080/your-web-app/myservlet （请根据您的实际配置和端口号进行相应替换）
HTTP客户端编程：您可以使用Java的HttpURLConnection或者第三方库如Apache HttpClient来通过编程方式调用Servlet。

Servlet常用方法

方法名	描述
`doGet()`	处理 HTTP GET 请求，用于获取资源或执行一些无副作用的操作。
`doPost()`	处理 HTTP POST 请求，通常用于提交数据到服务器端。
`doPut()`	处理 HTTP PUT 请求，用于更新服务器上的资源。
`doDelete()`	处理 HTTP DELETE 请求，用于删除服务器上的资源。
`doHead()`	类似于 `doGet()`，但只返回响应头部信息，不返回实际数据。
`doOptions()`	处理 HTTP OPTIONS 请求，返回服务器支持的请求方法和头信息。
`doTrace()`	处理 HTTP TRACE 请求，返回服务器收到的请求信息，用于测试和诊断。
`service()`	根据请求的方法（GET、POST 等）调用适当的 `doXxx()` 方法处理请求。
`init()`	初始化方法，用于执行一些一次性的初始化操作，比如加载配置。
`destroy()`	销毁方法，在 Servlet 容器关闭时调用，用于执行一些清理操作，释放资源等。
`getServletConfig()`	获取 Servlet 的配置信息，可以用于获取初始化参数等。
`getServletContext()`	获取 Servlet 上下文，用于访问 Servlet 容器的其他功能，比如获取资源、日志等。
`getInitParameter()`	获取初始化参数的值，可以在 web.xml 中配置。
`getInitParameterNames()`	获取所有初始化参数的名称。
`getServletInfo()`	获取 Servlet 的信息，一般是版本、作者等。
`getLastModified()`	获取最后修改时间，用于实现缓存机制。

9.EL表达式（Expression Language）介绍与基础使用

什么是EL表达式？

EL表达式（Expression Language）是一种用于在JavaWeb应用中访问和操作数据的简化表达方式。它通常用于JSP（JavaServer Pages）页面中，允许开发人员在页面上直接引用和操作JavaBean中的属性，从而实现动态数据的展示和处理。

EL表达式的优点

简化代码：EL表达式可以帮助减少繁琐的Java代码，使页面逻辑更加清晰简洁。
易读性：EL表达式的语法更接近自然语言，提高了代码的可读性。
与JSP兼容：EL表达式与JSP标签配合使用，可以轻松地在JSP页面中嵌入动态数据。

EL表达式的基础用法

访问属性

通过${}语法来访问JavaBean中的属性。

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<title>EL表达式示例</title>
</head>
<body>
<c:set var="userName" value="John" /> <!-- 设置一个变量 -->
<p>Welcome, ${userName}!</p> <!-- 访问变量值 -->
</body>
</html>

执行运算

EL表达式支持各种数学和逻辑运算。

1
2
3

<p>Sum: ${5 + 3}</p>
<p>Product: ${2 \* 4}</p>
<p>Is True: ${true && false}</p>

调用方法

可以调用JavaBean中的方法。

1	<p>Current Time: ${java.time.LocalDateTime.now()}</p>

访问集合

访问List、Map等集合类型的元素。

<c:set var="fruits" value="${['Apple', 'Banana', 'Orange']}"/>
<p>Second Fruit: ${fruits[1]}</p>
<c:set var="person" value="${{'name': 'Alice', 'age': 30}}"/>
<p>Name: ${person['name']}, Age: ${person['age']}</p>

条件判断和循环

使用EL表达式进行条件判断和循环。

<c:if test="${age >= 18}">
<p>You are an adult.</p>
</c:if>
<c:forEach items="${fruits}" var="fruit">
<p>${fruit}</p>
</c:forEach>

总结

EL表达式是一种简化访问和操作数据的方式，可以在JSP页面中轻松地引用JavaBean的属性和方法。它的简洁语法和强大功能使得在Web开发中更加便捷和高效。

10.JSTL (JavaServer Pages Standard Tag Library) 简介与基础使用

什么是 JSTL？

JavaServer Pages Standard Tag Library (JSTL) 是一组用于在 JSP 页面中执行通用任务的标签集合。它提供了一种在 JSP 页面中编写更简洁、易于维护的代码的方式，同时还有助于将页面逻辑和显示分离开来。JSTL 包含多个标签库，每个库都专注于不同的任务。

JSTL 的核心标签库

JSTL 核心标签库提供了基本的控制结构和变量处理功能。

1. `<c:out>`

用于在页面中输出变量值，可以防止 HTML 和 JavaScript 注入攻击。

1	<c:out value="${variable}" />

2. `<c:set>`

用于设置变量值。

1	<c:set var="count" value="10" />

3. `<c:if>`

条件判断标签，根据表达式的值决定是否执行其中的内容。

1
2
3

<c:if test="${age > 18}">
<!-- 在年龄大于 18 时显示的内容 -->
</c:if>

4. `<c:choose>`, `<c:when>`, `<c:otherwise>`

类似于 Java 中的 switch 语句，根据条件执行不同的分支。

<c:choose>
<c:when test="${day == 'Monday'}">
<!-- 星期一的处理 -->
</c:when>
<c:when test="${day == 'Tuesday'}">
<!-- 星期二的处理 -->
</c:when>
<c:otherwise>
<!-- 其他情况的处理 -->
</c:otherwise>
</c:choose>

5. `<c:forEach>`

用于循环迭代集合或数组。

1
2
3

<c:forEach items="${products}" var="product">
<!-- 对每个产品执行的操作 -->
</c:forEach>

6. `<c:url>`

用于生成带有参数的 URL。

1
2
3

<c:url value="/productDetails.jsp">
<c:param name="productId" value="123" />
</c:url>

示例

下面是一个简单的示例，展示如何在 JSP 页面中使用 JSTL 标签库来输出一个集合中的用户列表：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<title>User List</title>
</head>
<body>
<h1>User List</h1>
<ul>
<c:forEach items="${users}" var="user">
<li><c:out value="${user}" /></li>
</c:forEach>
</ul>
</body>
</html>

在上述示例中，${users} 是一个从后端传递到前端的用户列表，<c:forEach> 标签用于循环遍历列表中的每个用户，并使用 <c:out> 标签输出用户信息。

这只是 JSTL 的基础使用介绍，它还有其他标签库，如格式化标签库、XML 标签库等，可以根据不同的需求进行学习和使用。

更容易理解的例子

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2023/8/28
Time: 14:39
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>数据展示</title>
</head>
<body>
<table border="1">
<tr>
<th>id</th>
<th>name</th>
<th>price</th>
<th>dese</th>
<th>状态</th>
</tr>
<c:forEach items="${list}" var="m" varStatus="status">
<tr>
<td>${m.id}</td>
<td>${m.product\_name}</td>
<td>${m.product\_price}</td>
<td>${m.product\_desc}</td>
<c:set var="flag" value="${m.flag}"></c:set>
<c:if test="${flag < 1}">
<td>上架</td>
</c:if>
<c:if test="${flag > 1}">
<td>下架</td>
</c:if>
</tr>
</c:forEach>
</table>
</body>
<script src="js/jquery.min.js"></script>
</html>

11.tomcat链接数据库

请求传值

通过超链接能够向java Service发值，然后用request.getParameter();进行接收

1	<button><a href="Stu?flag=Del&xid=${stu.sid}">删除</a></button>

Java接收

1	String flag = request.getParameter("flag");

提交表单传值

通过提交from表单可以将表单的值全部传递到Java接收，照理同样用request.getParameter();进行接收

<form method="post" action="Stu">
<c:forEach items="${liststu}" var="stu" varStatus="status">
<input type="hidden" name="xid" value="${stu.sid}">
<input type="hidden" name="flag" value="upDate">
<p>名字: <input type="text" value="${stu.sname}" name="xname"></p>
<p>性别: <input type="text" value="${stu.sgender}" name="xgender"></p>
<p>年龄: <input type="text" value="${stu.sage}" name="xage"></p>
<p>地址: <input type="text" value="${stu.saddress}" name="xaddress"></p>
<p>邮箱: <input type="text" value="${stu.semail}" name="xemail"></p>
<input type="submit" value="更改">
<button><a href="Stu?flag=Del&xid=${stu.sid}">删除</a></button>
</c:forEach>
</form>

Java接收

String xname = request.getParameter("xname");
String xgender = request.getParameter("xgender");
String xage = request.getParameter("xage");
String xaddress = request.getParameter("xaddress");
String xemail = request.getParameter("xemail");
String xid = request.getParameter("xid");
System.out.println("测试获取FindID的表值" + xaddress + xage + xname + xgender + xemail +xid);
int i = StuList.UpDate(xname, xgender, Integer.parseInt(xage), xaddress, xemail,Integer.parseInt(xid));
if (i > 0){
List<Student> students = StuList.StuShow();
session.setAttribute("list",students);
response.sendRedirect("home.jsp");
}else{
response.sendRedirect("index.jsp");
}

如果有一些特殊的值需要传递但是又不能用a标签传递，那么可以用input标签将属性设定为隐藏后，一同提交到Java Service里

Java Service跳转JSP网页

通过使用response.sendRedirect进行跳转

1	response.sendRedirect("home.jsp");

Java Service如何传值给Jsp网页

通过保存会话到Session，然后在JSP网页中调用会话，进行传递

可以选择压缩成集合进行传递，也可以单个变量，使用集合后可以在Jsp里用JSTL核心标签库的<c:forEach>标签进行循环遍历

System.out.println("第三个flag:" + flag);
String xname = request.getParameter("xname");
String xgender = request.getParameter("xgender");
String xage = request.getParameter("xage");
String xaddress = request.getParameter("xaddress");
String xemail = request.getParameter("xemail");
String xid = request.getParameter("xid");
System.out.println("测试获取FindID的表值" + xaddress + xage + xname + xgender + xemail +xid);
int i = StuList.UpDate(xname, xgender, Integer.parseInt(xage), xaddress, xemail,Integer.parseInt(xid));
if (i > 0){
List<Student> students = StuList.StuShow();
session.setAttribute("list",students);
response.sendRedirect("home.jsp");
}else{
response.sendRedirect("index.jsp");
}

Jsp页面

<form method="post" action="Stu">
<c:forEach items="${liststu}" var="stu" varStatus="status">
<input type="hidden" name="xid" value="${stu.sid}">
<input type="hidden" name="flag" value="upDate">
<p>名字: <input type="text" value="${stu.sname}" name="xname"></p>
<p>性别: <input type="text" value="${stu.sgender}" name="xgender"></p>
<p>年龄: <input type="text" value="${stu.sage}" name="xage"></p>
<p>地址: <input type="text" value="${stu.saddress}" name="xaddress"></p>
<p>邮箱: <input type="text" value="${stu.semail}" name="xemail"></p>
<input type="submit" value="更改">
<button><a href="Stu?flag=Del&xid=${stu.sid}">删除</a></button>
</c:forEach>
</form>

在这其中，通过使用${stu.sname}可以调用Java代码，用来插入需要的信息

12.Ajax和jQuery

下午编写笔记

Web学习笔记

Web学习笔记

1.架构

B/S架构

C/S架构

2.Tomcat

Tomcat目录

3.JSP

JSP介绍

JSP工作原理

JSP基础代码

JSP关于out.print报红解决办法

JSP实例演示1

4.JSP核心内置对象

基础介绍

使用格式

from表格提交与接收

转发和重定向的区别

转发

重定向

5.session对象

Session 对象

介绍

特点

使用方法

示例

session 常用方法介绍与举例

1. setAttribute(String name, Object value)

2. getAttribute(String name)

3. removeAttribute(String name)

4. invalidate()

5. getId()

6. getCreationTime()

7. getLastAccessedTime()

JSP连接数据库模板

6.Cookie

7.JSP数据访问

include

application

JSP作用域介绍

JavaBean

8.Serviet

Servlet创建、配置和调用

创建Servlet

配置Servlet

调用Servlet

Servlet常用方法

9.EL表达式（Expression Language）介绍与基础使用

什么是EL表达式？

EL表达式的优点

EL表达式的基础用法

访问属性

执行运算

调用方法

访问集合

条件判断和循环

总结

10.JSTL (JavaServer Pages Standard Tag Library) 简介与基础使用

什么是 JSTL？

JSTL 的核心标签库

1. <c:out>

2. <c:set>

3. <c:if>

4. <c:choose>, <c:when>, <c:otherwise>

5. <c:forEach>

6. <c:url>

示例

更容易理解的例子

11.tomcat链接数据库

请求传值

提交表单传值

Java Service跳转JSP网页

Java Service如何传值给Jsp网页

12.Ajax和jQuery

`session` 常用方法介绍与举例

1. `setAttribute(String name, Object value)`

2. `getAttribute(String name)`

3. `removeAttribute(String name)`

4. `invalidate()`

5. `getId()`

6. `getCreationTime()`

7. `getLastAccessedTime()`

1. `<c:out>`

2. `<c:set>`

3. `<c:if>`

4. `<c:choose>`, `<c:when>`, `<c:otherwise>`

5. `<c:forEach>`

6. `<c:url>`