JSP 基本介绍及使用。

傷城~ 2023-10-02 21:16 20阅读 0赞

**目录**

一、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代码
> 
>     <html>
>         <head>
>             <title>Title</title>
>         </head>
>         <body>
>             <h1>JSP,Hello World</h1>
>             <%
>             	System.out.println("hello,jsp~");
>             %>
>         </body>
>     </html>
> 
> 上面代码 \`h1\` 标签内容是展示在页面上，而 Java 的输出语句是输出在 idea 的控制台。
> 
> **▶ JSP 能干什么？**
> 
> ![916f808739a24b74bffc7b1037da2a24.png][]
> 
> 要想实现上面这样的用户登录，然后动态的弹出“某某，欢迎您” ，我们看看它的代码实现： ![30d4f6ca9c5b4c639ad32c2d12b05e6e.png][]
> 
> 上面的代码有大量使用到 \`writer\` 对象向页面写标签内容，这样我们的代码就显得很麻烦；将来如果展示的效果出现了问题，排错也显得有点力不从心。而 JSP 就能解决这个问题，我们看看JSP怎么实现：
> 
> ![b7e2fdf4a7ae43008a0726d87116309b.png][]
> 
> 上面代码可以看到里面基本都是 \`HTML\` 标签，而动态数据使用 Java 代码进行展示；这样操作看起来要比用 \`servlet\` 实现要舒服很多。
> 
> **JSP 作用：简化开发，避免了在Servlet中直接输出HTML标签。**
> 
> ### 2、快速入门 ###
> 
> **▶ 搭建环境**
> 
> 创建一个maven的 web 项目，项目结构如下：
> 
> ![fcaa7324618f4438a57cd7dab6fb6b80.png][]
> 
> \`pom.xml\` 文件内容如下：
> 
>     <?xml version="1.0" encoding="UTF-8"?>
>     <project xmlns="http://maven.apache.org/POM/4.0.0"
>              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
>              xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
>         <modelVersion>4.0.0</modelVersion>
>     
>         <groupId>org.example</groupId>
>         <artifactId>jsp-demo</artifactId>
>         <version>1.0-SNAPSHOT</version>
>         <packaging>war</packaging>
>     
>         <properties>
>             <maven.compiler.source>8</maven.compiler.source>
>             <maven.compiler.target>8</maven.compiler.target>
>         </properties>
>     
>         <dependencies>
>           <dependency>
>                 <groupId>javax.servlet</groupId>
>                 <artifactId>javax.servlet-api</artifactId>
>                 <version>3.1.0</version>
>                 <scope>provided</scope>
>             </dependency>
>         </dependencies>
>     
>         <build>
>             <plugins>
>                 <plugin>
>                     <groupId>org.apache.tomcat.maven</groupId>
>                     <artifactId>tomcat7-maven-plugin</artifactId>
>                     <version>2.2</version>
>                 </plugin>
>             </plugins>
>         </build>
>     </project>
> 
> **▶ 导入 JSP 依赖**
> 
> 在 \`dependencies\` 标签中导入 JSP 的依赖，如下
> 
>     <dependency>
>         <groupId>javax.servlet.jsp</groupId>
>         <artifactId>jsp-api</artifactId>
>         <version>2.2</version>
>         <scope>provided</scope>
>     </dependency>
> 
> 该依赖的 \`scope\` 必须设置为 \`provided\`，因为 tomcat 中有这个jar包了，所以在打包时我们是不希望将该依赖打进到我们工程的war包中。
> 
> **▶ 创建 jsp 页面**
> 
> 在项目的 \`webapp\` 下创建jsp页面
> 
> ![6368c3a5caf84d988d2cac7ce1a72d9b.png][]
> 
> 通过上面方式创建一个名为 \`hello.jsp\` 的页面。
> 
> **▶ 编写代码**
> 
> 在 \`hello.jsp\` 页面中书写 \`HTML\` 标签和 \`Java\` 代码，如下
> 
>     <%@ page contentType="text/html;charset=UTF-8" language="java" %>
>     <html>
>     <head>
>         <title>Title</title>
>     </head>
>     <body>
>         <h1>hello jsp</h1>
>     
>         <%
>             System.out.println("hello,jsp~");
>         %>
>     </body>
>     </html>
> 
> **▶ 测试**
> 
> 启动服务器并在浏览器地址栏输入 \`http://localhost:8080/jsp-demo/hello.jsp\`，我们可以在页面上看到如下内容
> 
> ![025995b11cc94ddf8470480fc6103b42.png][]
> 
> 同时也可以看到在 \`idea\` 的控制台看到输出的 \`hello,jsp~\` 内容。
> 
> ### 3、JSP 原理 ###
> 
> **▶ 基本流程**
> 
> 我们之前说 JSP 就是一个页面，那么在 JSP 中写 \`html\` 标签，我们能理解，但是为什么还可以写 \`Java\` 代码呢？因为 JSP 本质上就是一个 Servlet。那么访问jsp时的流程是怎么的？![95766040e9634b4cbe53c440fed387be.png][]
> 
> 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\`
> 
> ![1509448404a24f769751d1869ed879f7.png][]
> 
> 打开 \`hello\_jsp.java\` 文件，来查看里面的代码：
> 
> ![e36beb501b244d5ba9c04fc547c07033.png][]
> 
> 由上面的类的继承关系可以看到继承了名为 \`HttpJspBase\` 这个类，那我们在看该类的继承关系。到资料中的找如下目录： \`资料\\tomcat源码\\apache-tomcat-8.5.68-src\\java\\org\\apache\\jasper\\runtime\` ，该目录下就有 \`HttpJspBase\` 类，查看该类的继承关系
> 
> ![61c18109550e434d80792bfddd9bff45.png][]
> 
> 可以看到该类继承了 \`HttpServlet\` ；那么 \`hello\_jsp\` 这个类就间接的继承了 \`HttpServlet\` ，也就说明 \`hello\_jsp\` 是一个 \`servlet\`。
> 
> 继续阅读 \`hello\_jsp\` 类的代码，可以看到有一个名为 \`\_jspService()\` 的方法，该方法就是每次访问 \`jsp\` 时自动执行的方法，和 \`servlet\` 中的 \`service\` 方法一样 。
> 
> 而在 \`\_jspService()\` 方法中可以看到往浏览器写标签的代码：
> 
> ![1300be4bbbe449bf9a86eee8241410ef.png][]
> 
> 以前我们自己写 \`servlet\` 时，这部分代码是由我们自己来写，现在有了 \`jsp\` 后，由tomcat完成这部分功能。
> 
> ### 4、JSP 脚本 ###
> 
> JSP脚本用于在 JSP页面内定义 Java代码。在之前的入门案例中我们就在 JSP 页面定义的 Java 代码就是 JSP 脚本。
> 
> **▶ JSP 脚本分类**
> 
> JSP 脚本有如下三个分类：
> 
>  *  <%...%>：内容会直接放到 \_jspService() 方法之中
>  *  <%=…%>：内容会放到out.print()中，作为out.print()的参数
>  *  <%!…%>：内容会放到\_jspService()方法之外，被类直接包含
> 
> **▶ 代码演示**
> 
> ▷ 在 \`hello.jsp\` 中书写
> 
>     <%
>         System.out.println("hello,jsp~");
>         int i = 3;
>     %>
> 
> 通过浏览器访问 \`hello.jsp\` 后，查看转换的 \`hello\_jsp.java\` 文件，i 变量定义在了 \`\_jspService()\` 方法中
> 
> ![28d408eb190c4594951417cf98329e94.png][]
> 
> ▷ 在 \`hello.jsp\` 中书写
> 
>     <%="hello"%>
>     <%=i%>
> 
> 通过浏览器访问 \`hello.jsp\` 后，查看转换的 \`hello\_jsp.java\` 文件，该脚本的内容被放在了 \`out.print()\` 中，作为参数
> 
> ![18627b1e20d141fd820c1fc9c89bc77b.png][]
> 
> ▷ 在 \`hello.jsp\` 中书写
> 
>     <%!
>         void  show(){}
>         String name = "zhangsan";
>     %>
> 
> 通过浏览器访问 \`hello.jsp\` 后，查看转换的 \`hello\_jsp.java\` 文件，该脚本的内容被放在了成员位置
> 
> ![6d17dd6934b54cf284594f54fc9c2536.png][]
> 
> ### 5、JSP 的缺点 ###
> 
> 由于 JSP页面内，既可以定义 HTML 标签，又可以定义 Java代码，造成了以下问题：
> 
>  *  书写麻烦：特别是复杂的页面，既要写 HTML 标签，还要写 Java 代码
>  *  阅读麻烦：上面案例的代码，相信你后期再看这段代码时还需要花费很长的时间去梳理
>  *  复杂度高：运行需要依赖于各种环境，JRE，JSP容器，JavaEE…
>  *  占内存和磁盘：JSP会自动生成.java和.class文件占磁盘，运行的是.class文件占内存
>  *  调试困难：出错后，需要找到自动生成的.java文件进行调试
>  *  不利于团队协作：前端人员不会 Java，后端人员不精 HTML，如果页面布局发生变化，前端工程师对静态页面进行修改，然后再交给后端工程师，由后端工程师再将该页面改为 JSP 页面。
> 
> 由于上述的问题等，JSP 已逐渐退出历史舞台，以后开发更多的是使用 HTML + Ajax 来替代。有了 Ajax 这个技术后，前端工程师负责前端页面开发，而后端工程师只负责前端代码开发。技术的发展：
> 
> ![6c3ca5111cf34e49b7dfd1961704ebd9.png][]
> 
> 1. 第一阶段：使用 \`servlet\` 即实现逻辑代码编写，也对页面进行拼接。这种模式我们之前也接触过
> 
> 2. 第二阶段：随着技术的发展，出现了 \`JSP\` ，人们发现 \`JSP\` 使用起来比 \`Servlet\` 方便很多，但是还是要在 \`JSP\` 中嵌套 \`Java\` 代码，也不利于后期的维护
> 
> 3. 第三阶段：使用 \`Servlet\` 进行逻辑代码开发，而使用 \`JSP\` 进行数据展示
> 
> ![ba0025525ccc4c929107b6f46297d320.png][]
> 
> 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\` 页面。
> 
>     @WebServlet("/demo1")
>       public class ServletDemo1 extends HttpServlet {
>           @Override
>           protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
>               //1. 准备数据
>               List<Brand> brands = new ArrayList<Brand>();
>               brands.add(new Brand(1,"三只松鼠","三只松鼠",100,"三只松鼠，好吃不上火",1));
>               brands.add(new Brand(2,"优衣库","优衣库",200,"优衣库，服适人生",0));
>               brands.add(new Brand(3,"小米","小米科技有限公司",1000,"为发烧而生",1));
>       
>               //2. 存储到request域中
>               request.setAttribute("brands",brands);
>       
>               //3. 转发到 el-demo.jsp
>               request.getRequestDispatcher("/el-demo.jsp").forward(request,response);
>           }
>       
>           @Override
>           protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
>               this.doGet(request, response);
>           }
>       }
> 
> 注意：此处需要用转发，因为转发才可以使用 request 对象作为域对象进行数据共享
> 
> ▷ 在 \`el-demo.jsp\` 中通过 EL表达式 获取数据
> 
>     <%@ page contentType="text/html;charset=UTF-8" language="java" %>
>       <html>
>       <head>
>           <title>Title</title>
>       </head>
>       <body>
>           ${brands}
>       </body>
>       </html>
> 
> ▷ 在浏览器的地址栏输入 \`http://localhost:8080/jsp-demo/demo1\` ，页面效果如下： ![d85e992b77aa48b09eff4ef7391c8f41.png][]
> 
> ### 2、域对象 ###
> 
> JavaWeb中有四大域对象，分别是：
> 
>  *  page：当前页面有效
>  *  request：当前请求有效
>  *  session：当前会话有效
>  *  application：当前应用有效
> 
> el 表达式获取数据，会依次从这4个域中寻找，直到找到为止。而这四个域对象的作用范围如下图所示
> 
> ![ffd6d673f5224aa0acb7ea8293dd9714.png][]
> 
> 例如： $\{brands\}，el 表达式获取数据，会先从page域对象中获取数据，如果没有再到 requet 域对象中获取数据，如果再没有再到 session 域对象中获取，如果还没有才会到 application 中获取数据。
> 
> ### 3、JSTL标签 ###
> 
> **▶ 概述**
> 
> JSP标准标签库(Jsp Standarded Tag Library) ，使用标签取代JSP页面上的Java代码。如下代码就是JSTL标签
> 
>     <c:if test="${flag == 1}">
>         男
>     </c:if>
>     <c:if test="${flag == 2}">
>         女
>     </c:if>
> 
> JSTL 提供了很多标签，如下图：
> 
> ![ddeca54f1e08434fbe67e90ee4202dd1.png][]
> 
> **▶ 使用步骤**
> 
> 1、导入坐标
> 
>     <dependency>
>           <groupId>jstl</groupId>
>           <artifactId>jstl</artifactId>
>           <version>1.2</version>
>       </dependency>
>       <dependency>
>           <groupId>taglibs</groupId>
>           <artifactId>standard</artifactId>
>           <version>1.1.2</version>
>       </dependency>
> 
> 2、在JSP页面上引入JSTL标签库
> 
>     <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
> 
> 3、使用标签  
> 
> 
> **▶ if 标签**
> 
> \`<c:if>\`：相当于 if 判断
> 
> 属性：test，用于定义条件表达式
> 
>     <c:if test="${flag == 1}">
>         男
>     </c:if>
>     <c:if test="${flag == 2}">
>         女
>     </c:if>
> 
> **▶ forEach 标签**
> 
> \`<c:forEach>\`：相当于 for 循环。java中有增强for循环和普通for循环，JSTL 中的 \`<c:forEach>\` 也有两种用法
> 
>  **▷ 第一种**
> 
> 类似于 Java 中的增强for循环。涉及到的 \`<c:forEach>\` 中的属性如下：
> 
>  *  items：被遍历的容器
>  *  var：遍历产生的临时变量
>  *  varStatus：遍历状态对象
> 
> 如下代码，是从域对象中获取名为 brands 数据，该数据是一个集合；遍历遍历，并给该集合中的每一个元素起名为 \`brand\`，是 Brand对象。在循环里面使用 EL表达式获取每一个Brand对象的属性值：
> 
>     <c:forEach items="${brands}" var="brand">
>         <tr align="center">
>             <td>${brand.id}</td>
>             <td>${brand.brandName}</td>
>             <td>${brand.companyName}</td>
>             <td>${brand.description}</td>
>         </tr>
>     </c:forEach>
> 
>  **▷ 第二种**
> 
> 类似于 Java 中的普通for循环。涉及到的 \`<c:forEach>\` 中的属性如下：
> 
>  *  begin：开始数
>  *  end：结束数
>  *  step：步长
> 
> 实例代码：从0循环到10，变量名是 \`i\` ，每次自增1
> 
>     <c:forEach begin="0" end="10" step="1" var="i">
>         ${i}
>     </c:forEach>

## 三、MVC模式及三层架构 ##

> ### 1、MVC 模式 ###
> 
> MVC 是一种分层开发的模式，其中：
> 
>  *  M：Model，业务模型，处理业务
>  *  V：View，视图，界面展示
>  *  C：Controller，控制器，处理请求，调用模型和视图
> 
> ![f0ec8d8119db4361870d298b16b29ebf.png][]
> 
> 控制器（serlvlet）用来接收浏览器发送过来的请求，控制器调用模型（JavaBean）来获取数据，比如从数据库查询数据；控制器获取到数据后再交由视图（JSP）进行数据展示。
> 
> MVC 的好处：
> 
>  *  职责单一，互不影响。每个角色做它自己的事，各司其职。
>  *  有利于分工协作。
>  *  有利于组件重用
> 
> ### 2、三层架构 ###
> 
> 三层架构是将我们的项目分成了三个层面，分别是 \`表现层\`、\`业务逻辑层\`、\`数据访问层\`。
> 
> ![1ea9e73e620f4bafaf6dd553670b3b58.png][]
> 
>  *  数据访问层：对数据库的CRUD基本操作
>  *  业务逻辑层：对业务逻辑进行封装，组合数据访问层层中基本功能，形成复杂的业务逻辑功能。例如 \`注册业务功能\` ，我们会先调用 \`数据访问层\` 的 \`selectByName()\` 方法判断该用户名是否存在，如果不存在再调用 \`数据访问层\` 的 \`insert()\` 方法进行数据的添加操作
>  *  表现层：接收请求，封装数据，调用业务逻辑层，响应数据
> 
> 而整个流程是，浏览器发送请求，表现层的Servlet接收请求并调用业务逻辑层的方法进行业务逻辑处理，而业务逻辑层方法调用数据访问层方法进行数据的操作，依次返回到serlvet，然后servlet将数据交由 JSP 进行展示。
> 
> 三层架构的每一层都有特有的包名称：
> 
>  *  表现层： \`com.itheima.controller\` 或者 \`com.itheima.web\`
>  *  业务逻辑层：\`com.itheima.service\`
>  *  数据访问层：\`com.itheima.dao\` 或者 \`com.itheima.mapper\`
> 
> ![ff4614d9d9cd42a799431fe06ab4504c.png][]
> 
> **▶ MVC 和 三层架构**
> 
> 两者的区别和联系：
> 
> ![df9bc761280242f6a75fa5238de21121.png][]
> 
> 如上图上半部分是 MVC 模式，上图下半部分是三层架构。 \`MVC 模式\` 中的 C（控制器）和 V（视图）就是 \`三层架构\` 中的表现层，而 \`MVC 模式\` 中的 M（模型）就是 \`三层架构\` 中的 业务逻辑层 和 数据访问层。可以将 \`MVC 模式\` 理解成是一个大的概念，而 \`三层架构\` 是对 \`MVC 模式\` 实现架构的思想。 那么我们以后按照要求将不同层的代码写在不同的包下，每一层里功能职责做到单一，将来如果将表现层的技术换掉，而业务逻辑层和数据访问层的代码不需要发生变化。

[916f808739a24b74bffc7b1037da2a24.png]: https://img-blog.csdnimg.cn/916f808739a24b74bffc7b1037da2a24.png
[30d4f6ca9c5b4c639ad32c2d12b05e6e.png]: https://img-blog.csdnimg.cn/30d4f6ca9c5b4c639ad32c2d12b05e6e.png
[b7e2fdf4a7ae43008a0726d87116309b.png]: https://img-blog.csdnimg.cn/b7e2fdf4a7ae43008a0726d87116309b.png
[fcaa7324618f4438a57cd7dab6fb6b80.png]: https://img-blog.csdnimg.cn/fcaa7324618f4438a57cd7dab6fb6b80.png
[6368c3a5caf84d988d2cac7ce1a72d9b.png]: https://img-blog.csdnimg.cn/6368c3a5caf84d988d2cac7ce1a72d9b.png
[025995b11cc94ddf8470480fc6103b42.png]: https://img-blog.csdnimg.cn/025995b11cc94ddf8470480fc6103b42.png
[95766040e9634b4cbe53c440fed387be.png]: https://img-blog.csdnimg.cn/95766040e9634b4cbe53c440fed387be.png
[1509448404a24f769751d1869ed879f7.png]: https://img-blog.csdnimg.cn/1509448404a24f769751d1869ed879f7.png
[e36beb501b244d5ba9c04fc547c07033.png]: https://img-blog.csdnimg.cn/e36beb501b244d5ba9c04fc547c07033.png
[61c18109550e434d80792bfddd9bff45.png]: https://img-blog.csdnimg.cn/61c18109550e434d80792bfddd9bff45.png
[1300be4bbbe449bf9a86eee8241410ef.png]: https://img-blog.csdnimg.cn/1300be4bbbe449bf9a86eee8241410ef.png
[28d408eb190c4594951417cf98329e94.png]: https://img-blog.csdnimg.cn/28d408eb190c4594951417cf98329e94.png
[18627b1e20d141fd820c1fc9c89bc77b.png]: https://img-blog.csdnimg.cn/18627b1e20d141fd820c1fc9c89bc77b.png
[6d17dd6934b54cf284594f54fc9c2536.png]: https://img-blog.csdnimg.cn/6d17dd6934b54cf284594f54fc9c2536.png
[6c3ca5111cf34e49b7dfd1961704ebd9.png]: https://img-blog.csdnimg.cn/6c3ca5111cf34e49b7dfd1961704ebd9.png
[ba0025525ccc4c929107b6f46297d320.png]: https://img-blog.csdnimg.cn/ba0025525ccc4c929107b6f46297d320.png
[d85e992b77aa48b09eff4ef7391c8f41.png]: https://img-blog.csdnimg.cn/d85e992b77aa48b09eff4ef7391c8f41.png
[ffd6d673f5224aa0acb7ea8293dd9714.png]: https://img-blog.csdnimg.cn/ffd6d673f5224aa0acb7ea8293dd9714.png
[ddeca54f1e08434fbe67e90ee4202dd1.png]: https://img-blog.csdnimg.cn/ddeca54f1e08434fbe67e90ee4202dd1.png
[f0ec8d8119db4361870d298b16b29ebf.png]: https://img-blog.csdnimg.cn/f0ec8d8119db4361870d298b16b29ebf.png
[1ea9e73e620f4bafaf6dd553670b3b58.png]: https://img-blog.csdnimg.cn/1ea9e73e620f4bafaf6dd553670b3b58.png
[ff4614d9d9cd42a799431fe06ab4504c.png]: https://img-blog.csdnimg.cn/ff4614d9d9cd42a799431fe06ab4504c.png
[df9bc761280242f6a75fa5238de21121.png]: https://img-blog.csdnimg.cn/df9bc761280242f6a75fa5238de21121.png