Json时间转Calendar类型，以及Calendar类型对象转json

做项目，之前对外接口是通过webservice发布出去的，现在局方要求通过Http+Json格式发布，在原项目里建servlet实现；

今天碰到的问题是入参中有时间格式为yyyy-mm-dd HH:mm:ss格式的入参，在用JSONObject.toBean(head, Head.class)转为对象的时候，报错；

查了网上的，Date格式的，没找到怎么转Calendar的，自己就照着Date写了一个CalendarMorpher类：

//注册，对时间格式进,转换；

 JSONUtils.getMorpherRegistry().registerMorpher(new CalendarMorpher(new String[] { "yyyy-MM-dd HH:mm:ss" }));
//将json字符串转换为json 
   Head headIn = (Head)JSONObject.toBean(head, Head.class);

然后将入参传入接口，返回的对象里面还是有Calendar格式的；

这次用了JsonConfig，同样写了JsonDateValueProcessor.class

 jsonConfig.registerJsonValueProcessor(java.util.Calendar.class, new JsonDateValueProcessor());      
将参数放入JSON对象里面：

bodyOut.put("NotifyOutList", JSONArray.fromObject(NotifyOut.value, jsonConfig));

此次用的都是json-lib-2.4-jdk15.jar包；

用Ali的fastJson我没成功：

1.用注解：@JSONField (format="yyyy-MM-dd HH:mm:ss")在实体类的参数上加注解，可是返回的还是微秒，是不是和jdk版本有关系？没去深究；

2.用SerializerFeature，或 JSON.toJSONStringWithDateFormat(data, "yyyy-MM-dd HH:mm:ss")

JSON.toJSONString(jsonText,SerializerFeature.WriteDateUseDateFormat);这么出来时间是转了，但是返回的是String，而且是带转义符的，后来找到解决方法了，再加一次转换：

bodyOut.put("NotifyOutList", JSON.parse(JSONArray.toJSONStringWithDateFormat(NotifyOut.value,"yyyy-MM-dd HH:mm:ss")));

3.在传输对象中 把对应的时间属性加上注解

@JsonSerialize(using = CalendarSerializer.class)

private Calendar createTime

这个我写了个CalendarSerializer.class,但是还是没转成..是不是jdk1.6的注解没用？

public class CalendarMorpher extends AbstractObjectMorpher
{
   private Calendar defaultValue;
   private String[] formats;
   private boolean lenient;
   private Locale locale;


   public CalendarMorpher( String[] formats )
   {
      this( formats, Locale.getDefault(), false );
   }


   public CalendarMorpher( String[] formats, boolean lenient )
   {
      this( formats, Locale.getDefault(), lenient );
   }


   public CalendarMorpher( String[] formats, Calendar defaultValue )
   {
      this( formats, defaultValue, Locale.getDefault(), false );
   }

   public CalendarMorpher( String[] formats, Calendar defaultValue, Locale locale, boolean lenient )
   {
      super( true );
      if( formats == null || formats.length == 0 ){
         throw new MorphException( "invalid array of formats" );
      }
      
      this.formats = formats;

      if( locale == null ){
         this.locale = Locale.getDefault();
      }else{
         this.locale = locale;
      }

      this.lenient = lenient;
      setDefaultValue( defaultValue );
   }

  
   public CalendarMorpher( String[] formats, Locale locale )
   {
      this( formats, locale, false );
   }

   
   public CalendarMorpher( String[] formats, Locale locale, boolean lenient )
   {
      if( formats == null || formats.length == 0 ){
         throw new MorphException( "invalid array of formats" );
      }
      
      this.formats = formats;

      if( locale == null ){
         this.locale = Locale.getDefault();
      }else{
         this.locale = locale;
      }

      this.lenient = lenient;
   }

   public boolean equals( Object obj )
   {
      if( this == obj ){
         return true;
      }
      if( obj == null ){
         return false;
      }

      if( !(obj instanceof CalendarMorpher) ){
         return false;
      }

      CalendarMorpher other = (CalendarMorpher) obj;
      EqualsBuilder builder = new EqualsBuilder();
      builder.append( formats, other.formats );
      builder.append( locale, other.locale );
      builder.append( lenient, other.lenient );
      if( isUseDefault() && other.isUseDefault() ){
         builder.append( getDefaultValue(), other.getDefaultValue() );
         return builder.isEquals();
      }else if( !isUseDefault() && !other.isUseDefault() ){
         return builder.isEquals();
      }else{
         return false;
      }
   }

   
   public Calendar getDefaultValue()
   {
      return (Calendar) defaultValue.clone();
   }

   public int hashCode()
   {
      HashCodeBuilder builder = new HashCodeBuilder();
      builder.append( formats );
      builder.append( locale );
      builder.append( lenient );
      if( isUseDefault() ){
         builder.append( getDefaultValue() );
      }
      return builder.toHashCode();
   }

   public Object morph( Object value )
   {
      if( value == null ){
         return null;
      }

      if( Calendar.class.isAssignableFrom( value.getClass() ) ){
         return (Calendar) value;
      }

      if( !supports( value.getClass() ) ){
         throw new MorphException( value.getClass() + " is not supported" );
      }

      String strValue = (String) value;
      SimpleDateFormat dateParser = null;

      for( int i = 0; i < formats.length; i++ ){
         if( dateParser == null ){
            dateParser = new SimpleDateFormat( formats[i], locale );
         }else{
            dateParser.applyPattern( formats[i] );
         }
         dateParser.setLenient( lenient );
         try{
            Date date = dateParser.parse( strValue.toLowerCase() );
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            return calendar;
         }
         catch( ParseException pe ){
            
         }
      }

      
      if( isUseDefault() ){
         return defaultValue;
      }else{
         throw new MorphException( "Unable to parse the date " + value );
      }
   }

   public Class morphsTo()
   {
      return Calendar.class;
   }


   public void setDefaultValue( Calendar defaultValue )
   {
      this.defaultValue = (Calendar) defaultValue.clone();
   }

   public boolean supports( Class clazz )
   {
      return String.class.isAssignableFrom( clazz );
   }
}  

public class JsonDateValueProcessor implements JsonValueProcessor {
    private String format ="yyyy-MM-dd HH:mm:ss";  

	@Override
	public Object processArrayValue(Object value, JsonConfig config) {
		// TODO Auto-generated method stub
		return process(value);
	}

	@Override
	public Object processObjectValue(String key, Object value, JsonConfig config) {
		// TODO Auto-generated method stub
		return process(value);  
	}    
    
	public Object process(Object value){  
        if(value instanceof Calendar){
            SimpleDateFormat sdf = new SimpleDateFormat(format);   
            return sdf.format(((Calendar) value).getTime());
    }
        return value == null ? "" : value.toString();
}
}