`
uule
  • 浏览: 6351913 次
  • 性别: Icon_minigender_1
  • 来自: 一片神奇的土地
社区版块
存档分类
最新评论

JSP自定义标签

    博客分类:
  • JSP
 
阅读更多

实际使用:

<td style="text-align: center;">
  	<b:Call type="com.techson.util.DateUtil" method="dateToStr"  var="checkin">
		<b:Param paramclass="java.util.Date"  value="${vo.checkin}" />
		<b:Param paramclass="java.lang.String" value="@dd@-@MMM@-@yy@" />
	</b:Call>
  	${checkin}
</td>

 输出的日期是Date类型,在dateToStr方法中将其格式化并转化为String类型显示,如

标签引入:

<%@ taglib uri="/WEB-INF/utils.tld" prefix="b"%> 

 utils.tld:

<?xml version="1.0" encoding="UTF-8"?>
<taglib version="2.0" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd">
  <tlib-version>1.0</tlib-version>
  <short-name>utils</short-name>
  <uri>/WEB-INF/utils</uri>
  <tag>
    <name>Call</name>
    <tag-class>tags.Call</tag-class>
    <body-content>scriptless</body-content>
    <attribute>
      <name>bean</name>
      <required>false</required>
      <rtexprvalue>true</rtexprvalue>
      <type>java.lang.Object</type>
    </attribute>
    <attribute>
      <name>type</name>
      <required>false</required>
      <rtexprvalue>true</rtexprvalue>
      <type>java.lang.String</type>
    </attribute>
    <attribute>
      <name>method</name>
      <required>true</required>
      <rtexprvalue>true</rtexprvalue>
      <type>java.lang.String</type>
    </attribute>
    <attribute>
      <name>var</name>
      <rtexprvalue>true</rtexprvalue>
      <type>java.lang.String</type>
    </attribute>
    <attribute>
      <name>scope</name>
      <rtexprvalue>true</rtexprvalue>
      <type>java.lang.String</type>
    </attribute>
    <dynamic-attributes>true</dynamic-attributes>
  </tag>

  <tag>
    <name>Param</name>
    <tag-class>tags.ParamTag</tag-class>
    <body-content>empty</body-content>
    <attribute>
      <name>paramclass</name>
      <required>true</required>
      <rtexprvalue>true</rtexprvalue>
      <type>java.lang.String</type>
    </attribute>
    <attribute>
      <name>value</name>
      <required>true</required>
      <rtexprvalue>true</rtexprvalue>
      <type>java.lang.Object</type>
    </attribute>
  </tag>
</taglib>

 tags.ParamTag.java类:

package tags;
import javax.servlet.jsp.JspException;

public class ParamTag extends SimpleTagSupport {

    private java.lang.String _class;
    private java.lang.Object value;
    
    public void doTag() throws JspException {
        StrictTypeParams parent = (StrictTypeParams)findAncestorWithClass(this, StrictTypeParams.class);
		//调用父标签,即b:call
        if (parent == null) {
            throw new JspException("The Param tag is not enclosed by a supported tag type");
        }
        parent.addStrictTypeParameter(this._class, this.value);  
		//addStr..是父标签中方法
        
    }    

    /**
     * Setter for the class attribute.
     */
    public void setParamclass(java.lang.String value) {
        this._class = value;
    }   
    public void setValue(java.lang.Object value) {
        this.value = value;
    }
}

 StrictTypeParams:一个引用父标签的接口

package tags;  
 
	public interface StrictTypeParams {  
		void addStrictTypeParameter(String type, Object value);  
	}  
 

tags.Call.java类:

 * Call.java

package tags;

import java.lang.reflect.Method;

public class Call extends SimpleTagSupport implements DynamicAttributes, StrictTypeParams  {
    
    /**
     * Initialization of bean property.
     */
    private java.lang.Object bean;
    
    private java.lang.String type;
    
    private java.lang.String method;    
   
    private java.lang.String var = null;
   
    private int scope = PageContext.PAGE_SCOPE;
    private List dynamicAttrValues = new ArrayList();
    private List typeList = null;
    
	//doTag()为标签默认执行方法
    public void doTag() throws JspException {
    	
        JspWriter out=getJspContext().getOut();
        try {
            JspFragment f=getJspBody();
            if (f != null) f.invoke(out);
        } catch (java.io.IOException ex) {
            throw new JspException(ex.getMessage());
        }
        boolean isStaticMethod = this.type!=null?true:false;
        Class cls = null;
    	if(isStaticMethod){
    		try {
    			cls = Class.forName(this.type);
    		} catch (ClassNotFoundException e1) {
    			throw new JspException("Class not be found for your type!");
    		}
    	}else{
    		cls = bean.getClass();
    	}
        Method[] methods = cls.getMethods();
        Method m = null;
        Class[] paramTypes = null;
        
        Method : for (int i = 0; i < methods.length; i++ ) {
            Method t = methods[i];
            paramTypes = t.getParameterTypes();  //这个方法的参数类型的集合
            if (t.getName().equals(method) && paramTypes.length == dynamicAttrValues.size()) {
                if (typeList != null){
                    for (int j = 0; j < paramTypes.length; j++){
                        if (!paramTypes[j].getName().equals(typeList.get(j))){
                        	continue Method;
                        }
                    }
                }
                m = t;
                break;
            }
        }
        
        if (m == null)
            throw new JspException("JavaBean Object hasn't no method named '" + method + "'");
        
        try {
            Object coercedValues[] = new Object[paramTypes.length];
            Iterator paramIterator = dynamicAttrValues.iterator();
            for (int i = 0; i < paramTypes.length; i++) {
                Object paramValue = paramIterator.next();
                Class paramClass = paramTypes[i];
                if (paramValue == null || paramValue.getClass() != paramClass)
                    try {
                        paramValue = Coercions.coerce(paramValue, paramClass, null);
                    } catch (ELException e) {
                        throw new JspException(e.getMessage(), e.getRootCause());
                    }
                coercedValues[i] = paramValue;
            }
            Object returnVal = null;
            if(isStaticMethod){
            	returnVal = m.invoke(null, coercedValues);
            }else{
            	returnVal = m.invoke(bean, coercedValues);
            }
            if (var != null)
                if (returnVal != null)
                    getJspContext().setAttribute(var, returnVal, scope);
                else
                    getJspContext().removeAttribute(var, scope);
            
        } catch (Exception ex) {
            ex.printStackTrace();
            throw new JspException("Call method is Error!");
        }
        
    }
    
    /**
     * Setter for the bean attribute.
     */
    public void setBean(java.lang.Object value) throws JspException {
        if (value == null)
            throw new JspException("Null 'bean' attribute in 'Call' tag");
        this.bean = value;
    }
    
    /**
     * Setter for the method attribute.
     */
    public void setMethod(java.lang.String value) throws JspException {
        if (value == null)
            throw new JspException("Null 'method' attribute in 'Call' tag");
        this.method = value;
    }
    
    /**
     * Setter for the var attribute.
     */
    public void setVar(java.lang.String value) throws JspException {
        if (value == null)
            throw new JspException("Null 'var' attribute in 'Call' tag");
        this.var = value;
    }
    
    /**
     * Setter for the scope attribute.
     */
    public void setScope(java.lang.String value) {
        if (value.equalsIgnoreCase("page"))
            scope = PageContext.PAGE_SCOPE;
        else if (value.equalsIgnoreCase("request"))
            scope = PageContext.REQUEST_SCOPE;
        else if (value.equalsIgnoreCase("session"))
            scope = PageContext.SESSION_SCOPE;
        else if (value.equalsIgnoreCase("application"))
            scope = PageContext.APPLICATION_SCOPE;
    }
    
    public void setDynamicAttribute(String uri, String localName, Object value) throws JspException {
        dynamicAttrValues.add(value);
    }

    public void addStrictTypeParameter(String type, Object value) {
        if (typeList == null)
            typeList = new ArrayList();
        typeList.add(type);
        dynamicAttrValues.add(value);
    }

	public void setType(java.lang.String type) {
		this.type = type;
	}
	
	public static void main(String[] agrs) throws ClassNotFoundException, JspException{
	    String type = "com.techson.util.DateUtil";
	    String method="dateDiff";
	    
	   List dynamicAttrValues = new ArrayList();
	   List typeList = new ArrayList();
	   
	   typeList.add("java.lang.Boolean");
       dynamicAttrValues.add(true);
       
       Class cls = Class.forName(type);
       Method[] methods = cls.getMethods();
       Method m = null;
       
       Class[] paramTypes = null;
       Method : for (int i = 0; i < methods.length; i++ ) {
           Method t = methods[i];
           paramTypes = t.getParameterTypes();
           if (t.getName().equals(method) && paramTypes.length == dynamicAttrValues.size()) {
               if (typeList != null){
                   for (int j = 0; j < paramTypes.length; j++){
                       if (!paramTypes[j].getName().equals(typeList.get(j))){
                    	   continue Method;
                       }
                   }
               }
               m = t;
               break;
           }
       }
       if (m == null)
           throw new JspException("JavaBean Object hasn't no method named '" + method + "'");
       
       try {
           Object coercedValues[] = new Object[paramTypes.length];
           Iterator paramIterator = dynamicAttrValues.iterator();
           for (int i = 0; i < paramTypes.length; i++) {
               Object paramValue = paramIterator.next();
               Class paramClass = paramTypes[i];
               System.out.println(paramClass);
               if (paramValue == null || paramValue.getClass() != paramClass)
                   try {
                	   System.out.println(paramValue.getClass() + "/ "+ paramClass);
                       paramValue = Coercions.coerce(paramValue, paramClass, null);
                   } catch (ELException e) {
                       throw new JspException(e.getMessage(), e.getRootCause());
                   }
               coercedValues[i] = paramValue;
           }
           Object returnVal = null;
           	returnVal = m.invoke(null, coercedValues);
           	System.out.print(returnVal);
       } catch (Exception ex) {
           ex.printStackTrace();
           throw new JspException("Call method is Error!");
       }
	}
}

 

处理方法DateUtils.java中方法dateToStr:

public static String dateToStr(Calendar cal , String format) {
		if(format.contains("@y")){
			int _y = cal.get(Calendar.YEAR);
			String _yyyy = new DecimalFormat("0000").format(_y);
			String _yy = _yyyy.substring(2);
			format = format.replaceAll("@[y]{4}@",_yyyy)
			.replaceAll("@[y]{2}@",_yy)
			.replaceAll("@[y]{1}@","" + _y);
		}
		
		if(format.contains("@M")){
			int _M= cal.get(Calendar.MONTH) + 1;
			String _MM = (_M<10)?"0"+_M:"" + _M;
			String _MMM = Constants.MTH[_M - 1];
			format=format.replaceAll("@MMM@",_MMM);
			format=format.replaceAll("@MM@",_MM);
			format=format.replaceAll("@M@","" + _M);
		}
		
		if(format.contains("@d")){
			int _D= cal.get(Calendar.DATE);
			String _DD=(_D<10)?"0"+_D:""+_D;
			format=format.replaceAll("@dd@",_DD);
			format=format.replaceAll("@d@","" +_D);
		}
		
		if(format.contains("@h")){
			int _h=cal.get(Calendar.HOUR_OF_DAY);
			String _hh=(_h<10)?"0"+_h:"" +_h;
			format=format.replaceAll("@hh@",_hh);
			format=format.replaceAll("@h@","" + _h);
		}
		
		if(format.contains("@m")){
			int _m=cal.get(Calendar.MINUTE);
			String _mm=(_m<10)?"0"+_m:""+_m;
			format=format.replaceAll("@mm@",_mm);
			format=format.replaceAll("@m@","" + _m);
		}
		
		if(format.contains("@s")){
			int _s=cal.get(Calendar.SECOND);
			String _ss=(_s<10)?"0"+_s:"" + _s;
			format=format.replaceAll("@ss@",_ss);
			format=format.replaceAll("@s@","" + _s);
		}
		
		if(format.contains("@W")){
			int _W=cal.get(Calendar.DAY_OF_WEEK);
			format=format.replaceAll("@WWW@",Constants.WEEK[_W-1]);
			format=format.replaceAll("@WW@",Constants.WEK[_W-1]);
			format=format.replaceAll("@W@","" + (_W-1));
		}
		return format;
	}
	
	public static String dateToStr(Date d , String format) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(d);
		return dateToStr(cal,format);
	}

参考:http://zengsun.iteye.com/category/25493?show_full=true

http://www.ibm.com/developerworks/cn/java/j-lo-jsp2tag/index.html?ca=drs-

http://blog.csdn.net/zavens/article/details/1685615

 

findAncestorWithClass:

http://www.ibm.com/developerworks/cn/java/j-taglib/

getParameterTypes:

http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Method.html#getParameterTypes%28%29

 

 

 

  • 大小: 510 Bytes
分享到:
评论

相关推荐

    jsp 自定义标签的使用

    本教程将深入探讨JSP自定义标签的使用,同时结合实例介绍分页和下拉框绑定值的封装。 一、JSP自定义标签基础 1. **定义标签库(Tag Library)**:自定义标签首先需要定义一个TLD(Tag Library Descriptor)文件,它...

    jsp 自定义标签实例

    本实例将深入探讨如何实现一个简单的JSP自定义标签。 首先,自定义标签的实现主要依赖于两个核心概念:Tag接口和TagSupport类。`Tag`接口定义了自定义标签必须实现的方法,如`doStartTag()`和`doEndTag()`,它们...

    jsp自定义标签例子,能在Tomcat下直接运行

    在JSP自定义标签的例子中,我们可以看到这个压缩包文件可能包含了一个完整的示例项目,可以在Apache Tomcat这样的Servlet容器下直接运行。Apache Tomcat是一款开源的Servlet容器,广泛用于部署和运行Java Web应用...

    JSP自定义标签学习笔记

    本篇学习笔记将深入探讨JSP自定义标签的相关概念、创建方法以及实际应用。 一、概述 1.1 使用简单标签机制 JSP自定义标签提供了类似HTML标签的语法结构,通过自定义标签,开发者可以封装复杂的Java代码,使得页面...

    jsp自定义标签报错的问题

    在使用JSP自定义标签时,开发者可能会遇到一些报错问题,这通常涉及到项目结构、类路径设置或自定义标签的编译与打包方式。在本文中,我们将深入探讨这些问题,以及如何解决“JspException”这个特定异常。 首先,...

    jsp自定义标签库实现数据列表显示

    本文将详细讲解如何利用JSP自定义标签库实现数据列表的显示,以及涉及到的相关技术。 首先,`UserListTag.java` 是自定义标签的核心类,它继承了`javax.servlet.jsp.tagext.TagSupport` 或 `javax.servlet.jsp....

    JSP自定义标签之自动完成框

    首先,我们要理解JSP自定义标签的概念。自定义标签是JSP的一种扩展机制,它允许开发者创建自己的标签库,以更加清晰和可维护的方式编写页面。自定义标签的实现通常涉及三个主要部分:标签库描述符(TLD)、标签处理...

    JSP自定义标签之日期显示

    本篇将深入探讨“JSP自定义标签之日期显示”,以及如何通过自定义标签来优雅地处理日期格式化和展示。 首先,我们要理解JSP自定义标签的基本概念。自定义标签是JSP的一种扩展,它不是Java内置的标签,而是由开发者...

    权威实用jsp自定义标签demo<select,checkbox,radio>

    综上所述,“权威实用jsp自定义标签demo,checkbox,radio&gt;”教程旨在帮助开发者掌握如何创建和使用与选择器相关的自定义标签,从而提升JSP开发的效率和质量。通过学习这个教程,你可以了解到自定义标签的核心概念、...

    JSP自定义标签JSP自定义标签

    综上所述,JSP自定义标签提供了一种强大的机制,使得JSP开发者能够创建定制的、可重用的代码片段,提升Web应用的开发效率和质量。通过理解和熟练运用自定义标签,开发者可以更好地组织和管理JSP项目,实现更高效的...

    jsp自定义标签编写的分页

    本教程将深入探讨如何利用JSP自定义标签来编写一个灵活、可扩展的分页系统,该系统不依赖于特定的数据库,具有很高的通用性。 首先,理解JSP自定义标签的工作原理至关重要。自定义标签由三部分组成:标签库描述符...

    jsp自定义标签库注意事项

    【jsp自定义标签库注意事项】 在Java服务器页面(JSP)开发中,自定义标签库是一种强大的工具,它能够帮助开发者创建可重用的代码片段,提高代码的可读性和可维护性。以下是对JSP自定义标签库的详细解释和使用注意...

    jsp权限控制,jsp自定义标签实现

    使用jsp自定义标签的功能实现权限的控制。(如果用户没有某个模块的删除权限,就不现实这个删除按钮) 在整个项目中所有的页面都可以引入自定义的标签去做到权限的控制。 自定义标签文件 删除 可以控制页面中的每...

    JSP自定义标签动态属性支持

    首先,我们需要理解JSP自定义标签的基本结构。自定义标签通常由两部分组成:标签库描述符(TLD)和标签处理类。TLD文件定义了标签的名称、属性、行为等元数据,而标签处理类则实现了这些行为,处理由JSP页面传递过来的...

    jsp自定义标签 jsp自定义标签

    jsp自定义标签jsp自定义标签jsp自定义标签jsp自定义标签

    jsp自定义标签大全.rar

    本资源“jsp自定义标签大全.rar”提供了一套全面的JSP自定义标签的实例和指南,旨在帮助开发者深入理解和应用这一特性。 **JSP自定义标签的基本概念** JSP自定义标签不同于标准动作标签(如&lt;jsp:include&gt;或&lt;jsp:...

    JSP自定义标签实例与详细讲解

    本教程将深入探讨JSP自定义标签的实例与详细讲解。 一、JSP自定义标签概述 JSP自定义标签是类似于HTML标签的自定义组件,但它们提供了更强大的功能,可以封装Java代码,提供复杂的业务逻辑。自定义标签通过TLD(Tag...

    由浅到深详细讲解JSP自定义标签

    本文将深入讲解JSP自定义标签的相关概念、格式、处理过程以及创建和使用自定义标签库的基本步骤。 1. 基本概念: - **标签**:JSP标签是XML元素,用于简化JSP页面,使其更易读且支持多语言版本。标签名和属性区分...

Global site tag (gtag.js) - Google Analytics