JSP 教程 (基于 Eclipse IDE)

本教程将涵盖以下核心内容：

jsp教程 eclipse
（图片来源网络，侵删）
  1. 第一部分：环境搭建 - 在 Eclipse 中配置 Tomcat 服务器，为 JSP 开发做好准备。
  2. 第二部分：创建第一个 JSP 项目 - 动手创建项目，并运行一个简单的 "Hello World" 页面。
  3. 第三部分：JSP 核心语法详解 - 学习 JSP 的指令、脚本、表达式等核心元素。
  4. 第四部分：JSP 内置对象 - 了解 JSP 提供的 9 个强大内置对象，特别是 request 和 response。
  5. 第五部分：JSP 与 JavaBean 结合 - 学习如何使用 JavaBean 来封装业务逻辑,实现代码分离。
  6. 第六部分：JSP 与 EL、JSTL - 学习更简洁的表达式语言和标准标签库，这是现代 JSP 开发的必备技能。
  7. 第七部分：总结与进阶 - 总结学习路径,并给出下一步的学习方向。

第一部分：环境搭建

在开始之前,请确保你已经安装了以下软件：

  1. JDK (Java Development Kit): JSP 是基于 Java 的，所以必须安装 JDK，建议使用 JDK 8 或更高版本。
  2. Eclipse IDE for Enterprise Java and Web Developers: 下载并安装 Eclipse，这个版本包含了 Web 开发所需的插件。
  3. Apache Tomcat: 一个开源的 Web 服务器和应用服务器，用于运行和部署 JSP 应用，建议下载 Tomcat 9 或 10。

步骤 1: 在 Eclipse 中配置 Tomcat

  1. 打开 Eclipse，点击顶部菜单栏的 Window -> Preferences (在 macOS 上是 Eclipse -> Preferences)。
  2. 在弹出的窗口中，导航到 Server -> Runtime Environments。
  3. 点击右侧的 Add... 按钮。
  4. 在弹出的窗口中，选择你下载的 Tomcat 版本（Apache Tomcat v9.0），然后点击 Next。
  5. 在 Tomcat installation directory 字段中，点击 Browse...，选择你解压后的 Tomcat 根目录。
  6. JRE 通常会自动检测，如果没有，请选择你安装的 JDK。
  7. 点击 Finish 完成配置。

步骤 2: 创建 Tomcat 服务器实例

  1. 切换到 Eclipse 的 Servers 视图，如果看不到，可以通过 Window -> Show View -> Servers 打开。
  2. 在 Servers 视图的空白处，右键点击，选择 New -> Server。
  3. 在弹出的窗口中，选择你刚刚配置好的 Tomcat 版本，点击 Next。
  4. 在 Server name 中可以保留默认名称。
  5. 关键步骤：在 Choose the default JRE for the server 中，确保选择的是你的 JDK。
  6. 点击 Finish，现在你的 Servers 视图中应该有一个可用的 Tomcat 服务器了。

第二部分：创建第一个 JSP 项目

步骤 1: 创建 Dynamic Web Project

  1. 在 Eclipse 的 Package Explorer 视图中，右键点击空白处，选择 New -> Dynamic Web Project。
  2. 输入项目名称，JspDemo。
  3. 在 Target runtime 下拉菜单中，选择你之前创建的 Tomcat 服务器。
  4. 点击 Finish，Eclipse 会为你生成一个标准的 Web 项目结构。

步骤 2: 项目结构解析

创建成功后,你会看到类似如下的结构：

  • JspDemo: 项目根目录
    • src: 存放 Java 源代码（如 Servlet、JavaBean）。
    • WebContent: 存放所有 Web 资源，这是部署到服务器的根目录。
      • META-INF: 项目配置信息。
      • WEB-INF: 安全目录，里面的内容不能被客户端直接访问。
        • web.xml: 部署描述符（项目配置文件）。
      • index.jsp: 默认首页。
    • build: 存放编译后的 .class 文件。

步骤 3: 编写并运行第一个 JSP

  1. 在 WebContent 文件夹下，右键点击，选择 New -> JSP File。

  2. 输入文件名，hello.jsp，然后点击 Finish。

    jsp教程 eclipse
    （图片来源网络，侵删）

  3. Eclipse 会为你生成一个模板，清空内容,输入以下代码：

    <%-- 这是一个注释，不会在客户端显示 --%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">我的第一个 JSP 页面</title>
</head>
<body>
    <h1>你好，JSP 世界！</h1>
    <p>当前时间是: <%= new java.util.Date() %></p>
</body>
</html>

  4. 代码解释:

    • <%@ page ... %>: 这是 page 指令，用于设置整个页面的属性，比如编码语言、内容类型等。
    • <%-- ... --%>: 这是 JSP 注释。
    • <%= ... %>: 这是 JSP 表达式，用于在页面上输出一个 Java 表达式的值，这里的 new java.util.Date() 会创建一个日期对象并显示。

  5. 运行项目:

    • 切换到 Servers 视图。
    • 右键点击你的 Tomcat 服务器，选择 Add and Remove...。
    • 在弹出的窗口中，将你的 JspDemo 项目从左侧 Available 移动到右侧 Configured，然后点击 Finish。
    • 再次右键点击 Tomcat 服务器，选择 Start，服务器启动后，会自动在浏览器中打开默认页面（通常是 index.jsp）。
    • 为了测试 hello.jsp，你需要在浏览器地址栏手动输入：http://localhost:8080/JspDemo/hello.jsp (端口号 8080 可能因你的 Tomcat 配置而不同)。

    你应该能看到一个标题和当前的时间戳，恭喜，你的第一个 JSP 成功运行了！

    jsp教程 eclipse
    （图片来源网络，侵删）

第三部分：JSP 核心语法详解

JSP 本质上是在 HTML 中嵌入 Java 代码,主要有三种方式：

JSP 指令

用于向 JSP 容器（如 Tomcat）提供全局信息,它不直接生成任何可见的输出。

  • page 指令: 定义页面的属性，如 contentType, pageEncoding, import 等。

    • <%@ page import="java.util.List, java.util.ArrayList" %>: 导入 Java 类。

  • include 指令: 在翻译阶段（将 JSP 转换为 Servlet 时）将一个文件的内容静态地包含进来。

    • <%@ include file="header.jsp" %>: 将 header.jsp 的代码原样插入到此处。

  • taglib 指令: 引入标签库，如 JSTL。

    • <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>: 引入 JSTL 核心库。

JSP 脚本

  • <%! ... %>: 声明**

    • 用于在 JSP 页面中定义变量或方法，这些会成为 Servlet 类的成员。
    • <%!
  private int count = 0;
  public String sayHello(String name) {
      return "Hello, " + name;
  }
%>

  • <% ... %>: 脚本片段**

    • 用于编写 Java 代码块，这些代码会被直接放入 Servlet 的 service 方法中。
    • <%
  for (int i = 0; i < 5; i++) {
      out.println("<p>这是第 " + i + " 次循环。</p>");
  }
%>

  • <%= ... %>: 表达式**

    • 用于输出一个 Java 表达式的值，它会被翻译为 out.println(...)。
    • 你好，<%= request.getParameter("username") %>: 输出从请求中获取的 username 参数。

第四部分：JSP 内置对象

JSP 容器为每个页面自动创建了一些内置对象，你可以在脚本片段和表达式中直接使用它们,无需声明。

最常用的内置对象是 request 和 response。

  • request: HttpServletRequest 对象,代表客户端的请求。

    • 示例: 创建一个 login.html 和一个 welcome.jsp。
      • login.html:
        <form action="welcome.jsp" method="post">
    用户名: <input type="text" name="username">
    <input type="submit" value="登录">
</form>
      • welcome.jsp:
        <h1>欢迎你, <%= request.getParameter("username") %>!</h1>

  • response: HttpServletResponse 对象,代表服务器的响应。

    • 示例: 实现一个简单的重定向。
      <%
    // 如果用户名为 "admin"，则重定向到管理页面
    String user = request.getParameter("username");
    if ("admin".equals(user)) {
        response.sendRedirect("admin.jsp");
    } else {
        response.sendRedirect("user.jsp");
    }
%>

  • 其他内置对象:

    • out: JspWriter 对象,用于向客户端输出内容。
    • session: HttpSession 对象，用于在多个请求之间保存用户的状态（如购物车）。
    • application: ServletContext 对象，代表整个 Web 应用,用于共享全局数据。
    • pageContext: PageContext 对象,提供对页面所有命名空间的访问。
    • config: ServletConfig 对象，包含 Servlet 的初始化信息。
    • exception: Throwable 对象，只有在 isErrorPage="true" 的页面中才可用。

第五部分：JSP 与 JavaBean 结合

直接在 JSP 中写大量的 Java 代码（Scriptlet）会使页面变得混乱，难以维护，最佳实践是使用 JavaBean 来封装业务逻辑和数据。

JavaBean 是一个遵循特定规范的 Java 类：

  1. 是一个公共类。
  2. 有一个无参的公共构造函数。
  3. 属性是私有的，并通过 getXxx() 和 setXxx() 方法来访问。

示例：使用 JavaBean

  1. 创建 JavaBean

    • 在 src 目录下创建包 com.example.bean，然后在包中创建 User.java。
      package com.example.bean;

    public class User { private String username; private String password;

    // 必须有无参构造函数
public User() {
}
// Getter 和 Setter 方法
public String getUsername() {
    return username;
}
public void setUsername(String username) {
    this.username = username;
}
public String getPassword() {
    return password;
}
public void setPassword(String password) {
    this.password = password;
}

  2. 在 JSP 中使用 JavaBean

    • JSP 提供了三个与 JavaBean 相关的动作标签：jsp:useBean, jsp:setProperty, jsp:getProperty。

    • 创建 register.jsp:

      <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ page import="com.example.bean.User" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>注册页面</title>
</head>
<body>
    <h1>用户注册</h1>
    <jsp:useBean id="userBean" class="com.example.bean.User" scope="page" />
    <form action="showUserInfo.jsp" method="post">
        用户名: <input type="text" name="username"><br>
        密码: <input type="password" name="password"><br>
        <input type="submit" value="注册">
    </form>
</body>
</html>

    • 创建 showUserInfo.jsp:

      <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ page import="com.example.bean.User" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>用户信息</title>
</head>
<body>
    <h1>用户信息</h1>
    <!-- 创建或获取一个名为 userBean 的 User 对象 -->
    <jsp:useBean id="userBean" class="com.example.bean.User" scope="request" />
    <!-- 自动将 request 参数中名为 username 的值，设置到 userBean 的 username 属性中 -->
    <jsp:setProperty name="userBean" property="*" />
    <!-- 获取并显示 userBean 的属性 -->
    <p>用户名: <jsp:getProperty name="userBean" property="username" /></p>
    <p>密码: <jsp:getProperty name="userBean" property="password" /></p>
</body>
</html>

    • 注意: scope 属性指定了 Bean 的作用域（page, request, session, application），这里使用 request，因为数据需要在 register.jsp 和 showUserInfo.jsp 之间传递。

第六部分：JSP 与 EL、JSTL

直接使用 JSP 表达式和动作标签虽然比 Scriptlet 好，但仍然有些冗长。表达式语言 和 JSP 标准标签库 的出现，让 JSP 页面变得更加简洁和易读。

表达式语言

EL 主要用于从各种作用域中获取数据并进行简单的运算。

  • 语法:
  • 示例:
    • 获取 request 中的 username 参数: ${param.username}
    • 获取 request 作用域中的 user 对象的 name 属性: ${requestScope.user.name}
    • 简单算术: ${10 + 20}
    • 逻辑判断: ${empty user ? '用户不存在' : user.name}

重要: 默认情况下，EL 在 JSP 2.0 及以上版本是启用的，如果不行，可以在 web.xml 中添加：

<jsp-config>
    <jsp-property-group>
        <url-pattern>*.jsp</url-pattern>
        <el-ignored>false</el-ignored>
    </jsp-property-group>
</jsp-config>

JSP 标准标签库

JSTL 提供了一组标准标签，用于处理逻辑、迭代、格式化等，避免在 JSP 中写 Java 代码。

  1. 添加 JSTL 库: 如果你的项目没有 JSTL 库,需要手动添加。

    • 下载 jstl-1.2.jar 文件。
    • 将其复制到项目的 WebContent/WEB-INF/lib 目录下。
    • 在 Eclipse 中，右键点击该 JAR 文件，选择 Build Path -> Add to Build Path。

  2. 使用 JSTL 核心标签:

    • c:if: 条件判断
      <%-- 假设 request 中有一个 role 属性 --%>
<c:if test="${not empty sessionScope.user and sessionScope.user.role == 'admin'}">
    <p>欢迎管理员！</p>
</c:if>
    • c:forEach: 循环迭代
      <%-- 假设 request 中有一个 userList 列表 --%>
<ul>
    <c:forEach items="${requestScope.userList}" var="user">
        <li>${user.name} - ${user.email}</li>
    </c:forEach>
</ul>

结合 EL 和 JSTL 的 showUserInfo.jsp 优化版:

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%<%-- 引入 JSTL 核心库 --%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">用户信息 (EL & JSTL版)</title>
</head>
<body>
    <h1>用户信息</h1>
    <!-- 创建或获取一个名为 userBean 的 User 对象 -->
    <jsp:useBean id="userBean" class="com.example.bean.User" scope="request" />
    <!-- 使用 JSTL 的 c:set 来设置属性，比 jsp:setProperty 更灵活 -->
    <c:set target="${userBean}" property="username" value="${param.username}" />
    <c:set target="${userBean}" property="password" value="${param.password}" />
    <!-- 使用 EL 来获取并显示属性，非常简洁 -->
    <p>用户名: ${userBean.username}</p>
    <p>密码: ${userBean.password}</p>
    <!-- 使用 JSTL 的 c:if 进行判断 -->
    <c:if test="${not empty userBean.username}">
        <p>欢迎你, <b>${userBean.username}</b>!</p>
    </c:if>
</body>
</html>

对比一下，你会发现代码的可读性大大提高，JSP 页面几乎不再包含任何 Java 代码。

第七部分：总结与进阶

  • 环境是基础: 熟练掌握在 Eclipse 中配置和使用 Tomcat 是第一步。
  • JSP 语法是核心: 理解指令、脚本和表达式是 JSP 开发的基石。
  • 内置对象是桥梁: request, response, session 等是与 Web 交互的关键。
  • JavaBean 是模型: 使用 JavaBean 封装数据,实现逻辑与表现的初步分离。
  • EL & JSTL 是最佳实践: 它们让 JSP 页面变得简洁、清晰，是现代 JSP 开发的标准。

进阶学习路径

学习完本教程，你已经掌握了 JSP 的基本技能,你可以朝以下方向深入：

  1. Servlet: JSP 的本质是 Servlet，深入学习 Servlet 的工作原理、生命周期、过滤器 和监听器，会让你对 Web 开发有更深刻的理解。
  2. MVC 设计模式: 这是 Web 开发中最重要的设计模式，学习如何将 Model (JavaBean)、View (JSP) 和 Controller (Servlet) 分离，构建可维护、可扩展的应用。Spring MVC 就是基于此模式的优秀框架。
  3. 数据库连接: 学习使用 JDBC 来连接数据库，实现数据的增删改查，通常会配合 连接池 (如 Druid, HikariCP) 使用。
  4. 框架学习: 直接学习 Spring Boot，它极大地简化了 Java Web 应用的开发，是目前的主流，Spring Boot 默认使用模板引擎（如 Thymeleaf）来替代传统的 JSP，但理解 JSP 的原理对于学习 Spring Boot 中的 Web 相关知识仍然非常有帮助。

祝你学习愉快！