Java Web 2023 题型和复习提纲

自律即自由TianXing
451 阅读41分钟

1、JSP的内置对象有哪些？

JSP内置对象被称为隐式对象，因为这些对象由JSP容器提供，无需明确声明就可直接使用。以下是JSP提供的9个内置对象及其作用：

  1. request：代表客户端的请求，此对象是 javax.servlet.http.HttpServletRequest 类的实例。可用于获取客户端发出的请求信息，如参数、头信息等。

  2. response：代表对客户端的响应，此对象是 javax.servlet.http.HttpServletResponse 类的实例。可用于控制发送给客户端的响应，如设置内容类型、字符编码等。

  3. pageContext：封装了与JSP页面相关的所有对象，此对象是 javax.servlet.jsp.PageContext 类的实例。提供对JSP页面范围内所有对象和命名空间的访问，也提供了一些辅助功能。

  4. session：代表用户的会话，此对象是 javax.servlet.http.HttpSession 类的实例。常用于存取跨多个页面或多个请求的用户特定信息。

  5. application：代表整个Web应用程序的上下文环境，此对象是 javax.servlet.ServletContext 类的实例。可用于在应用程序范围内存取数据。

  6. out：提供了向客户端输出响应内容的一种方法，此对象是 javax.servlet.jsp.JspWriter 类的实例。常用于将内容输出到客户端的Web浏览器。

  7. config：此对象是 javax.servlet.ServletConfig 类的实例，提供了关于Servlet配置的信息，如初始化参数。

  8. page：此对象是对JSP页面自身的引用，它是 java.lang.Object 类的实例（实际上是当前Servlet类的实例）。

  9. exception：仅在出现错误时，错误页面可以访问此对象。此对象是 java.lang.Throwable 类的实例。若页面指令属性 isErrorPage 设为 true，则此对象可用。

每个内置对象都有它特定的范围和用途，在编写JSP时，可以灵活使用这些对象来完成对请求的处理和响应的生成。

2、jsp页面之间对象传递的方法。

在JSP页面之间传递对象或数据，可以通过以下几种不同的方法：

  1. 使用请求参数 (Request Parameters)

    • 通过URL或表单提交的请求参数可以在JSP页面之间传递数据。
    • 示例：<a href="nextPage.jsp?param=value">Link</a>

  2. 使用请求属性 (Request Attributes)

    • 在一个请求的范围内，可以设置属性来传递对象。
    • 示例：请求转发之前，request.setAttribute("attributeName", object); 然后在另一个JSP页面中，使用 request.getAttribute("attributeName"); 来获取对象。

  3. 使用会话对象 (Session Object)

    • 你可以将对象存储在用户的session中，以便跨多个页面和请求使用。
    • 示例：session.setAttribute("attributeName", object);

  4. 使用应用上下文 (Application Context)

    • 应用上下文中的属性可以被同一Web应用程序中的所有用户和请求访问。
    • 示例：application.setAttribute("attributeName", object);

  5. 使用Cookie

    • 可以创建Cookie来存储数据，并将其发送到客户端浏览器中。这适用于需要跨会话持久存储的小量数据。
    • 示例：创建一个新的Cookie对象并将其添加到response中，Cookie cookie = new Cookie("cookieName", "cookieValue"); response.addCookie(cookie);

  6. 使用 HttpServletResponse 对象

    • 可以在响应中包含某些数据，将其发送回客户端，并在另一个请求中再次取回数据。
    • 这可以结合使用隐藏表单字段、URL重写等技术。

  7. 使用重定向 (Redirection)

    • 当使用HTTP重定向时，可以在URL中加入查询字符串来传递简单的数据。
    • 注意，使用重定向时创建的是新的请求，所以不能用请求属性来传递对象，因为新的请求不会保持原来的请求属性。

具体使用哪种方法，取决于你的具体需求，比如传递的数据大小、是否跨会话传递数据，以及你关于性能和安全的考虑。通常，Servlet/JSP容器会处理这些对象的序列化和反序列化，从而方便开发者存取数据。

3、jsp有哪些动作?作用分别是什么?

JSP动作用于控制Servlet的行为、实现页面之间的通讯以及使用JavaBean等。以下是一些常见的JSP动作及其作用：

  1. <jsp:include>：包含其他资源，如JSP、HTML页面或Servlet等。在当前JSP执行时，即时包含其他资源的内容到该JSP页面。可以实现页面模块化。

  2. <jsp:forward>：将请求转发到另一个资源（如另一个JSP页面、Servlet或HTML文件）。该动作执行后，当前页面不再执行，控制权交给新资源。

  3. <jsp:useBean>：查找或实例化一个JavaBean组件（如果指定的bean不存在，则实例化）。通常与 <jsp:setProperty> 和 <jsp:getProperty> 配合使用来设置和获取bean属性的值。

  4. <jsp:setProperty>：设置存在于当前页面的JavaBean的属性值。如果属性与请求参数同名，还可以自动从请求参数中设置属性值。

  5. <jsp:getProperty>：从JavaBean中获取属性的值并自动插入到输出流中，用于展示在页面上。

  6. <jsp:param>：与 <jsp:include>, <jsp:forward> 以及 <jsp:plugin> 等动作联合使用，用于传递参数。

  7. <jsp:plugin>：为客户端浏览器生成适当的HTML代码，以便下载并运行指定的Applet或JavaBean组件。

  8. <jsp:element>：动态定义XML元素。此动作能够在运行时生成元素的名字和内容。

  9. <jsp:attribute>：用于为动态创建的XML元素定义属性。

  10. <jsp:body>：用于指定 <jsp:element>，或者其它体标签的体内容。

这些动作提供了一个标准的方式来控制Servlet的行为，而无需在JSP页面中编写Java代码。它们的主要目的是为了简化在JSP页面中执行常见任务的复杂性，使JSP代码更加简明和维护更易。通过这些动作，我们可以有效地利用JSP与JavaBeans的交互、进行页面间的转发和包含来创建动态响应的web页面。

4、JSP和Servlet有哪些相同点和不同点，他们之间的联系是什么？

JSP (Java Server Pages) 和 Servlet 都是 Java EE 规范的一部分，它们用于在Web应用程序中生成动态内容。虽然它们目的相同，但是在使用和执行机制上有所不同。

相同点

  1. 平台无关性：JSP和Servlet都是用Java编写的，因此它们都能够在任何支持Java的Web服务器上运行。
  2. 生成动态内容：两者都可以生成动态的Web页面。
  3. 可以访问相同的对象：JSP和Servlet都可以访问相同的请求和响应对象，并且可以共享数据通过使用相同的上下文（如session和application scope）。
  4. Web服务器支持：都需要一个支持Java的Web服务器（如 Apache Tomcat）来运行。

不同点

  1. 设计目的：

    • Servlet是用Java编写的服务器端程序，它主要用于处理业务逻辑。
    • JSP是以HTML为主的文本文档，它主要用于展现数据，即提供网页的视图部分。

  2. 编写方式：

    • Servlet完全由Java代码组成。
    • JSP是HTML中嵌入Java代码，或使用特定的JSP标记和表达式。

  3. 转换和编译：

    • Servlet代码直接被编译成.class文件。
    • JSP页面在第一次请求时，被编译成一个Servlet（.java文件），然后编译成.class文件。实际上，JSP就是Servlet的简化形式。

  4. 易用性与易读性：

    • JSP更容易编写，特别是对于页面设计人员和前端开发者来说，因为它更像是编写HTML文档。
    • Servlet则适合那些熟悉Java语言的开发者，适合处理更复杂的业务逻辑。

  5. 修改后更新：

    • 对JSP页面的修改可以立即反映出来，只需简单刷新页面，无需重新编译（只要服务器配置了自动编译）。
    • 修改Servlet通常需要重新编译Java代码并重启服务器。

他们之间的联系

  • 互操作性：在JSP页面中可以使用JavaBean处理业务逻辑，然后通过JSP输出结果；同时，也可以在Servlet中生成业务逻辑，并通过RequestDispatcher将结果转发到JSP页面进行展示。
  • 底层实现：实际上，每个JSP页面都会被转换成一个实现了javax.servlet.jsp.JspPage接口的Java Servlet。
  • 功能替代：某些情况下，可以互相替代。即你可以选择仅使用Servlet或JSP来生成整个Web应用程序的响应，虽然这样做并不是最佳实践。

在实际的Web应用开发中，最佳实践是将两者结合使用，利用JSP来负责页面展示，利用Servlet来处理更为复杂的业务逻辑，这样可以将视图层和业务逻辑层分离，使得Web应用程序更容易维护和管理。

5、serverlet的生命周期及各阶段的作用。

Servlet 的生命周期由 Web 容器（如 Tomcat）控制，它通过调用 Servlet 类的特定方法来进行。Servlet 的生命周期主要包括以下三个阶段及其作用：

  1. 初始化阶段（Initialization）

    • 作用：创建 Servlet 实例并为其初始化资源。
    • 方法：init(ServletConfig config) 方法在 Servlet 被创建后调用，只执行一次。它接受一个 ServletConfig 对象，包含 Servlet 的初始化参数。在此方法中，可以执行如打开数据库连接等资源初始化的操作。

  2. 处理请求阶段（Service/Request Handling）

    • 作用：响应客户端请求。
    • 方法：service(ServletRequest req, ServletResponse res) 方法是主要的执行点，用于处理来自客户端（通常是浏览器）的请求。每当客户端请求该 Servlet 时，该方法就会被调用一次。它会根据请求的类型（比如 GET 或 POST）进一步调用 doGet、doPost、doPut、doDelete 等方法。在这些方法中实现了具体的业务逻辑和数据处理。

  3. 销毁阶段（Destruction）

    • 作用：释放 Servlet 占用的资源并进行清理操作。
    • 方法：destroy() 方法在 Servlet 生命周期即将结束之前调用，也只调用一次。在这个方法中，可以释放 Servlet 开辟的资源，如关闭数据库连接、清理缓存等。

在 Servlet 的整个生命周期中，init() 方法和 destroy() 方法只会被调用一次，分别标志着 Servlet 对象的创建和销毁。而 service() 方法则会被调用多次，每次处理客户端的请求。Servlet 由容器控制，当需要 Servlet 服务时容器会创建 Servlet 实例，并在不再需要时销毁它。如果 Servlet 已经存在于内存中，容器将重用现有的 Servlet 来处理进来的请求。

Servlet 的这种生命周期设计能够使得资源使用更加高效，因为你不必为每个请求都创建一个新的 Servlet 实例，同时也保证了在销毁前可以清理资源。

6、简述servlet进行中文处理的方法。

Servlet 处理中文主要涉及到两个方面：中文数据的接收和发送。在接收时，需要确保正确解析 HTTP 请求中的中文参数；在发送时，要保证响应的内容可以被客户端准确地解码。

Servlet 中文处理常用的一些方法如下：

接收中文数据

  • GET 请求：在 GET 请求中，参数通常是通过 URL 传递的。由于 Servlet API 会使用容器的默认字符集来解码 URL（和参数），这可能会导致中文乱码。如果使用的容器是 Tomcat，可以通过修改 server.xml 文件中的 <Connector> 标签，设置 URIEncoding="UTF-8" (或其他适合的字符集)，来保证使用 UTF-8 来解码 URL 和 Query String。

  • POST 请求：对于 POST 请求，可以使用 request.setCharacterEncoding("UTF-8") 方法来告诉 Servlet 以 UTF-8 字符集来解析请求体中的参数。但这必须在请求参数被读取之前调用。

request.setCharacterEncoding("UTF-8");
String value = request.getParameter("param"); // "param" 是你要接收的参数名

发送中文数据

  • 设置响应字符集：在发送中文数据时，应设置响应头的字符集为 UTF-8（或其他适当的字符集），以确保客户端能正确解码。
response.setContentType("text/html; charset=UTF-8");
// 或者分开设置
response.setCharacterEncoding("UTF-8");
response.setContentType("text/html");
  • PrintWriter 使用：在发送响应时，可能会通过 PrintWriter 发送数据。此处应确保 PrintWriter 使用正确的字符编码。设置了正确的 response.setCharacterEncoding("UTF-8") 后，使用 response.getWriter() 获取的 PrintWriter 会自动采用这一编码。
PrintWriter out = response.getWriter();
out.println("中文数据"); // 发送的中文不会乱码

示例代码

protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    // 处理接收数据的字符集
    request.setCharacterEncoding("UTF-8");

    // 处理发送数据的字符集
    response.setContentType("text/html; charset=UTF-8");

    // 处理业务逻辑
    String chineseContent = request.getParameter("chinese");
    PrintWriter writer = response.getWriter();
    writer.println("接收到的中文内容是：" + chineseContent);
    writer.close();
}

使用这种方式，可以确保 Servlet 处理中文时不出现乱码问题。但也需要确保前端页面发送请求时，对中文内容进行了适当的编码（通常是用 encodeURIComponent 函数对 URL 中的参数编码），并且 HTML 页面的编码设置也是 UTF-8（或者与你所设置的编码相同）。

7、include的两种实现方式的区别?

在 Java Servlet 编程中，include 操作是将一个资源的内容插入到另一个资源的响应内容中，实现资源的复用。这个功能可以通过两种方式实现：RequestDispatcher 的 include 方法和 JSP 的 <jsp:include> 动作。这两种方式的基本目标是相同的，但执行细节和适用场合有所不同。

1. RequestDispatcher 的 include 方法

这是一个 Servlet API 中的功能，允许从一个 Servlet 在服务器端包含另一个资源（例如另一个 Servlet、JSP 页面或 HTML 文件）的内容。这种包含是透明的，即包含的资源的输出被直接插入到调用 include 方法的地方。

RequestDispatcher dispatcher = request.getRequestDispatcher("includedServlet");
dispatcher.include(request, response);

特点：

  • 请求和响应对象（request 和 response）在包含资源的执行过程中被共享，这使得可以在不同的资源之间共享请求参数和属性。
  • 因为响应是直接写入到输出流中的，所以被 include 的资源不应该设置响应头或调用任何可能影响响应的方法（比如设置 Content-Length）。
  • 调用 include 方法不会改变原始请求的 URL。

2. JSP 的 <jsp:include> 动作

这是 JSP 页面中的标准动作，它也可以将另一个资源的输出包含到当前 JSP 页面中。与 RequestDispatcher 的 include 方法不同，<jsp:include> 可以在执行时动态地执行另一个页面，并将该页面的结果输出到当前页。

<jsp:include page="includedPage.jsp" />

或者使用属性传递参数：

<jsp:include page="includedPage.jsp">
    <jsp:param name="paramName" value="paramValue" />
</jsp:include>

特点：

  • 这种包含是在运行时动态完成的，使得每次包含操作时都可以获取最新内容，适合动态页面的包含。
  • <jsp:include> 标签可以传递参数，并且它也共享相同的 request 对象，但可以指定局部参数。
  • 它更适用于 JSP 页面间的包含，而不是 Servlet 间。

区别总结

  • 执行方式：RequestDispatcher.include 是在服务器内部完成的; <jsp:include> 会导致另一个页面被执行，然后将执行结果包含进来。
  • 动态 vs 静态：<jsp:include> 更适合包含页面内容动态变化的情况；RequestDispatcher.include 则适合内容相对静态，不需要重新执行的包含。
  • 适用范围：RequestDispatcher 可用于 Servlet 和 JSP 两者之间的包含；<jsp:include> 主要用在 JSP 页面中。
  • 效率：直接使用 RequestDispatcher 的方式通常效率更高，因为它不需要额外的页面调用过程。

8、cookie和session区别?

Cookie 和 Session 都是 Web 开发中用于保持用户状态的技术。它们有各自的机制和用途，以下是它们的主要区别：

存储位置

  • Cookie：存储在客户端的浏览器上。每次客户端发起请求到服务器时，Cookie 会被自动附加到请求头中发送到服务器。
  • Session：存储在服务器端。服务器为每个用户会话创建一个唯一的 Session 对象，并且会发给客户端一个唯一的标识符（通常是名为 JSESSIONID 的 Cookie），用于在后续请求中识别这个 Session。

生命周期

  • Cookie：可以设置长时间保留（例如，一个月、一年或更久），直到到达设定的过期时间，或者被用户手动清除。
  • Session：通常依赖于单个浏览器会话的生命周期。当用户关闭浏览器或者服务器端程序指定 Session 过期时，Session 会结束。但 Session 的实际过期时间可以被服务器配置。

安全性

  • Cookie：由于存储在客户端，可能会被用户禁用或者篡改，安全性较低。敏感信息不应以明文保存在 Cookie 中。
  • Session：由于存储在服务器端，相比 Cookie 更安全，难以被外部访问，适合存储敏感信息。

性能影响

  • Cookie：每次 HTTP 请求都会发送到服务器，因此如果 Cookie 过多或体积过大，会增加请求的负担，影响性能。
  • Session：存储在服务器内存中，可以优化为存储在文件、数据库或缓存中。过多的 Session 可能会占用较多的服务器资源。

适用场景

  • Cookie：适用于存储客户端的个性化设置，如界面风格、语言选择等，或是进行用户追踪（如广告追踪）。
  • Session：适用于存在用户登录状态、保存用户购物车信息等重要状态信息的场景。

可扩展性

  • Cookie：因为是存储在客户端，不依赖服务器资源，所以可扩展性较好。
  • Session：存于服务器，如果涉及到集群配置，需要考虑 Session 的共享问题，可能需要使用 Session 一致性保持机制，如 Session 副本、数据库存储或持久化 Session。

数据容量限制

  • Cookie：每个域名下存储的 Cookie 数量和大小都有限制，不同浏览器有不同的限制，但一般大小限制为4KB左右。
  • Session：理论上没有大小限制，但过多的数据会影响性能和服务器资源。

综上所述，Cookie 和 Session 各有利弊，在实际的 Web 开发中，通常会组合使用它们来实现更加完整和安全的用户状态管理。

9、MVC模式的特点。

MVC（Model-View-Controller）模式是一种软件设计典范，用于组织代码以实现业务逻辑、用户界面和输入控制之间的分离。MVC 模式的核心理念是将软件分成三个基本组件，每个组件有各自的职责。下面是 MVC 模式的主要特点：

分离关注点（Separation of Concerns）

MVC 模式将一个应用程序分为三个核心组件：

  • Model（模型）：代表应用程序的数据结构，通常负责在数据库和类对象之间转换数据（如 ORM 技术）。
  • View（视图）：负责展示数据（用户界面），并将用户指令传送到控制器。
  • Controller（控制器）：解释用户输入，通过调用模型的方法来处理数据，并选择视图来显示。

通过这样的分离，应用程序的内部业务逻辑可以独立于用户界面，也就是说，同一个模型可以使用不同的视图来展示，而控制器则协调模型和视图。

易于维护和扩展

由于不同组件独立分工，各自关注不同的逻辑，因此在修改和扩展应用程序时不太可能影响到其他组件。这就降低了维护成本，并且使得应用程序更加易于扩展。

复用性

在 MVC 模型中，特别是模型组件，通常不和特定的输出表示或输入处理逻辑直接关联，因此模型可以在不同的系统中复用。

多视图支持

由于视图和模型是解耦的，可以为同一个模型创建多个视图。举个例子，一份数据可以以 HTML、PDF或 Excel格式呈现给不同的用户。

开发角色划分

MVC 允许不同的开发人员专注于他们擅长的领域：后端开发人员可以专注于模型和控制器的编写，而前端开发人员则可以专注于视图的开发。

测试的便利

MVC 模式中组件的分离，使得单元测试和功能测试变得更容易。特别是对模型逻辑进行测试，因为它不依赖视图层或控制器层。

适应多种架构风格

MVC 不仅应用于传统的桌面应用程序，也广泛应用于 Web 应用程序和移动应用程序。这种模式容易适配不同的技术和架构风格，比如 RESTful 应用程序、单页应用（SPA）或传统的动态网站。

潜在的缺点

尽管 MVC 模式有许多优点，但它也有一些潜在的缺点。例如，如果控制器过于臃肿，可能会违反单一职责原则，这会导致代码难以维护。此外，对于一些非常简单的应用程序来说，使用 MVC 可能会过于复杂，造成不必要的工程。

总的来说，MVC 模式强调了关注点分离，使得应用程序的组织更加清晰、结构更加鲜明，这有助于开发大型应用程序和团队协作开发。然而，选择适合的架构模式应该基于应用程序的具体需求来确定。

10、MVC可以用哪些技术实现？

在提交表单请求时，HTTP 协议定义了几种不同的方法来处理数据，其中最常用的是 GET 和 POST。以下是这两种方法的主要区别：

1. 数据传输方式

  • GET：参数通过 URL 编码后附加在 URL 后面进行发送，用户可以在浏览器的地址栏中看到提交的参数。
  • POST：参数放置在 HTTP 请求的消息体（Body）中，用户无法在浏览器地址栏中见到，这样更为隐蔽。

2. 数据大小限制

  • GET：由于数据是附在 URL 后，因此受 URL 长度限制，不同的浏览器和服务器限制不同，但通常有长度限制（例如 Internet Explorer 限制在 2048 个字符）。
  • POST：理论上没有大小限制，可以传输大量数据，受限于服务器配置的最大请求体大小。

3. 安全性

  • GET：由于提交的数据在 URL 中完全暴露，容易被截取和篡改，不适合传递敏感信息。
  • POST：相对于 GET 来说更安全一些，因为数据不会出现在 URL 中，但真正的安全性还需要通过 HTTPS 加密等方式来实现。

4. 缓存和历史记录

  • GET：请求可以被浏览器缓存，参数也会保存在浏览器历史记录中，用户可以进行书签收藏。
  • POST：由于数据在请求体中，一般不会被缓存，也不会保存在浏览器历史记录中，不能被收藏为书签。

5. 数据类型

  • GET：只允许 ASCII 字符。
  • POST：可以发送二进制数据，例如文件上传等操作。

6. 适用场景

  • GET：适用于查询字符串、请求显示某个资源或者无副作用的搜索操作。
  • POST：适合需要服务器进行数据处理的操作，如表单提交、文件上传、通过请求来改变服务器上的状态等。

7. 请求副作用

  • GET：设计为无副作用和幂等的，意味着多次执行同一个 GET 请求，资源的状态和副作用是不变的。
  • POST：设计为有副作用的操作，每次请求都可能在服务器上引起状态改变，例如提交订单。

8. 请求回放

  • GET：如果用户尝试刷新页面，浏览器通常会无需警告地重新发起 GET 请求。
  • POST：刷新页面时，浏览器通常会警告用户数据会被重新提交。

在实际的 Web 开发实践中，应根据数据处理的具体需求选择使用 GET 还是 POST 方法。对于发送大量数据或包含敏感信息的情形，或者是对服务器数据或状态产生变化的场景，推荐使用 POST 方法。而对于简单的数据检索，可以使用 GET 方法。

11、提交表单请求时，post和get有哪些区别?

当通过Web表单提交数据时，GET和POST这两种HTTP方法之间有几个重要区别：

  1. 数据可见性和安全性：

    • GET请求将数据附加到URL中，作为参数对所有人都是可见的。这使得GET不适合传输敏感或私密数据，因为它会暴露在URL上，容易受到拦截。
    • POST请求中的数据则包含在请求体内，不会显示在URL上，从而提供了更高的隐私保护。但这并不意味着POST是绝对安全的，而是相对于GET来说更难以被第三方直接获取。

  2. 数据大小限制：

    • GET请求通常受URL长度的限制，不同的浏览器和Web服务器都有各自的限制，限制可能从几千字符到几万字符不等。
    • POST请求的数据尺寸通常被Web服务器限制，但这种限制远大于GET，因此POST更适合大量数据传输。

  3. 缓存和历史记录：

    • GET请求可以被缓存，并保存在浏览器历史中，用户也可以将包含查询参数的完整URL保存为书签。
    • POST请求不会被浏览器缓存，也不会出现在浏览器的历史记录中，不能保存为书签。

  4. 用途：

    • GET通常用于请求数据，并且不会导致服务器上数据的改变。它用于搜索、查询、读取操作，因此设计为幂等的，多次执行相同的GET请求应该获得相同的结果。
    • POST通常用于数据提交、文件上传等操作，会导致服务器状态变化或引发服务器上进一步的处理。

  5. 编码类型：

    • GET请求只能进行URL编码。
    • POST请求支持多种编码类型，可以处理非字符型的数据，如二进制数据。

  6. 幂等性：

    • GET是幂等的，意味着多次发起同样的请求，其效果是一样的。
    • POST不是幂等的，因为每次请求都可能在服务器上引起不同的行为，如创建或修改数据。

选择哪种方法取决于实际的应用需求，例如如果需要用户提交敏感数据（如密码或其他个人信息），则应使用POST方法。如果只是在不更改任何服务器状态的情况下检索数据，GET可能是更好的选择。在设计RESTful API时，这两种方法具有特定的语义，需要考虑到API的合理使用。

12、B/S和C/S的区别。

在计算机网络体系中，有两种常见的架构模式，分别是客户端/服务器（Client/Server，简称C/S）架构和浏览器/服务器（Browser/Server，简称B/S）架构。它们各自的特点和区别如下：

C/S架构（客户端/服务器架构）：

  1. 客户端应用程序：在C/S架构中，客户端是安装在用户设备上的专门软件，需要独立开发和安装。这种客户端通常提供丰富的用户界面和功能。
  2. 数据处理：客户端软件能够处理部分业务逻辑和数据存储工作，降低服务器压力。
  3. 网络依赖：比B/S架构下降，因为部分数据和业务逻辑可以在本地处理，减少了对服务器的请求次数。
  4. 维护更新：更新需要在每个客户端单独执行，维护成本高于B/S架构。
  5. 安全性：一般比B/S架构更安全，因为客户端可以实现更复杂的安全策略和数据加密。
  6. 多样性：可以针对不同操作系统开发对应的客户端软件。

B/S架构（浏览器/服务器架构）：

  1. 无需专门的客户端软件：用户通过Web浏览器作为客户端访问服务器上的应用程序，忽略了操作系统和设备类型的差异。
  2. 纯服务器端数据处理：所有的业务逻辑和数据处理都在服务器端完成，客户端主要负责显示和输入。
  3. 高度依赖网络：所有的操作都需要通过网络传输，因此对网络的依赖度高。
  4. 更新容易：只需要在服务器端进行更新，所有用户都能使用最新的版本，容易维护。
  5. 安全性：较C/S架构为弱，因为所有的交互都通过HTTP/HTTPS协议，在网络传输过程中可能会被截获和篡改。
  6. 通用性：基于Web的界面可以运行在任何支持Web标准的浏览器上，具有良好的跨平台性。

区别总结：

  • 应用部署：C/S需要在客户端安装专门的应用程序，B/S只需要浏览器。
  • 软件更新：C/S更新较为麻烦，需要用户手动更新；B/S更新容易，服务器端一旦更新，用户即可访问到新版本。
  • 用户访问方式：C/S通常通过专有协议访问服务器，B/S通过HTTP/HTTPS访问。
  • 跨平台性：B/S强于C/S，用户只需使用浏览器即可使用服务，而C/S可能需要为不同平台开发不同的客户端。
  • 用户体验：C/S通常提供更丰富和响应更快的用户界面，B/S在用户体验方面可能受限于Web技术的限制。

随着Web技术的发展，B/S架构越来越被广泛采用，尤其是随着AJAX、HTML5、CSS3、WebSocket等技术的兴起，B/S架构能提供和C/S架构相媲美的用户体验，同时在维护和跨平台上有着无可比拟的优势。

13、使用forward和sendRedirect进行重定向有什么区别?

forward（转发）和sendRedirect（重定向）是在Java Servlet中用来控制页面跳转的两种不同机制，各有特点和适用场景。

使用forward（转发）时：

  • 处理者：由服务器内部完成，对客户端来说是透明的。
  • URL地址：客户端浏览器的地址栏不会变化，仍显示原始请求的URL。
  • 性能：转发发生在服务器内部，不需要额外的网络往返，所以性能比重定向要稍好一些。
  • 请求和响应对象：对同一个请求内部转发，在转发过程中，请求（request）和响应（response）对象不变，转发的目标页面可以使用原始的请求中的数据。
  • 使用：通常用于web应用内部页面的跳转，因为它不能重定向到其他网站的URL。

在Java Servlet代码中，转发通常如下所实现：

request.getRequestDispatcher("page.jsp").forward(request, response);

使用sendRedirect（重定向）时：

  • 处理者：响应会先发送到客户端（浏览器），然后由客户端再向新的URL发送请求。
  • URL地址：客户端浏览器的地址栏会更新到新的URL。
  • 性能：需要进行额外的网络请求，因为客户端必须重新向新的地址发起请求，这会降低性能。
  • 请求和响应对象：重定向会创建一个全新的请求，前一个请求的所有对象都不再可用。
  • 使用：适用于重定向到当前网站上的另一个页面或者是完全不同的网站。

在Java Servlet代码中，重定向通常如此实现：

response.sendRedirect("page.jsp");

区别总结：

  • 实现方式：forward是服务器端的转发（不可见），sendRedirect是客户端的重定向（可见）。
  • URL变化：forward不改变浏览器URL，sendRedirect导致浏览器URL变化。
  • 域：forward保持请求范围内的数据，sendRedirect不保持这些数据。
  • 网络请求次数：forward只有一次请求，sendRedirect至少需要两次请求。

选择哪一个通常取决于是否需要保留请求数据以及是否需要从客户端浏览器到新的URL。如果需要将控制权交给另一个web资源，并且期望保留请求信息，那么应该使用forward。如果需要重定向到不同的域，或者需要一个全新的请求，那么应该使用sendRedirect。

14、jsp的工作原理是什么？

JSP（Java Server Pages）是一种Java servlet技术，用于创建动态web内容。JSP可以包含HTML代码、JavaScript、JSP标签和Java代码片段，这些都被嵌入到文本文档（通常是带有.jsp扩展名的文件）中。下面是JSP的工作原理：

  1. 编写JSP文件：开发者编写包含HTML标记和Java代码的JSP文件。

  2. 部署在服务器：JSP文件部署在支持Java的Web服务器或应用服务器上，例如Apache Tomcat。

  3. 客户端请求：用户通过浏览器发起请求，该请求的URL指向JSP文件。

  4. Web服务器接收请求：Web服务器接收到对JSP文件的请求后，将其传递给JSP引擎。在首次请求时，如果尚未编译该JSP文件，JSP引擎将执行下一个步骤；否则直接执行步骤7。

  5. JSP转换为Servlet：JSP引擎将JSP文件转换为等效的Java Servlet源代码。这是通过解析JSP文件中的HTML代码、JSP标签和Java代码片段来实现的。

  6. 编译Servlet：生成的Java Servlet源码被编译成可执行的.class文件，即编译后的Servlet。

  7. 执行Servlet：编译后的Servlet由JSP引擎加载，并执行Servlet的service方法来处理请求。在这个过程中，Servlet可以执行嵌入其中的Java代码，进行数据库访问、调用业务逻辑以及创建响应内容等操作。

  8. 生成响应：Servlet执行完成后，它会生成一个HTTP响应，这通常包括动态生成的HTML内容。

  9. 发送响应到客户端：生成的响应通过Web服务器发送回客户端的浏览器。

  10. 客户端呈现：浏览器接收到HTTP响应，并像处理普通HTML页面一样解析和显示它。

在整个JSP生命周期中，需要注意的是，JSP文件在首次请求时被转换为Servlet并编译。之后的请求通常直接使用已编译的Servlet，从而提高了效率。如果JSP文件被修改，服务器会重新编译JSP以生成更新后的Servlet。

简而言之，JSP的工作原理涉及将JSP页面转换为Servlet，然后由Java容器编译和执行这个Servlet，输出结果发送到客户端。这个过程将动态内容和静态模板（如HTML）结合到一起，为用户提供丰富的、动态更新的web页面。

15、JSP中动态INCLUDE与静态INCLUDE的区别？

JSP中可以使用两种方法来包含其他文件的内容：静态包含（Static Include）和动态包含（Dynamic Include），两者有明显的区别：

静态包含（Static Include）

使用JSP的指令进行静态包含：

<%@ include file="header.jsp" %>
  • 处理时机：在JSP页面被转换成Servlet的时候处理，即编译时包含。
  • 效果：include指令字面上将指定页面的内容复制到当前页面中。这就好像是在JSP文件还是文本形式的时候，就将包含的内容拷贝进来。
  • 性能：因为包含是在编译时处理的，所以不会在运行时增加额外开销。
  • 适用场景：适合用来包含静态内容，如页面布局、版权声明、导航栏等。

动态包含（Dynamic Include）

使用JSP的<jsp:include>动作进行动态包含：

<jsp:include page="header.jsp" flush="true" />
  • 处理时机：在请求被处理时（运行时）处理。
  • 效果：<jsp:include>动作执行时，会将指定页面作为独立的Servlet执行，然后将执行结果包含到当前页面中。因此，被包含的页面可以是动态内容。
  • 性能：每次请求都会执行包含的页面，所以与静态包含相比，动态包含具有更多的运行时开销。
  • 适用场景：适合动态内容的插入，例如根据不同用户的权限显示不同的菜单项、或者显示基于用户动态生成的数据报告。

区别总结：

  • 转换时间：静态包含在编译时完成，动态包含在运行时完成。
  • 更新反映：静态包含的内容改变后，包含此内容的JSP页面也需重新编译才能反映更新。而动态包含的内容改变后，无需重新编译调用它的JSP页面。
  • 性能开销：相比静态包含，动态包含在运行时会有额外的处理开销。
  • 灵活性：动态包含提供了比静态包含更高的灵活性，可以包含动态生成的内容。

开发者通常需要根据实际需求来选择合适的包含方式，以获得最佳性能和适当的灵活性。

16、JavaBean的定义与特性？

JavaBean 是一种遵循特定约定的 Java 类，它可以被重用并且可以轻松地通过工具和框架进行操作。JavaBean 主要用于封装数据，常见于多层架构中，特别是在表示层和业务层之间传输数据。

JavaBean 的定义：

一个类要成为 JavaBean，需要符合以下规范：

  1. 类是公共的（Public）：JavaBean 必须是公共的，以便其他类可以访问。

  2. 有一个无参构造器：JavaBean 应该有一个无参的构造方法，以便可以通过反射机制进行实例化。

  3. 属性私有：JavaBean 的属性通常是私有的（private），防止直接访问属性值，保证数据的封装性。

  4. 属性访问方法：JavaBean 提供公共的 getter 和 setter 方法来访问它的属性，遵守命名规范，如 getProperty() 和 setProperty(Type value)。

  5. 实现可序列化接口：JavaBean 通常实现 java.io.Serializable 接口，以便可以进行流的输入输出操作，如网络传输、存储到文件等。

JavaBean 的特性：

  1. 封装性：通过使用私有变量和公共的 getter 和 setter 方法，JavaBean 封装了它的属性，这允许属性在修改前可以进行检查，并且可以隐藏实现的细节。

  2. 可重用性：作为一个可重用的组件，在不同的环境中，相同的 JavaBean 可以用于不同的应用程序。

  3. 可替换性：JavaBean 对其他JavaBean来说是可替换的，可以在不影响其他Bean的情况下替换一个Bean。

  4. 集成性：JavaBeans 可以与其他JavaBean协同工作，通过工具或容器来组织，以建立更为复杂的系统。

  5. 易于操作和维护：由于遵循了严格的命名和设计规范，开发工具可以轻松地识别JavaBean的属性和方法，使得它们易于操作和维护。

JavaBean 主要用途是在不同层之间传输数据（作为一个数据载体），也可以在 JavaBean 之间组织业务逻辑。在像 Java EE 这样的企业级应用中，JavaBean 通常用来定义服务数据结构、表格数据或其他任何可以被序列化和传输的对象。

17、简述使用Cookie进行会话跟踪的过程。（写出主要步骤，即存取数据的步骤，教材有实例）

在Web应用中，HTTP协议本身是无状态的，这意味着服务器不会记住请求之间的状态信息。为了实现会话跟踪，即在不同请求之间保持状态，通常会使用Cookie。下面是使用Cookie进行会话跟踪的基本步骤：

1. 服务器创建Cookie并发送给客户端

当用户首次访问服务器时，服务器会创建一个Cookie来标识用户。这可以通过在服务器端的编程语言（如Java、PHP）中创建一个Cookie对象来完成。

// 示例：在Java中创建并发送一个Cookie
Cookie cookie = new Cookie("sessionId", "123456789");
// 可以设置cookie的有效期
cookie.setMaxAge(60*60*24); // 例如，设置cookie有效期为一天
// 将cookie添加到响应中，发送给客户端
response.addCookie(cookie);

2. 客户端存储Cookie

客户端浏览器会接收到这个Cookie，并将其存储在本地。在Cookie的有效期内，浏览器会持有这个Cookie。

3. 客户端随请求发送Cookie给服务器

在之后的每个请求中，只要访问的是该Cookie对应的域名和有效路径，浏览器都会自动将那个Cookie通过HTTP请求的头信息发送给服务器。

GET /index.html HTTP/1.1
Host: www.example.com
Cookie: sessionId=123456789

4. 服务器读取Cookie信息

服务器通过请求头中的Cookie信息识别用户，并通过查找与Cookie相关联的会话数据来恢复之前的会话状态。

// 示例：在Java中读取客户端发送的Cookie
Cookie[] cookies = request.getCookies();
if (cookies != null) {
    for (Cookie cookie : cookies) {
        if ("sessionId".equals(cookie.getName())) {
            String sessionId = cookie.getValue();
            // 根据sessionId恢复用户会话
        }
    }
}

5. 服务器可以更新Cookie信息

如果需要，服务器可以修改Cookie的信息，并通过响应头将更新的Cookie发送回客户端。

// 示例：在Java中更新Cookie信息，并发送给客户端
Cookie cookie = new Cookie("sessionId", "987654321");
response.addCookie(cookie);

6. 客户端替换或更新本地存储的Cookie

客户端收到更新后的Cookie信息后，会更新本地存储的Cookie数据。

通过这些步骤，服务器能够跟踪客户端的会话状态，即使是在无状态的HTTP协议之上。注意，Cookie通常用于存储不敏感的数据，因为客户端可以访问和修改Cookie。对于敏感数据，要么加密存放到Cookie中，要么使用更安全的会话管理方案，如HTTPSession等。

18．JavaBeans具有的特点有哪些？

JavaBeans 是在 Java 语言编程中，遵循特定规范的可重用组件。其具有以下特点：

  1. 封装性：JavaBean 将属性隐藏起来，只能通过公共的 getter 和 setter 方法访问。

  2. 可重用性：JavaBean 设计成可重用的组件以便在不同的环境和应用程序中使用。

  3. 可替换性：JavaBeans 可以相互替换，提供了一定程度的模块化。

  4. 可操作性：因为有标准的设计模式，它们可以很容易地通过工具进行操作。

  5. 集成性：JavaBeans 可以与其他 JavaBeans 集成，协同完成更复杂的功能。

  6. 组件化：JavaBeans 通常被设计为完成特定的功能，可以作为组件插入到应用程序中。

  7. 事件处理：JavaBeans 支持事件处理机制，允许Bean通过事件监听器与外界交互。

  8. 序列化：JavaBeans 通常实现了 Serializable 接口，因此它们可以被序列化和反序列化，以在网络上传输或存储到磁盘。

  9. 自省性（Introspection）：JavaBeans 支持自省机制，允许开发工具分析 Bean 的能力，如查看属性、方法和事件。

这些特点使 JavaBeans 成为了开发各种Java应用程序的基本构建块，尤其是在企业级开发以及需要组件重用的场景中。

avatar
文章
阅读
粉丝