精华内容
下载资源
问答
  • JSP 动作元素

    2021-01-08 22:41:08
    与JSP指令元素不同的是,JSP动作元素在请求处理阶段起作用。JSP动作元素是用XML语法写成的。 利用JSP动作可以动态地插入文件、重用JavaBean组件、把用户重定向到另外的页面、为Java插件生成HTML代码。 动作元素只有...
  • JSP动作元素学习

    2018-12-05 15:15:53
        &...(1)JSP动作元素简介   &

         一JSP动作元素概述

           (1)JSP动作元素简介

           与JSP指令元素不同的是,JSP动作元素在请求处理阶段起作用。JSP动作元素是用XML语法写成的。利用JSP动作

    可以动态地插入文件、重用JavaBean组件、把用户重定向到另外的页面、为Java插件生成HTML代码。

           JSP动作元素(action elements),动作元素为请求处理阶段提供信息。动作元素遵循XML元素的语法,有一个包

    含元素名的开始标签,可以有属性、可选的内容、与开始标签匹配的结束标签。

           动作元素只有一种语法,它符合XML标准:

    <jsp:action_name attribute="value" />

           动作元素基本上都是预定义的函数,JSP规范定义了一系列的标准动作,它用JSP作为前缀,可用的标准动作元素

    如下:

           

           (2)JSP动作元素常见的属性

           所有的动作要素都有两个属性:id属性和scope属性。

           1)id属性

           id属性是动作元素的唯一标识,可以在JSP页面中引用。动作元素创建的id值可以通过PageContext对象来调

    用。这些我们会在下面的实例中进行演示。

           2)scope属性

           scope属性用于识别动作元素的生命周期。 id属性和scope属性有直接关系,scope属性定义了相关联id对象的

    寿命。 scope属性有四个可能的值:page、request、session和application,这是JSP的四个作用域。

          (3)JSP动作元素分类

          JSP动作元素包含五类:

          第一类是与JavaBean有关的,包括3个动作元素:

    <jsp:useBean>  <jsp:getProperty>  <jsp:setProperty>

          第二类是JSP1.2就开始有的基本元素,包括6个动作元素:

    <jsp:include>  <jsp:foward>  <jsp:param>  <jsp:plugin>  <jsp:params>  <jsp:fallback>

          第三类是JSP2.0新增加的元素,主要与JSP Document有关,包括6个动作元素:

    <jsp:root>  <jsp:declaration>  <jsp:scriptlet>  <jsp:expression> <jsp:text>  <jsp:output>

          第四类是JSP2.0新增加的元素,主要是用来动态生成XML元素标签的值,包括3个动作元素:

    <jsp:attribute>   <jsp:body>   <jsp:element>

          第五类是JSP2.0新增加的元素,主要使用在Tag Filter中,包括2个动作元素:

    <jsp:invoke>  <jsp:dobody>

           二JavaBean

           (1)JavaBean简介

           JavaBean就是符合某种特定的规范的Java类。使用JavaBean的好处是解决代码重复编写,减少代码冗余,功能

    区分明显,提高了代码的可维护性。

           (2)JavaBean设计原则

           先使用图示来说明JavaBean的四个设计原则:

           

           1)公有类

           JavaBean其实就是Java程序,只不过需要在JSP页面中应用,不定义成public类型的,当不是在同一个包下时(项

    目里一般会把JavaBean放在单独的文件夹下,所有不可能在同一包下了)不可以访问。

            2)属性私有

            定义成私有变量实际上是出于安全性的考虑,把变量封装起来,所以需要public的getter和setter方法访问这些

    私有属性。

            3)无参的公有构造方法

            一般不显式的写出构造方法,那么类都会默认的创建一个无参的公有构造方法,这是为了方便创建类的实例对

    象。

            4)getter和setter方法

            对类的私有属性进行重构,得到这些私有属性的getter和setter方法,为的是获取属性值和设置属性值。

            实例:设计一个符合JavaBean设计原则的类

    package com.entity;
    

    /**
     * 用户实体类的访问属性是public
     * @author Administrator
     * @date 2016年7月11日
     */
    public class Users {
    //私有属性
    private String username;
    private String password;

    //无参构造器
    public Users(){

    }

    //通过重构得到setter和getter方法
    public String getUsername() {
    return username;
    }

    public void setUsername(String username) {
    this.username = username;
    }

    public String getPassword() {
    return password;
    }

    public void setPassword(String password) {
    this.password = password;
    }

    }

            三JSP页面中使用JavaBean

            (1)像使用普通Java类一样,创建JavaBean类实例

            实例:在JavaBean项目下的Java Resources目录下创建一个JavaBean类Users,在WebContent目录下创建

    index.jsp页面。

            JavaBean类Users的代码为如上个例子中创建的Users类。

            index.jsp页面源代码:

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!-- 导入包 -->
    <%@ page import="com.entity.Users" %>
    <!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>JavaBean实例</title>
    </head>
    <body>
          <h1>使用普通方式创建JavaBean的实例</h1>
          <hr>
          <%
            Users user = new Users();  //创建JavaBean类的实例user
            user.setUsername("admin");  //设置用户名
            user.setPassword("123456");  //设置密码
          %>
          用户名:<%=user.getUsername() %><br>
          密码:<%=user.getPassword() %><br>
    </body>
    </html>

            运行结果:

            

            (2)在JSP页面中通常使用JSP动作元素使用JavaBean类

            1)<jsp:useBean>动作元素

            作用:在JSP页面中实例化或者在指定范围内使用JavaBean。<jsp:useBean>动作元素用来加载一个将在JSP页

    面中使用的JavaBean。这个功能非常有用,因为它使得我们可以发挥JavaBean组件复用的优势。

            最简单的语法为:

    <jsp:useBean id="标识符" class="Java类名" scope="作用范围" ></jsp:useBean>
    
             在JavaBean类载入后,我们既可以通过<jsp:setProperty>动作元素和<jsp:getProperty>动作元素来修改和检索Bean的属性。 以下是useBean动作元素相关的属性列表:

            

            在给出具体实例前,让我们先来看下<jsp:setProperty>动作元素和<jsp:getProperty>动作元素。

            2)<jsp:setProperty>动作元素

            <jsp:setProperty>动作元素用来设置已经实例化的Bean对象的属性,有两种用法。首先,你可以在<jsp:setProperty>动作元素的外面(后面)使用<jsp:setProperty>动作元素,如下所示:

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

            此时,不管<jsp:setProperty>动作元素是找到了一个现有的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>动作元素有下面四个属性,如下表:

            

            3)<jsp:getProperty>动作元素

            <jsp:getProperty>动作元素提取指定Bean类属性的值,转换成字符串,然后输出。

            语法格式如下:

    <jsp:useBean id="myName" ... /><jsp:useBean>
    ...
    <jsp:getProperty name="myName" property="someProperty" .../>

            下表是与getProperty相关联的属性:

            

            实例

            依然使用上面例子中的JavaBean类Users类。

            新建的useBean.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>JavaBean实例</title>
    </head>
    <body>
          <h1>使用useBean方式创建JavaBean的实例</h1>
          <hr>
          <jsp:useBean id="myUsers" class="com.entity.Users" scope="page"></jsp:useBean>
          
          <!-- 使用setProperty方式来设置用户名和密码 -->
          <jsp:setProperty property="username" name="myUsers" value="admin"/><br>
          <jsp:setProperty property="password" name="myUsers" value="123456"/><br>
          
          <!-- 使用传统的表达式来获取用户名和密码 -->
          用户名:<%=myUsers.getUsername() %><br>
          密码:<%=myUsers.getPassword() %><br>
          
          <hr>
          <!-- 使用getProperty方式来获取用户名和密码 -->
          用户名:<jsp:getProperty property="username" name="myUsers"/><br>
          密码:<jsp:getProperty property="password" name="myUsers"/><br>
    </body>
    </html>
    

            运行结果:

            

            (3)对于<jsp:setProperty>动作元素的延伸

         <jsp:setProperty>动作元素作用:给已经实例化的JavaBean对象的属性赋值,一共有四种形式:

    //跟表单关联 <jsp:setProperty name="JavaBean实例名" property="*" />  

    // 跟表单关联 <jsp:setProperty name="JavaBean实例名" property="JavaBean属性名" /> 

    //手工设置属性值 <jsp:setProperty name="JavaBean实例名" property="JavaBean属性名" value="BeanValue" />  

    //跟request参数关联  <jsp:setProperty name="JavaBean实例名" property="propertyName" param="request对象中的参数名" />

                  实例:

            照常使用JavaBean类Users类。

            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>登录页面</title>
    </head>
    <body>
         <h1>登录表单</h1>
         <hr>
         <form name="loginForm" action="dologin.jsp" method="post">
             <table>
                  <tr>
                      <td>用户名:</td>
                      <td><input type="text" name="username" value="" /></td>
                  </tr>
                  <tr>
                      <td>密码:</td>
                      <td><input type="password" name="password" value="" /></td>
                  </tr>
                  <tr>
                      <td colspan="2" align="center"><input type="submit" value="登录" /></td>
                  </tr>
             </table>
         </form>
    </body>
    </html>
    

           dologin.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>登录页面</title>
    </head>
    <body>
          <%
            //防止中文乱码
            request.setCharacterEncoding("utf-8"); 
           %>
          <h1>setProperty动作元素的使用</h1>
          <hr>
          <jsp:useBean id="myUsers" class="com.entity.Users" scope="page"></jsp:useBean>
          
          
          <!-- 通过request对象得到属性值 -->
          用户名:<%=request.getParameter("username") %><br>
          密码:<%=request.getParameter("password") %><br>
          
          <hr>
          <!-- 根据表单自动匹配所有属性 -->
          <jsp:setProperty property="*" name="myUsers"/>
          用户名:<%=myUsers.getUsername() %><br>
          密码:<%=myUsers.getPassword() %><br>
          
          <hr>
          <!-- 根据表单匹配部分的属性 -->
          <jsp:setProperty property="username" name="myUsers"/>
          <jsp:setProperty property="password" name="myUsers"/>
          用户名:<%=myUsers.getUsername() %><br>
          密码:<%=myUsers.getPassword() %><br>
          
          <hr>
          <!-- 跟表单无关,通过手动赋值给属性 -->
          <jsp:setProperty property="username" name="myUsers" value="Rose" />
          <jsp:setProperty property="password" name="myUsers" value="888888" />
          用户名:<%=myUsers.getUsername() %><br>
          密码:<%=myUsers.getPassword() %><br>
          
    </body>
    </html>
    

           运行结果:

           

           

           对于最后一种我们这样修改:

           在login.jsp中的表单中做出如下修改:

       

           在dologin.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>登录页面</title>
    </head>
    <body>
          <%
                //防止中文乱码
                request.setCharacterEncoding("utf-8"); 
           %>
          <h1>setProperty动作元素的使用</h1>
          <hr>
          <jsp:useBean id="myUsers" class="com.entity.Users" scope="page"></jsp:useBean>
          
          <hr>
          <!-- 通过URL传参数给属性赋值 -->
          <jsp:setProperty property="username" name="myUsers" param="user" />
          <jsp:setProperty property="password" name="myUsers" param="pass" />
          用户名:<%=myUsers.getUsername() %><br>
          密码:<%=myUsers.getPassword() %><br>
          
    </body>
    </html>
    

           运行后我们输入用户名:李四,密码:123456,最后的结果是:

           


         <jsp:include>动作元素

            (1)<jsp:include>动作元素

            <jsp:include>动作元素用来包含静态和动态的文件。该动作把指定文件插入正在生成的页面。

            <jsp:include>动作元素语法格式如下:

    <jsp:include page="相对URL地址" flush="true" />

         前面已经介绍过include指令,它是在JSP文件被转换成Servlet的时候引入文件,而这里的<jsp:include>动作元素不同,插入文件的时间是在页面被请求的时候。

           以下是include动作相关的属性列表:

           

           实例:以下我们定义了两个文件date.jsp和include.jsp

           date.jsp页面源代码:

    <%@page import="java.text.SimpleDateFormat"%>
    <%@page import="java.util.Date"%>
    <%@ 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>date页面</title>
    </head>
    <body>
          <%
                Date date = new Date();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
                
                String string = sdf.format(date);
                out.println(string);
          %>
    </body>
    </html>
    

           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>include指令</title>
    </head>
    <body>
          <h1>include指令</h1>
          <hr>
          <%@ include file="date.jsp"  %>
    </body>
    </html>
    

           运行结果:

           

           (2)include指令与include动作的区别

           JSP指令: 相当于是把被包含的文件的代码原封不动的放进了包含它的文件 ,编译的时候生成一个class文件。

           JSP动作:   被包含的文件和包含的文件在编译的时候生成的是两个class文件。

           <%@ include %>指令编译后文件包括其所包含jsp的源代码。

           <jsp:include>动作元素编译后文件不包括,只写明所包含文件的名字,其和所包含文件之间是相对独立的存

    在。

           页面内容经常变化时更适合使用<jsp:include>动作元素。

           页面内容不经常变化时更适合使用include指令。

           <jsp:include>动作元素包含的是执行结果,而include指令包含的是文件内容。

           <jsp:include>动作元素在请求期间被执行,而include指令在编译期页面间被执行。

           include指令与include动作比较图表:

           

           include指令保存的文件:

           

           include动作保存的文件:

           

           <jsp:forward>动作元素

           <jsp:forward>动作元素把请求转到另外的页面。<jsp:forward>动作元素只有一个属性page。

           <jsp:forward>动作元素语法格式如下所示:

    <jsp:forward page="相对 URL 地址" />

           以下是forward相关联的属性:

    属性 描述
    page page属性包含的是一个相对URL。page的值既可以直接给出,也可以在请求的时候动态计算,可以是一个JSP页面或者一个 Java Servlet.

           <jsp:forward>动作元素等同于服务器内部跳转或转发:

    request.getRequestDispatcher("/url").forward(request,response);

           实例:我们使用了三个文件,分别是

           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>登录界面</title>
    </head>
    <body>
         <h1>系统登录</h1>
         <hr>
         <form action="forward_action.jsp" name="loginForm" method="post">
              <table>
                   <tr>
                       <td>用户名:</td>
                       <td><input type="text" name="username" /></td>
                   </tr>
                   <tr>
                       <td>密码:</td>
                       <td><input type="password" name="password" /></td>
                   </tr>
                    <tr>
                       <td colspan="2"><input type="submit" value="登录" /></td>
                   </tr>
              </table>
          </form>
    </body>
    </html>
    

           users.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>用户资料界面</title>
    </head>
    <body>
          <h1>用户资料</h1>
          <hr>
          <%
                request.setCharacterEncoding("UTF-8");
          
                String username = "";
                String password = "";
                if(request.getParameter("username") != null){
                	username = request.getParameter("username");
                }
                if(request.getParameter("password") != null){
                	password = request.getParameter("password");
                }
          %>
          用户名:<%=username %><br>
          密码:<%=password %><br>
    </body>
    </html>
    

           forward_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>forward动作元素</title>
    </head>
    <body>
         <h1>forward动作元素</h1>
          <hr>
          <jsp:forward page="users.jsp"  />
          
          <!-- 上面的动作等同于下面的服务器内部转发 -->
          <%-- 
          <%
                request.getRequestDispatcher("users.jsp").forward(request, response);
          %>
          --%>
    </body>
    </html>
    

           运行结果:

           

           

           <jsp:param>动作元素

           常常与<jsp:forward >动作元素一起使用。

           <jsp:param>动作元素语法:

    <jsp:param name="参数名" value="参数值" />

           实例:

           还是那个login.jsp页面,修改的地方为:

          

           增加一个dologin.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>登录界面</title>
    </head>
    <body>
        <jsp:forward page="users.jsp">
             <jsp:param value="admin@123.net" name="email"/>
             <jsp:param value="888888" name="password"/>
        </jsp:forward>
    </body>
    </html>
    
           在users.jsp页面增加代码:

       
           运行结果:

           

           

           <jsp:plugin>动作元素

           <jsp:plugin>动作元素用来根据浏览器的类型,插入通过Java插件运行Java Applet所必需的OBJECT或EMBED元素。如果需要的插件不存在,它会下载插件,然后执行Java组件。 Java组件可以是一个applet或一个JavaBean。

    plugin动作有多个对应HTML元素的属性用于格式化Java 组件。param元素可用于向Applet或Bean传递参数。

            以下是使用<jsp:plugin>动作元素的典型实例:

    <jsp:plugin type="applet" codebase="dirname" code="MyApplet.class"
                               width="60" height="80">
       <jsp:param name="fontcolor" value="red" />
       <jsp:param name="background" value="black" />
    

    <jsp:fallback>
    Unable to initialize Java Plugin
    </jsp:fallback>

    </jsp:plugin>

            如果你有兴趣可以尝试使用applet来测试<jsp:plugin>动作元素,<jsp:fallback>动作元素是一个新元素,在组件出现故障的错误是发送给用户错误信息。

           <jsp:element> 、 <jsp:attribute>、 <jsp:body>动作元素

           <jsp:element> 、 <jsp:attribute>、 <jsp:body>动作元素动态定义XML元素。动态是非常重要的,这就意味着XML元素在编译时是动态生成的而非静态。

            以下实例动态定义了XML元素:

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="utf-8">
    <title>菜鸟教程(runoob.com)</title>
    </head>
    <body>
       <jsp:element name="xmlElement">
           <jsp:attribute name="xmlElementAttr">
           属性值
           </jsp:attribute>
           <jsp:body>
           XML 元素的主体
           </jsp:body>
       </jsp:element>
    </body>
    </html>

            浏览器访问以下页面,输出结果如下所示:

            

           <jsp:text>动作元素

           <jsp:text>动作元素允许在JSP页面和文档中使用写入文本的模板,语法格式如下:

    <jsp:text>模板数据</jsp:text>

           以上文本模板不能包含其他元素,只能只能包含文本和EL表达式。请注意,在XML文件中,不能使用表达式如 ${whatever > 0},因为>符号是非法的。 我们可以使用 ${whatever gt 0}表达式或者嵌入在一个CDATA部分的值。

    <jsp:text><![CDATA[<br>]]></jsp:text>

           如果需要XHTML中声明DOCTYPE,必须使用到<jsp:text>动作元素,实例如下:

    <jsp:text><![CDATA[<!DOCTYPE html
    PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "DTD/xhtml1-strict.dtd">]]>
    </jsp:text>
    <head><title>jsp:text action</title></head>
    <body>
    

    <books><book><jsp:text>
    Welcome to JSP Programming
    </jsp:text></book></books>

    </body>
    </html>

            你可以对以上实例尝试使用<jsp:text>及不使用该动作元素执行结果的区别。


    转载自:https://blog.csdn.net/qq_29028175/article/details/53729048
    展开全文
  • JSP动作元素

    2016-09-04 20:04:51
    JSP动作元素在请求处理阶段起作用,用来控制JSP的行为,执行一些常用的JSP页面动作。利用JSP动作可以动态地插入文件、重用JavaBean组件、把用户重定向到另外的页面、为Java插件生成HTML代码、自定义标签等。 1.<jsp...

    JSP动作元素在请求处理阶段起作用,用来控制JSP的行为,执行一些常用的JSP页面动作。利用JSP动作可以动态地插入文件、重用JavaBean组件、把用户重定向到另外的页面、为Java插件生成HTML代码、自定义标签等。
    1.<jsp:include>动作元素
    可以包含静态文件或动态文件,把指定文件插入到正在生成的页面

    <jsp:include page="relative URL" flush="false" />

    page属性:包含文件的url地址,是一个相对路径
    flush属性:指定当缓冲区满时,是否将其清空,默认为false
    特别:
    include指令,它是在JSP文件被转换成Servlet的时候引入文件,
    jsp:include动作,插入文件的时间是在页面被请求的时候。
    例:
    date.jsp

    <%@ page import="java.util.*" %>
    <%=(new Date()).toString() %>

    include.jsp

    <jsp:include page="date.jsp"></jsp:include>

    访问include.jsp就会显示date.jsp的内。
    2.<jsp:forward>动作元素
    一种用于页面重定向的动作元素
    语法格式:<jsp:forward page="relative URL" />
    3.<jsp:param>动作元素
    它是一种提供参数的附属动作元素,以“名-值”对的形式为其他动作元素提供附加信息,一般与<jsp:include><jsp:forward><jsp:plugin>联合使用。
    语法格式:<jsp:param name="参数名字" value="指定给param的参数值">
    4.<jsp:plugin>动作元素

    该动作元素可以将服务器端的JavaBean或Applet下载到客户端执行。
    例:

    <jsp:plugin type="applet|bean" codebase="dirname" code="MyApplet.class"
                               width="60" height="80">
       <jsp:param name="fontcolor" value="red" />
       <jsp:param name="background" value="black" />
    
       <jsp:fallback>
          Unable to initialize Java Plugin
       </jsp:fallback>
    
    </jsp:plugin>

    5.<jsp:usebean>动作元素
    该动作元素用来装载一个将在JSP页面中使用的JavaBean。它发挥了Java组件重用的优势,也提高了JSP使用的方便性。
    语法格式:

    <jsp:usebean id="beanInstanceName" class="classname" scope="page|request|session|application" />

    说明:
    id: 指定JavaBean的实例名
    class: 指定JavaBean的全限定类名
    scope: 指定引入的JavaBean实例的作用域。默认为当前页。

    <jsp:setProperty>动作元素

    设置或修改Bean中的属性值。
    语法格式:
    <jsp:setProperty name="beanInstanceName" property="propertyName" value=""value" />

    <jsp:getProperty>动作元素

    用来提取指定Bean属性的值。
    语法格式:<jsp:getProperty name="beanInstanceName" property="propertyName" />

    例:
    User.java

    public class User {
        private String username;  //用户名
    
        //username属性对应的getter方法
        public String getUsername(){
            return username;
        }
    
        //username属性对应的setter方法
        public void setUsername(String username){
            this.username=username;
        }
    }

    jspbean.jsp

    <jsp:useBean id="user" class="jsp.User" scope="page">
        <jsp:setProperty name="user" property="username" value="Leon"/>
        用户名: <jsp:getProperty name="user" property="username" />
    </jsp:useBean>
    展开全文
  • JSP动作元素.pptx

    2021-10-27 21:48:34
    JSP相关资料
  • jsp动作元素

    2019-09-18 22:40:48
    与JSP指令元素不同的是,JSP动作元素在请求处理阶段起作用。JSP动作元素是用XML语法写成的。 利用JSP动作可以动态地插入文件、重用JavaBean组件、把用户重定向到另外的页面、为Java插件生成HTML代码。 动作元素只有...

    JSP 动作元素

    与JSP指令元素不同的是,JSP动作元素在请求处理阶段起作用。JSP动作元素是用XML语法写成的。

    利用JSP动作可以动态地插入文件、重用JavaBean组件、把用户重定向到另外的页面、为Java插件生成HTML代码。

    动作元素只有一种语法,它符合XML标准:

    1.<jsp:action_name attribute="value" />
    

    动作元素基本上都是预定义的函数,JSP规范定义了一系列的标准动作,它用JSP作为前缀,可用的标准动作元素如下:

    语法描述
    jsp:include在页面被请求的时候引入一个文件。
    jsp:useBean寻找或者实例化一个JavaBean。
    jsp:setProperty设置JavaBean的属性。
    jsp:getProperty输出某个JavaBean的属性。
    jsp:forward把请求转到一个新的页面。
    jsp:plugin根据浏览器类型为Java插件生成OBJECT或EMBED标记。
    jsp:element定义动态XML元素
    jsp:attribute设置动态定义的XML元素属性。
    jsp:body设置动态定义的XML元素内容。
    jsp:text在JSP页面和文档中使用写入文本的模板

    常见的属性

    所有的动作要素都有两个属性:id属性和scope属性。

    id属性:

    id属性是动作元素的唯一标识,可以在JSP页面中引用。动作元素创建的id值可以通过PageContext来调用。

    scope属性:

    该属性用于识别动作元素的生命周期。 id属性和scope属性有直接关系,scope属性定义了相关联id对象的寿命。 scope属性有四个可能的值: (a) page, (b)request, ©session, 和 (d) application。

    <jsp:include>动作元素

    <jsp:include>动作元素用来包含静态和动态的文件。该动作把指定文件插入正在生成的页面。语法格式如下:

    1.<jsp:include page="relative URL" flush="true" />
    

    前面已经介绍过include指令,它是在JSP文件被转换成Servlet的时候引入文件,而这里的jsp:include动作不同,插入文件的时间是在页面被请求的时候。

    以下是include动作相关的属性列表。

    属性描述
    page包含在页面中的相对URL地址。
    flush布尔属性,定义在包含资源前是否刷新缓存区。

    实例

    以下我们定义了两个文件date.jsp和main.jsp,代码如下所示:

    date.jsp文件代码:

    1.<p>
    2.   Today's date: <%= (new java.util.Date()).toLocaleString()%>
    3.</p>
    

    main.jsp文件代码:

    1.<html>
    2.<head>
    3.<title>The include Action Example</title>
    4.</head>
    5.<body>
    6.<center>
    7.<h2>The include action Example</h2>
    8.<jsp:include page="date.jsp" flush="true" />
    9.</center>
    10.</body>
    11.</html>
    

    现在将以上两个文件放在服务器的根目录下,访问main.jsp文件。显示结果如下:

    1.The include action Example
    2.Today's date: 12-Sep-2013 14:54:22
    

    <jsp:useBean>动作元素

    jsp:useBean动作用来装载一个将在JSP页面中使用的JavaBean。

    这个功能非常有用,因为它使得我们既可以发挥Java组件重用的优势,同时也避免了损失JSP区别于Servlet的方便性。

    jsp:useBean动作最简单的语法为:

    1.<jsp:useBean id="name" class="package.class" />
    

    在类载入后,我们既可以通过 jsp:setProperty 和 jsp:getProperty 动作来修改和检索bean的属性。

    以下是useBean动作相关的属性列表。

    属性描述
    class指定Bean的完整包名。
    type指定将引用该对象变量的类型。
    beanName通过 java.beans.Beans 的 instantiate() 方法指定Bean的名字。

    在给出具体实例前,让我们先来看下 jsp:setProperty 和 jsp:getProperty 动作元素:

    <jsp:setProperty>动作元素

    jsp:setProperty用来设置已经实例化的Bean对象的属性,有两种用法。首先,你可以在jsp:useBean元素的外面(后面)使用jsp:setProperty,如下所示:

    1.<jsp:useBean id="myName" ... />
    2....
    3.<jsp:setProperty name="myName" property="someProperty" .../>
    

    此时,不管jsp:useBean是找到了一个现有的Bean,还是新创建了一个Bean实例,jsp:setProperty都会执行。第二种用法是把jsp:setProperty放入jsp:useBean元素的内部,如下所示:

    1.<jsp:useBean id="myName" ... >
    2....
    3.   <jsp:setProperty name="myName" property="someProperty" .../>
    4.</jsp:useBean>
    

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

    属性描述
    namename属性是必需的。它表示要设置属性的是哪个Bean。
    propertyproperty属性是必需的。它表示要设置哪个属性。有一个特殊用法:如果property的值是"*",表示所有名字和Bean属性名字匹配的请求参数都将被传递给相应的属性set方法。
    valuevalue 属性是可选的。该属性用来指定Bean属性的值。字符串数据会在目标类中通过标准的valueOf方法自动转换成数字、boolean、Boolean、 byte、Byte、char、Character。例如,boolean和Boolean类型的属性值(比如"true")通过 Boolean.valueOf转换,int和Integer类型的属性值(比如"42")通过Integer.valueOf转换。   value和param不能同时使用,但可以使用其中任意一个。
    paramparam 是可选的。它指定用哪个请求参数作为Bean属性的值。如果当前请求没有参数,则什么事情也不做,系统不会把null传递给Bean属性的set方法。因此,你可以让Bean自己提供默认属性值,只有当请求参数明确指定了新值时才修改默认属性值。

    <jsp:getProperty>动作元素

    jsp:getProperty动作提取指定Bean属性的值,转换成字符串,然后输出。语法格式如下:

    1.<jsp:useBean id="myName" ... />
    2....
    3.<jsp:getProperty name="myName" property="someProperty" .../>
    

    下表是与getProperty相关联的属性:

    属性描述
    name要检索的Bean属性名称。Bean必须已定义。
    property表示要提取Bean属性的值

    实例

    以下实例我们使用了Bean:

    1./* 文件: TestBean.java */
    2.package action;
    3. 
    4.public class TestBean {
    5.   private String message = "No message specified";
    6. 
    7.   public String getMessage() {
    8.      return(message);
    9.   }
    10.   public void setMessage(String message) {
    11.      this.message = message;
    12.   }
    13.}
    

    编译以上实例并生成 TestBean.class 文件,将该文件拷贝至服务器正式存放Java类的目录下,而不是保留给修改后能够自动装载的类的目录( 如:C:\apache-tomcat-7.0.2\webapps\WEB-INF\classes\action目录中,CLASSPATH 变量必须包含该路径。 )。例如,对于Java Web Server来说,Bean和所有Bean用到的类都应该放入classes目录,或者封装进jar文件后放入lib目录,但不应该放到servlets 下。   下面是一个很简单的例子,它的功能是装载一个Bean,然后设置/读取它的message属性。

    现在让我们在main.jsp文件中调用该Bean:

    1. <html>
    2.<head>
    3.<title>Using JavaBeans in JSP</title>
    4.</head>
    5.<body>
    6.<center>
    7.<h2>Using JavaBeans in JSP</h2>
    8. 
    9.<jsp:useBean id="test" class="action.TestBean" />
    10. 
    11.<jsp:setProperty name="test" 
    12.                    property="message" 
    13.                    value="Hello JSP..." />
    14. 
    15.<p>Got message....</p>
    16. 
    17.<jsp:getProperty name="test" property="message" />
    18. 
    19.</center>
    20.</body>
    21.</html>
    

    执行以上文件,输出如下所示:

    1.Using JavaBeans in JSP
    2.Got message....
    3.Hello JSP...
    

    <jsp:forward> 动作元素

    jsp:forward动作把请求转到另外的页面。jsp:forward标记只有一个属性page。语法格式如下所示:

    1.<jsp:forward page="Relative URL" />
    

    以下是forward相关联的属性:

    属性描述
    page page属性包含的是一个相对URL。page的值既可以直接给出,也可以在请求的时候动态计算,可以是一个JSP页面或者一个 Java Servlet.

    实例

    以下实例我们使用了两个文件,分别是: date.jps 和 main.jsp。

    date.js文件代码如下:

    1.<p>
    2.   Today's date: <%= (new java.util.Date()).toLocaleString()%>
    3.</p>
    

    main.jsp文件代码:

    1.<html>
    2.<head>
    3.<title>The forward Action Example</title>
    4.</head>
    5.<body>
    6.<center>
    7.<h2>The forward action Example</h2>
    8.<jsp:forward page="date.jsp" />
    9.</center>
    10.</body>
    

    现在将以上两个文件放在服务器的根目录下,访问main.jsp文件。显示结果如下:

    1.Today's date: 12-Sep-2010 14:54:22
    

    <jsp:plugin>动作元素

    jsp:plugin动作用来根据浏览器的类型,插入通过Java插件 运行Java Applet所必需的OBJECT或EMBED元素。

    如果需要的插件不存在,它会下载插件,然后执行Java组件。 Java组件可以是一个applet或一个JavaBean。

    plugin动作有多个对应HTML元素的属性用于格式化Java 组件。param元素可用于向Applet 或 Bean 传递参数。

    以下是使用plugin 动作元素的典型实例:

    1.<jsp:plugin type="applet" codebase="dirname" code="MyApplet.class"
    2.                           width="60" height="80">
    3.   <jsp:param name="fontcolor" value="red" />
    4.   <jsp:param name="background" value="black" />
    5. 
    6.   <jsp:fallback>
    7.      Unable to initialize Java Plugin
    8.   </jsp:fallback>
    9. 
    10.</jsp:plugin>
    

    如果你有兴趣可以尝试使用applet来测试jsp:plugin动作元素,元素是一个新元素,在组件出现故障的错误是发送给用户错误信息。

    <jsp:element> 、 <jsp:attribute>、 <jsp:body>动作元素

    <jsp:element> 、<jsp:attribute>、 <jsp:body>动作元素动态定义XML元素。动态是非常重要的,这就意味着XML元素在编译时是动态生成的而非静态。

    以下实例动态定义了XML元素:

    1.<%@page language="java" contentType="text/html"%>
    2.<html xmlns="http://www.w3c.org/1999/xhtml"
    3.      xmlns:jsp="http://java.sun.com/JSP/Page">
    4. 
    5.<head><title>Generate XML Element</title></head>
    6.<body>
    7.<jsp:element name="xmlElement">
    8.<jsp:attribute name="xmlElementAttr">
    9.   Value for the attribute
    10.</jsp:attribute>
    11.<jsp:body>
    12.   Body for XML element
    13.</jsp:body>
    14.</jsp:element>
    15.</body>
    16.</html>
    

    执行时生成HTML代码如下:

    1.<html xmlns="http://www.w3c.org/1999/xhtml"
    2.      xmlns:jsp="http://java.sun.com/JSP/Page">
    3. 
    4.<head><title>Generate XML Element</title></head>
    5.<body>
    6.<xmlElement xmlElementAttr="Value for the attribute">
    7.   Body for XML element
    8.</xmlElement>
    9.</body>
    10.</html>
    

    <jsp:text>动作元素

    <jsp:text>动作元素允许在JSP页面和文档中使用写入文本的模板,语法格式如下:

    1.<jsp:text>Template data</jsp:text>
    

    以上文本模板不能包含其他元素,只能只能包含文本和EL表达式。请注意,在XML文件中,您不能使用表达式如 ${whatever > 0},因为>符号是非法的。 你可以使用 ${whatever gt 0}表达式或者嵌入在一个CDATA部分的值。

    1.<jsp:text><![CDATA[<br>]]></jsp:text>
    

    如果你需要在 XHTML 中声明 DOCTYPE,必须使用到<jsp:text>动作元素,实例如下:

    1.<jsp:text><![CDATA[<!DOCTYPE html
    2.PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    3."DTD/xhtml1-strict.dtd">]]>
    4.</jsp:text>
    5.<head><title>jsp:text action</title></head>
    6.<body>
    7. 
    8.<books><book><jsp:text>  
    9.    Welcome to JSP Programming
    10.</jsp:text></book></books>
    11. 
    12.</body>
    13.</html>
    

    你可以对以上实例尝试使用<jsp:text>及不使用该动作元素执行结果的区别。

    展开全文
  • JSP 动作元素与JSP指令元素不同的是,JSP动作元素在请求处理阶段起作用。JSP动作元素是用XML语法写成的。利用JSP动作可以动态地插入文件、重用JavaBean组件、把用户重定向到另外的页面、为Java插件生成HTML代码。...

    JSP 动作元素

    与JSP指令元素不同的是,JSP动作元素在请求处理阶段起作用。JSP动作元素是用XML语法写成的。

    利用JSP动作可以动态地插入文件、重用JavaBean组件、把用户重定向到另外的页面、为Java插件生成HTML代码。

    动作元素只有一种语法,它符合XML标准:

    <jsp:action_name attribute="value" />

    动作元素基本上都是预定义的函数,JSP规范定义了一系列的标准动作,它用JSP作为前缀,可用的标准动作元素如下:

    语法描述
    jsp:include在页面被请求的时候引入一个文件。
    jsp:useBean寻找或者实例化一个JavaBean。
    jsp:setProperty设置JavaBean的属性。
    jsp:getProperty输出某个JavaBean的属性。
    jsp:forward把请求转到一个新的页面。
    jsp:plugin根据浏览器类型为Java插件生成OBJECT或EMBED标记。
    jsp:element定义动态XML元素
    jsp:attribute设置动态定义的XML元素属性。
    jsp:body设置动态定义的XML元素内容。
    jsp:text在JSP页面和文档中使用写入文本的模板

    常见的属性

    所有的动作要素都有两个属性:id属性和scope属性。

    • id属性:

      id属性是动作元素的唯一标识,可以在JSP页面中引用。动作元素创建的id值可以通过PageContext来调用。

    • scope属性:

      该属性用于识别动作元素的生命周期。 id属性和scope属性有直接关系,scope属性定义了相关联id对象的寿命。 scope属性有四个可能的值: (a) page, (b)request, (c)session, 和 (d) application。


    <jsp:include>动作元素

    <jsp:include>动作元素用来包含静态和动态的文件。该动作把指定文件插入正在生成的页面。语法格式如下:

    <jsp:include page="相对 URL 地址" flush="true" />

     前面已经介绍过include指令,它是在JSP文件被转换成Servlet的时候引入文件,而这里的jsp:include动作不同,插入文件的时间是在页面被请求的时候。

    以下是include动作相关的属性列表。

    属性描述
    page包含在页面中的相对URL地址。
    flush布尔属性,定义在包含资源前是否刷新缓存区。

    <jsp:useBean>动作元素

    jsp:useBean 动作用来加载一个将在JSP页面中使用的JavaBean。

    这个功能非常有用,因为它使得我们可以发挥 Java 组件复用的优势。

    jsp:useBean动作最简单的语法为:

    <jsp:useBean id="name" class="package.class" />

    在类载入后,我们既可以通过 jsp:setProperty 和 jsp:getProperty 动作来修改和检索bean的属性。

    以下是useBean动作相关的属性列表。

    属性描述
    class指定Bean的完整包名。
    type指定将引用该对象变量的类型。
    beanName通过 java.beans.Beans 的 instantiate() 方法指定Bean的名字。

    在给出具体实例前,让我们先来看下 jsp:setProperty 和 jsp:getProperty 动作元素:


    <jsp:setProperty>动作元素

    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动作有下面四个属性,如下表:

    属性描述
    namename属性是必需的。它表示要设置属性的是哪个Bean。
    propertyproperty属性是必需的。它表示要设置哪个属性。有一个特殊用法:如果property的值是"*",表示所有名字和Bean属性名字匹配的请求参数都将被传递给相应的属性set方法。
    valuevalue 属性是可选的。该属性用来指定Bean属性的值。字符串数据会在目标类中通过标准的valueOf方法自动转换成数字、boolean、Boolean、 byte、Byte、char、Character。例如,boolean和Boolean类型的属性值(比如"true")通过 Boolean.valueOf转换,int和Integer类型的属性值(比如"42")通过Integer.valueOf转换。   value和param不能同时使用,但可以使用其中任意一个。
    paramparam 是可选的。它指定用哪个请求参数作为Bean属性的值。如果当前请求没有参数,则什么事情也不做,系统不会把null传递给Bean属性的set方法。因此,你可以让Bean自己提供默认属性值,只有当请求参数明确指定了新值时才修改默认属性值。

    <jsp:getProperty>动作元素

    jsp:getProperty动作提取指定Bean属性的值,转换成字符串,然后输出。语法格式如下:

    <jsp:useBean id="myName" ... />
    ...
    <jsp:getProperty name="myName" property="someProperty" .../>

    下表是与getProperty相关联的属性:

    属性描述
    name要检索的Bean属性名称。Bean必须已定义。
    property表示要提取Bean属性的值

    <jsp:forward> 动作元素

     jsp:forward动作把请求转到另外的页面。jsp:forward标记只有一个属性page。语法格式如下所示:

    <jsp:forward page="相对 URL 地址" />

    以下是forward相关联的属性:

    属性描述
    pagepage属性包含的是一个相对URL。page的值既可以直接给出,也可以在请求的时候动态计算,可以是一个JSP页面或者一个 Java Servlet.


    <jsp:plugin>动作元素

    jsp:plugin动作用来根据浏览器的类型,插入通过Java插件 运行Java Applet所必需的OBJECT或EMBED元素。

    如果需要的插件不存在,它会下载插件,然后执行Java组件。 Java组件可以是一个applet或一个JavaBean。

    plugin动作有多个对应HTML元素的属性用于格式化Java 组件。param元素可用于向Applet 或 Bean 传递参数。

    以下是使用plugin 动作元素的典型实例:

    <jsp:plugin type="applet" codebase="dirname" code="MyApplet.class"
                               width="60" height="80">
       <jsp:param name="fontcolor" value="red" />
       <jsp:param name="background" value="black" />
     
       <jsp:fallback>
          Unable to initialize Java Plugin
       </jsp:fallback>
     
    </jsp:plugin>

    如果你有兴趣可以尝试使用applet来测试jsp:plugin动作元素,<fallback>元素是一个新元素,在组件出现故障的错误时发送给用户错误信息。


    <jsp:element> 、 <jsp:attribute>、 <jsp:body>动作元素

    <jsp:element> 、 <jsp:attribute>、 <jsp:body>动作元素动态定义XML元素。动态是非常重要的,这就意味着XML元素在编译时是动态生成的而非静态。


    <jsp:text>动作元素

    <jsp:text>动作元素允许在JSP页面和文档中使用写入文本的模板,语法格式如下:

    <jsp:text>模板数据</jsp:text>

    以上文本模板不能包含其他元素,只能只能包含文本和EL表达式(注:EL表达式将在后续章节中介绍)。请注意,在XML文件中,您不能使用表达式如 ${whatever > 0},因为>符号是非法的。 你可以使用 ${whatever gt 0}表达式或者嵌入在一个CDATA部分的值。

    <jsp:text><![CDATA[<br>]]></jsp:text>

    如果你需要在 XHTML 中声明 DOCTYPE,必须使用到<jsp:text>动作元素,实例如下:

    <jsp:text><![CDATA[<!DOCTYPE html
    PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "DTD/xhtml1-strict.dtd">]]>
    </jsp:text>
    <head><title>jsp:text action</title></head>
    <body>
    
    <books><book><jsp:text>  
        Welcome to JSP Programming
    </jsp:text></book></books>
    
    </body>
    </html>


    展开全文
  • JSP动作格式为: < jsp:tag attributel="value1" attriblute2="value2"> < jsp:include > 在当前JSP页面中动作标记所在位置指定的资源内容包含进来,其格式为: < jsp:include pag...
  • 先说下怎样编写一个JSP文件 点开你的web项目,点开WebContent-----new-----JSP File ...这说明HTML中的元素可以被JSP容器所解析,实际上,JSP只是在原有的HTML文件中加入了一些具有Java特点的代码。 J...
  • jsp动作元素:<jsp:include>动作元素
  • JSP动作元素用来控制JSP的行为,执行一些常用的JSP页面动作。通过动作元素可以实现使用多行Java代码能够实现的效果,如包含页面文件、实现请求转发等。 <jsp:include>动作元素 在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
  • JSP动作元素

    2013-03-04 21:27:56
    JSP动作元素 本章将介绍JSP的动作元素的作用,并对JSP动作元素进行分类。将详细介绍其中的JSP基本动作元素,包括、、、、、。 熟练使用动作元素来包含文件。 熟练使用动作元素来实现页面跳转。 熟练使用动作...
  • javabean和jsp动作元素

    2021-03-08 15:53:01
    model1就是利用了jsp和javabean 的组合来处理问题。jsp页面如果有太多的逻辑代码的话,维护起来和扩展起来是相当的麻烦的。所以jsp的逻辑代码部分都打包到一种java类当中进行编写。这种符合特定原则的java类就叫做...
  • JSP指令元素 - include动作 PAGE 3 实训实 验 报 告 实训(实验)项目: 在JSP页面中使用include动作 实验目的 学会在JSP页面中使用include动作 实训实验设计器材步骤结论 简介 <jsp:include>动作标签用于包含其他子...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,708
精华内容 11,483
关键字:

jsp动作元素

友情链接: Andre_Gerck_h2.zip