• JSP 基本介绍及使用。

    目录

    一、JSP 原理

    1、JSP 概述

    2、快速入门

    3、JSP 原理

    4、JSP 脚本

    5、JSP 的缺点 

    二、EL 表达式和 JSTL 标签

    1、EL 表达式

    2、域对象

    3、JSTL标签

    三、MVC模式及三层架构

    1、MVC 模式

    2、三层架构

    一、JSP 原理

    1、JSP 概述

    ▶ 基本介绍

     JSP（全称：Java Server Pages）：Java 服务端页面。是一种动态的网页技术，其中既可以定义 HTML、JS、CSS等静态内容，还可以定义 Java代码的动态内容，也就是 `JSP = HTML + Java`。如下就是jsp代码

    1. <html>
    2.     <head>
    3.         <title>Titletitle>
    4.     head>
    5.     <body>
    6.         <h1>JSP,Hello Worldh1>
    7.         <%
    8.         	System.out.println("hello,jsp~");
    9.         %>
    10.     body>
    11. html>

    上面代码 `h1` 标签内容是展示在页面上，而 Java 的输出语句是输出在 idea 的控制台。

    ▶ JSP 能干什么？

    要想实现上面这样的用户登录，然后动态的弹出“某某，欢迎您” ，我们看看它的代码实现： 

     上面的代码有大量使用到 `writer` 对象向页面写标签内容，这样我们的代码就显得很麻烦；将来如果展示的效果出现了问题，排错也显得有点力不从心。而 JSP 就能解决这个问题，我们看看JSP怎么实现：

     上面代码可以看到里面基本都是 `HTML` 标签，而动态数据使用 Java 代码进行展示；这样操作看起来要比用 `servlet` 实现要舒服很多。

    JSP 作用：简化开发，避免了在Servlet中直接输出HTML标签。

     2、快速入门

    ▶ 搭建环境

    创建一个maven的 web 项目，项目结构如下：

    `pom.xml` 文件内容如下：

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0modelVersion>
    6.  
    7.     <groupId>org.examplegroupId>
    8.     <artifactId>jsp-demoartifactId>
    9.     <version>1.0-SNAPSHOTversion>
    10.     <packaging>warpackaging>
    11.  
    12.     <properties>
    13.         <maven.compiler.source>8maven.compiler.source>
    14.         <maven.compiler.target>8maven.compiler.target>
    15.     properties>
    16.  
    17.     <dependencies>
    18.       <dependency>
    19.             <groupId>javax.servletgroupId>
    20.             <artifactId>javax.servlet-apiartifactId>
    21.             <version>3.1.0version>
    22.             <scope>providedscope>
    23.         dependency>
    24.     dependencies>
    25.  
    26.     <build>
    27.         <plugins>
    28.             <plugin>
    29.                 <groupId>org.apache.tomcat.mavengroupId>
    30.                 <artifactId>tomcat7-maven-pluginartifactId>
    31.                 <version>2.2version>
    32.             plugin>
    33.         plugins>
    34.     build>
    35. project>

    ▶ 导入 JSP 依赖

    在 `dependencies` 标签中导入 JSP 的依赖，如下

    1. <dependency>
    2.     <groupId>javax.servlet.jspgroupId>
    3.     <artifactId>jsp-apiartifactId>
    4.     <version>2.2version>
    5.     <scope>providedscope>
    6. dependency>

    该依赖的 `scope` 必须设置为 `provided`，因为 tomcat 中有这个jar包了，所以在打包时我们是不希望将该依赖打进到我们工程的war包中。

    ▶ 创建 jsp 页面

    在项目的 `webapp` 下创建jsp页面

    通过上面方式创建一个名为 `hello.jsp` 的页面。

    ▶ 编写代码

    在 `hello.jsp` 页面中书写 `HTML` 标签和 `Java` 代码，如下

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head>
    4.     <title>Titletitle>
    5. head>
    6. <body>
    7.     <h1>hello jsph1>
    8.  
    9.     <%
    10.         System.out.println("hello,jsp~");
    11.     %>
    12. body>
    13. html>

    ▶ 测试

    启动服务器并在浏览器地址栏输入 `http://localhost:8080/jsp-demo/hello.jsp`，我们可以在页面上看到如下内容

    同时也可以看到在 `idea` 的控制台看到输出的 `hello,jsp~` 内容。

    3、JSP 原理

    ▶ 基本流程

     我们之前说 JSP 就是一个页面，那么在 JSP 中写 `html` 标签，我们能理解，但是为什么还可以写 `Java` 代码呢？因为 JSP 本质上就是一个 Servlet。那么访问jsp时的流程是怎么的？

     1. 浏览器第一次访问 `hello.jsp` 页面
     2. `tomcat` 会将 `hello.jsp` 转换为名为 `hello_jsp.java` 的一个 `Servlet`
     3. `tomcat` 再将转换的 `servlet` 编译成字节码文件 `hello_jsp.class`
     4. `tomcat` 会执行该字节码文件，向外提供服务

     我们可以到项目所在磁盘目录下找 `target\tomcat\work\Tomcat\localhost\jsp-demo\org\apache\jsp` 目录，而这个目录下就能看到转换后的 `servlet`

     打开 `hello_jsp.java` 文件，来查看里面的代码：

     由上面的类的继承关系可以看到继承了名为 `HttpJspBase` 这个类，那我们在看该类的继承关系。到资料中的找如下目录： `资料\tomcat源码\apache-tomcat-8.5.68-src\java\org\apache\jasper\runtime` ，该目录下就有 `HttpJspBase` 类，查看该类的继承关系

     可以看到该类继承了 `HttpServlet` ；那么 `hello_jsp` 这个类就间接的继承了 `HttpServlet` ，也就说明 `hello_jsp` 是一个 `servlet`。

     继续阅读 `hello_jsp` 类的代码，可以看到有一个名为 `_jspService()` 的方法，该方法就是每次访问 `jsp` 时自动执行的方法，和 `servlet` 中的 `service` 方法一样 。

    而在 `_jspService()` 方法中可以看到往浏览器写标签的代码：

     以前我们自己写 `servlet` 时，这部分代码是由我们自己来写，现在有了 `jsp` 后，由tomcat完成这部分功能。

    4、JSP 脚本

    JSP脚本用于在 JSP页面内定义 Java代码。在之前的入门案例中我们就在 JSP 页面定义的 Java 代码就是 JSP 脚本。

    ▶ JSP 脚本分类

    JSP 脚本有如下三个分类：

    • <%...%>：内容会直接放到 _jspService() 方法之中
    • <%=…%>：内容会放到out.print()中，作为out.print()的参数
    • <%!…%>：内容会放到_jspService()方法之外，被类直接包含

    ▶ 代码演示

     ▷ 在 `hello.jsp` 中书写

    1. <%
    2.     System.out.println("hello,jsp~");
    3.     int i = 3;
    4. %>

    通过浏览器访问 `hello.jsp` 后，查看转换的 `hello_jsp.java` 文件，i 变量定义在了 `_jspService()` 方法中

     ▷ 在 `hello.jsp` 中书写

    1. <%="hello"%>
    2. <%=i%>

    通过浏览器访问 `hello.jsp` 后，查看转换的 `hello_jsp.java` 文件，该脚本的内容被放在了 `out.print()` 中，作为参数

      ▷ 在 `hello.jsp` 中书写

    1. <%!
    2.     void  show(){}
    3.     String name = "zhangsan";
    4. %>

    通过浏览器访问 `hello.jsp` 后，查看转换的 `hello_jsp.java` 文件，该脚本的内容被放在了成员位置

    5、JSP 的缺点 

    由于 JSP页面内，既可以定义 HTML 标签，又可以定义 Java代码，造成了以下问题：

    • 书写麻烦：特别是复杂的页面，既要写 HTML 标签，还要写 Java 代码
    • 阅读麻烦：上面案例的代码，相信你后期再看这段代码时还需要花费很长的时间去梳理
    • 复杂度高：运行需要依赖于各种环境，JRE，JSP容器，JavaEE…
    • 占内存和磁盘：JSP会自动生成.java和.class文件占磁盘，运行的是.class文件占内存
    • 调试困难：出错后，需要找到自动生成的.java文件进行调试
    • 不利于团队协作：前端人员不会 Java，后端人员不精 HTML，如果页面布局发生变化，前端工程师对静态页面进行修改，然后再交给后端工程师，由后端工程师再将该页面改为 JSP 页面。

    由于上述的问题等，JSP 已逐渐退出历史舞台，以后开发更多的是使用 HTML +  Ajax 来替代。有了 Ajax 这个技术后，前端工程师负责前端页面开发，而后端工程师只负责前端代码开发。技术的发展：

     1. 第一阶段：使用 `servlet` 即实现逻辑代码编写，也对页面进行拼接。这种模式我们之前也接触过

     2. 第二阶段：随着技术的发展，出现了 `JSP` ，人们发现 `JSP` 使用起来比 `Servlet` 方便很多，但是还是要在 `JSP` 中嵌套 `Java` 代码，也不利于后期的维护

     3. 第三阶段：使用 `Servlet` 进行逻辑代码开发，而使用 `JSP` 进行数据展示

     4. 第四阶段：使用 `servlet` 进行后端逻辑代码开发，而使用 `HTML` 进行数据展示。而这里面就存在问题，`HTML` 是静态页面，怎么进行动态数据展示呢？这就是 `ajax` 的作用了。

    那既然 JSP 已经逐渐的退出历史舞台，那我们为什么还要学习 `JSP` 呢？原因有两点：

    • 一些公司可能有些老项目还在用 `JSP` ，所以要求我们必须动 `JSP`
    • 我们如果不经历这些复杂的过程，就不能体现后面阶段开发的简单

    二、EL 表达式和 JSTL 标签

    1、EL 表达式

    ▶ 概述

     EL（全称Expression Language ）表达式语言，用于简化 JSP 页面内的 Java 代码。EL 表达式的主要作用是 获取数据。其实就是从域对象中获取数据，然后将数据展示在页面上。

    而 EL 表达式的语法也比较简单：${expression} 。例如：${brands} 就是获取域中存储的 key 为 brands 的数据。

    ▶ 代码示例

     ▷ 定义servlet，在 servlet 中封装一些数据并存储到 request 域对象中并转发到 `el-demo.jsp` 页面。

    1. @WebServlet("/demo1")
    2.   public class ServletDemo1 extends HttpServlet {
    3.       @Override
    4.       protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    5.           //1. 准备数据
    6.           List<Brand> brands = new ArrayList<Brand>();
    7.           brands.add(new Brand(1,"三只松鼠","三只松鼠",100,"三只松鼠，好吃不上火",1));
    8.           brands.add(new Brand(2,"优衣库","优衣库",200,"优衣库，服适人生",0));
    9.           brands.add(new Brand(3,"小米","小米科技有限公司",1000,"为发烧而生",1));
    10.   
    11.           //2. 存储到request域中
    12.           request.setAttribute("brands",brands);
    13.   
    14.           //3. 转发到 el-demo.jsp
    15.           request.getRequestDispatcher("/el-demo.jsp").forward(request,response);
    16.       }
    17.   
    18.       @Override
    19.       protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    20.           this.doGet(request, response);
    21.       }
    22.   }

      注意：此处需要用转发，因为转发才可以使用 request 对象作为域对象进行数据共享

     ▷ 在 `el-demo.jsp` 中通过 EL表达式 获取数据

    1.  <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2.   <html>
    3.   <head>
    4.       <title>Titletitle>
    5.   head>
    6.   <body>
    7.       ${brands}
    8.   body>
    9.   html>

     ▷ 在浏览器的地址栏输入 `http://localhost:8080/jsp-demo/demo1` ，页面效果如下： 

     2、域对象

    JavaWeb中有四大域对象，分别是：

    • page：当前页面有效
    • request：当前请求有效
    • session：当前会话有效
    • application：当前应用有效

    el 表达式获取数据，会依次从这4个域中寻找，直到找到为止。而这四个域对象的作用范围如下图所示

    例如： ${brands}，el 表达式获取数据，会先从page域对象中获取数据，如果没有再到 requet 域对象中获取数据，如果再没有再到 session 域对象中获取，如果还没有才会到 application 中获取数据。

    3、JSTL标签

    ▶ 概述

    JSP标准标签库(Jsp Standarded Tag Library) ，使用标签取代JSP页面上的Java代码。如下代码就是JSTL标签

    1. <c:if test="${flag == 1}">
    2.     男
    3. c:if>
    4. <c:if test="${flag == 2}">
    5.     女
    6. c:if>

    JSTL 提供了很多标签，如下图：

    ▶ 使用步骤

     1、导入坐标

    1.  <dependency>
    2.       <groupId>jstlgroupId>
    3.       <artifactId>jstlartifactId>
    4.       <version>1.2version>
    5.   dependency>
    6.   <dependency>
    7.       <groupId>taglibsgroupId>
    8.       <artifactId>standardartifactId>
    9.       <version>1.1.2version>
    10.   dependency>

      2、在JSP页面上引入JSTL标签库

    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 

     3、使用标签
     

    ▶ if 标签

    ``：相当于 if 判断

     属性：test，用于定义条件表达式

    1. <c:if test="${flag == 1}">
    2.     男
    3. c:if>
    4. <c:if test="${flag == 2}">
    5.     女
    6. c:if>

    ▶ forEach 标签

     ``：相当于 for 循环。java中有增强for循环和普通for循环，JSTL 中的  `` 也有两种用法

     ▷ 第一种

     类似于 Java 中的增强for循环。涉及到的 `` 中的属性如下：

    • items：被遍历的容器
    • var：遍历产生的临时变量
    • varStatus：遍历状态对象

    如下代码，是从域对象中获取名为 brands 数据，该数据是一个集合；遍历遍历，并给该集合中的每一个元素起名为 `brand`，是 Brand对象。在循环里面使用 EL表达式获取每一个Brand对象的属性值：

    1. <c:forEach items="${brands}" var="brand">
    2.     <tr align="center">
    3.         <td>${brand.id}td>
    4.         <td>${brand.brandName}td>
    5.         <td>${brand.companyName}td>
    6.         <td>${brand.description}td>
    7.     tr>
    8. c:forEach>

     ▷ 第二种

    类似于 Java 中的普通for循环。涉及到的 `` 中的属性如下：

    • begin：开始数
    • end：结束数
    • step：步长

    实例代码：从0循环到10，变量名是 `i` ，每次自增1

    1. <c:forEach begin="0" end="10" step="1" var="i">
    2.     ${i}
    3. c:forEach>

    三、MVC模式及三层架构

    1、MVC 模式

    MVC 是一种分层开发的模式，其中：

    • M：Model，业务模型，处理业务
    • V：View，视图，界面展示
    • C：Controller，控制器，处理请求，调用模型和视图

     控制器（serlvlet）用来接收浏览器发送过来的请求，控制器调用模型（JavaBean）来获取数据，比如从数据库查询数据；控制器获取到数据后再交由视图（JSP）进行数据展示。

    MVC 的好处：

    • 职责单一，互不影响。每个角色做它自己的事，各司其职。
    • 有利于分工协作。
    • 有利于组件重用

    2、三层架构

    三层架构是将我们的项目分成了三个层面，分别是 `表现层`、`业务逻辑层`、`数据访问层`。

    •  数据访问层：对数据库的CRUD基本操作
    • 业务逻辑层：对业务逻辑进行封装，组合数据访问层层中基本功能，形成复杂的业务逻辑功能。例如 `注册业务功能` ，我们会先调用 `数据访问层` 的 `selectByName()` 方法判断该用户名是否存在，如果不存在再调用 `数据访问层` 的 `insert()` 方法进行数据的添加操作
    • 表现层：接收请求，封装数据，调用业务逻辑层，响应数据

    而整个流程是，浏览器发送请求，表现层的Servlet接收请求并调用业务逻辑层的方法进行业务逻辑处理，而业务逻辑层方法调用数据访问层方法进行数据的操作，依次返回到serlvet，然后servlet将数据交由 JSP 进行展示。

    三层架构的每一层都有特有的包名称：

    • 表现层： `com.itheima.controller` 或者 `com.itheima.web`
    • 业务逻辑层：`com.itheima.service`
    • 数据访问层：`com.itheima.dao` 或者 `com.itheima.mapper`

    ▶ MVC 和 三层架构

     两者的区别和联系：

     如上图上半部分是 MVC 模式，上图下半部分是三层架构。 `MVC 模式` 中的 C（控制器）和 V（视图）就是 `三层架构` 中的表现层，而 `MVC 模式` 中的 M（模型）就是 `三层架构` 中的 业务逻辑层 和 数据访问层。可以将 `MVC 模式` 理解成是一个大的概念，而 `三层架构` 是对 `MVC 模式` 实现架构的思想。 那么我们以后按照要求将不同层的代码写在不同的包下，每一层里功能职责做到单一，将来如果将表现层的技术换掉，而业务逻辑层和数据访问层的代码不需要发生变化。

  • 相关阅读:
    JavaDemo——关于BigDecimal类
    vite和webpack的区别
    Day19_8 Java学习之打印流、属性集、类加载器与反射
    cs231n_2022的assignment-1实现（KNN部分）
    第四届“传智杯”全国大学生IT技能大赛（初赛A组） 补题
    Linux--信号量
    十大服装店收银系统有哪些 好用的服装收银软件推荐
    Python——format格式输出
    《动手学深度学习 Pytorch版》 4.4 模型选择、欠拟合和过拟合
    【微信小程序】使用webstorm进行开发，支持代码提示高亮等
  • 原文地址：https://blog.csdn.net/yzh2776680982/article/details/126943063