【JSP】EL函數和自定義EL函數

時間 2019-11-15

標籤 JSP 函數自定義欄目 JSP 简体版

原文原文鏈接

簡介

EL本來是JSTL1.0中的技術（因此EL和JSTL感情如此好就是天然的了），可是從JSP2.0開始，EL就分離出來歸入了JSP的標準了。可是EL函數仍是和JSTL技術綁定在一塊兒。下面將介紹如何自定義EL函數，以及JSTL中的EL函數。java

自定義EL函數雖然用得不多(JSTL自帶的EL函數已經夠用了)，可是能夠幫助理解自定義tag打下基礎。web

自定義EL函數

1、編寫Java實現函數apache

必須是public類中的public static 函數，每個靜態函數就能夠成爲一個EL函數。
必須在工程的classes下，（Eclipse 的src下），能夠放到單獨的包裏。數組

package custom;

public class Functions
{
     //反轉一個字符串
     public static String reverseString(String str)
     {
          return (new StringBuilder(str).reverse().toString());
     }
     //返回字符串的長度
     public static Integer stringLength(String str)
     {
          return str.length();
     }
}

2、編寫.tld文件（tag library descriptor 標籤庫描述符），註冊EL函數，使之可在JSP中被識別。app

.tld文件能夠放在 WEB-INF下，或者是WEB-INF下的子目錄下

【這裏我取名爲mytag.tld 】

WEB-INF
     --mytag.tld
 
<!--或者 -->

WEB-INF
     --subfolder
           --mytag.tld

<?xml version="1.0" encoding="UTF-8" ?>

<taglib xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"
    version="2.1">

<!--
     tld文件是一個XML文件，他定義了一個tag library。
     這個文件描述了一個標籤庫的相關信息。
     每個tld文件能夠定義多個EL函數，還有自定義標籤。

-->


     <description>這是我本身的標籤庫哦</description>     <!-- 標籤庫的說明信息 -->

     <tlib-version>1.0</tlib-version>                <!-- 定義這個標籤庫的版本 -->

<!--
           定義函數庫做者推薦的(首選的)名稱空間前綴，即在JSP頁面經過taglib指令導入標籤庫時，指定的prefix的值，
           固然，使用者能夠徹底不使用這個值，而是其它的值。
           例如JSTL核心庫前綴是通常是c 。
           <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
-->
     <short-name>nutlee</short-name>

     <!-- 標識這個在互聯網上的惟一地址，通常是做者的網站，這個網址能夠根部不存在對應的資源，但必定要是惟一的。這裏的值用在將在 taglib 指令中 uri的值-->
     <uri>http://www.nutlee.com/jsp-custom</uri>

     <!-- 沒一個function結點 定義一個EL自定義函數 -->
     <function>
          <description>返回一個字符串的長度</description>   <!--函數的功能描述-->

          <!--EL函數名,也就是在JSP頁面中使用時的名稱，他能夠和java代碼中的函數名不同-->
          <name>stringLength</name>

          <!--函數所在的類 -->
          <function-class>custom.Functions</function-class>

          <!-- 函數的簽名 。函數的返回類型和參數類型強烈建議 給出全名，如：java.lang.String -->
          <function-signature>java.lang.Integer stringLength(java.lang.String)</function-signature>
     </function>

     <function>
          <description>反轉一個字符串</description>
          <name>reverseString</name>
          <function-class>custom.Functions</function-class>
          <function-signature>java.lang.String reverseString(java.lang.String)</function-signature>
     </function>

     <!-- 自定義標籤tag也是在這個文件中配置的，後面會講到 -->

</taglib>

3、在web.xml中對標籤庫的位置進行映射（若是將本身的標籤庫打包爲jar文件，則能夠像使用JSTL那樣方便，無需在web.xml中編寫代碼）jsp

<!--省略-->
<jsp-config>
          <taglib>
              <taglib-uri>     <!--taglib指令下的uri屬性的值-->
                   http://www.nutlee.com/jsp-custom
              </taglib-uri>
                               <!--tld文件在工程中的位置-->
               <taglib-location>/WEB-INF/mytag.tld</taglib-location>
          </taglib>

 </jsp-config>

4、在JSP文件中使用ide

<%@taglib uri="http://www.nutlee.com/jsp-custom" prefix="nutlee"%>

<!--省略。。。。-->

反轉字符串${param.msg}:  ${nutlee:reverseString(param.msg)} <br />

字符串長度${param.msg}:  ${nutlee:stringLength(param.msg)}  <br />

<!--省略。。。。-->

打包本身的EL函數庫爲jar文件

若是編寫的EL函數常常使用，能夠打包爲jar文件，這樣拷貝到工程的lib下就能夠導入使用了。自定義標籤庫的打包方法也是如此。函數

步驟：測試

測試完標籤庫，確保OK後，右鍵自定義標籤所在的頂層包，【Export】-->【java】下的【JAR file】網站

而後用解壓軟件打開jar文件，將先前的tld文件添加到META-INF目錄下，這樣就OK了。使用時直接放到lib下，讓後在JSP中導入。

JSTL中自帶的EL函數

導入:

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

${fn:contains(string,substring)}	判斷字符串string中是否包含子串substring，是則返回true，不然false
${fn:containsIgnoreCase(string,substring)}	同上，可是忽略大小寫
${fn:substring(string,beginIndex,endIndex)}	返回一個字符串string指定的起始索引的到結束索引（不包含）之間的子串
${fn:substringAfter(string,substring)}	返回string中第一次出現的substring後面的子字符串 "hello word" , "l" 返回 "lo word"
${fn:substringBefore(string,substring )}	返回string中第一次出現的substring前面的子字符串 "hello word" , "l" 返回 "he"
${fn:endsWith(string,end)}	判斷字符串string是否以字符串end結尾，是則返回true，不然false
${fn:startsWith(string,start)}	判斷字符串string是否以字符串start開始，是則返回true，不然false
${fn:indexOf(string,substring)}	返回substring子串在string中第一次出現的索引，若是找不到則返回-1
${fn:toUpperCase(string)}	返回字符串的大寫形式
${fn:toLowerCase(string)}	返回字符串的小寫形式
${fn:trim(string)}	返回字符串先後的空白符返回
${fn:escapeXml(string)}	對字符串進行轉碼 < < > > & & ' ' " "
${fn:join(stringArray,separatorString)}	將String數組中的字符串使用字符串separatorString鏈接。返回鏈接後的字符串
${fn:split(string , delimiters)}	將字符串string根據指定的分割字符串delimiters來分割成字符串數組返回
${fn:length(squence)}	返回一個字符串的字符數，或者集合中的元素個數
${fn:replace(string, oldStr , newStr )}	將字符串string中的全部的oldStr子字符串替換爲指定的新的字符串newStr並返回。

Apahe的實現源代碼

package org.apache.taglibs.standard.functions;

import java.lang.reflect.Array;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Map;
import java.util.StringTokenizer;
import javax.servlet.jsp.JspTagException;
import org.apache.taglibs.standard.resources.Resources;
import org.apache.taglibs.standard.tag.common.core.Util;

public class Functions
{
  public static String toUpperCase(String input)
  {
    return input.toUpperCase();
  }

  public static String toLowerCase(String input)
  {
    return input.toLowerCase();
  }

  public static int indexOf(String input, String substring)
  {
    if (input == null) {
      input = "";
    }
    if (substring == null) {
      substring = "";
    }
    return input.indexOf(substring);
  }

  public static boolean contains(String input, String substring)
  {
    return indexOf(input, substring) != -1;
  }

  public static boolean containsIgnoreCase(String input, String substring)
  {
    if (input == null) {
      input = "";
    }
    if (substring == null) {
      substring = "";
    }
    String inputUC = input.toUpperCase();
    String substringUC = substring.toUpperCase();
    return indexOf(inputUC, substringUC) != -1;
  }

  public static boolean startsWith(String input, String substring)
  {
    if (input == null) {
      input = "";
    }
    if (substring == null) {
      substring = "";
    }
    return input.startsWith(substring);
  }

  public static boolean endsWith(String input, String substring)
  {
    if (input == null) {
      input = "";
    }
    if (substring == null) {
      substring = "";
    }
    int index = input.indexOf(substring);
    if (index == -1) {
      return false;
    }
    if ((index == 0) && (substring.length() == 0)) {
      return true;
    }
    return index == input.length() - substring.length();
  }

  public static String substring(String input, int beginIndex, int endIndex)
  {
    if (input == null) {
      input = "";
    }
    if (beginIndex >= input.length()) {
      return "";
    }
    if (beginIndex < 0) {
      beginIndex = 0;
    }
    if ((endIndex < 0) || (endIndex > input.length())) {
      endIndex = input.length();
    }
    if (endIndex < beginIndex) {
      return "";
    }
    return input.substring(beginIndex, endIndex);
  }

  public static String substringAfter(String input, String substring)
  {
    if (input == null) {
      input = "";
    }
    if (input.length() == 0) {
      return "";
    }
    if (substring == null) {
      substring = "";
    }
    if (substring.length() == 0) {
      return input;
    }
    int index = input.indexOf(substring);
    if (index == -1) {
      return "";
    }
    return input.substring(index + substring.length());
  }

  public static String substringBefore(String input, String substring)
  {
    if (input == null) {
      input = "";
    }
    if (input.length() == 0) {
      return "";
    }
    if (substring == null) {
      substring = "";
    }
    if (substring.length() == 0) {
      return "";
    }
    int index = input.indexOf(substring);
    if (index == -1) {
      return "";
    }
    return input.substring(0, index);
  }

  public static String escapeXml(String input)
  {
    if (input == null) {
      return "";
    }
    return Util.escapeXml(input);
  }

  public static String trim(String input)
  {
    if (input == null) {
      return "";
    }
    return input.trim();
  }

  public static String replace(String input, String substringBefore, String substringAfter)
  {
    if (input == null) {
      input = "";
    }
    if (input.length() == 0) {
      return "";
    }
    if (substringBefore == null) {
      substringBefore = "";
    }
    if (substringBefore.length() == 0) {
      return input;
    }
    StringBuffer buf = new StringBuffer(input.length());
    int startIndex = 0;
    int index;
    while ((index = input.indexOf(substringBefore, startIndex)) != -1)
    {
      buf.append(input.substring(startIndex, index)).append(substringAfter);
      startIndex = index + substringBefore.length();
    }
    return input.substring(startIndex);
  }

  public static String[] split(String input, String delimiters)
  {
    if (input == null) {
      input = "";
    }
    if (input.length() == 0)
    {
      String[] array = new String[1];
      array[0] = "";
      return array;
    }
    if (delimiters == null) {
      delimiters = "";
    }
    StringTokenizer tok = new StringTokenizer(input, delimiters);
    int count = tok.countTokens();
    String[] array = new String[count];
    int i = 0;
    while (tok.hasMoreTokens()) {
      array[(i++)] = tok.nextToken();
    }
    return array;
  }

  public static int length(Object obj)
    throws JspTagException
  {
    if (obj == null) {
      return 0;
    }
    if ((obj instanceof String)) {
      return ((String)obj).length();
    }
    if ((obj instanceof Collection)) {
      return ((Collection)obj).size();
    }
    if ((obj instanceof Map)) {
      return ((Map)obj).size();
    }
    int count = 0;
    if ((obj instanceof Iterator))
    {
      Iterator iter = (Iterator)obj;
      count = 0;
      while (iter.hasNext())
      {
        count++;
        iter.next();
      }
      return count;
    }
    if ((obj instanceof Enumeration))
    {
      Enumeration enum_ = (Enumeration)obj;
      count = 0;
      while (enum_.hasMoreElements())
      {
        count++;
        enum_.nextElement();
      }
      return count;
    }
    try
    {
      return Array.getLength(obj);
    }
    catch (IllegalArgumentException ex)
    {
      throw new JspTagException(Resources.getMessage("FOREACH_BAD_ITEMS"));
    }
  }

  public static String join(String[] array, String separator)
  {
    if (array == null) {
      return "";
    }
    if (separator == null) {
      separator = "";
    }
    StringBuffer buf = new StringBuffer();
    for (int i = 0; i < array.length; i++)
    {
      buf.append(array[i]);
      if (i < array.length - 1) {
        buf.append(separator);
      }
    }
    return buf.toString();
  }
}

View Code

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。