JAVA 网页开发（涉及服务器）结构是什么？代码逻辑是怎样的？
JAVA 网页开发（涉及服务器）结构是什么？代码逻辑是怎样的？(不使用 spring框架)
•HTML、CSS和JavaScript运行在浏览器中，称为前端脚本
•服务器端脚本是运行在服务器上，动态生成网页（HTML、CSS和JavaScript）的程序。
•常见服务器端脚本：
- PHP
- ASP
- Perl
- JSP
- 服务器端JavaScript（如node.js）
JSP源文件是由安装在Web服务器上的JSP引擎编译执行的。比如Tomcat就是一种JSP引擎。JSP引擎把来自客户端的请求传递给JSP源文件，然后JSP引擎再把对它的响应从JSP源文件传递给客户端。
![![[Pasted image 20241119133505.png]]](https://i-blog.csdnimg.cn/direct/062fbfa74b5f4499bedb97a9dc067b7d.png)
Servlet（Java服务器小程序）是用Java编写的服务器端程序，是由服务器端调用和执行的、按照Servlet自身规范编写的Java类
到底什么是 servlet?
servlet 并不是某个类,而是 Java 平台上的一个接口，用于扩展 Web 服务器的功能。实现 Servlet接口后 可以处理来自客户端的请求，并返回响应
Servlet 自身规范是什么?一个 Servlet 至少需要什么要素?
Servlet部署在容器里，它的生命周期由容器管理
什么是容器?
Servlet的生命周期概括为以下几个阶段：
- 装载Servlet：这项操作一般是动态执行的。有些服务器提供了相应的管理功能。可以在启动的时候Servlet就装载Servlet并能够初始化特定的Servlet。
- 创建一个Servlet实例。
- 调用Servlet的init()方法。
- 服务：如果容器接收到对此Servlet的请求，那么它调用Servlet的service()方法。
- 销毁：实例被销毁，通过调用Servlet的destory()方法来销毁Servlet。
JSP 和 Servlet 什么关系?
JSP 文件本质上是一个包含 HTML 和 Java 代码的文本文件。
编译和执行：当 JSP 页面第一次被请求时，Web 容器会将 JSP 文件编译成一个 Servlet 类。这个 Servlet 类随后会被加载并执行，生成 HTML 内容发送给客户端。
Jsp本质上还是一个 servlet
虽然 JSP 文件看起来像是 HTML 文件中嵌入了一些 Java 代码，但实际上，JSP 文件在运行时会被转换成一个 Servlet 类，然后由 Web 容器（如 Tomcat）编译和执行
Jsp 到 Servlet 的转换过程：
生成 Servlet 源代码：Web 容器将 JSP 文件转换成一个 Java 类（Servlet）。这个过程包括将静态内容（HTML、CSS、JavaScript）转换成字符串输出，将嵌入的 Java 代码放入适当的位置
编译 Servlet：生成的 Java 类被编译成字节码文件（.class 文件）
加载和执行 Servlet：编译后的 Servlet 被加载到内存中，并由 Web 容器调用其生命周期方法（如 init、service、destroy）来处理客户端请求
也就是说当 jsp 被编译为 servlet 之后，这个 servlet 就会被保存到内存上；再申请 jsp 请求，就会由服务器直接对应到这个 jsp 编译出的 servlet上进行处理（返回相应的 html 字符串输出），而不会再编译 jsp
如下 hello.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Hello JSP</title>
</head>
<body>
<%
String name = request.getParameter("name");
if (name == null || name.isEmpty()) {
name = "Guest";
}
%>
<h1>Hello, <%= name %>!</h1>
</body>
</html>
转化为对应的 servlet
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class hello_jsp extends HttpServlet {
public void init(ServletConfig config) throws ServletException {
super.init(config);
}
public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<head>");
out.println("<title>Hello JSP</title>");
out.println("</head>");
out.println("<body>");
String name = request.getParameter("name");
if (name == null || name.isEmpty()) {
name = "Guest";
}
out.println("<h1>Hello, " + name + "!</h1>");
out.println("</body>");
out.println("</html>");
}
public void destroy() {
// Cleanup code, if any
}
}
就是说要向显示页面内容,就必然要将整个页面(.jsp 文件)发送给服务器吗?只有服务器将.jsp 编译为 servlet 并加以执行取得输出返回给页面后,前端才能显示吗?还是说在前端当中静态界面是不发送回服务器的,而是只有请求内容(.jsp 文件中涉及的部分)发送给服务器?
当时没理解客户端向服务端发送的到底是什么，实际上客户端发送的就是 url 请求，而不是页面资源代码等
访问某个服务器(域名),肯定是先进 index 吧,会发出 index.html 还是 index.jsp 亦或是其它的请求呢?
客户端与服务器的互动流程是怎样的?相互之间的数据流是什么?
1. 客户端就是不断地向服务器发送请求 url,看到的页面,资源等都是由客户端发送 url来获取的
进入首页(服务器域名)时,就是向服务器发送了这样一个裸域名,然后在服务器端依据配置,自动选择相应的资源进行返回
2. 在服务器返回相应资源后,会对外暴露出相应的点击链接(即 href),然后用户就可以点击那些 href,即可隐式地向服务器发送.jsp 文件中规定的请求或者 url 了
3. 然后这些 url 再由服务器接收,处理,返回相应资源或重定位
客户端发送的请求 ,url 的后缀一般都可能是什么?即请求一般都可能是什么?
静态资源：如 HTML、CSS、JavaScript、图片等，通常使用 GET 方法请求。
动态资源：如 JSP、PHP、ASP.NET 等，可以使用 GET 或 POST 方法请求。
API 接口：通常返回 JSON 或 XML 格式的数据，可以使用多种 HTTP 方法（GET, POST, PUT, DELETE 等）。
客户端发送页面资源请求后,服务端返回响应,那么客户端如何解析这个服务端返回的页面资源?客户端是显示的服务端记录的.jsp 文件吗?
处理流程
1. 客户端发送请求
客户端（通常是浏览器）通过 HTTP 协议发送请求到服务端。请求可以是 GET、POST 等方法。
2. 服务端处理请求
服务端接收到请求后，根据请求的 URL 找到对应的 JSP 文件，并进行以下步骤
1. 编译 JSP 文件：如果这是 JSP 文件的首次请求，服务器会将 JSP 文件编译成一个 Servlet 类。
2. 执行 Servlet：编译后的 Servlet 类被加载到内存中并执行。
3. 生成响应：Servlet 类生成动态内容（通常是 HTML），并将其发送回客户端。
如果不是 JSP 文件的首次请求,服务端又怎样处理?
1. 检查缓存：服务端首先检查是否有已编译的 Servlet 类。如果存在且没有过期，则跳过编译步骤，直接执行 Servlet 类。
2. 执行 Servlet：编译后的 Servlet 类被加载到内存中并执行。
3. 生成响应：Servlet 类生成动态内容（通常是 HTML），并将其发送回客户端
3. 服务端返回响应
1. 服务端生成的响应通过 HTTP 协议返回给客户端。响应包括状态码、头部信息和响应体
4. 客户端解析响应
1. 客户端（浏览器）接收到服务端的响应后，进行以下步骤：
1. 解析 HTTP 响应：浏览器首先解析 HTTP 响应的状态码和头部信息。
2. 解析 HTML 内容：根据 Content-Type 头部信息，浏览器确定响应体的内容类型（例如 text/html），并开始解析 HTML 内容。
3. 构建 DOM 树：浏览器将 HTML 内容解析成文档对象模型（DOM）树。
4. 渲染页面：浏览器根据 DOM 树和 CSS 样式表（如果有）渲染页面，显示给用户。
5. 显示页面
1. 最终，用户在浏览器中看到的是经过解析和渲染的 HTML 页面，而不是原始的 JSP 文件
所以最后显示的并不是服务端记录的 JSP 文件,JSP 文件是一种服务器端技术，用于生成动态内容。客户端接收到的是 JSP 文件生成的 HTML 内容，而不是 JSP 文件本身
一个 .jsp 是怎样构成的?编写规范是怎样的?
一个典型的 JSP 文件通常包含以下几个部分：
指令（Directives）：用于设置整个 JSP 页面的属性。
<% @ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
解析一下其中的各参数?
contentType=“text/html; charset=UTF-8”：指定页面内容类型为 HTML，并且字符编码为 UTF-8
contentType 除了 HTML 以外,是否还有其它类型?
Content-Type 是 HTTP 头部的一个重要字段，用于指示资源的 MIME 类型。MIME 类型（Multipurpose Internet Mail Extensions）定义了文件的类型和格式
文本类型
text/html：HTML 文档。
text/plain：纯文本文件。
text/css：CSS 样式表。
text/javascript：JavaScript 文件。
text/xml：XML 文档。
图像类型
image/jpeg：JPEG 图像。
image/png：PNG 图像。
image/gif：GIF 图像。
image/svg+xml：SVG 图像。
应用程序类型
application/json：JSON 数据。
application/pdf：PDF 文件。
application/xml：XML 文档。
application/x-www-form-urlencoded：表单数据（通常用于 POST 请求）。
application/octet-stream：二进制数据流（通常用于下载文件）。
application/javascript：JavaScript 文件（也可以用 text/javascript）。
多部分类型
multipart/form-data：用于文件上传的表单数据。
multipart/mixed：混合内容类型，通常用于电子邮件。
声明（Declarations）：用于声明变量和方法。
脚本元素（Scriptlets）：用于嵌入 Java 代码。
表达式（Expressions）：用于在页面中输出 Java 表达式的值。
标准动作（Standard Actions）：用于执行特定的操作，如包含其他文件、转发请求等。
静态内容（Static Content）：如 HTML、CSS、JavaScript 等。
服务端解析.jsp 文件返回的既然是静态的 html,那客户端又是怎样通过.jsp返回的静态显示页面继续向服务端发送请求并展示服务端回应的?如重定向或进行验证,获取资源等?
表单提交或链接点击
用户在页面上进行操作，例如点击按钮、提交表单或点击链接。
这些操作通常会触发新的 HTTP 请求，这些请求可以是 GET 或 POST 方法。
响应生成与返回：
服务器处理完请求后，生成相应的响应内容。
响应内容可以是新的 HTML 页面、JSON 数据、重定向指令等
重定向
如果服务器返回的是重定向指令（HTTP 状态码 302），浏览器会自动发起一个新的请求到指定的 URL。
服务器可以使用 response.sendRedirect(“new_url”)来实现重定向
动态内容更新
如果响应内容是新的 HTML 页面，浏览器会重新渲染页面。
如果响应内容是 JSON 数据，可以通过 JavaScript（例如 AJAX）动态更新页面的部分内容，而不需要刷新整个页面。
用户在点击.jsp 解析出的 Html页面交互时发送的请求 Url 是什么,在.jsp 文件上是如何定义的?发送出的完整url 是什么？
由页面提交 Url的方式：
表单提交 (Form Submission)
在 .jsp 文件中，通常使用 HTML 表单 (< form >) 来定义用户提交数据的请求 URL。
超链接 (Hyperlink)
使用 < a > 标签来定义超链接，指向其他页面或资源。
JavaScript 调用
使用 JavaScript 进行 AJAX 请求或其他动态操作时，可以在 JavaScript 代码中定义请求 URL。
JSP 动态生成 URL
使用 JSP 内置对象 response 或 pageContext 来动态生成 URL。
在静态页面上确实是可以提交 url,在页面上显示后，那些跳转到的 url 是就已经定义好了，点击就会发送
要么是 Js 脚本的形式，要么是 html表单的形式
<c:url value="/login.jsp" var="loginUrl" />
<a href="${loginUrl}">登录</a>
上述代码中，<c:url> 标签用于生成 URL，并将其存储在变量 loginUrl 中，然后在 < a > 标签中使用。
详细解释一下表单提交？发送出的 url 具体是什么？
这个表单提交就是静态 html 页面自带的，点击后自动发送出一个 url，而不涉及到任何其它技术
依据请求的 method 属性，
GET 方法：如果 method 属性设置为 GET，表单数据会附加在 URL 后面作为查询字符串（query string）。
例如：http://example.com/login.jsp?username=John&password=123456
POST 方法：如果 method 属性设置为 POST，表单数据会放在请求体（request body）中，不会显示在 URL 中。
例如：请求 URL 仍然是 http://example.com/login.jsp，但表单数据在请求体中。
在表单提交的 URL 中，域名部分并不是自动生成的，而是由开发者在编写 HTML 或 JSP 代码时明确指定的。具体来说，域名可以有以下几种形式：
绝对 URL:包含完整的域名和路径。
例如：http://example.com/login.jsp
这种形式明确指定了请求的目标服务器和路径。
相对 URL:只包含路径部分，不包含域名。
例如：/login.jsp
浏览器会根据当前页面的域名自动补全完整的 URL。
如果当前页面的 URL 是 http://example.com/index.jsp ，那么 /login.jsp 会被解析为 http://example.com/login.jsp 。
上下文路径
在 JSP 中，可以使用 ${pageContext.request.contextPath} 获取应用的上下文路径。
如果希望当前发送的请求如 login,追加到当前 url 的尾部，如何做，比如 /login 接到/index.jsp的后面而不是只有 login？
html 的 form 表单，在不借助 js 脚本等其它方法以外，发送请求是否只能是发送出"域名+请求"结构的 url?
存在两种，一种是相对 url，一种是绝对 url
相对 url好像都是默认地“域名+请求”结构？
详细解释一下 JSP 动态生成 URL？
过使用 JSP 内置对象和表达式语言（EL），你可以生成符合当前应用上下文的完整 URL
JSP 内建对象
JSP 为了简化页面的开发提供了一些内部对象。这些内部对象不需要由 JSP 的编写者实例化，它们由容器实现和管理，在所有的 JSP 页面中都能使用内部对象
常见的 JSP 内部对象有：
- out 对象：主要用来向客户端输出数据。
- request 对象：代表请求对象，通过 getParameter()方法可以得到 request 的参数。
- response 对象：封装了 JSP 产生的响应。
- session 对象：用来保存每个用户信息，以便跟踪每个用户的操作状态。其中，session 信息保存在服务器端，session 的 id 保存在客户端的 Cookie 中。
- application 对象 ：为多个应用程序保存信息。服务器启动后，就会自动创建 application 对象，这个对象一直会保持，直到服务器关闭为止。
jsp 内建对象是怎么发挥用场的？举几个例子？
页面提交请求时，不是直接提交的 url 吗？好像并没有经过 jsp 内建对象的 request?
页面提交请求时确实直接提交的是 URL，但这个请求最终会被 Web 容器（如 Tomcat）处理，并且在这个过程中，JSP 内建对象 request 会被创建并填充相关信息
请求处理流程
1. 客户端发起请求
用户在浏览器中输入 URL 或点击表单提交按钮，发起一个 HTTP 请求。
请求包含 URL、HTTP 方法（GET、POST 等）、请求头、请求体等信息。
2. Web 容器接收请求
Web 容器（如 Tomcat）接收到客户端的请求。
容器解析请求，提取出 URL、方法、头信息、参数等。
3. 创建 HttpServletRequest 对象
容器根据请求信息创建一个 HttpServletRequest 对象，这个对象封装了所有请求相关的数据。
这个 HttpServletRequest 对象就是 JSP 内建对象 request 的具体实现。
4. 请求分发到 JSP 页面
容器将请求分发到相应的 JSP 页面或 Servlet。
在 JSP 页面中，request 对象作为内建对象可以直接使用。
如果请求的是 jsp,发送 url 中附带参数，那么在服务器端，当请求 url 到对应 jsp 后，就会去解析那些参数，最后将 jsp 转换为最终显示的静态页面 html，并返回给客户端
要到服务端的任何一个服务，都需要 url(都可能附带参数)，任何一个服务也都会返回一个响应到客户端
![![[Pasted image 20241119165103.png]]](https://i-blog.csdnimg.cn/direct/506067f121ad4dc2aa35760fc5b9dcd6.png)
JSP网站开发技术标准给出了两种使用JSP的方法：模式一和模式二。模式一是JSP+JavaBean的结合，模式二是JSP+JavaBean+Servlet的结合。在当今的开发中，比较偏向于使用模式二，但是模式一在小型应用开发中比较占优势。
模式一：
![![[Pasted image 20241119165243.png]]](https://i-blog.csdnimg.cn/direct/68d3637dc1f144c494005efa082c0fdb.png)
模式二：
![![[Pasted image 20241119165249.png]]](https://i-blog.csdnimg.cn/direct/0e97c74843974f4098f37d53acf019de.png)
什么是 JavaBean？JavaBean 的用处，目的是什么？
所谓 JavaBean 实际上就是实体类，实现了 get,set 等方法，没什么稀奇的
为什么需要 JavaBean?不用 JavaBean会有什么后果？举几个例子？
详细解释一下这两个模式有什么区别？
模式一：JSP页面独自响应请求并将处理结果返回客户。所有的数据通过JavaBean来处理，JSP实现页面的展现
简单直接：直接在 JSP 页面中编写业务逻辑和展示逻辑；使用 JavaBean 来封装数据和业务逻辑。
代码耦合度高：业务逻辑和展示逻辑混杂在一起，导致代码可维护性和可扩展性较差。
模式二：此模式遵循试图控制器模式（Model-View-Controler, MVC），它的主要思想是使用一个或多个Servlet作为控制器。请求由前沿的Servlet接收并处理后，会重新定向到JSP
模式二细化：
![![[Pasted image 20241119170044.png]]](https://i-blog.csdnimg.cn/direct/83af078d6f3141f08eaa44dae726b875.png)
模式二就是 MVC 架构：
采用 MVC（Model-View-Controller）架构，将模型（Model）、视图（View）和控制器（Controller）分离。
Servlet 作为控制器，处理用户请求和业务逻辑。
JSP 作为视图，负责展示数据。
就是说都处理好后，把数据传给 jsp 进行显示，所以叫视图层
JavaBean 作为模型，封装数据和业务逻辑。
在 servlet 转到 jsp，就是 servlet 向 jsp 发送请求的过程，配置相应的参数进 request 当中，然后在 jsp 中再获取 request 中配置好的参数，之后就是在 jsp 的 servlet 当中取出 request 的参数，配置好相应的 html字符输出进 response,然后返回。
即
客户端 url->服务器控制层 servlet->service 业务处理->servlet配置好 request->调用对应 jsp->编译 jsp 为相应的 servlet->使用对应 jsp 的 servlet->jsp 的 servlet 将输出保存进 response->逐层返回
request.getRequestDispatcher("/myPage.jsp").forward(request, response);
.forward 什么意思？
请求转发（Forward）：在服务器内部将请求从一个资源转发到另一个资源，客户端浏览器的地址栏不会发生变化，用于在服务器内部将请求和响应对象传递给另一个资源进行处理
请求调度器（RequestDispatcher）：用于在服务器内部调度请求的对象
重定向细究
sendRedirect 方法：
发送一个 HTTP 302 状态码和一个 Location 头，告诉浏览器去请求新的 URL。
浏览器会发起一个新的请求，因此 URL 会改变。
适用于跨服务器的重定向。
forward 方法：
在服务器内部转发请求，不涉及客户端的第二次请求。
URL 不会改变，用户看到的仍然是原来的 URL。
适用于同一应用内的页面跳转。