JSP速通

已于 2022-09-27 17:45:27 修改
阅读量2.4k 收藏 16
点赞数 4
分类专栏： 后端开发 # Java 文章标签： java JSP EL JSTL
于 2022-09-27 11:40:37 首次发布
该文章版权属于知识汲取者，未经允许请勿转载
本文链接：https://blog.csdn.net/qq_66345100/article/details/127068581
版权

文章目录

JSP速通

文章导入

  • JSP现在是不是已经被淘汰了？我们还有必要学习吗？

    JSP现在算是已经被淘汰了，但我们还是有必要学习。

    JSP算是一门老技术了，如今很多企业都极少用它了，可能在一些国企中还能见到吧🌝，那么我们还有必要学习JSP吗？我的答案是肯定的，一是，毕竟以前JSP很火，很多企业都用了JSP，这就导致企业可能还有遗留或者还在使用JSP，我们懂JSP能够进一步提高竞争力；其次，学习旧技术不一定是为了去使用它，我们在学习过程中，能偶丰富我们的眼界，提高我们的学习能力，了解新技术相对旧技术有哪些改进、哪些相同点、不同点，从而更有利于我们对新技术的掌握和理解。

  • 是什么导致JSP的没落？

    主要原因还得是前后端分离，其次就是主流的spring框架不支持JSP。

    在Web2.0时代，当时都是前后端一体化，一个程序员既要干后端又要干前端（简称全干工程师😆），而JSP能够将Java代码和HTML代码混着写，非常符合当时的趋势，所以就大火。然而现在，随着技术的发展、时代的进步，很多互联网公司都为追求高效率，开始盛行前后端分离，所以说前后端分离是JSP。

    前后端分离主要有以下几个好处：

    • 提高工作效率。前端和后端的逻辑思维、需求都有很大区别，专门的人干专门的事
    • 减小服务器的压力。很多请求处理都交给了前端来做
    • 降低维护成本。对前端代码和后端代码进行了解耦，调试前端代码无需后端人员的参与
    • 提升用户体验。实现页面的按需加载，无需一开始加载首页便加载网站的所有的资源，服务器也不再需要解析前端页面，在页面交互及用户体验上有所提升

  • 谁取代了JSP？

    JSP的大部分功能都被thymeleaf 取代了。

    JSP存在的意义就是解决网页能动态获取来自服务器的响应数据，而thymeleaf也能。同时在当今Java界叱咤风云的Springboot框架统治下，对于JSP更加更加学上加霜，首先Springboot不支持JSP，它很好地继承了thymeleaf模板引擎，让thymeleaf在使用了Springboot的Web项目下显得更加如鱼得水，其次就是Sun公司（已被Oracle公司收购）停止了对JSP的更新，连亲爹都放弃它了🤣。

总的来说JSP的没落是技术的更新换代，是行业趋势所致，是时代的更迭。

1、JSP概述

  • 什么是JSP？

      JSP是一种动态网页技术，能够将Java代码和特定变动内容嵌入到静态的页面中，实现以静态页面为模板，动态生成其中的部分内容。JSP主要作用是为了简化Servlet的工作而出现的替代品，，本质仍然是Servlet！因为Servlet输出HTML非常繁琐，JSP就是替代Servlet输出HTML的。

      JSP（JavaServer Pages）是由Sun Microsystems公司主导创建的一种动态网页技术标准。JSP部署于网络服务器上，可以响应客户端发送的请求，并根据请求内容动态地生成HTML、XML或其他格式文档的Web网页，然后返回给请求者。JSP技术以Java语言作为脚本语言，为用户的HTTP请求提供服务，并能与服务器上的其它Java程序共同处理复杂的业务需求。

  • JSP的组成：静态标签 + JSP脚本 + 动态标签

    • 静态标签主要是html标签

    • JSP脚本主要是Java代码

    • 动态标签主要是JSTL标签

  • JSP的优缺点：

    • 优点：
      • 跨平台。由于JSP是基于Java的，所以它们也有Java语言的最大优点——平台无关性，“一次编写，随处运行“
      • 动态交互。实现静态HTML页面中数据的动态变化
      • 生态较好。有很多优秀且免费的JSP开发工具可供使用
      • 简化Servlet的开发。将原本Servlet客户端程序输出HTML内容的工作给包揽了，简化了Servlet的开发
    • 缺点：
      • 占用内存。JSP会自动生成.java和.class文件占用磁盘大量内存
      • 增加项目的复杂性。前端后端混合在一起，书写麻烦、代码阅读性不高、维护难度大。同时需要依赖于各种环境，比如：JSP容器(Tomcat)、JRE、Servlet相关jar包……搭建环境要费时间且不易
      • 开发效率低。前后端未分离，分工不明确，开发效率较低
      • 增大后端服务器压力。后端服务器既要处理前端数据，又要处理后端数据
      • 调试困难。 首先被转换为.java文件(Servlet)，然后将.java文件编译为.class文件. 这样,出错信息实际上指向的是转换后的那个.java文件(Servlet)，而不是JSP本身(调试有难度)

看着这一堆缺点，也难怪JSP会被淘汰😆，但不可否认它以前也是一代霸王

2、JSP初体验
创建JSP文件
编写JSP代码
部署项目
测试
导入项目依赖

  • Step1：导入项目依赖

    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">
    <!--===============项目信息===================-->
    <!--Maven版本信息-->
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.hhxy</groupId>
    <artifactId>day9_jsp</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--项目打包方式-->
    <packaging>war</packaging>
    <!--项目所依赖的JDK版本-->
    <properties>
        <maven.compiler.source>16</maven.compiler.source>
        <maven.compiler.target>16</maven.compiler.target>
    </properties>
    <!--=============================================-->

    <!--===============导入项目依赖==================-->
    <!--导入Servlet依赖-->
    <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!--导入JSP依赖-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
            <!--排除Tomcat中原有的JSPjar包-->
            <scope>provided</scope>
        </dependency>

    </dependencies>

    <!--导入项目所依赖的插件-->
    <build>
        <plugins>
            <!--导入Tomcat7-maven插件-->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>8080</port><!--设置端口号-->
                    <!--                    <path>/</path>设置虚拟目录-->
                </configuration>
            </plugin>
        </plugins>
    </build>
    <!--============================================-->
</project>

  • Step2：创建JSP文件

    image-20220807102202295

  • Step3：编写JSP代码

    hello.jsp：

    <%--
  Created by IntelliJ IDEA.
  User: ghp
  Date: 2022/1/7
  Time: 10:22
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>JSP初体验</title>
</head>
<body>
    <%--这是html代码--%>
    <h1>Hello,JSP!</h1>
    <%
        /*这是Java代码*/
        System.out.println("这是我的第一个JSP程序");
    %>
</body>
</html>

  • Step4：启动Tomcat，同时将JSP项目部署到Tomcat上

    备注：所需插件：Tomcat7+MavenHelper

    image-20220807103047038

  • Step5：测试

    image-20220807103219858

3、JSP运行原理

image-20220807175631474

备注：

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

可以在E:\项目\Project_JavaWeb\day9_jsp\target\tomcat\work\Tomcat\localhost\day9_jsp\org\apache\jsp目录下看到转换后的 servlet：

image-20220807175902763

可以通过查看hello_jsp.java，发现它是继承HttpJspBase类的：

image-20220807181010545

而后我们可以去查看Tomcat的源码，发现HttpJspBase类是继承HttpServlet类的，这也充分说明了JSP本质就是一个Servlet，在tomcat源码\apache-tomcat-8.5.68-src\java\org\apache\jasper\runtime\HtpJspBase.java中查看（Tomcat源码可以去官网下载）

image-20220807180716546

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

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

image-20210818114008998

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

4、JSP脚本

JSP脚本也叫Java脚本，其实就是Java代码片段，指用<%%>括起来的JSP页面中的Java脚本；所有能在java程序中执行的代码，都可以通过jsp脚本执行。

JSP脚本分为三种：<%...%>、<%=…%>、<%!...%>

  • <%...%>：编写Java语句。内容会直接放到_jspService()方法之中
  • <%=…%>：编写Java表达式。内容会放到out.print()中，作为out.print()的参数，然后会直接输出到页面上
  • <%!…%>：编写Java定义类成员。内容会放到_jspService()方法之外，被类直接包含

示例：

hello.jsp：

<%--
  Created by IntelliJ IDEA.
  User: ghp
  Date: 2022/8/7
  Time: 10:22
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>JSP初体验</title>
</head>
<body>
    <%--这是html代码--%>
    <h1>Hello,JSP!</h1>
    <%
        /*这是Java代码*/
        System.out.println("这是我的第一个JSP程序");
        int i=1;
    %>
    <%=i%>
<%!
    void show(){}
    String name = "zhangsan";
%>
</body>
</html>

测试结果和执行流程：

image-20220807192125715

备注：html标签中的内容和<%=>一样，也是需要加载到Tomcat中，然后通过_jspService成员方法中的out.print()方法直接输出到网页上，加载后，也可以再hello_jsp.java中查看：

image-20220807193405062

5、EL表达式

EL（Expression Language ）表达式语言，用于简化 JSP 页面内的 Java 代码，主要功能用于从域对象中获取数据。它的灵感来自XPath表达式语言。主要作用就是简化<%=expression%>代码

详细学习：JSP表达式语言|菜鸟教程

后面再详细学习吧，先了解一下，掌握EL表达式的常用方式

5.1 基本语法

语法：

${expression};//获取域对象expression中的数据
相当于替换了原来JSP中的：<%=expression%>

eg：

	  <%
        Person pperson = new Person();
        person.setName("zhangsan");
        person.setPhones(new String[]{"123","456","789"});//给Person对象中的数组进行赋值
        //设置List集合
        List<String> cities = new ArrayList<String>();
        cities.add("北京");
        cities.add("上海");
        cities.add("深圳");
        person.setCities(cities);
		//设置map集合
		Map<String,Object> map = new HashMap<>();
        map.put("key1","value1");
        map.put("key2","value2");
        map.put("key3","value3");
        person.setMap(map);
		pageContext.setAttribute("p", person);//将Person对象传递进Page域对象中
		%>
<%--EL表达式中对象名.属性名不找属性的值，而是找名字对应的getXxx方法，没有此方法会报错--%>
    输出Person对象的值：${p}   <%--需要重写p对象的toString方法，不然输出的是对象的 全类名+@哈希码--%>
    输出Person的name属性：${p.name} <%--p对象中即使没有name属性也不会报错，但是必须有getName的方法，否则会报错--%>
    输出Person的arr数组地址值：${p.phones} 
    输出Person的arr数组属性值：${p.phones[2]} 
    输出Person的list集合中的元素值：${p.cities} 
    输出Person的List集合中个别元素值：${p.cities[2]} 
    输出Person的Map集合: ${p.map} 
    输出Person的Map集合中某个key的值: ${p.map.key1}

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

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

image-20220807204516545

EL表达式会从这些域对象中依次由内到外进行查找，直到找到为止

5.2 示例

一般EL表达式需要和JSTL标签结合使用

image-20220807210211965

Servlet：

package com.hhxy.jsp;

import com.hhxy.pojo.Brand;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@WebServlet("/JspDemo1")
public class JspDemo1 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("doPost方法别调用了");
        this.doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("doGet方法被调用了");
        //1. 准备数据
        List<Brand> brands = new ArrayList<>();
        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("lists",brands);

        //3. 请求转发到JSP中
        request.getRequestDispatcher("/brand.jsp").forward(request,response);
    }
}

JSP：

  • 使用EL表达式：
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page import="com.hhxy.pojo.Brand" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<input type="button" value="新增"><br>
<hr>
<table border="1" cellspacing="0" width="800">
    <tr>
        <th>序号</th>
        <th>品牌名称</th>
        <th>企业名称</th>
        <th>排序</th>
        <th>品牌介绍</th>
        <th>状态</th>
        <th>操作</th>
    </tr>
    <%--========================核心代码============================--%>
    <c:forEach items="${lists}" var="brand">
        <%--El表达式中对象的遍历需要搭配JSTL标签使用--%>
        <tr align="center">
            <td>${brand.id}</td>
            <td>${brand.brandName}</td>
            <td>${brand.companyName}</td>
            <td>${brand.ordered}</td>
            <td>${brand.description}</td>
            <td>${brand.status == 1 ? "启用":"禁用"}</td>
            <td><a href="#">修改</a> <a href="#">删除</a></td>
        </tr>
    </c:forEach>
<%--
   使用不同for循环的方式进行遍历
    <c:forEach begin="0" end="${lists.size()-1}" step="1" var="i">
        <tr align="center">
            <td>${lists[i].id}</td>
            <td>${lists[i].brandName}</td>
            <td>${lists[i].companyName}</td>
            <td>${lists[i].ordered}</td>
            <td>${lists[i].description}</td>
            <td>${lists[i].status == 1 ? "启用":"禁用"}</td>
            <td><a href="#">修改</a> <a href="#">删除</a></td>
        </tr>
    </c:forEach>
--%>
    <%--==========================================================--%>
</table>
</body>
</html>
  • 不使用EL表示式：
<%@ page import="com.hhxy.pojo.Brand" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<input type="button" value="新增"><br>
<hr>
<table border="1" cellspacing="0" width="800">
    <tr>
        <th>序号</th>
        <th>品牌名称</th>
        <th>企业名称</th>
        <th>排序</th>
        <th>品牌介绍</th>
        <th>状态</th>
        <th>操作</th>
    </tr>
    <%--========================核心代码============================--%>
    <%
        List<Brand> lists = (List<Brand>) request.getAttribute("lists");
        for (int i = 0; i < lists.size(); i++) {
            Brand brand = lists.get(i);
    %>
    
    <tr align="center">
        <td><%=brand.getId()%></td>
        <td><%=brand.getBrandName()%></td>
        <td><%=brand.getCompanyName()%></td>
        <td><%=brand.getOrdered()%></td>
        <td><%=brand.getDescription()%></td>
        <td><%=brand.getStatus() == 1 ? "启用":"禁用"%></td>
        <td><a href="#">修改</a> <a href="#">删除</a></td>
    </tr>
    
    <%
        }
    %>
    <%--=========================================================--%>
</table>
</body>
</html>

直接运行Servlet，效果是一样的

image-20220808094406481

推荐阅读：

EL表达式

6、JSTL标签

JSTL（Java server pages standarded tag library，即JSP标准标签库）是由JCP（Java community Proces）所制定的标准规范，它主要提供给Java Web开发人员一个标准通用的标签库，并由Apache的Jakarta小组来维护。开发人员可以利用这些标签取代JSP页面上的Java代码，从而提高程序的可读性，降低程序的维护难度。

image-20220807215957243

6.1 JSTL所需环境

JSTL所需依赖：

<?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">
    <!--===============项目信息===================-->
    <!--Maven版本信息-->
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.hhxy</groupId>
    <artifactId>day9_jsp</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--项目打包方式-->
    <packaging>war</packaging>
    <!--项目所依赖的JDK版本-->
    <properties>
        <maven.compiler.source>16</maven.compiler.source>
        <maven.compiler.target>16</maven.compiler.target>
    </properties>
    <!--=============================================-->

    <!--===============导入项目依赖==================-->
    <!--导入Servlet依赖-->
    <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!--导入JSP依赖-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
            <!--排除Tomcat中原有的JSPjar包-->
            <scope>provided</scope>
        </dependency>
        <!--导入JSTL依赖-->
        <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>
    </dependencies>
    
    <!--导入项目所依赖的插件-->
    <build>
        <plugins>
            <!--导入Tomcat7-maven插件-->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>8080</port><!--设置端口号-->
                    <!--                    <path>/</path>设置虚拟目录-->
                </configuration>
            </plugin>
        </plugins>
    </build>
    <!--============================================-->
</project>

在JSP页面中引入JSTL标签库：

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

6.2 JSTL常见标签

  • <c:if test=""></c:if>：和Java中的if条件判断是一样的，test属性中放判断表达式
  • <c:forEach items="" var="" varStatus="i"></c:forEach>：作用等价于Java中的foreach语句
    • items：表示遍历的容器（可以是数组也可以是集合）
    • var：表示每一次产生的临时对象或者值
    • varStatus：该属性中的i表示第几次遍历，从0开始
  • <c:forEach begin="" end="" step="1" var="i"></c:forEach>：作用等价于Java中的普通for循环
    • begin：起始条件
    • end：终止条件
    • step：表示遍历的步长，1表示一个一个遍历，类似于for循环中的i++，2表示隔一个遍历一个，类似于for循环中的 i+=2
    • var：该属性中的i表示第几次遍历，从0开始

相关示例代码请参看前面

心有所感：

看到这些标签让我想起了MyBatis的动态SQL😃熟悉的配方，知识真的是越学越有趣，越学越容易触类旁通，然而当懂的多了的时候，反而感觉有点迷茫了，可能这是在逐渐了解知识的海洋的深而远所产生恐惧感吧(●’◡’●)

学习的路途中要时常回顾，时常总结……

要学的东西真™多啊┭┮﹏┭┮

参考文章：

知识汲取者
关注
  • 4
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
专栏目录
2020还有必要学JSP吗？
诗与远方的博客
11-26 8711
前言 2020年了，还需要学JSP吗？我相信现在还是在大学的同学肯定会有这个疑问。 其实我在18年的时候已经见过类似的问题了「JSP还应该学习吗」。我在18年发了几篇JSP的文章，已经有不少的开发者评论『这不是上个世纪的东西了吗』『梦回几年前』『这么老的的东西，怎么还有人学』 现在问题来了，JSP放在2020年，是真的老了吗？对，是真的老了 现在问题又来了，为什么在几年前已经被定义『老』的技术，到2020年了还是有热度，每年还是有人在问：『还需要学习JSP吗』。我认为理由也很简单：JSP在之前用的是真的
jsp后台管理
12-17
实现增删改查，数据库的链接。
都2024现在还有人用jsp吗
最新发布
yncjxnc的博客
04-17 157
大公司用前后分享当然很好，不过现在大环境下，很多公司都是在节约成本，一台服务器搞微服务，前后分离就有点搞笑了，关键是应用一天也就那么几个人在访问，所以做为一名老程序员，我一直都是反对微服务，前后分离(大公司、大项目另讲)
jsp 知乎_jsp还有学的必要吗?
weixin_39870199的博客
12-19 185
首先看看JSP的优缺点优点:vs. Active Server Pages (ASP) - 因为JSP使用JAVA编写，最终会被Tomcat(Jetty)等容器转化为Servlet，由于JAVA的跨平台型，JSP可以被运行在几乎所有操作系统上，但是ASP只能运行在微软自家的平台vs. Pure(纯) Servlets相比 - 更加便捷，在Servlets中你需要拼凑HTML代码，极不方便，开发效率...
2024还有必要学JSP吗？，java面试问项目中遇到的问题
2401_84002630的博客
04-02 792
JSP全名为Java Server Pages，java服务器页面。JSP是一种基于文本的程序，其特点就是HTML和Java代码共同存在！JSP是为了简化Servlet的工作出现的替代品，Servlet输出HTML非常困难，JSP就是替代Servlet输出HTML的。Tomcat访问任何的资源都是在访问Servlet！，当然了，JSP也不例外！JSP本身就是一种Servlet。为什么我说JSP本身就是一种Servlet呢？
什么是jsp，它有什么用+jsp的本质是什么
你好牛蛙！
11-30 1万+
jsp的全称是：java servlet pages，java的服务器页面 主要作用：替代servlet程序回传html页面的数据，因为servlet程序回传html页面数据是一件非常繁琐的事情，开发成本和维护成本都极高 如下： 这是servlet回传html页面的方法，超级麻烦 虽然也能打印成功 我们来尝试用jsp回传html页面来试试 我们先来创建一个jsp文件 如图，在web下面我们可以创建一个jsp文件 jsp文件，如下和servlet打印出来的html页面一样，但是这个方便简洁了很多
关于JSP是否被逐渐淘汰
JBIB ENGINE
12-03 1194
本人将近二十年javaweb项目经验来看，一会流行ssh，一会ssm，一会springmvc，springboot，一直在更新换代，其实这些玩意核心都是servlet，这些个框架只是拐弯抹角定义一些规则，为开发者提供某些便利而已，最终运行的还是servlet，这些框架大都依赖xml配置，当一个项目过大时，xml文件就变得臃肿不堪，启动一下web服务都得半天，万一有点啥错误，直接gg，头疼要命，最头疼的是这些框架一旦过时，其规则慢慢被人淡忘，你再维护这些框架项目时，那就有好戏看了。
JSP是否被逐渐淘汰了
weixin_35755640的博客
02-09 1635
JSP (JavaServer Pages) 是一种用于创建动态 Web 页面的技术，它使用 Java 代码来生成 HTML 内容。JSP 在最初出现时非常流行，但随着 Web 开发技术的不断演进，它已经逐渐被其他技术所取代。例如，JavaScript 和 AJAX 技术使得前端开发变得越来越流行，而 Java 在后端开发中的地位也逐渐被其他语言所取代，例如 Python 和 Go。 尽管如此，J...
jsp入门教程
09-20
亲爱的朋友，你们好吗？如果你想用 jsp 做网站， 小程序，或者其他什么东西，那么你算是找对地方了。我们这份教程正好是介绍这些的。
jsp实用教程上机实验
05-21
jsp实用教程第四版,(耿祥义)上机实验课后代码
ueditor jsp版
04-12
ueditor1.4的jsp版本，官方原版，鉴于官网总是崩，有的同学下载不到，再次提供一下
jsp网上书店
09-29
jsp动态网站学习 书籍大类小类双下拉框动态获取数据库后台数据， 书籍列表的基本展示， 书籍详情。 折扣、公告等的动态数据获取。 页面整体算是小清新了 效果查看地址：...
JavaWeb项目为什么我们要放弃jsp？为什么要前后端解耦？为什么要前后端分离？2.0版，为分布式架构打基础。
热门推荐
欢迎！欢迎来到17号城市！
03-23 6万+
前言 前后端分离已成为互联网项目开发的业界标准使用方式，通过nginx+tomcat的方式（也可以中间加一个nodejs）有效的进行解耦， 并且前后端分离会为以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务（多种客户端，例如：浏览器，车载终端，安卓，IOS等等）打下坚实的基础。 这个步骤是系统架构从猿进化成人的必经之路。 核心思想是前端html页面通过ajax调用后端...
大公司为什么还在采用过时的技术！
技术人生
08-16 3859
大公司为什么还在采用过时的技术！ 本文出自一朋友给我的提问，于是博主呕心沥血给他花式洗脑了几个小时。忽然发现，应该还有许多朋友有同样的疑问。所以整理成文。 作者：孤独烟来源：Java后端技术|2018-08-16 15:30   背景 本文出自一朋友给我的提问，于是博主呕心沥血给他花式洗脑了几个小时。忽然发现，应该还有许多朋友有同样的疑问。所以整理成文。 许多刚毕业的程序员朋友...
为什么要放弃 JSP ？
公众号：Java后端
07-19 1085
作者 |水车链接 |www.cnblogs.com/xuange306前言以前的项目大多数都是Java程序猿又当爹又当妈，既搞前，又搞后端。随着时代的发展，渐渐的许多...
jsp技术过时了吗？
weixin_46048519的博客
04-04 5040
jsp技术 JSP（全称JavaServerPages）是由SunMicrosystems公司主导创立的一种动态网页技能标准。JSP布置于网络服务器上，能够呼应客户端发送的请求，并依据请求内容动态地生成HTML、XML或其他格式文档的Web网页，然后返回给请求者。JSP技能以Java语言作为脚本语言，为用户的HTTP请求提供服务，并能与服务器上的其它Java程序一起处理复杂的业务需求。 JSP将Java代码和特定变化内容嵌入到静态的页面中，实现以静态页面为模板，动态生成其间的部分内容。JSP引入了被称为“J
JSP为什么不行了？为什么大家都不愿意用了？
xmt1139057136的专栏
01-28 1976
前言以前的项目大多数都是Java程序猿又当爹又当妈，既搞前，又搞后端。随着时代的发展，渐渐的许多大中小公司开始把前后端的界限分的越来越明确，前端工程师只负责前端的事情，后端工程师只管后端...
都说了多少遍，不要再学 JSP 了！
好好学java
07-03 538
点击上方好好学java，选择星标公众号重磅资讯、干货，第一时间送达 今日推荐：在滴滴和头条干了 2 年后端开发，太真实…个人原创100W+访问量博客：点击前往，查看更多 陈龙|h...
jsp
05-31
JSP（Java Server Pages）是一种基于Java技术的动态网页开发技术，它类似于ASP和PHP，可以通过嵌入Java代码在HTML页面中实现动态内容的生成。JSP技术主要用于Web应用程序的开发，可以方便地与Java Servlets一起使用来生成动态Web页面。 JSP页面的开发过程与HTML页面的开发类似，但是在JSP页面中可以嵌入Java代码，例如使用脚本标签<% %>嵌入Java代码块，或使用表达式标签<%= %>输出Java表达式的值。 以下是一个简单的JSP页面示例： ```html <html> <head> <title>Hello JSP</title> </head> <body> <% String name = request.getParameter("name"); %> <h1>Hello <%= name %>!</h1> </body> </html> ``` 在上面的示例中，通过request.getParameter()方法获取HTTP请求中的参数值，然后在页面中输出参数值，实现了动态内容的生成。这个JSP页面可以接受一个名为"name"的HTTP请求参数，并输出"Hello name!"的字符串。例如，当访问"http://localhost:8080/hello.jsp?name=John"时，会输出"Hello John!"的字符串。 除了嵌入Java代码块和表达式外，JSP页面还支持使用指令、动作、EL表达式等方式来实现更复杂的功能，例如定义JSP页面的属性、引入外部资源、控制页面的流程等。JSP技术可以与Java Servlets、JavaBeans等技术组合使用，实现更强大的Web应用程序开发。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

知识汲取者

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值