如何避免JSP文件中的Java代码？


How to avoid Java code in JSP files?

我是JavaEE的新手，我知道下面的三行

1
2
3
<%= x+1 %>
<%= request.getParameter("name") %>
<%! counter++; %>

是一种旧的编码方式，在JSP版本2中存在一种在JSP文件中避免Java代码的方法。有人能告诉我替代的JSP 2行，以及这种技术叫什么？

相关讨论

自从2001年taglibs(如jstl)和el(表达式语言，即${})的诞生以来，在jsp中使用scriptlet(这些<% %>事物)确实是非常不受欢迎的。好的。

脚本的主要缺点是：好的。

  • 可重用性：不能重用脚本。
  • 可替换性：不能将scriptlets抽象化。
  • OO能力：你不能利用继承/组合。
  • 可调试性：如果Scriptlet中途抛出异常，您得到的只是一个空白页。
  • 可测试性：脚本不可单元测试。
  • 可维护性：每个saldo需要更多的时间来维护混合/混乱/重复的代码逻辑。

    • sunoracle本身也建议在JSP编码约定中避免在(tag)类可以实现相同功能时使用scriptlet。以下是几个相关的引文：好的。

    From JSP 1.2 Specification, it is highly recommended that the JSP Standard Tag Library (JSTL) be used in your web application to help reduce the need for JSP scriptlets in your pages. Pages that use JSTL are, in general, easier to read and maintain.

    Ok.

    ...

    Ok.

    Where possible, avoid JSP scriptlets whenever tag libraries provide equivalent functionality. This makes pages easier to read and maintain, helps to separate business logic from presentation logic, and will make your pages easier to evolve into JSP 2.0-style pages (JSP 2.0 Specification supports but de-emphasizes the use of scriptlets).

    Ok.

    ...

    Ok.

    In the spirit of adopting the model-view-controller (MVC) design pattern to reduce coupling between the presentation tier from the business logic, JSP scriptlets should not be used for writing business logic. Rather, JSP scriptlets are used if necessary to transform data (also called"value objects") returned from processing the client's requests into a proper client-ready format. Even then, this would be better done with a front controller servlet or a custom tag.

    Ok.

    如何替换scriptlet完全取决于代码/逻辑的唯一目的。通常，这个代码将被放置在一个完整的Java类中：好的。

    • 如果您希望在每个请求上调用相同的Java代码，那么不管请求的页面是否较少，例如检查用户是否登录，然后在EDCOX1×2方法中实现过滤器并相应地编写代码。例如。：好的。

      1
      2
      3
      4
      5
      6
      7
      public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
          if (((HttpServletRequest) request).getSession().getAttribute("user") == null) {
              ((HttpServletResponse) response).sendRedirect("login"); // Not logged in, redirect to login page.
          } else {
              chain.doFilter(request, response); // Logged in, just continue request.
          }
      }

      当映射到覆盖感兴趣的JSP页面的适当上时，就不需要复制粘贴整个JSP页面中的同一段代码。好的。

    • 如果您想调用一些Java代码来预处理请求，例如从数据库中预加载一些列表以显示在某个表中，如果需要的话，根据一些查询参数，然后实现servlet并相应地在EDCOX1×4方法中编写代码。例如。：好的。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          try {
              List<Product> products = productService.list(); // Obtain all products.
              request.setAttribute("products", products); // Store products in request scope.
              request.getRequestDispatcher("/WEB-INF/products.jsp").forward(request, response); // Forward to JSP page to display them in a HTML table.
          } catch (SQLException e) {
              throw new ServletException("Retrieving products failed!", e);
          }
      }

      这种处理异常的方法更容易。数据库在JSP呈现过程中不被访问，但在显示JSP之前还远未被访问。当DB访问抛出异常时，仍然可以更改响应。在上面的示例中，将显示默认错误500页，您可以通过web.xml中的进行自定义。好的。

    • 如果您想调用一些Java代码来处理请求，例如处理表单提交，那么在servlet中实现一个servlet并相应地编写代码。例如。：好的。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          String username = request.getParameter("username");
          String password = request.getParameter("password");
          User user = userService.find(username, password);

          if (user != null) {
              request.getSession().setAttribute("user", user); // Login user.
              response.sendRedirect("home"); // Redirect to home page.
          } else {
              request.setAttribute("message","Unknown username/password. Please retry."); // Store error message in request scope.
              request.getRequestDispatcher("/WEB-INF/login.jsp").forward(request, response); // Forward to JSP page to redisplay login form with error.
          }
      }

      这种处理不同结果页目的地的方法更容易：在出现错误的情况下重新显示带有验证错误的表单(在这个特定的示例中，您可以使用EL中的${message}重新显示表单)，或者在成功的情况下直接使用所需的目标页。好的。

    • 如果您想调用一些Java代码来控制请求和响应的执行计划和/或目的地，则根据MVC的前端控制器模式实现servlet。例如。：好的。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          try {
              Action action = ActionFactory.getAction(request);
              String view = action.execute(request, response);

              if (view.equals(request.getPathInfo().substring(1)) {
                  request.getRequestDispatcher("/WEB-INF/" + view +".jsp").forward(request, response);
              } else {
                  response.sendRedirect(view);
              }
          } catch (Exception e) {
              throw new ServletException("Executing action failed.", e);
          }
      }

      或者只采用一个MVC框架，比如JSF、SpringMVC、Wicket等，这样就只需要一个JSP/Facelets页面和一个JavaBean类，而不需要定制servlet。好的。

    • 如果您想调用一些Java代码来控制JSP页面内的流，那么您需要抓取一个(现有的)流控制TAGLIB，如JSTL核心。例如，在表格中显示List：好的。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
      ...
      <table>
          <c:forEach items="${products}" var="product">
              <tr>
                  <td>${product.name}</td>
                  <td>${product.description}</td>
                  <td>${product.price}</td>
              </tr>
          </c:forEach>
      </table>

      有了XML风格的标签，这些标签非常适合所有的HTML，代码的可读性(因此可维护性也更好)要比一堆带有不同的左括号和右括号的脚本更好("这个右括号属于哪里？").一个简单的帮助是配置Web应用程序在脚本仍然被使用时抛出异常，方法是将以下部分添加到web.xml中：好的。

      1
      2
      3
      4
      5
      6
      <jsp-config>
          <jsp-property-group>
              <url-pattern>*.jsp</url-pattern>
              <scripting-invalid>true</scripting-invalid>
          </jsp-property-group>
      </jsp-config>

      在FACELET中，JSP的继承者，它是JavaEE提供的MVC框架JSF的一部分，已经不可能使用Script。这样你就会自动地被迫以"正确的方式"做事。好的。

    • 如果你想调用一些Java代码来访问和显示一个JSP页面内的"后端"数据，那么你需要使用EL(表达式语言)，那些EDCOX1的2个事物。例如，重新显示提交的输入值：好的。

      1
      <input type="text" name="foo" value="${param.foo}" />

      ${param.foo}显示request.getParameter("foo")的结果。好的。

    • 如果您想在JSP页面中直接调用一些实用Java代码(通常是EDCOX1，5种方法)，那么您需要将它们定义为EL函数。JSTL中有一个标准函数taglib，但是您也可以自己轻松地创建函数。下面是一个JSTLfn:escapeXml如何在防止XSS攻击方面有用的示例。好的。

      1
      2
      3
      <%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
      ...
      <input type="text" name="foo" value="${fn:escapeXml(param.foo)}" />

      请注意，XSS灵敏度与Java/JSP/JSTL/ EL /无论什么无关，在开发的每一个Web应用程序中都需要考虑这个问题。脚本的问题在于它不提供任何预防措施，至少不使用标准的Java API。JSP的后继Facelets已经隐式HTML转义，所以您不必担心Facelets中的XSS漏洞。好的。

    参见：

    • JSP、servlet和JSF有什么区别？
    • servlet、servletcontext、httpsession和httpservletrequest/response如何工作？
    • 带有JSP、servlet和JDBC的基本MVC示例
    • Java Web应用程序中的设计模式
    • JSP/servlet的隐藏特性

    好啊。

    相关讨论

    作为一个disable保障：好的脚本

    为讨论另一个问题是，你可以和我disable脚本应该在你的web.xmlDESCRIPTOR的Web应用。

    我总是这样做为了预防任何脚本开发者增，尤其是在较高的公司，你将失去概述早或以后。"这看起来像是web.xml参数：

    1
    2
    3
    4
    5
    6
    <jsp-config>
      <jsp-property-group>
        <url-pattern>*.jsp</url-pattern>
         <scripting-invalid>true</scripting-invalid>
      </jsp-property-group>
    </jsp-config>
    相关讨论

    conditionals JSTL标记为受害者，循环结束分支等。例如：

    1
    2
    3
    <c:if test="${someAttribute == 'something'}">
       ...
    </c:if>

    JSTL厂与请求属性-他们是必须的或看到的servlet请求一个前锋，这两个操作。

    相关讨论

    在我不确定如果我是正确的。

    你应该读东西的MVC。跳struts MVC &；2是最常见的两种解决方案。

    相关讨论

    你可以使用JSTL标签与EL表达式的两个在一起，避免混杂的Java和HTML代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
    <html>
        <head>
        </head>
        <body>

            <c:out value="${x + 1}" />
            <c:out value="${param.name}" />
            // and so on

        </body>
    </html>

    也有分型框架如Generate小门，很多你的HTML。"这比IP标签的HTML是非常基本的和有virtually没有逻辑，在得到的混合。结果是空的冰状与HTML页面的HTML元素的典型。"是的，下方有很多部件的小门API学习和一些事情可以做……很难达到的，在这些约束。

    MVC模式的代表建筑，JSP视图层。嵌入的Java代码在日本学术振兴会考虑一冰浴的做法。 你可以使用JSTL，FreeMarker，速度与质量为"模板引擎"。 数据提供商《两个框架标记取决于那些对你是有目的的。作为一个Struts 2和webwork实现MVC模式辨别ognl"两个非常有趣的技术expose PIQ置业两豆"。

    有经验的操作shown，有一些缺点，他们有一个很难避免混合标记与实际的代码。

    如果你可以，那么考虑采用专门的技术，你需要做的。在Java EE 6有JSF 2.0，它提供了很多很好的特性，包括Java Bean的gluing一起与JSF页面#{bean.method(argument)}通的方法。

    相关讨论

    如果您只是想避免JSP中的Java编码的缺点，即使使用脚本也可以这样做。只是遵循一些规则，在JSP中有最小的Java，并且在JSP页面中几乎没有计算和逻辑。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <%//instantiate a JSP controller
    MyController clr = new MyController(request, response);

    //process action if any
    clr.process(request);

    //process page forwaring if necessary

    //do all variable assignment here
    String showMe = clr.getShowMe();%>

    <html>
        <head>
        </head>
        <body>
            <form name="frm1">
                <p>
    <%= showMe %>
                <p>
    <% for(String str : clr.listOfStrings()) { %>
                <p>
    <%= str %><% } %>

                // and so on  
            </form>
        </body>
    </html>

    学习和两个customize写你自己使用JSTL标签

    注意，电力危机(exceptions冰运行时重构) 门可能是邪恶的(性能太辛苦，或简单的小应用程序视图层) 例如，从java2s，

    这一定是加了两个Web应用的web.xml

    1
    2
    3
    4
    <taglib>
        <taglib-uri>/java2s</taglib-uri>
        <taglib-location>/WEB-INF/java2s.tld</taglib-location>
    </taglib>

    创建的文件：java2s.tld /WEB-INF /

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    <!DOCTYPE taglib
      PUBLIC"-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
      "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">

    <!-- a tab library descriptor -->
    <taglib xmlns="http://java.sun.com/JSP/TagLibraryDescriptor">
        <tlib-version>1.0</tlib-version>
        <jsp-version>1.2</jsp-version>
        <short-name>Java2s Simple Tags</short-name>

        <!-- this tag manipulates its body content by converting it to upper case
        -->
        <tag>
            <name>bodyContentTag</name>
            <tag-class>com.java2s.BodyContentTag</tag-class>
            <body-content>JSP</body-content>
           
              <name>howMany</name>
            </attribute>
        </tag>
    </taglib>

    下面的代码编译成的Web信息。 java2s COM类。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    package com.java2s;

    import java.io.IOException;
    import javax.servlet.jsp.JspWriter;
    import javax.servlet.jsp.tagext.BodyContent;
    import javax.servlet.jsp.tagext.BodyTagSupport;

    public class BodyContentTag extends BodyTagSupport{
        private int iterations, howMany;

        public void setHowMany(int i){
            this.howMany = i;
        }

        public void setBodyContent(BodyContent bc){
            super.setBodyContent(bc);
            System.out.println("BodyContent = '" + bc.getString() +"'");
        }

        public int doAfterBody(){
            try{    
                BodyContent bodyContent = super.getBodyContent();
                String bodyString  = bodyContent.getString();
                JspWriter out = bodyContent.getEnclosingWriter();

                if ( iterations % 2 == 0 )
                    out.print(bodyString.toLowerCase());
                else
                    out.print(bodyString.toUpperCase());

                iterations++;
                bodyContent.clear(); // empty buffer for next evaluation
            }
            catch (IOException e) {
                System.out.println("Error in BodyContentTag.doAfterBody()" + e.getMessage());
                e.printStackTrace();
            } // end of catch

            int retValue = SKIP_BODY;

            if ( iterations < howMany )
                retValue = EVAL_BODY_AGAIN;

            return retValue;
        }
    }

    启动服务器和负载的bodycontent.jsp在浏览器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    <%@ taglib uri="/java2s" prefix="java2s" %>
    <html>
        <head>
            A custom tag: body content
        </head>
        <body>
            This page uses a custom tag manipulates its body content.Here is its output:
           
                <java2s:bodyContentTag howMany="3">
               
    <li>
    java2s.com
    </li>

                </java2s:bodyContentTag>
           
        </body>
    </html>
    相关讨论

    门冰完全替代，这也取决于separates Java的HTML，所以一个设计师和程序可以工作在不同的集合在一起，学院和大学的小代码理解每个其他。

    面貌的小门。

    你和一个好育问题尽管你得到了很好的答案，我知道的，你摆脱操作。它是outdated科技，eventually将阳极。用现代的方法，类模板引擎。你会有很清楚的分离层和商学院的介绍，不一定与Java代码的模板，所以你可以直接从Generate Web演示文稿模板编辑软件，在大多数情况leveraging所见即所得。

    鸭子一定走开(过滤器和预处理和后处理，否则你可能与支持/调试困难的因为你永远不知道在哪里得到的变量的值。

    相关讨论

    无论您试图避免多少，当您与其他开发人员合作时，他们中的一些人仍然喜欢使用scriptlet，然后将邪恶的代码插入到项目中。因此，如果您真的想减少scriptlet代码，那么在第一个符号处设置项目是非常重要的。有几种方法可以克服这个问题(包括其他提到的几个框架)。但是，如果您喜欢纯JSP方式，那么使用JSTL标记文件。这方面的好处是，您还可以为项目设置母版页，以便其他页面可以继承母版页。

    在WEB-INF/标签下创建一个名为base.tag的母版页，内容如下

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    <%@tag description="Overall Page template" pageEncoding="UTF-8"%>

    <%@attribute name="title" fragment="true" %>

    <html>
      <head>
         
           <jsp:invoke fragment="title"></jsp:invoke>
       

      </head>
      <body>
       
           ....
       
       
          <jsp:doBody/>
       
       
          .....
       
      </body>
    </html>

    在这个母版页上，我创建了一个名为"标题"的片段，这样在子版页中，我可以在母版页的这个位置插入更多的代码。此外，标记将替换为子页的内容。

    在WebContent文件夹中创建子页面(child.jsp)：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <%@ taglib prefix="t" tagdir="/WEB-INF/tags" %>

    <t:base>
        <jsp:attribute name="title">
            <bean:message key="hello.world" />
        </jsp:attribute>

        <jsp:body>
        [Put your content of the child here]
        </jsp:body>  
    </t:base>

    用于指定要使用的母版页(此时为base.tag)。这里的标记中的所有内容将替换您主页上的。您的子页面也可以包含任何标记库，您可以像前面提到的那样正常使用它。但是，如果您在这里使用任何scriptlet代码(<%= request.getParameter("name") %>…)并尝试运行此页，您将得到一个JasperException because Scripting elements ( <%!, <jsp:declaration, <%=, <jsp:expression, <%, <jsp:scriptlet ) are disallowed here。因此，其他人无法将邪恶的代码包含到JSP文件中。

    从控制器调用此页：

    您可以从控制器轻松调用child.jsp文件。这也适用于Struts框架

    为了避免在Java代码的Java JSP文件提供的图书馆现在也把Java类JSTL有IP与JSF来写，你可以为所有的编程结构的形式标记

    在使用JSTL Tag librariesPIQ，这将是完美的工作。

    完全使用jstl标签和电力的表达。

    如果有人真的反对多语言编程，我建议GWT，理论上你可以避免所有的JS和HTML元素，因为Google工具箱将所有的客户端和共享代码转换为JS，你不会对它们有任何问题，所以你有一个没有任何其他语言编码的WebService。甚至你也可以从某个地方使用一些默认的CSS，因为它是由扩展(smartgwt或vaadin)提供的。你不需要学习很多注释。

    当然，如果你愿意的话，你可以深入到代码的深度，注入JS并丰富你的HTML页面，但是如果你愿意的话，你确实可以避免它，并且结果会和其他框架中写的一样好。我说值得一试，而且基本的GWT有很好的文档记录。

    当然，许多程序员同事在此描述或推荐了其他几种解决方案。GWT适用于真正不想处理Web部件或将其最小化的人。

    相关讨论

    Python世界中的一个简洁的思想是模板属性语言；TAL是由Zope(因此，A.K.A)Zope页面模板"，ZPT"引入的，是一个标准，在PHP、XSLT和Java中也有实现(我已经使用了Python／Zope和PHP化身)。在这类模板语言中，上面的一个示例可能如下所示：

    1
    2
    3
    4
    5
    6
    7
    <table>
        <tr tal:repeat="product products">
            <td tal:content="product/name">Example product</td>
            <td tal:content="product/description">A nice description</td>
            <td tal:content="product/price">1.23</td>
        </tr>
    </table>

    代码看起来像普通的HTML(或XHTML)加上XML名称空间中的一些特殊属性；它可以通过浏览器查看，并由设计者安全地进行调整。还支持宏和i18n：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    <h1 i18n:translate="">Our special offers
    <table>
        <tr tal:repeat="product products">
            <td tal:content="product/name"
                i18n:translate="">Example product</td>
            <td tal:content="product/description"
                i18n:translate="">A nice description</td>
            <td tal:content="product/price">1.23</td>
        </tr>
    </table>

    如果内容的翻译可用，则使用它们。

    不过，我对Java实现并不太了解。

    相关讨论

    在JSP中使用脚本不是一个好的实践。

    相反，您可以使用：

  • JSTL标签
  • 表达式
  • 自定义标记-您可以定义自己要使用的标记。

    • 请参考：

  • http://docs.oracle.com/javaee/1.4/tutorial/doc/jstl3.html
  • 埃尔

    • 当然，将<%! counter++; %>替换为事件生产者-消费者体系结构，在该体系结构中，业务层被通知需要增加计数器，它相应地作出反应，并通知演示者，以便他们更新视图。涉及到许多数据库事务，因为将来我们需要知道计数器的新值和旧值，计数器的值是谁增加的，以及考虑到了什么目的。显然涉及到序列化，因为层是完全分离的。你可以在RMI，IIOP，SOAP上增加你的计数器。但只需要HTML，而您不需要实现它，因为这是一个很普通的情况。您的新目标是在新的闪亮E764GB RAM服务器上达到每秒250次的增量。

    我在编程方面有20多年的经验，大多数项目在sexte之前就失败了：可重用性、可替换性、可调试性、可维护性甚至是必需的。其他由只关心功能的人运行的项目非常成功。此外，在项目中过早实现的僵硬的对象结构使代码无法适应规范中的剧烈变化(也称为敏捷)。

    因此，我将定义"层"或冗余数据结构的活动视为拖延，不管是在项目的早期还是在没有特别要求的时候。nbsp；

    从技术上讲，JSP在运行时都转换为servlet。最初创建JSP的目的是按照MVC模式分离业务逻辑和设计逻辑。因此，JSP在运行时在技术上都是Java代码。但是为了回答这个问题，标签库通常用于将逻辑(删除Java代码)应用到JSP页面。

    如果我们使用下面的东西在一个Java Web应用的Java代码，可以从foreground eliminated的操作。

  • 使用MVC架构的Web应用

  • 使用JSP标签

    一个标准的标签。

    定制标记B。

  • 语言表达

    • 如何避免JSP文件中的Java代码？

    除了表达式语言(EL)之外，还可以使用JSTL等选项卡库标记。但是EL与JSP的关系并不好。所以最好完全放弃JSP并使用facelet。

    FACELET是为JSF(Java Server FACTS)设计的第一个非JSP页面声明语言，它为JSF开发人员提供了比JSP更简单和更强大的编程模型。它解决了Web应用程序开发中JSP中出现的不同问题。

    enter image description here

    来源

    相关讨论

    使用scriptlets是一种非常古老的方法，不推荐使用。如果您想直接输出JSP页面中的内容，只需使用表达式语言(EL)和JSTL。

    还有其他的选择，比如使用模板引擎，比如速度、FreeMarker、Thymeleaf等，但是使用普通的JSP和EL和JSTL大多数时候都是我的目的，对于初学者来说，这似乎也是最简单的。

    另外，请注意，在视图层中执行业务逻辑并不是最佳实践，您应该在服务层中执行业务逻辑，并通过控制器将输出结果传递给视图。

    我的朋友，我的建议是将视图(css、html、javascript等)与服务器分离。

    在我的例子中，我使用Angular来处理视图，所需的任何数据都是使用REST服务从服务器获取的。

    相信我，这会改变你的设计方式

    使用主干，角度类似的javascript框架进行用户界面设计并使用RESTAPI获取数据。这将完全从UI中删除Java依赖关系。

    JSP 2.0有一个称为"标记文件"的特性，您可以在没有外部java代码和tld的情况下编写标记。您需要创建一个.tag文件并将其放入WEB-INF\tags中，甚至可以创建一个目录结构来打包标记。

    例如：

    1
    2
    3
    4
    5
    6
    /WEB-INF/tags/html/label.tag

    <%@tag description="Rensders a label with required css class" pageEncoding="UTF-8"%>
    <%@attribute name="name" required="true" description="The label"%>

    <label class="control-label control-default"  id="${name}Label">${name}</label>

    像它一样使用它

    1
    2
    <%@ taglib prefix="h" tagdir="/WEB-INF/tags/html"%>
    <h:label  name="customer name" />

    此外，您还可以轻松阅读标签正文

    1
    2
    3
    4
    /WEB-INF/tags/html/bold.tag
    <%@tag description="Bold tag" pageEncoding="UTF-8"%>

      <jsp:doBody/>

    用它

    1
    2
    <%@ taglib prefix="h" tagdir="/WEB-INF/tags/bold"%>
    <h:bold>Make me bold</h:bold>

    示例非常简单，但您可以在这里执行许多复杂的任务。请考虑您可以使用其他标签(例如：JSTL，它具有控制标签，如if/forEcah/chosen文本操作，如format/contains/uppercase，甚至SQL标签select/update，传递各种参数，如Hashmap、access session、request……也在你的标签文件中。

    标记文件非常容易开发，因为在更改它们(如JSP文件)时不需要重新启动服务器。这使得它们易于开发。

    即使使用struts 2这样的框架，它有很多好的标记，您可能会发现拥有自己的标记可以大大减少代码。您可以将标记参数传递给struts，这样就可以定制您的框架标记。

    您可以使用标签不仅避免Java，还可以最小化HTML代码。我自己试着检查HTML代码，并在看到代码重复出现在我的页面开始时，立即构建很多标记。

    (即使最终在JSP代码中使用Java，但我希望不是这样，您可以将该代码封装在标签中)

  • 在servlet类中生成值和参数
  • 使用jstl/taglib在JSP中获取这些值和参数

    • The good thing about this approach is that your code is also HTML like
    code!

    正如许多答案所说，使用JSTL或创建自己的自定义标记。以下是创建自定义标记的好解释

    通过将JSTL标记与EL表达式一起使用，可以避免这种情况。在JSP页面中放置以下内容：

    1
    2
    3
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>