struts2 数据转换器

四、数据类型的转换（明白原理，实际开发中几乎不用）

      1、开发中的情况：

              实际开发中用户通过浏览器输入的数据都是String或者String[]。

              String/String[]————填充模型(set方法)————>POJO(plain old java object)  pojo中有java的数据类型。

              POJO————————获取(get方法)————>页面展示：String

      2、类型转换情况

               写数据：（增，删，改）都是String或String[]数组转换为其他类型。

              读数据：（查）其他类型转换为String。

      3、Struts2提供的常用类型转换

              a.基本数据类型自动转换。

              b.日期类型：默认按照本地日期格式转换（yyyy-MM-dd）。

              c.字符串数组：默认用逗号+空格，连接成一个字符串。

      4、自定义类型转换器（知道）

                   示例：把日期格式按照 MM/dd/yyyy的格式转换

           4.1、Struts2中的类型转换器结构：

        

/**
 * Interface for accessing the type conversion facilities within a context.
 * 
 * This interface was copied from OGNL's TypeConverter
 * 
 * @author Luke Blanshard (blanshlu@netscape.net)
 * @author Drew Davidson (drew@ognl.org)
 */
public interface TypeConverter
{
    /**
       * Converts the given value to a given type.  The OGNL context, target, member and
       * name of property being set are given.  This method should be able to handle
       * conversion in general without any context, target, member or property name specified.
       * @param context context under which the conversion is being done
       * @param target target object in which the property is being set
       * @param member member (Constructor, Method or Field) being set
       * @param propertyName property name being set
       * @param value value to be converted
       * @param toType type to which value is converted
       * @return Converted value of type toType or TypeConverter.NoConversionPossible to indicate that the
                 conversion was not possible.
     */
    public Object convertValue(Map<String, Object> context, Object target, Member member, String propertyName, Object value, Class toType);
    
    public static final Object NO_CONVERSION_POSSIBLE = "ognl.NoConversionPossible";
    
    public static final String TYPE_CONVERTER_CONTEXT_KEY = "_typeConverter";
}

/**
 * Default type conversion. Converts among numeric types and also strings.  Contains the basic 
 * type mapping code from OGNL.
 * 
 * @author Luke Blanshard (blanshlu@netscape.net)
 * @author Drew Davidson (drew@ognl.org)
 */
public class DefaultTypeConverter implements TypeConverter {

    protected static String MILLISECOND_FORMAT = ".SSS";

    private static final String NULL_STRING = "null";

    private final Map<Class, Object> primitiveDefaults;

    public DefaultTypeConverter() {
        Map<Class, Object> map = new HashMap<Class, Object>();
        map.put(Boolean.TYPE, Boolean.FALSE);
        map.put(Byte.TYPE, Byte.valueOf((byte) 0));
        map.put(Short.TYPE, Short.valueOf((short) 0));
        map.put(Character.TYPE, new Character((char) 0));
        map.put(Integer.TYPE, Integer.valueOf(0));
        map.put(Long.TYPE, Long.valueOf(0L));
        map.put(Float.TYPE, new Float(0.0f));
        map.put(Double.TYPE, new Double(0.0));
        map.put(BigInteger.class, new BigInteger("0"));
        map.put(BigDecimal.class, new BigDecimal(0.0));
        primitiveDefaults = Collections.unmodifiableMap(map);
    }

    public Object convertValue(Map<String, Object> context, Object value, Class toType) {
        return convertValue(value, toType);
    }

    public Object convertValue(Map<String, Object> context, Object target, Member member,
            String propertyName, Object value, Class toType) {
        return convertValue(context, value, toType);
    }
    

public abstract class StrutsTypeConverter extends DefaultTypeConverter {
    public Object convertValue(Map context, Object o, Class toClass) {
        if (toClass.equals(String.class)) {
            return convertToString(context, o);
        } else if (o instanceof String[]) {
            return convertFromString(context, (String[]) o, toClass);
        } else if (o instanceof String) {
            return convertFromString(context, new String[]{(String) o}, toClass);
        } else {
            return performFallbackConversion(context, o, toClass);
        }
    }

    /**
     * Hook to perform a fallback conversion if every default options failed. By default
     * this will ask Ognl's DefaultTypeConverter (of which this class extends) to
     * perform the conversion.
     *
     * @param context
     * @param o
     * @param toClass
     * @return The fallback conversion
     */
    protected Object performFallbackConversion(Map context, Object o, Class toClass) {
        return super.convertValue(context, o, toClass);
    }


    /**
     * Converts one or more String values to the specified class.
     *
     * @param context the action context
     * @param values  the String values to be converted, such as those submitted from an HTML form
     * @param toClass the class to convert to
     * @return the converted object
     */
    public abstract Object convertFromString(Map context, String[] values, Class toClass);

    /**
     * Converts the specified object to a String.
     *
     * @param context the action context
     * @param o       the object to be converted
     * @return the converted String
     */
    public abstract String convertToString(Map context, Object o);
}

DefaultTypeConverter 实现接口 TypeConverTer ；

Struts2TypeConverter 继承了DefaultTypeConverter 

             其它转换器都几乎继承自 Struts2TypeConverter 

      

           4.2、编写类型转换器（编写一个类继承StrutsTypeConverter，实现抽象方法）

             

/**
 * 需求：
 *       把表单中的MM/dd/yyyy格式的数据转成日期类型
 *   把数据库中的本地日期格式，转成MM/dd/yyyy形式输出
 * 
 * 自定义子类转换器：
 *     第一步：编写一个类，继承自StrutsTypeConverter，实现convertFromString，convertToString抽象方法
 * @author zhy
 *
 */
public class MyTypeConvertor extends StrutsTypeConverter {
    
    //定义一个类型转换器
    private DateFormat format = new SimpleDateFormat("MM/dd/yyyy");
    
    /**
     * 把字符串数组中的数据转成日期类型
     * 
     * 方法参数详解：
     *     Map context：是OGNL的上下文对象，我们暂时不知道，所以暂时也不用
     *  String[] values：要转换的数据
     *  Class toClass：目标类型
     */
    public Object convertFromString(Map context, String[] values, Class toClass) {
        //1.先看看有没有数据
        if(values == null || values.length == 0){
            return null;
        }
        //2.取出数组中的第一个元素
        String date = values[0];
        //3.判断目标类型的字节码是不是日期类型
        if(toClass == java.util.Date.class){
            try {
                //4.使用DateFormat进行转换，并且返回转换后的结果
                return format.parse(date);
            } catch (ParseException e) {
                e.printStackTrace();
                return null;
            }
        }
        return null;
    }
    
    /**
     * 把日期类型的数据转换成字符串
     * 
     * 方法参数详解：
     *     Map context：是OGNL的上下文对象，我们暂时不知道，所以暂时也不用
     *  Object o：要转换的数据
     */
    public String convertToString(Map context, Object o) {
        //1.判断object是不是日期类型
        if(o instanceof Date){
            Date date = (Date)o;
            //2.是日期类型，使用转换器转成指定格式的字符串，并返回
            return format.format(date);
        }
        return null;
    }

}

 

           4.3、注册类型转换器

                             局部类型转换器：只能指定javabean中的属性用

                                          按照属性来注册。在属性所属的javabean的包下建立一个.properties文件。文件名称：javabean名称-conversion.properties

#局部类型转换器文件名的命名规范：javabean的名称-conversion.properties
#局部类型转换器声明，声明方式是以使用的属性名称作为key，以类型转换器的全类名作为value
birthday=com.itheima.web.converter.MyTypeConvertor

                            全局类型转换器：（推荐）

                                          按照要转换的数据类型来注册。

                                          at the top op classpath，建立一个固定名称xwork-conversion.properties的属性文件。

#全局类型转换器文件名的命名规范：xwork-conversion.properties。文件放到类路径的根路径
#全局类型转换器声明，声明方式是以使用的数据类型（全类名）作为key，以类型转换器的全类名作为value
java.util.Date=com.itheima.web.converter.MyTypeConvertor

         

      5、转换失败后的处理（需要掌握）

              当转换失败后，页面提示：

      　　　　　　　　一串英文的错误提示

              解决办法：配置回显结果视图　　

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <constant name="struts.devMode" value="true"/>
    <package name="p1" extends="struts-default">
        <action name="register" class="com.itheima.web.action.UserAction" method="register" >
            <result type="redirect">/success.jsp</result><!-- 当注册成功之后重定向的结果视图 -->
            <result name="exists">/message.jsp</result><!-- 当用户名已经存在之后，转向的结果视图 -->
            <!-- 当出现问题之后，需要从哪来回哪去 -->
            <result name="input">/register1.jsp</result>
        </action>
    </package>
</struts>

              问题：

                     配置了回显视图后，当转换失败时，可以回到请求页面，但是表单数据都没了？

                      

                     显示错误提示：借助Struts2的标签库。

                     回显数据：使用struts2的标签库生成表单。（建议使用）

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%--导入struts2的标签库 --%>
<%@ taglib uri="/struts-tags" prefix="s" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>用户注册，使用的是struts2的标签</title>
    <s:head></s:head>
  </head>
  <body>
      <s:actionerror/><%-- 动作错误 --%>
      <s:fielderror /><%-- 字段错误 --%>
      <%--struts2的form标签，它提供了和原始html表单标签几乎一致的属性
          action：请求的地址。直接写动作名称。不用写contextPaht
          method：请求的方式。在这里不用写。struts2的form表单默认就是post
          enctype：表单编码的MIME类型
      --%>
      <s:form action="register.action">
          <s:textfield name="username" label="用户名" requiredLabel="true" requiredPosition="left"/>
          <s:password name="password" label="密码" showPassword="true"/>
          <s:textfield name="birthday" label="生日"/>
          <s:submit value="注册"/>
      </s:form>
  </body>
</html>

    

              错误信息中文提示：使用的是struts2的国际化。

             （在国际化中进行详解）

                    

                     问题：

                            类型转换器当转换失败后，如何进入input视图的？

                     原因：

                            是由一个叫做conversionError的拦截器完成的。

                     注意：

                            要想使用类型转换中的错误处理，在定义Action时必须继承ActionSupport