web开发基础jsp知识大全

最新推荐文章于 2022-11-06 23:32:36 发布
最新推荐文章于 2022-11-06 23:32:36 发布
阅读量458 收藏 1
点赞数
分类专栏： web 前端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaocai9999/article/details/97140970
版权
java 同时被 3 个专栏收录
180 篇文章 1 订阅
订阅专栏
web
59 篇文章 0 订阅
订阅专栏
前端
13 篇文章 0 订阅
订阅专栏

一、JSP基础语法

1、JSP模板元素

JSP页面中的HTML内容称之为JSP模版元素。

JSP模版元素定义了网页的基本骨架，即定义了页面的结构和外观。

2、JSP脚本片段

JSP脚本片断(scriptlet)用于在JSP页面中编写多行Java代码（在<%%>不能定义方法）。语法：<%多行java代码 %>

例如：

<%
    int num = 0;
    num = ++num;
    out.println("num:" + num);
%>

 


image

注意：

1、JSP脚本片断中只能出现java代码，不能出现其它模板元素， JSP引擎在翻译JSP页面中，会将JSP脚本片断中的Java代码将被原封不动地放到Servlet的_jspService方法中。

2、JSP脚本片断中的Java代码必须严格遵循Java语法，例如，每执行语句后面必须用分号（;）结束。

3、在一个JSP页面中可以有多个脚本片断，在两个或多个脚本片断之间可以嵌入文本、HTML标记和其他JSP元素。

4、多个脚本片断中的代码可以相互访问

3、JSP表达式

JSP脚本表达式（expression）用于将程序数据输出到客户端，语法：<%=变量或表达式 %>

例如：

<%="123" %>

 

image

4、JSP声明

JSP页面中编写的所有代码，默认会翻译到servlet的service方法中， 而Jsp声明中的java代码被翻译到_jspService方法的外面。语法：<%！java代码 %>

JSP声明可用于定义JSP页面转换成的Servlet程序的静态代码块、成员变量和方法。

例如：

<%!
static { 
    System.out.println("静态代码块"); 
}

private String name = "Zender";

public void TestFun(){
    System.out.println("成员方法！");
}
%>
<%
    TestFun();
    out.println("name:" + name);
%>

控制台：

image

页面：

image

5、JSP注释

在JSP中，注释有显式注释， 隐式注释，JSP自己的注释：

显式注释直接使用HTML风格的注释：
隐式注释直接使用JAVA的注释：//、/……/
JSP自己的注释<%- - 注释内容- -%>

区别：

HTML的注释在浏览器中查看源文件的时候是可以看得到的，而JAVA注释和JSP注释在浏览器中查看源文件时是看不到注释的内容的。

二、JSP原理

1、Web服务器是如何调用并执行一个jsp页面的？

浏览器向服务器发请求，不管访问的是什么资源，其实都是在访问Servlet，所以当访问一个jsp页面时，其实也是在访问一个Servlet，服务器在执行jsp的时候，首先把jsp翻译成一个Servlet，所以我们访问jsp时，其实不是在访问jsp，而是在访问jsp翻译过后的那个Servlet。

例如下面的代码：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<base href="<%=basePath%>">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <%!
    static { 
        System.out.println("静态代码块"); 
    }

    private String name = "Zender";

    public void TestFun(){
        System.out.println("成员方法！");
    }
    %>
    <%
        TestFun();
        out.println("name:" + name);
    %>
</body>
</html>

当我们通过浏览器访问index.jsp时，服务器首先将index.jsp翻译成一个index_jsp.class，在Tomcat服务器的work\Catalina\localhost\项目名\org\apache\jsp目录下可以看到index_jsp.class的源代码文件index_jsp.java

image

index_jsp.java的代码如下：

package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;

public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent {


    static { 
        System.out.println("静态代码块"); 
    }

    private String name = "Zender";

    public void TestFun(){
        System.out.println("成员方法！");
    }

  private static final javax.servlet.jsp.JspFactory _jspxFactory =
          javax.servlet.jsp.JspFactory.getDefaultFactory();

  private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;

  private volatile javax.el.ExpressionFactory _el_expressionfactory;
  private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;

  public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
    return _jspx_dependants;
  }

  public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
    if (_el_expressionfactory == null) {
      synchronized (this) {
        if (_el_expressionfactory == null) {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
        }
      }
    }
    return _el_expressionfactory;
  }

  public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
    if (_jsp_instancemanager == null) {
      synchronized (this) {
        if (_jsp_instancemanager == null) {
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      }
    }
    return _jsp_instancemanager;
  }

  public void _jspInit() {
  }

  public void _jspDestroy() {
  }

  public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
        throws java.io.IOException, javax.servlet.ServletException {

    final javax.servlet.jsp.PageContext pageContext;
    javax.servlet.http.HttpSession session = null;
    final javax.servlet.ServletContext application;
    final javax.servlet.ServletConfig config;
    javax.servlet.jsp.JspWriter out = null;
    final java.lang.Object page = this;
    javax.servlet.jsp.JspWriter _jspx_out = null;
    javax.servlet.jsp.PageContext _jspx_page_context = null;


    try {
      response.setContentType("text/html; charset=UTF-8");
      pageContext = _jspxFactory.getPageContext(this, request, response,
                null, true, 8192, true);
      _jspx_page_context = pageContext;
      application = pageContext.getServletContext();
      config = pageContext.getServletConfig();
      session = pageContext.getSession();
      out = pageContext.getOut();
      _jspx_out = out;

      out.write("\r\n");
      out.write("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\r\n");
      out.write("<html>\r\n");
      out.write("<head>\r\n");
      out.write("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">\r\n");
      out.write("<title>Insert title here</title>\r\n");
      out.write("</head>\r\n");
      out.write("<body>\r\n");
      out.write("\t");
      out.write('\r');
      out.write('\n');
      out.write('   ');

        TestFun();
        out.println("name:" + name);

      out.write("\r\n");
      out.write("</body>\r\n");
      out.write("</html>");
    } catch (java.lang.Throwable t) {
      if (!(t instanceof javax.servlet.jsp.SkipPageException)){
        out = _jspx_out;
        if (out != null && out.getBufferSize() != 0)
          try {
            if (response.isCommitted()) {
              out.flush();
            } else {
              out.clearBuffer();
            }
          } catch (java.io.IOException e) {}
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
        else throw new ServletException(t);
      }
    } finally {
      _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}

index_jsp这个类是继承org.apache.jasper.runtime.HttpJspBase这个类的，通过查看HttpJspBase源代码，可以知道HttpJspBase类是继承HttpServlet的，所以HttpJspBase类是一个Servlet，而index_jsp又是继承HttpJspBase类的，所以index_jsp类也是一个Servlet，所以当浏览器访问服务器上的index.jsp页面时，其实就是在访问index_jsp这个Servlet，index_jsp这个Servlet使用_jspService这个方法处理请求。

HttpJspBase源码如下：

import java.io.IOException;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.jsp.HttpJspPage;
import javax.servlet.jsp.JspFactory;

import org.apache.jasper.compiler.Localizer;

public abstract class HttpJspBase extends HttpServlet implements HttpJspPage{

    protected HttpJspBase() {
    }

    public final void init(ServletConfig config) 
    throws ServletException 
    {
        super.init(config);
    jspInit();
        _jspInit();
    }

    public String getServletInfo() {
    return Localizer.getMessage("jsp.engine.info");
    }

    public final void destroy() {
    jspDestroy();
    _jspDestroy();
    }

    /**
     * Entry point into service.
     */
    public final void service(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException 
    {
        _jspService(request, response);
    }

    public void jspInit() {
    }

    public void _jspInit() {
    }

    public void jspDestroy() {
    }

    protected void _jspDestroy() {
    }

    public abstract void _jspService(HttpServletRequest request, 
                     HttpServletResponse response) 
    throws ServletException, IOException;
}

2、_jspService方法

问题1：Jsp页面中的html排版标签是如何被发送到客户端的？

浏览器接收到的这些数据，都是在_jspService方法中使用如下的代码输出给浏览器的。

问题2：Jsp页面中的java代码服务器是如何执行的？

在jsp中编写的java代码会被翻译到_jspService方法中去，当执行_jspService方法处理请求时，就会执行在jsp编写的java代码了，所以Jsp页面中的java代码服务器是通过调用_jspService方法处理请求时执行的。

3、jsp在服务器的执行流程

第一次执行：

  1. 客户端通过电脑连接服务器，因为是请求是动态的，所以所有的请求交给WEB容器来处理

  2. 在容器中找到需要执行的*.jsp文件

  3. 之后.jsp`文件通过转换变为`.java文件

  4. .java`文件经过编译后，形成`.class文件

  5. 最终服务器要执行形成的*.class文件

第二次执行：

  1. 因为已经存在了*.class文件，所以不在需要转换和编译的过程

修改后执行：

  1. 源文件已经被修改过了，所以需要重新转换，重新编译。

三、JSP指令

JSP指令（directive）是为JSP引擎而设计的，它们并不直接产生任何可见输出，而只是告诉引擎如何处理JSP页面中的其余部分。

1、Page指令

page指令用于定义JSP页面的各种属性，无论page指令出现在JSP页面中的什么地方，它作用的都是整个JSP页面，为了保持程序的可读性和遵循良好的编程习惯，page指令最好是放在整个JSP页面的起始位置。

page指令的完整语法：

<%@ page 
    [ language="java" ] 
    [ extends="package.class" ] 
    [ import="{package.class | package.*}, ..." ] 
    [ session="true | false" ] 
    [ buffer="none | 8kb | sizekb" ] 
    [ autoFlush="true | false" ] 
    [ isThreadSafe="true | false" ] 
    [ info="text" ] 
    [ errorPage="relative_url" ] 
    [ isErrorPage="true | false" ] 
    [ contentType="mimeType [ ;charset=characterSet ]" | "text/html ; charset=ISO-8859-1" ] 
    [ pageEncoding="characterSet | ISO-8859-1" ] 
    [ isELIgnored="true | false" ] 
%>

import属性

可以在一条page指令的import属性中引入多个类或包，其中的每个包或类之间使用逗号(,)分隔

<%@ page import="java.util.*,java.io.*,java.sql.*"%>

备注：

在Jsp页面中，Jsp引擎会自动导入下面的包

java.lang.*

javax.servlet.*

javax.servlet.jsp.*

javax.servlet.http.*

errorPage属性

使用errorPage属性指明出错后跳转的错误页面，errorPage属性的设置值必须使用相对路径，如果以"/"开头，表示相对于当前Web应用程序的根目录，否则，表示相对于当前页面。

image

比如index.jsp页面有如下的代码：

<%@ page language="java" errorPage="/error.jsp" contentType="text/html; charset=UTF-8"
            pageEncoding="UTF-8"%>
        <%
            String path = request.getContextPath();
            String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
        %>
        <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
        <html>
        <head>
        <base href="<%=basePath%>">
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Insert title here</title>
        </head>
        <body>
            <%
              //错误代码
              int x = 1/0;
            %>
        </body>
        </html>

在index.jsp中，page指令的errorPage属性指明了出错后跳转到"/error.jsp"，error.jsp页面代码如下：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<base href="<%=basePath%>">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>error jsp</title>
</head>
<body>
        <h1>对不起，出错了，请联系网站管理员解决！</h1>
</body>
</html>

运行结果如下：

image

我们也可以在在web.xml中使用标签为整个web应用设置错误处理页面，web.xml的代码下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>JSP</display-name>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  <!-- 404错误的处理页面 -->
  <error-page>
      <error-code>404</error-code>
      <location>/error.jsp</location>
  </error-page>
</web-app>

error.jsp页面代码同上

当访问一个不存在的web资源时，就会跳转到在web.xml中配置的404错误处理页面error.jsp，如下图所示：

image

一个jsp页面是作为系统的错误处理页面，那么建议将page指令的isErrorPage属性(默认为false)设置为"true"来显式声明这个Jsp页面是一个错误处理页面。

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" isErrorPage="true"%>

将error.jsp页面显式声明为错误处理页面后，Jsp引擎在将jsp页面翻译成Servlet的时候，在Servlet的 _jspService方法中会声明一个exception对象，然后将运行jsp出错的异常信息存储到exception对象中，由于Servlet的_jspService方法中声明了exception对象，那么就可以在error.jsp页面中使用exception对象。源码如下：

image

2、include指令

在JSP中对于包含有两种语句形式：

  1. @include指令

    include指令用于引入其它JSP页面，如果使用include指令引入了其它JSP页面，那么JSP引擎将把这两个JSP翻译成一个servlet。所以include指令引入通常也称之为静态引入。

    语法：<%@ include file="relativeURL"%>

    file属性用于指定被引入文件的路径。路径以"/"开头，表示代表当前web应用。

    注意细节：

    1. 被引入的文件必须遵循JSP语法。

    2. 被引入的文件可以使用任意的扩展名，即使其扩展名是html，JSP引擎也会按照处理jsp页面的方式处理它里面的内容，为了见明知意，JSP规范建议使用.jspf（JSP fragments(片段)）作为静态引入文件的扩展名。

    3. 由于使用include指令将会涉及到2个JSP页面，并会把2个JSP翻译成一个servlet，所以这2个JSP页面的指令不能冲突（除了pageEncoding和导包除外）。

  2. 标签

    标签用于把另外一个资源的输出内容插入进当前JSP页面的输出内容之中，这种在JSP页面执行时的引入方式称之为动态引入。

    语法：<jsp:include page="relativeURL | <%=expression%>" flush="true|false" />

    page属性：用于指定被引入资源的相对路径，它也可以通过执行一个表达式来获得。

    flush属性：指定在插入其他资源的输出内容时，是否先将当前JSP页面的已输出的内容刷新到客户端。

  3. 标签与include指令的区别

    标签是动态引入，标签涉及到的2个JSP页面会被翻译成2个servlet，这2个servlet的内容在执行时进行合并。 而include指令是静态引入，涉及到的2个JSP页面会被翻译成一个servlet，其内容是在源文件级别进行合并。

四、JSP中的九个内置对象

名称类型描述
outjavax.servlet.jsp.JspWriter用于页面输出
requestjavax.servlet.http.HttpServletRequest得到用户请求信息，
responsejavax.servlet.http.HttpServletResponse服务器向客户端的回应信息
configjavax.servlet.ServletConfig服务器配置，可以取得初始化参数
sessionjavax.servlet.http.HttpSession用来保存用户的信息
applicationjavax.servlet.ServletContext所有用户的共享信息
pagejava.lang.Object指当前页面转换后的Servlet类的实例
pageContextjavax.servlet.jsp.PageContextJSP的页面容器
exceptionjava.lang.Throwable表示JSP页面所发生的异常，在错误页中才起作用

1、page

page对象表示当前一个JSP页面，可以理解为一个对象本身

2、out

out对象用于向客户端发送文本数据。

3、pageContext

pageContext对象是JSP技术中最重要的一个对象，它代表JSP页面的运行环境，这个对象不仅封装了对其它8大隐式对象的引用，它自身还是一个域对象(容器)，可以用来保存数据。并且，这个对象还封装了web开发中经常涉及到的一些常用操作，例如引入和跳转其它资源、检索其它域对象中的属性等。

通过pageContext获得其他对象：

getException方法返回exception隐式对象
getPage方法返回page隐式对象
getRequest方法返回request隐式对象
getResponse方法返回response隐式对象
getServletConfig方法返回config隐式对象
getServletContext方法返回application隐式对象
getSession方法返回session隐式对象
getOut方法返回out隐式对象

pageContext作为域对象

pageContext对象可以作为容器来使用，因此可以将一些数据存储在pageContext对象中。

pageContext对象的常用方法：

setAttribute(String name,Object value)添加一个名称为name的属性，值为value
getAttribute(String name)获取名称为name的属性
removeAttribute(String name)移除名称为name的属性
findAttribute(String name)根据name查找各个域中的属性

当使用findAttribute查找某个属性时，findAttribute方法按照查找顺序"page→request→session→application"在这四个对象中去查找，只要找到了就返回属性值，如果四个对象都没有找到要查找的属性，则返回一个null。

五、JSP属性范围

JSP中提供了四种属性范围，如下：

当前页（pageContext）：一个属性只能在一个页面中取得，跳转到其他页面无法取得

一次服务器请求（request）：一个页面中设置的属性，只要经过了服务器跳转，则跳转之后的页面可以继续取得。

一次会话（session）：一个用户设置的内容，只要是与此用户相关的页面都可以访问（一个会话表示一个人，这个人设置的东西只要这个人不走，就依然有效）

上下文中（application）：在整个服务器上设置的属性，所有人都可以访问

1、page属性范围（pageContext）

在一个页面设置的属性，跳转到其他页面就无法访问了。但是在使用page属性范围的时候必须注意的是，虽然习惯上将页面范围的属性称为page范围，但是实际上操作的时候是使用pageContext内置对象完成的。

例如：

<%@ page language="java" errorPage="/error.jsp" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<base href="<%=basePath%>">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <%
        pageContext.setAttribute("name","Zender");

        String name = (String)pageContext.getAttribute("name");
    %>
        name:<%=name %>
</body>
</html>

运行结果如下：

image

使用<jsp:forward page="/index2.jsp" />标签进行服务器跳转到index2.jsp

Index.jsp

<%@ page language="java" errorPage="/error.jsp" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<base href="<%=basePath%>">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <%
        pageContext.setAttribute("name","Zender");
    %>
    <%--使用jsp:forward标签进行服务器端跳转--%>
    <jsp:forward page="/index2.jsp" />
</body>
</html>

Index2.jsp

<%@ page language="java" errorPage="/error.jsp" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<base href="<%=basePath%>">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <%
        String name = (String)pageContext.getAttribute("name");
    %>
        name:<%=name %>
</body>
</html>

运行结果如下：

image

使用了服务器端跳转，但是发现内容并不能取得，证明page范围的属性只能在本页中取得，跳转到其他页面之中不能取得。

2、request属性范围

request属性范围表示在一次服务器跳转中有效，只要是服务器跳转，则设置的request属性可以一直传递下去。

例如：

Index.jsp

<%
    request.setAttribute("name","Zender");
%>
<%--使用jsp:forward标签进行服务器端跳转--%>
<jsp:forward page="/index2.jsp" />

Index2.jsp

<%
    String name = (String)request.getAttribute("name");
%>
    name:<%=name %>

运行结果如下：

image

修改Index2.jsp代码如下：

<%
    String name = (String)request.getAttribute("name");
%>
    name:<%=name %>
<a href="/JSP/index3.jsp">链接跳转</a>

Index3.jsp代码如下：

<%
    String name = (String)request.getAttribute("name");
%>
    name:<%=name %>

使用了超链接的方式传递的话，则属性是无法向下继续传递的，一旦跳转之后，地址栏改变，所以此种跳转也可以称为客户端跳转。点击链接跳转结果如下：

image

3、Session属性范围

session设置的属性不管如何跳转，都可以取得的（session只针对一个用户）。

例如：

Index.jsp

<%
session.setAttribute("name","Zender");
%>
<%--使用jsp:forward标签进行服务器端跳转--%>
<jsp:forward page="/index2.jsp" />

Index2.jsp

<%
    String name = (String)session.getAttribute("name");
%>
    name:<%=name %>
<%--使用超链接这种客户端跳转--%>
<a href="/JSP/index3.jsp">链接跳转</a>

Index3.jsp

<%
    String name = (String)session.getAttribute("name");
%>
    name:<%=name %>

访问Index.jsp（服务器端跳转到index2.jsp）：

image

点击链接跳转（客户端跳转到index3.jsp）：

image

4、application属性范围

application属性范围是在服务器上设置的一个属性，所以一旦设置之后任何用户都可以浏览到此属性（服务器上设置了过多的application属性，则会影响到服务器的性能）。

例如：

Index.jsp

<%
application.setAttribute("name","Zender");
%>
<%--使用jsp:forward标签进行服务器端跳转--%>
<jsp:forward page="/index2.jsp" />

Index2.jsp

<%
    String name = (String)application.getAttribute("name");
%>
    name:<%=name %>
<%--使用超链接这种客户端跳转--%>
<a href="/JSP/index3.jsp">链接跳转</a>

Index3.jsp

<%
    String name = (String)application.getAttribute("name");
%>
    name:<%=name %>

访问Index.jsp（服务器端跳转到index2.jsp）：

image

点击链接跳转（客户端跳转到index3.jsp）：

image

重启web服务器后访问index2.jsp或者index3.jsp：

image

image

六、JSP标签

JSP标签也称之为Jsp Action(JSP动作)元素，它用于在Jsp页面中提供业务逻辑功能，避免在JSP页面中直接编写java代码，造成jsp页面难以维护。

常用标签有以下三个：

1、标签

标签用于把另外一个资源的输出内容插入进当前JSP页面的输出内容之中，这种在JSP页面执行时的引入方式称之为动态引入。

语法：<jsp:include page="relativeURL | <%=expression%>" flush="true|false" />

page用于指定被引入资源的相对路径，它也可以通过执行一个表达式来获得。
flush指定在插入其他资源的输出内容时，是否先将当前JSP页面的已输出的内容刷新到客户端。

标签与include指令的区别：

标签是动态引入，标签涉及到的2个JSP页面会被翻译成2个servlet，这2个servlet的内容在执行时进行合并。 而include指令是静态引入，涉及到的2个JSP页面会被翻译成一个servlet，其内容是在源文件级别进行合并。

2、标签

标签用于把请求转发给另外一个资源（服务器跳转，地址不变）。

语法：<jsp:forward page="relativeURL | <%=expression%>" />

3、标签

在使用和标签引入或将请求转发给其它资源时，可以使用标签向这个资源传递参数。value属性用于指定参数值。在和标签中可以使用多个标签来传递多个参数。

语法1：

<jsp:include page="relativeURL | <%=expression%>">

<jsp:param name="parameterName" value="parameterValue|<%= expression %>" />

</jsp:include>

语法2：

<jsp:forward page="relativeURL | <%=expression%>">

<jsp:param name="parameterName" value="parameterValue|<%= expression %>" />

</jsp:forward>

 

name用于指定参数名
value指定参数值

例如：

index.jsp

<%--使用jsp:forward标签进行服务器端跳转,--%>
<jsp:forward page="/index2.jsp" >
    <jsp:param value="10086" name="num"/>
    <jsp:param value="10010" name="num2"/>
</jsp:forward>

Index2.jsp

num:<%=request.getParameter("num") %>
<br/>
num2:<%=request.getParameter("num2") %>

运行结果如下：

博大的Java世界
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA WEB之jsp语法篇
yeyun666的博客
03-28 924
无论学什么语言，新手最容易犯的就是语法错误，今天我们来了解一下jsp的语法 1、如何在jsp中嵌入java代码 jsp中的java代码需要写在里面，不能写在别的地方，不然就会当成字符直接在网页上显示出来，下面是个正确的例子 <% int j=0; for(int i=0;i<10;i++) j++; %> 2、全局变量和方法的声明 如果需要声明全局变量或者方法，应将声
java后端开发每天遇到的jsp
qq_42306104的博客
01-09 260
一、JSP基础语法 1、JSP模板元素 JSP页面中的HTML内容称之为JSP模版元素。 JSP模版元素定义了网页的基本骨架，即定义了页面的结构和外观。 2、JSP脚本片段 JSP脚本片断(scriptlet)用于在JSP页面中编写多行Java代码（在&lt;%%&gt;不能定义方法）。语法：&lt;%多行java代码 %&gt; 例如： 注意： 1、JSP脚本片断中只能出现java代码，不能出...
Web基础-JSP
J的博客
03-14 808
主要介绍JSP的九大内置对象以及常用标签
Web-Jsp
qq_48865614的博客
10-06 539
Jsp全称Java Server Pages，运行在java服务器中的页面【不能直接在浏览器中运行】Jsp能够以HTML页面的方式呈现数据，是一个可以嵌入Java代码的HTML。Jsp其本质就是一个Servlet。Servlet能做的事情JSP都能做。Jsp必须运行在服务器中，不能直接使用浏览器打开。Jsp是Web网页的技术标准,主要语法组成包括:指令，html模板元素，脚本片段(小脚本)，表达式，声明，注释，后缀是*.jsp。生活中域【区域-快递】︰将物品从一个区域快递到另一区域【共享】
Web JSP
qq_45828537的博客
08-22 304
webjsp
Java Web开发实例大全.基础卷
03-12
基础卷》是一本深入浅出的教程，旨在为读者提供全面的Java Web开发基础知识。本书涵盖了从入门到实践的关键技术，是初学者和有一定经验的开发者提升技能的理想参考资料。标签“Java”明确了本书的核心内容，即Java...
Java Web开发实例大全 基础卷
09-20
全书分4部分共17章，内容包括Java Web开发简介，HTML、JavaScript简介，XML简介，Tomcat服务器的安装及配置，JSP基础语法，JSP内置对象，JavaBean，文件上传，Servlet程序开发，表达式语言，Tomcat数据源，JSP标签...
Java Web开发实例大全基础卷和提高卷
08-07
《Java Web开发实例大全基础卷和提高卷》是一份针对Java Web开发的全面学习资源，包含基础和进阶两个部分，总计约1200个实例。这份资料旨在帮助初学者和有经验的开发者深入理解和掌握Java Web开发的核心技术。 在...
Java+Web开发实例大全+基础卷+软件开发技术联盟编
03-14
《Java+Web开发实例大全+基础卷》是由软件开发技术联盟编著的一本全面介绍Java Web开发基础的书籍。这本书涵盖了从Java编程语言基础到Web应用程序开发的各个环节，旨在为初学者提供一个全面的学习路径，同时也适合有...
web-JSP
zcl_200886的专栏
06-01 120
概念: java servlet page:java服务器端页面 可以理解为一个特殊的页面，既可以定义html，又可以定义Java代码。 用于简化servlet的开发。 1.服务器解析请求消息，找到index.jsp资源。 2.如果找到了，会将index.jsp转换为_index.java文件 3.编译成.class文件 4.由字节码文件提供访问。 原理 JSP本质上就是一个servlet。 jsp的脚本：jsp声明Java代码的方式。 1.<% Java代码 %&g..
Web_Jsp
weixin_45639955的博客
01-06 134
1tomcat 1.1tomcat简介 JSP和Servlet引擎，主要处理JSP和Servlet。JSP其实就是XML文件的改造版本，经过引擎处理，变成一个Java类。 那么Tomcat和Apache服务器有何区别呢？Apache主要负责静态页面的处理，Tomcat主要处理动态的部分。 常用的Servlet容器有Tomcat、JBoss、Glassfish、Weblogic、Websphere...
JavaWeb知识总结-jsp
shark_pupper的博客
01-26 520
jsp简介 jsp的全称是java server pages。Java的服务器页面。 jsp的主要作用是代替Servlet程序回传html页面的数据。 因为Servlet程序回传html页面数据是一件非常繁琐的事情。开发成本和维护成本都极高。 jsp页面和html页面一样，都是存放在web目录下。访问也跟访问html页面一样。 jsp的本质 jsp页面的本质上是一个Servlet程序 jsp的三种语法 a) jsp头部的page指令 jsp的page指令可以修改jsp页面中一些重要
JavaWeb-JSP知识点详细总览
cying7的博客
10-30 646
JSP 简介 JSP全名为Java Server Pages，中文名叫java服务器页面，其根本是一个简化的Servlet设计，它 是由Sun Microsystems公司倡导、许多公司参与一起建立的一种动态网页技术标准。JSP技术有点类似ASP技术，它是在传 统的网页HTML文件(.htm,.html)中插入Java程序段(Scriptlet)和JSP标记(tag)，从而形成JSP文件，后缀名为 (*.jsp)。 用JSP开发的Web应用是跨平台的，既能在Linux下运行，也能在其他操作系统上运行。 JS
jsp 后端
fengfffffgui的博客
02-25 262
转发和重定向的区别：
WEB核心之JSP
超威蓝猫的博客
11-14 1076
JSP全名是Java Server Pages，它是建立在Servlet规范之上的动态网页开发技术。在JSP文件中， HTML代码与Java代码共同存在，其中，HTML代码用来实现网页中静态内容的显示，Java代码用来实现网页中动态内容的显示。
JavaWeb之JSP
最新发布
m0_69855013的博客
11-06 1088
JavaWeb之JSP
web学习 -- jsp
qq_39273039的博客
04-06 192
Java Server Pages： java服务器端页面，一个特殊的页面，其中既可以指定定义html标签，又可以定义java代码
web应用开发之jsp
努力是最好的捷径
07-06 998
1、当配置好web.xml时，修改后要先启动Tomcat，我知道的有两种方式，一种是在Tomcat的安装目录下的D:\apache-tomcat-7.0.41\bin有个startup.bat文件，运行这个文件（或者是把这个文件发送到桌面快捷方式，就像运行其他应用程序一样就可以了）。第二种方式是在Myeclipse中启动Tomcat，之后就可以再浏览器中运行jsp文件了。 2、Jsp文件如果出现
【JavaWeb】jsp
博客包含书籍、B站、其他博主博客等内容，只为了记录笔记，作业，问题，软件配置等，为了以后方便查阅，如有侵权，请联系删除
05-05 529
文章目录一、什么是 jsp，它有什么用1、jsp 如何访问：二、jsp 的本质是什么三、jsp 的三种语法1、jsp 头部的 page 指令2、jsp 中的常用脚本1、声明脚本(极少使用) 一、什么是 jsp，它有什么用 jsp 的全称是 java server pages。Java 的服务器页面。 jsp 的主要作用是代替 Servlet 程序回传 html 页面的数据。 因为 Servlet 程序回传 html 页面数据是一件非常繁锁的事情。开发成本和维护成本都极高。 Servlet 回传 html
EL与JSTL全攻略：Java Web开发必备
本资源是一份关于EL和JSTL在Web开发中的经典PPT，针对初学者设计，主要聚焦于Java Database Connectivity (JDBC)的基础知识及其在Web开发中的应用。JDBC是Java平台下用于连接和操作数据库的标准API，由Sun公司推动，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值