精华内容
下载资源
问答
  • 不同于JSP指令元素JSP动作元素(Action Element)是在客户端请求时动态执行的,是通过XML语法格式标记来实现控制Servlet引擎行为的。JSP动作元素是一种特殊标签,并且以前缀jsp和其他的HTML标签相区别,利用JSP...
         不同于JSP指令元素,JSP动作元素(Action Element)是在客户端请求时动态执行的,是通过XML语法格式标记来实现控制Servlet引擎行为的。JSP动作元素是一种特殊标签,并且以前缀jsp和其他的HTML标签相区别,利用JSP动作元素可以实现很多功能,包括动态地插入文件、重用JavaBean组件、把用户重定向到另外的页面、为Java插件生成HTML代码等。JSP定义了几个预设的Action Element标签。
    


    JSP预设Action Element标签:

    1.JavaBean(在后面学习JavaBean时再详细总结)

        <jsp:useBean>   使用JavaBean

        <jsp:setProperty>  设置JavaBean的属性值

        <jsp:getProperty>  取得JavaBean的属性值

        <jsp:param>    设置传达参数


    2.一般元素

        <jsp:plugin>    载入Java Applet或javaBean

        <jsp:forward>    网页重新定向

        <jsp:include>     载入HTML或JSP文件


    3.XML(2.0新增)

        <jsp:attribute>   设置标签属性

        <jsp:body>       动态设置XML标签主体

        <jsp:element>     动态设置XML标签


    下面我来详细总结一下一般性的Action Element的使用方式!!!


    一、<jsp:include>

        <jsp:include>动作元素可以用来包含其他静态和动态页面。<jsp:include>的包含是运行时包含,同时支持编译时包含。<%@ include file=""%>指令是编译时包含,编译时包含只是将静态文件内容加载到JSP页面中,优点是速度快;运行时包含是指包含的文件在运行时被JSP容器编译执行。


    1.1 <jsp:include>动作元素的语法格式

    ▶带参数

    <jsp:includepage="relative URL"flush="true|false"/>

    ▶不带参数

    <jsp:includepage="relative URL" flush="true|false">

    <jsp:param name="attributeName" value="attributeValue"/>

    <jsp:param...

    </jsp:include>

    其中,relative URL 为被包含文件的相对路径;属性flush为true时,表示实时输出缓冲区。

    <jsp:param>用于在包含文件时传递一些参数,一个<jsp:include>中可以包含一个或多个<jsp:param>动作元素。


    1.2 <jsp:include>动作元素使用实例

     例:文件jsp_include.jsp静态包含文件static.html,动态包含action.jsp

    static.html代码如下:

    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>static.html文件</title>
    </head>
    <body>
    <form method="post" action="jsp_include.jsp">
    <table>
        <tr>
            <td>please input your name:</td>
            <td><input type="text" name="name">
        </tr>
        <tr>
            <td>input your password:</td>
            <td><input type="password" name="password"></td>
        </tr>
        <tr>
            <td></td>
            <td><input type="submit" value="login"></td>
        </tr>   
    </table>
    </form>
    </body>
    </html>

    jsp_include.jsp代码如下

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>jsp_include.jsp文件</title>
    </head>
    <body>
    <%@ include file="static.html" %>
    <%
    //静态包含只是把文件包含进来 
    %>
    <a href="action.jsp">goto action--></a>
    <br>
    <!-- 超链接转到action.jsp文件和动态包含该文件的显示是不同的 -->
    this example show include works
    <br>
    <!-- 动态包含文件并传递参数 -->
    <%
        String name = (String)request.getParameter("name");
        String pwd = (String)request.getParameter("password");
    %>
    <jsp:include page="action.jsp" flush="true">
        <jsp:param name="a1" value="<%=name %>"/>
        <jsp:param name="a2" value="<%=pwd %>"/>
    </jsp:include>
    </body>
    </html>

    action.jsp代码如下:

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>action.jsp文件</title>
    </head>
    <body>
    举例说明动态包含的工作原理
    <br>
    参数a1: name:
    <%=request.getParameter("a1")%>
    <br>
    参数a2: password:
    <%=request.getParameter("a2") %>
    <br>
    <%
    	out.println("hello from action.jsp");
    %>    
    </body>
    </html>
    结果如下:




        其中,方法String request.getParameter("parameterName")以字符串的形式返回客户端传来的某一个请求参数的值,改参数名由parameterName指定。当传递给此方法的参数名没有实际参数与之对应时,返回null。

        action.jsp的内容是动态变化的,他的内容由参数a1,a2决定,而static.html文件的内容是不变的。超链接中并没有传递参数,所以a1和a2都显示null。


    1.3 JSP中include指令与include动作的区别

    ▶include指令是指把其他页面的Java代码加进来,和本页面的代码合并在一起,相当于把源代码从那个页面复制到本页面中,然后编译。并且由于本页面编译时已经包含了别的文件的源代码,所以以后其他页面更改时,本页面不会理,因为已经编译过了。JSP引擎将对所包含文件进行语法分析。

    ▶<jsp:include>动作是指两个页面的代码运行完以后,再把包含的那个页面运行后的HTML结果页面,加到本页面运行后的HTML结果页面中来。所以是运行时包含,并且还可以传递参数给被包含页面。JSP引擎不对所包含的文件进行语法分析。


    二、<jsp:forward>

       <jsp:forward>用于在服务器端结束当前页面的执行,并从当前页面跳转到其他指定页面。转向的目标页面可以是静态的HTML页面、JSP文件或Servlet类。语法与<jsp:include>类似。


     2.1 <jsp:forward>语法格式

    ▶带参数

    <jsp:forwardpage="pageURL"/>

    ▶不带参数

    <jsp:forwardpage="pageURL"/>
    <jsp:param name="attributeName" value="attributeValue"/>
    <jsp:param...
    </jsp:forward>


    2.2 <jsp:forward>动作元素使用实例

    <jsp:forward>操作的典型使用就是登录,如进行权限检验的页面。
    例:logoin.jsp是用户登陆界面,checklogin.jsp是登录检验页面,当验证通过后,把页面forward到success.jsp页面,如不成功,就把页面forward到login.jsp页面进行重新验证。

    login.jsp代码:

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>这是login.jsp页面</title>
    </head>
    <body>
    <form method="get" action="checklogin.jsp">
        <table>
            <tr>
                <td>输入用户名:</td>
                <td><input type="text" name="name" value=<%=request.getParameter("user") %>></td>
            </tr>
            <tr>
                <td>输入密码:</td>
                <td><input type="password" name="password"></td>
            </tr>
            <tr colspan="2">
                <td><input type="submit" value="login"></td>
            </tr>
        </table>
    </form>
    </body>
    </html>
    checklogin.jsp代码:
    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>这是checklogin.jsp页面</title>
    </head>
    <body>
    <%--进行登陆检查 --%>
    <%
        String name=request.getParameter("name");
        String password=request.getParameter("password");
        //如果验证通过,forward-->success.jsp,否则forward-->login.jsp
        if(name.equals("Amy") && password.equals("123456")) {
    %>
    <jsp:forward page="success.jsp">
        <jsp:param name="user" value="<%=name %>"/>
    </jsp:forward>
    <%  }else{ %>
    <jsp:forward page="login.jsp">
        <jsp:param value="<%=name %>" name="user"/>
    </jsp:forward>
    <%  } %>
    </body>
    </html>
    success.jsp代码:
    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>这是success.jsp页面</title>
    </head>
    <body>
    登录成功!<br>
    *******Welcome******* <%=request.getParameter("user") %>
    </body>
    
    </html>
    执行结果




        注意,在页面重定向的过程中(后面两个截图中),地址栏的地址并没有发生变化,这样防止用户跳过登录验证页面而直接进入到其他网页。另外,由于地址不变,就不会产生新的request,可在页面重定向时不传递参数。


    三、<jsp:param>

        ▶<jsp:param>元素主要是用来传递参数给JSP程序,而由程序取得参数值,在程序中便是一个变量值。

        ▶语法:<jsp:paramname="attributeName"value="attributeValue"/>
    name属性表示传递参数的名称,并通过value属性来设置属性的值。且JSP操作元素和HTML元素不同,属性值必须加上双引号“ ”,否则执行时会报错。

        ▶使用<jsp:param>元素来传递参数,在JSP程序中通过request.getParameter("attributeName");来取得参数的值。

        ▶<jsp:param>必须配合<jsp:inclue>、<jsp:forward>和<jsp:plugin>等元素,在加载外部程序或是网页转换的时候,传递参数给另外一个JSP程序



    四、<jsp:useBean>、<jsp:setProperty>和<jsp:getProperty>动作

    4.1 <jsp:useBean>

    4.1.1<jsp:useBean>用来加载JSP页面中使用的JavaBean,其语法格式如下:

       <jsp:useBean  id="beanIntanceName"  scope="page|request|session|application"  class="package.class"></useBean>

         其中,id 指定该JavaBean的实例变量的名称,scope 指定该Bean变量的有效范围。
         page 指只在当前JSP页面有效;request 指在任何执行相同请求的JSP文件中使用Bean,直到页面执行完毕;session 指从创建该Bean开始,在相同session下的JSP页面中可以使用该Bean;application 指从创建Bean开始,在相同application下的JSP下的JSP页面中可以使用该Bean。


     4.1.2 <useBean>简单示例    

    ▶class 属性指定Bean的类路径和类名,不可接受动态值,这个class不能是抽象的

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>useBean.jsp页面</title>
    </head>
    <body>
    <h1>
        <jsp:useBean id="clock" class="java.util.Date"/> 
        Now,It's <%=clock %>
    </h1>
    </body>
    </html>


    ▶bean属性用于指定Bean的名字,可以接收动态值,beanName属性必须与type属性结合使用,不能与class属性同时使用。

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>jsp:useBeanBeanName演示</title>
    </head>
    <body>
    <h1>
        <jsp:useBean id="clock" type="java.io.Serializable" beanName="java.util.Date"/>
        Now, it's <%=clock %>
    </h1>
    </body>
    </html>



    4.2 <jsp:setProperty>

    4.2.1 <jsp:setProperty>用于设置Bean的属性值。语法格式:

    <jsp:setProperty
        name="beanInstanceName"
        {
            property="*"|
            property="propertyName" [param="parameter"]|
            property="propertyName"value="{String|<%=expression%>}"
        }
    />


    4.2.2 <jsp:setProperty>动作用来设置已经实例化的Bean对象的属性,它有两种方法:

    ▶ 可以在jsp:useBean元素的外面使用<jsp:setProperty>

    <jsp:useBean id="myName".../>
    ...
    <jsp:setProperty name="myName"property=“someProperty” .../>

    此时,不管jsp:useBean是找到了一个现有的Bean,还是新创建了一个Bean实例,jsp:setProperty都会执行。


    ▶ 把<jsp:setProperty>放在jsp:useBean元素的内部

    <jsp:useBean id="myName"...>
    ...
    <jsp:setProperty name="myName"property=“someProperty” .../>
    </jsp:useBean>

    此时,<jsp:setProperty>只有在新建Bean实例时才会执行,如果使用现有实例,则不执行<jsp:setProperty>

    注:<jsp:setProperty>中name值必须和<jsp:useBean>中的id值相同,且大小写敏感


    4.2.3 <jsp:setProperty>的属性和用法

    name (必须有)

        表示要设置的是那个Bean

    property(必须有)

        表示要设置那个属性

        有一种特殊方法,如果property的值是“*”,表示所有名字和Bean属性名字匹配的请求参数都将被传递给相应属性的set方法。

    value(可选,不能与param同时用)

        用来指定Bean属性的值。

        字符串数据会在目标类中通过标准的valueOf方法自动转换成数字、Boolean、boolean、byte、Byte、char、Character。

    param(可选,不能与value同时用)

        指定用哪个请求参数作为Bean属性的值。

        如果当前请求没有参数,则什么事情也不做,系统不会把null传递给Bean属性的set方法。因此,可以让Bean自己提供默认属性的值,只有当请求参数明确指定了新值时才修改默认属性值。


    4.3 <jsp:getProperty>

         使用<jsp:getProperty>可获取Bean的属性值,用于在页面中显示。

        <jsp:getProperty name="beanInstanceName" property="propertyName"/>

        其中Bean的名字name由<jsp:useBean>中的id指定;property指定Bean的属性名。



    五、<jsp:plugin>

    <jsp:plugin>功能在于从JSP网页中加载Java Applet或JavaBean程序组件,与HTML的<Applet>与<Object>标签有着类似的功能。这个元素有许多属性设置

    ▶type    加载Java程序的类型,可设置的值有applet和bean。

    ▶code    加载Java程序编译后的类名称,如showpic.class。

    ▶codebase    编译后Java程序类所在的目录,可设置绝对路径或者相对路径。若未设置此属性,则以当前执行网页所在的目录为默认值。

    ▶name     用来对加载的Java Applet或JavaBean程序设置一个用以识别的名称。

    ▶align    设置加载的程序在窗口的对齐方式,可设置的有bottom(下对齐)、top(上对齐)、middle(居中)、left(左对齐)、right(右对齐)。

    ▶height     加载的程序在窗口中显示的高度。

    ▶width     加载的程序在窗口中显示的宽度。

    ▶hspace     加载程序的显示区与网页其他内容的水平间距。

    ▶vspace    加载程序的显示区与网页其他内容的垂直间距。

    ▶<jsp:params>    若要传递参数给加载的程序,则必须在<jsp:params></jsp:params>的起始和结束标签中使用<jsp:param>操作元素来设置。



    补充:Post与Get的差异:

         标签<form>的Method属性有两个取值,Post和Get,两者主要差别在于数据的传输方式。Post将所要传送的数据包包含在HTTP文件头中,隐藏了提交信息,适用于传输大量数据;Get则是将数据直接串接在网址栏后端,只适合数据量较小时用,速度快,如百度就是用的get方式。




    展开全文
  • JSP六大标识详解

    千次阅读 2019-01-01 22:33:53
    指令标识在客户端是不可见的, 在之前写服务器的文章中, 我就强调过, 服务器的一功能就是执行浏览器请求的动态页面, 比如ASP页面, JSP页面。然后最终是生成HTML页面,再返回给浏览器。 所以我们可知, 像这些...

    未经博主允许,请勿转载。转载请注明出处:https://blog.csdn.net/weixin_42512488/article/details/85534690
    知识图谱:
    在这里插入图片描述
    一、JSP页面的基本构成

    <!-- JSP中的指令标识 -->
    <%@ page language="java" contentType="text/html; charset=gb2312" %>
    <%@ page import="java.util.Date" %>
    <!-- HTML标记语言 -->
    <html>
      <head><title>JSP页面的基本构成</title></head>
      <body>
       <center>
    <!-- 嵌入的Java代码 -->
        <% String today=new Date().toLocaleString(); %>
    <!-- JSP表达式 -->
        今天是:<%=today%>
    <!-- HTML标记语言 -->
       </center>
      </body>
    </html>
    

    注:这只是jsp页面的基本构成,我认为JSP页面是由HTML+六大标识构成的。


    二、JSP指令标识

    指令标识在客户端是不可见的, 在之前写服务器的文章中, 我就强调过, 服务器的一大功能就是执行浏览器请求的动态页面, 比如ASP页面, JSP页面。然后最终是生成HTML页面,再返回给浏览器。 所以我们可知, 像这些个标识, 最终都是被服务器解释执行的。通过指令标识可以使服务器按照指令的设置来执行动作和设置在整个JSP页面范围内有效的属性。

    <%@ page
              [ language="java" ]
              [ contentType="mimeType;charset=CHARSET" ]
              [ import="{package.class|pageage.*},…" ]
              [ extends="package.class" ]
              [ session="true|false" ]
              [ buffer="none|8kb|size kb ]
              [ autoFlush="true|false" ]
              [ isThreadSafe="true|false" ]
              [ info="text" ]
              [ errorPage="relativeURL" ]
              [ isErrorPage="true|false" ]
              [ isELIgnored="true|false" ]
              [ pageEncoding="CHARSET" ]
    %>
    

    1.page指令
    page指令从字面意思上,就可以知道,指的是页面属性的设置。可以定义在整个JSP页面范围内的有效属性。习惯放在文件的开始部分,但是它本身是可以放在任意行的。语法如下:

    <%@ page attribute1=“value1” attribute2=“value2” … %>

    page指令的重点在于它的众多属性们,下面进行一一介绍。


    • language属性:
      设置编写当前页面所使用的语言,默认是Java,也只能是Java。从此处可以看出,当年设计JSP技术的人,野心很大。他可能希望其他语言,像C、C++啊这些都能编写JSP。

      <%@ page language=“java” %>

    • contentType属性:
      在页面中正确设置当前页面响应的MIME类型

      MIME(多用途互联网邮件扩展),它是一个互联网标准,在1992年最早应用于电子邮件系统,但后来也应用到浏览器。服务器会将它们发送的多媒体数据的类型告诉浏览器,而通知手段就是说明该多媒体数据的MIME类型,从而让浏览器知道接收到的信息哪些是MP3文件,哪些是Shockwave文件等等。服务器将MIME标志符放入传送的数据中来告诉浏览器使用哪种插件读取相关文件。

      <%@ page contentType=“text/html;charset=utf-8” %> //在页面中正确设置当前页面响应的MIME类型为text/html
      <% @ page contentType=“application/msword” %> //在当前页面中设置响应的MIME类型是Microsoft Word文件

    • import属性:
      import属性类似于Java中的import语句,用来向JSP文件中导入需要用到的包。包名后千万不要加;号,不然会报错。 在JSP中默认导入了java.lang.*、javax.servlet.*、javax.servlet.jsp.*、java.servlet.http.*

      <%@ page import=“java.util."%>
      <%@ page import="java.text.
      ” %>
      或者通过逗号间隔,来导入多个包。
      <%@ page import=“java.util.*,java.text.*” %>

    • extends属性:
      extends属性用于指定将一个JSP页面转换为Servlet后继承的类。在JSP中通常不会设置该属性,JSP容器会提供继承的父类。如果设置了该属性,一些改动会影响JSP的编译能力。

    • session属性:
      该属性默认值为true,表示当前页面支持session,设为false表示不支持session

    • buffer属性:
      该属性用来设置out对象(JspWriter类对象)使用的缓冲区的大小。 若设置为none,表示不使用缓存,而直接通过PrintWriter对象进行输出;如果将该属性指定为数值,则输出缓冲区的大小不应小于该值,默认值为8KB(因不同的服务器而不同,但大多数情况下都为8KB)

    • autoFlush属性:
      该属性默认值为true,表示当缓冲区已满时,自动将其中的内容输出到客户端。
      如果设为false,则当缓冲区中的内容超出其设置的大小时,会产生“JSP Buffer overflow”溢出异常。

    • isThreadSafe属性:

      该属性默认值为true,表示当前JSP页面被转换为Servlet后,会以多线程的方式来处理来自多个用户的请求;如果设为false,则转换后的Servlet会实现SigleThreadModel接口,该Servlet将以单线程的方式来处理用户请求,即其他请求必须等待直到前一个请求处理结束
      本质是:CPU使用权切换还是后续用户排队

    • info属性:
      info属性:该属性可设置为任意字符串,如当前页面的作者或其他有关的页面信息。可通过Servlet.getServletInfo()方法来获取设置的字符串。

      <%@ page info="This is index.jsp!" %>
      <%=this.getServletInfo()%>
      

      访问页面后,将显示:This is index.jsp!
      说明:当JSP页面被转译成Java文件时,转译成的类是Servlet的一个子类,所以在JSP页面中可以使用Servlet类的方法: getServletInfo()

    • errorPage属性:
      该属性用来指定一个当前页面出现异常时所要调用的页面。如果属性值是以“/“开头的路径,则将在当前应用程序的根目录下查找文件;否则,将在当前页面的目录下查找文件

    • isErrorPage属性:
      isErrorPage属性:将该属性值设为true,此时在当前页面中可以使用exception异常对象
      若在其他页面中通过errorPage属性指定了该页面,则当前者出现异常时,会跳转到该页面,并可在该页面中通exception对象输出错误信息。相反,如果将该属性设置为false,则在当前页面中不能使用exception对象。该属性默认值为false

      案例:

      <%@ page contentType="text/html;charset=utf-8" errorPage="show.jsp"%>
      <%
      	String name ="JONCY";
      	Integer.parseInt(name);
      %>
      
      <%@ page contentType="text/html;charset=utf-8" isErrorPage="true" %>
      出现错误,错误如下:<br>
      <%=exception.getMessage()%>
      

      运行结果:
      在这里插入图片描述

    • isELIgnored属性:
      其值只能为true或false。设为true,则忽略表达式语言。

    • pageEncoding属性:
      该属性用来设置JSP页面字符的编码。默认值为ISO-8859-1


    2.include指令:该指令用于在当前的JSP页面中,在当前使用该指令的位置嵌入其他的文件, 如果被包含的文件中有可执行的代码,则显示代码执行后的结果。 千万注意 被包含文件和包含文件的page指令属性要相同。因为两者最终要合成为一个文件 使用include指令引用外部文件,可以减少代码的冗余。

    <%@ include file=“文件的绝对路径或相对路径” %>



    3.taglib指令:在JSP页面中,可以直接使用JSP提供的一些动作元素标识来完成特定功能,如使用包含一个文件 通过使用taglib指令,开发者就可以在页面中使用这些基本标识或自定义的标识来完成特殊的功能

    <%@ taglib uri=“tagURI” prefix=“tagPrefix” %>

    三、JSP声明标识(Declaration)


    在JSP页面中可以声明变量或方法,其声明格式为:

    <%! 声明变量或方法的代码 %>

    特别要注意,在“<%”与“!”之间不要有空格。声明的语法与Java语言中声明变量和方法时是一样的。相当于JAVA中的静态方法。在页面中通过声明标识声明的变量和方法,在整个页面内都有效,它们将成为JSP页面被转换为Java类后类中的属性和方法。并且它们会被多个线程即多个用户共享。也就是说,其中的任何一个线程对声明的变量或方法的修改都会改变它们原来的状态。它们的生命周期从创建到服务器关闭后结束。下面将通过一个具体实例来介绍声明标识的应用
    在这里插入图片描述

    实际案例:

    <%@ page contentType="text/html;charset=utf-8"%> 
    <%!
        int num=0; //声明一个计数变量
        synchronized void add(){//该方法实现访问次数的累加操作
            num++;
        }
    %>
    <% add();//该脚本程序调用实现访问次数累加的方法%>
    <html>
        <body><center>您是第<%=num%>位访问该页的游客!</center></body>
    </html>
    
    

    运行结果:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述


    四、JSP表达式标识(Expression)


    表达式用于向页面中输出信息,其使用格式为:

    <%= 变量或可以返回值的方法或Java表达式 %>

    特别要注意,“<%”与“=”之间不要有空格。SP表达式在页面被转换为Servlet后,转换为了out.print()方法。所以JSP表达式与JSP页面中嵌入到小脚本程序中的out.print()方法实现的功能相同。如果通过JSP表达式输出一个对象,则该对象的toString()方法会被自动调用,表达式将输出toString()方法返回的内容。

    (1)向页面输出内容,例如下面的代码:

    <% String name="www.xxx.com"; %>
    用户名:<%=name%>
    

    (2)生成动态的链接地址,例如下面的代码:

    <% String path="welcome.jsp"; %>
    <a href="<%=path%>">链接到welcom.jsp</a>
    

    (3)动态指定Form表单处理页面,例如下面的代码:

    <% String name="logon.jsp"; %>
    <form action="<%=name%>"></form>
    

    (4)为通过循环语句生成的元素命名,例如下面的代码:

    <% for(int i=1;i<3;i++){ %> 
      	file<%=i%>:
               <input type="text" name="<%="file"+i%>"><br>
    <% } %>
    



    五、JSP脚本程序标识(Scriptlet)


    脚本程序是在JSP页面中使用“<%”与“%>”标记起来的一段Java代码。在脚本程序中可以定义变量、调用方法和进行各种表达式运算,且每行语句后面要加入分号。在脚本程序中定义的变量在当前的整个页面内都有效,但不会被其他的线程共享,当前用户对该变量的操作不会影响到其他的用户。当变量所在的页面关闭后就会被销毁

    • 和声明标识的区别?
      在脚本程序中定义的变量在整个页面内都有效,但不会被其他的线程共享,当前用户对该变量的操作不会影响到其他用户,这就是和声明标识的区别
    <%@ page contentType="text/html;charset=utf-8"%> 
    <% int able=1;%>
    <html>
        <body>
            <table>
                <% if(able==1){%>
                    <tr><td>欢迎登录!您的身份为“普通管理员”。 </td></tr>
                <%}
                     else if(able==2){
                %>
                     <tr><td>欢迎登录!您的身份为“系统管理员”。 </td></tr>
                <%} %>
            </table>
        </body>
    </html>
    
    

    运算结果:
    在这里插入图片描述

    <%@ page contentType="text/html;charset=utf-8" %>
    <%@ page import="java.util.Date"  %>             
    <%!  Date date;                                  
             public int continueSum(int start,int end){  
             int sum =0; 
             for(int i=start;i<=end;i++)  
                sum=sum+i; 
             return sum;                 }     %>
    <HTML><title>example2_1.jsp</title>
     <body  background='back.jpg'>              
    <font size=4><p>程序片创建Date对象:
       <% date=new Date();                            
          out.println("<BR>"+date);
          int start=1;
          int end=100;
          int sum=continueSum(start,end);      %>
    <br>从   <%= start %>                                
       至   <%= end %>  的连续和是   <%= sum %> 
    </font></body></HTML>
    
    

    运算结果:
    在这里插入图片描述

    六、JSP注释标识(Expression)

    1.HTML注释标识

    <!-- 注释内容 -->

    查看源代码会看到对应的注释

    2.带有JSP表达式的注释

    <!-- comment<%=expression %>–>

    包含该注释语句的JSP页面被请求后,服务器能够识别注释中的JSP表达式,从而来执行该表达式,而对注释中的其他内容不做任何操作。当服务器将执行结果返回给客户端后,客户端浏览器会识别该注释语句,所以被注释的内容不会显示在浏览器中

    <%@ page contentType="text/html;charset=utf-8" %>
    <%@ page import="java.util.*" %>
    <% String name="YXQ";%>
    <!--当前用户:<%=name%> -->
    <table><tr><td>欢迎登录:<%=name%></td></tr></table>
    

    运行结果:
    在这里插入图片描述
    在这里插入图片描述

    3.隐藏注释
    在前面已经介绍了如何应用HTML中的注释,这种注释虽然在客户端浏览页面时不会看见,但它却存在于源代码中,可通过在客户端查看源代码看到被注释的内容。所以严格来说,这种注释并不安全。下面将介绍一种隐藏注释,注释格式如下:

    <%-- 注释内容 --%>

    4.脚本程序(Scriptlet)中的注释

    • 单行注释

    // 注释内容

    • 多行注释

    /*
    * 注释内容1
    * 注释内容2
    * …
    */

    • 提示文档注释

    /**
    提示信息1
    提示信息2

    */

    七、动作标识

    1. <jsp:useBean>
      通过应用jsp:useBean动作标识可以在JSP页面中创建一个Bean实例,并且通过属性的设置可以将该实例存储到JSP中的指定范围内。如果在指定的范围内已经存在了指定的Bean实例,那么将使用这个实例,而不会重新创建。通过jsp:useBean标识创建的Bean实例可以在Scriptlet中应用。
    • id属性定义一个变量名,程序中将使用该变量名对所创建的Bean实例进行引用。
      解释:id就相当于Object obj = new Object();中的对象句柄obj。一定要记住是id。后面的表示如<get:property>是不存在该属性的,它们用的name。
    • type属性type属性用于设置由id属性指定的变量的类型。type属性可以指定要创建实例的类的本身、类的父类或者是一个接口
    • scope属性:该属性指定了所创建Bean实例的存取范围,省略该属性时的值为page。
    scope属性值 作用 范围
    page 指定了所创建的Bean实例只能够在当前的JSP文件中使用 当前JSP页面,包括在通过include指令静态包含的页面中有效
    request 指定了所创建的Bean实例可以在请求范围内进行存取。在请求被转发至的目标页面中可通过request对象的getAttribute(“id属性值”)方法获取创建的Bean实例。 一次request请求,包括请求转发。请求重定向就会消失
    session 指定了所创建的Bean实例的有效范围为session。session是当用户访问Web应用时,服务器为用户创建的一个对象,服务器通过session的ID值来区分其他的用户。针对某一个用户而言,在该范围中的对象可被多个页面共享。 网站不关闭不会消失
    application 该值指定了所创建的Bean实例的有效范围从服务器启动开始到服务器关闭结束。application对象是在服务器启动时创建的,它被多个用户共享。 服务器不关闭不会消失
    • class属性:指定一个完整类名
    <jsp:useBean id="us" class="com.Bean.UserInfo" scope="session"/>
    

    程序首先会在session范围中来查找是否存在名为“us”的UserInfo类的实例,如果不存在,那么会通过new操作符实例化UserInfo类来获取一个实例,并以“us”为实例名称存储到session范围内。


    <jsp:useBean id="us" class="com.Bean.UserInfo" type="com.Bean.UserBase" scope="session"/>
    

    该标识被执行时,程序首先创建了一个以type属性的值为类型,以id属性值为名称的变量us,并赋值为null;然后在session范围内来查找这个名为“us”的Bean实例,如果存在,则将其转换为type属性指定的UserBase类型(类型转换必须是合法的)并赋值给变量us;如果实例不存在,那么将通过new操作符来实例化一个UserInfo类的实例并赋值给变量us,最后将us变量储在session范围内

    注:这里就可以看出useBean标识实质上就是在诠释一种东西。这种东西就是new对象的三种方式,只不过,它封装成了jsp标签,用标签的形式来做。type指定的是 Object obj = new Object();中的Object,它可以是类本身,父类,接口。父类的话,对应着类型转换,即:SupperObject obj = (SupperObject )new Object()。接口的话就是再设计模式中常用的向上转型。

    <jsp:useBean id="us" beanName="com.Bean.UserInfo" type="com.Bean.UserBase"/>
    

    这里假设UserBase类为UserInfo类的父类。该标识被执行时,程序首先创建了一个以type属性的值为类型,以id属性值为名称的变量us,并赋值为null;然后在session范围内来查找这个名为“us”的Bean实例,如果存在,则将其转换为type属性指定的UserBase类型(类型转换必须是合法的)并赋值给变量us;如果实例不存在,那么将通过instantiate()方法从UserInfo类中实例化一个类并将其转换成UserBase类型后赋值给变量us,最后将变量us存储在session范围内。

    1. <jsp:setProperty>
      标识通常情况下与jsp:useBean标识一起使用,它将调用Bean中的setXxx()方法将请求中的参数赋值给由jsp:useBean标识创建的JavaBean中对应的简单属性或索引属性。
    • name属性:
      name属性用来指定一个存在JSP中某个范围中的Bean实例。jsp:setProperty标识将会按照page、request、session和application的顺序来查找这个Bean实例,直到第一个实例被找到

    • 用HTTP表单的所有参数的值设置bean相对应的属性的值

    <jsp:setProperty property="*" />
    
    • 用HTTP表单的某个参数的值设置bean的某个属性的值
    <jsp:setProperty property="propertyName"param="parameterName" />
    
    • 将bean属性的值设置为一个表达式的值的语法格式
    <jsp:setProperty property="propertyName“ />
    
    • 将bean属性的值设置为一个字符串语法格式
    <jsp:setProperty property="propertyName" value="值“ />
    
    1. <jsp:getProperty>
      jsp:getProperty属性用来从指定的Bean中读取指定的属性值,并输出到页面中。该Bean必须具有getXxx()方法。
    <jsp:getProperty name="Bean实例名(id)" property="propertyName"/>
    
    1. <jsp:forward>
      jsp:forward动作标识用来将请求转发到另外一个JSP、HTML或相关的资源文件中。当该标识被执行后,当前的页面将不再被执行,而是去执行该标识指定的目标页面。
    <jsp:forward page="文件路径 | 表示路径的表达式"/>
    

    请求转发和请求重定向:
    在这里插入图片描述
    在这里插入图片描述

    1. <jsp:include>
      jsp:include动作标识用于向当前的页面中包含其他的文件,这个文件可以是动态文件也可以是静态文件。该标识的使用格式如下:

      <jsp:include page="被包含文件的路径" flush="true|false"/>
      

      jsp:include动作标识与include指令标识的区别:

      1.属性:
      include指令通过file属性来指定被包含的页面;jsp:include动作标识通过page属性来指定被包含的页面,该属性支持JSP表达式。
      2.处理方式:
      使用include指令被包含的文件,在一个JSP页面中使用include指令来包含另外一个JSP页面,最终编译后的文件只有一个。
      使用jsp:include动作标识包含文件时,当该标识被执行时,程序会将请求转发到(注意是转发,而不是请求重定向)被包含的页面,并将执行结果输出到浏览器中,然后返回包含页继续执行后面的代码。因为服务器执行的是两个文件,所以JSP编译器会分别对这两个文件进行编译
      3.包含方式
      使用include指令包含文件,最终服务器执行的是将两个文件合成后由JSP编译器编译成的一个Class文件,所以被包含文件的内容应是固定不变的,若改变了被包含的文件,则主文件的代码就发生了改变,因此服务器会重新编译主文件。include指令的这种包含过程称为静态包含
      使用jsp:include动作标识通常是来包含那些经常需要改动的文件。此时服务器执行的是两个文件,被包含文件的改动不会影响到主文件,因此服务器不会对主文件重新编译,而只需重新编译被包含的文件即可。而对被包含文件的编译是在执行时才进行的,也就是说,只有当jsp:include动作标识被执行时,使用该识包含的目标文件才会被编译,否则被包含的文件不会被编译,所以这种包含过程称为动态包含
      4.对被包含文件的约定
      使用include指令包含文件时,对被包含文件有约定。


    留言板案例:

    <%@ page contentType="text/html;charset=gb2312" %>
    <HTML><body bgcolor=cyan>
     <form action="example3_18_pane.jsp" method="post" name="form">
       输入名字:<input  type="text" name="peopleName">
       <br>留言标题:<input  type="text"  name="title">
       <br>留言:<br> <textArea name="messages" rows="10" cols=36 
                       wrap="physical"></textArea>
       <br><input type="submit" value="提交" name="submit">
     </form>
     <a href="example3_18_show.jsp">查看留言板</a>
    </body></HTML>
    
    
    <%@ page contentType="text/html;charset=gb2312" %>
    <%@ page import="java.util.*" %>
    <HTML><body>
         <%! Vector v=new Vector();
             int i=0; 
             ServletContext  application;
             synchronized void leaveWord(String s) { //留言方法
                application=getServletContext();;
                i++;
                v.add("No."+i+","+s);
                application.setAttribute("Mess",v); 
             }
         %> 
         <% String name=request.getParameter("peopleName");
            String title=request.getParameter("title");
            String messages=request.getParameter("messages");
               if(name==null)
                  name="guest"+(int)(Math.random()*10000);
               if(title==null)
                  title="无标题";
               if(messages==null)
                  messages="无信息";
               String s=name+"#"+title+"#"+messages; 
               leaveWord(s);
               out.print("您的信息已经提交!");
         %>
      <a href="example3_18_input.jsp" >返回留言页面 
    </body></HTML>
    
    <%@ page contentType="text/html;charset=gb2312" %>
    <%@ page import="java.util.*" %>
    <%! public String handleStr(String s) {
           try {  byte [] bb= s.getBytes("iso-8859-1");
                  s = new String(bb);
           }
           catch(Exception exp){}
           return s;
        }
    %>
    <HTML><body>
      <% Vector v=(Vector)application.getAttribute("Mess");
         for(int i=0;i<v.size();i++) {
            String message=(String)v.elementAt(i);
            String []a =message.split("#");
            out.print("留言人:"+handleStr(a[0])+","+"<br>");
            out.print("标题:"+handleStr(a[1])+"<br>");
            out.print("留言内容:<br>"+handleStr(a[2]));
            out.print("<br>--------------<br>");
         } 
      %>
    </body></HTML>
    

    运行结果:
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • jsp页面元素

    2010-12-10 17:43:00
    jsp页面元素 JSP是Java Server Page的缩写,通常JSP页面使用HTML表示网页上的静态内容,而使用JAVA代码表示动态内容.构成元素包括:1.静态内容:即一些HTML代码.它与java和jsp的语法无关.例如:任意的html代码2.JSP指令:...

    jsp页面元素 

    JSP是Java Server Page的缩写,通常JSP页面使用HTML表示网页上的静态内容,而使用JAVA代码表示动态内容.构成元素包括:
    1.静态内容:即一些HTML代码.它与java和jsp的语法无关.例如:
    <html>任意的html代码</html>
    2.JSP指令:以"<%@"开始,"%>"结束,它在服务器端首先被执行.例如:
    <%@ page import="包或类的路径"%>
    3.JSP表达式:以"<%="开始,"%>"结束.例如:
    <%=new String("aaa")%>
    4.JSP Scriptlet:以"<%"开始,"%>"结束,其中间为java代码.例如:
    <%
       String name = "张三";
       out.println(name);
    %>
    5.JSP声明:以"<%!"开始,"%>"结束,用于定义变量和方法.例如:
    <%!
       public String sayHello(String name)
       {
        return "Hello!" + name;
       } 
    %>
    6.JSP动作:以"<jsp:动作名"开始,"/jsp:动作名>"结束,例如:
    <jsp:include flush="false" page="welcome.jsp">
       <jsp:param name="aaa"/>
    </jsp:include>
    7.JSP注释:这里的注释有两种格式,一是:
       <!--这是注释,但是客户端可以看到-->;
    二是:
       <%--这也是注释,但是客户端不能查看到--%>
    值得注意的是:JSP在运行前是要 被web容器转译成Servlet的, 所以为了更好的区分JSP Scriptlet和JSP声明,可以这样认为:JSP Scriptlet就是Servlet里面的service方法里面的内容,JSP声明就是service方法外面的内容,即其他的方法,或者成员变量.
    JSP九大隐式对象:
    1.request:表示客户端的请求,包含了所有的请求信息,是service方法的      resquest参数.
    2.response:处理JSP生成的响应,然后将响应结果发送给客户端.是service方法   的response参数.
    3.out:表示输出流,将作为请求的响应发送给客户端.是PrintWriter的一个实例.
    4.session:表示用户的会话状况,用此机制可以轻易的识别每一个用户,能保存和 跟踪用户的会话状态.是HttpSession的一个实例.
    5.pageContext:作用于此页面,可以访问页面作用域中定义的所有隐式对象.是
    PageContext的一个实例.
    6.application:作用于整个应用程序.是ServletContext的一个实例.
    7.page:提供对网页上定义的所有对象的访问.是一个Object对象.是此Servlet的 一个引用.
    8.config:存储Servlet的一些初始信息.是ServletConfig的一个实例.
    9.exception:此对象负责处理程序执行过程中引发的异常.

    本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/xxyyww/archive/2010/07/27/5769565.aspx

     

    展开全文
  • include:将一个外部文件嵌入jsp中,同时解析这个页面中的jsp语句。 taglib:使用标签库,自定义新的标签,在jsp中启动定制行为<%@ include file="login.jsp" %>include动作:动作标签 语法 <jsp:include page

    常用的有page、include、taglib指令这三种指令;
    page:位于页面顶端,一个页面可以包含多个page指令
    include:将一个外部文件嵌入jsp中,同时解析这个页面中的jsp语句。
    taglib:使用标签库,自定义新的标签,在jsp中启动定制行为

    <%@ include file="login.jsp" %>
    include动作:动作标签
    语法
    <jsp:include page="URL" flush="true|false,默认为false" ></jsp:include>
    page:要包含的页面
    flush:被包含的页面是否从缓冲区22读取

    include指令:
    include指令是编译阶段的指令,即include所包含的文件的内容是编译的时候插入到JSP文件中‘因此如果只修改了include文件内容,而没有对JSP修改,得到的结构将不会改变,所以直接执行已经存在的字节码文件,而没有重新编译。因此对不经常变化的内容,用include指令是合适的,如果需要的内容是经常变化的,则需要动作元素。
    include指令的主要优点是功能强大,所包含的代码可以含有总体上影响主页面的JSP构造,比如属性、方法的定义和文档类型的设定。它的缺点是难于维护只要被包含的页面发生更改,就得更改主页面,这是因为主页面不会自动地查看被包含的页面是否发生更改。
    仅当include动作不能满足要求时,我们才应该使用include指令。
    include动作在维护上的优势十分巨大,当两种方法都可以使用时,include动作几乎肯定是首选的方法。
    对于文件包含,应该尽可能地使用include动作。仅在所包含的文件中定义了主页面要用到的字段或方法,或所包含的文件设置了主页面的响应报头时,才应该使用include指令。

    因为include指令更为强大。include指令允许所包含的文件中含有影响主页面的Jsp代码,比如响应报头的设置和字段、方法的定义。

    inlude指令与include动作的区别:
    include指令是编译阶段的指令,是将主页面和包含页面转换成一个servlet,因此编译较慢,执行较快。
    include动作在编译阶段是将主页面和包含页面编译成俩个servlet,在执行期间调用页面输出。因此编译较快,执行较慢。

    forward动作

    语法:<jsp:forward page="URL"/>
    等于服务器内部转发指令 request.getRequestDispacher(“URL”).forward(req,res);

    四种跳转.
    <% response.sendRedirect(“login_seccess.jsp”); %>//地址栏地址会改变
    <jsp:forward page="login_fail.jsp"></jsp:forward>//服务器将请求转发到另一页面,携带信息
    <% pageContext.forward(“login_fail.jsp”);%>
    <% request.getRequestDispatcher(“login_fail.jsp”).forward(request,response);%>

    param动作

    方法为post
    1、<jsp:param name="参数名" value="参数值">
    2、常与<jsp:forward></jsp:forward>一起使用,并作为其子标签。
    3、用于传递新参数或者修改原有参数值,修改参数时使用form表单里的参数名称即可。同样用request.getParameter("参数名")获取
    
    必须与forward、include及plugin动作配合使用。通常与forward动作一起使用,作为它的子标签,它的作用是指定某个参数值,可以用于传递参数,
    <jsp:forward page="login.jsp"> 
    <jsp:param value="1380000000" name="phoneNum"/> 
    </jsp:forward>
    展开全文
  • JSP(Java Server Page) jsp本质就是一个servlet ... Jsp执行过程 客户端发出Request (请求);...JSP Container 将JSP 转译成Servlet 的源代码;...jsp基本元素: 注释元素 模板元素 指令元素 脚本元素 ...
  • 详解JSP动作元素useBean语法

    千次阅读 2017-03-28 21:22:47
    一. JSP动作元素useBean语法: <jsp:useBean id="beanInstanceName" scope="page | request | session | application" { class="package.class" | type="package.cl
  • 【前言】抬头仰望活在网络上的各位牛人们,是他们让我学习到很多新的东西,也让我明白了...这个功能非常有用,因为它使得我们既可以发挥Java组件重用的优势,同时也避免了损失JSP区别于Servlet的方便性。一. JSP
  • 一. JSP动作元素useBean语法:    id="beanInstanceName"   scope="page | request | session | application"   {   class="package.class" |   type="package.class
  • 一、从JSP到Servlet 1、JSP生命周期 (1)JSP最后会被容器转译为Servlet源代码、自动编译为.class文件、载入.class文件,然后生成Servlet对象,所以第一次请求JSP页面会慢许多才得到响应。 (2)JSP在转译为Servlet...
  • JSP六种主要动作

    千次阅读 2005-07-31 10:11:00
    JSP动作主要有以下种: 1、 javaBean是特殊类型的java类,它与普通java类相比主要区别是包含了两种特殊的方法:set…(设置属性的方法)、get…(取属性值的方法)。 动作用来查找或实例化一个jsp页面使用的...
  • jsp技术(二)jsp基础语法1、JSP模版元素 网页的静态内容。如:html标签和文本。2、JSP的脚本: - 小脚本 代码 %> - 表达式 <%= 2+3 %> 等价于out.print(2+3); - 声明 ! %> 表示在类中定义全局成员,和静态块...
  • JSP()动作标签

    千次阅读 2018-06-10 02:00:37
    1、六大动作指令2、JSTL核心标签库
  • JSP系列JSP自定义标签

    千次阅读 2008-08-20 06:05:00
     * JSP 自定义标记提供了替代简单的 JavaBean 和 Java 脚本的方法。 更好的是在 JSTL 中已存在一组已定义的标准的自定义标记库。 * 目的在于将业务和表示逻辑分离,代码的可重用性,可移植性。二,标签库:按照...
  • JSP

    千次阅读 2016-12-28 18:22:40
    JSP(全称Java Server Pages)JSP技术是以...JSP文件后缀名为(*.jsp)。  JSP 简介 什么是Java Server Pages? JSP是一种动态网页开发技术。它使用JSP标签在HTML网页中插入Java代码。标签通常以结束。 JSP是一种Java se
  • request.getRequestDispatcher("/userTasks.jsp").forward(request, response); ----------------------------------------------------------- userTask的监听器 总共有4种: create表示当创建任务...
  • 一.JSP 原理:JSP其实就是一个servlet。...1. JSP模板元素JSP中HTML标签及文本 2. 脚本:写JAVA代码, 3. 表达式:用于输出变量及表达式, 4. 注释:分为三种 a) :JSP翻译成Servlet时也将进行翻译
  • jsp课-在jsp中使用数据库

    千次阅读 2012-03-08 23:39:49
    本章部分例子采用的模式是JSP+JavaBean模式,即JSP页面调用bean来完成对数据库的操作,使用的数据库管理系统是SQL Server 2000。 1. SQL Server 2000数据库管理系统 SQL Server 2000是一个网络数据库,可以使...
  • JSP详解

    千次阅读 多人点赞 2017-11-04 09:15:46
    JSP详解主要内容简介:1. JSP简介 a) 什么是JSP b) JSP的组成 c) JSP的特点 d) JSP的执行过程 e) JSP的生命周期2. JSP语法 a) JSP模板元素 b) JSP表达式 c) JSP脚本片段 d) JSP注释3. JSP指令 ...
  • Java web之 JSP

    2017-05-24 15:18:46
    Servlet的缺点: ...Java开发人员和前台设计人员无法共同工作 ...浏览器请求JSP页面–>服务器–>服务器当中JSP容器 –>JSP文件—>Servlet文件–>Class文件加载—>Servlet实例 —>返回响应JSP页面组成第一个部分
  • JSP六个动作详解...

    千次阅读 2012-05-13 11:13:51
    ...JSP中6个动作为:1.Include、 2.Forward、3.UseBean、 4.GetProperty、 5.SetProperty、 6.Plugin。 一、Include指令 标签表示包含一个静态的或者动态的文件。 语法: page="pat
  • 1.jsp技术  jsp是sun提供动态web资源开发技术。为了解决在Servlet中拼写html内容css、js内容十分不方便的问题,sun提供了这样一门技术。如果说Servlet是在java中嵌套HTML,则jsp就是在HTML中嵌套java代码,从而十分...
  • jsp

    2018-08-28 17:23:27
    转载:...   一、JSP  1、什么是JSP?  JSP(Java Server Pages):是以Java语言为基础的动态网页开发技术,  特点:  Servlet特点:在Java源码中嵌入html源码  JSP特点:在html源码中...
  • 与多数动态页面相同的是 jsp 最基础的 有三 元素 JSP 页面的 三 元素 一、JSP模版元素  JSP页面中的HTML内容称之为JSP模版元素。  JSP模版元素定义了网页的基本骨架,即定义了页面的结构和外观。 二、JSP...
  • 一.JSP    原理:JSP其实就是一个servlet。  Servlet负责业务逻辑处理,JSP只负责显示。开发中,JSP中不能有一行JAVA...JSP模板元素JSP中HTML标签及文本  2.  脚本:写JAVA代码,  3.  表达式:用于
  • Java web基础知识 第JSP的复习

    千次阅读 2020-04-14 12:20:55
    JSP概述一、JSP概述1. 什么是JSP?2. JSP基本语法3. 控制流语句4. JSP 指令 一、JSP概述 1. 什么是JSP? JSP全称Java Server Pages,是一种动态网页开发技术。它使用JSP标签在HTML网页中插入Java代码。标签...
  • Servlet笔记()JSP EL

    2014-04-20 08:24:15
    〇、常用动作元素  :动态包含  include file="2.jsp" %>...一、JSP隐式对象(记住):在JSP的java脚本或表达式中直接可以使用的对象。比如out  1、原理:就是JSP对应的Servlet的service方法中的局部变量。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,640
精华内容 8,256
关键字:

jsp六大元素