Struts2学习笔记（十一） 类型转换（Type Conversion）（上）

最新推荐文章于 2022-04-30 18:46:36 发布
最新推荐文章于 2022-04-30 18:46:36 发布
阅读量192 收藏
点赞数
文章标签： java

类型转换概述

把请求参数映射到动作属性的工作是由Parameters拦截器来负责，它是defaultStack拦截器栈中的医院。我们知道，所有的请求参数都是String类型，但是动作的属性却并不都是String类型，那么肯定需要通过某种方式来实现String类型和其他数据类型之间的转换。前面我刚刚学习了OGNL，我们知道通过OGNL能够在拦截器和视图中操作我们的Action成员属性，我们也知道将请求参数映射到Action属性的工作是由Parameters拦截器来实现，那么我们可以推测Struts2正是通过这二者的结合来完成数据类型的转换的。如果我们查看Struts2的源代码，我们就会发现Strtus2确实是通过OGNL的API来实现类型转换的。

OGNL中有一个TypeConversion接口，实现这个类接口的类都可以被当作类型转换器，并且OGNL提供了一个默认的实现类DefaultTypeConversion，这个类通过调用OgnlOps类的converteValue静态方法来实现类型转换：

public static Object convertValue(Object value, Class toType, boolean preventNulls) { Object result = null; if (value != null && toType.isAssignableFrom(value.getClass())) return value; if (value != null) { /* If array -> array then convert components of array individually */ if (value.getClass().isArray() && toType.isArray()) { Class componentType = toType.getComponentType(); result = Array.newInstance(componentType, Array.getLength(value)); for(int i = 0, icount = Array.getLength(value); i < icount; i++) { Array.set(result, i, convertValue(Array.get(value, i), componentType)); } } else if (value.getClass().isArray() && !toType.isArray()) { return convertValue(Array.get(value, 0), toType); } else if (!value.getClass().isArray() && toType.isArray()){ if (toType.getComponentType() == Character.TYPE) { result = stringValue(value).toCharArray(); } else if (toType.getComponentType() == Object.class) { return new Object[] { value }; } } else { if ((toType == Integer.class) || (toType == Integer.TYPE)) { result = new Integer((int) longValue(value)); } if ((toType == Double.class) || (toType == Double.TYPE)) result = new Double(doubleValue(value)); if ((toType == Boolean.class) || (toType == Boolean.TYPE)) result = booleanValue(value) ? Boolean.TRUE : Boolean.FALSE; if ((toType == Byte.class) || (toType == Byte.TYPE)) result = new Byte((byte) longValue(value)); if ((toType == Character.class) || (toType == Character.TYPE)) result = new Character((char) longValue(value)); if ((toType == Short.class) || (toType == Short.TYPE)) result = new Short((short) longValue(value)); if ((toType == Long.class) || (toType == Long.TYPE)) result = new Long(longValue(value)); if ((toType == Float.class) || (toType == Float.TYPE)) result = new Float(doubleValue(value)); if (toType == BigInteger.class) result = bigIntValue(value); if (toType == BigDecimal.class) result = bigDecValue(value); if (toType == String.class) result = stringValue(value); } } else { if (toType.isPrimitive()) { result = OgnlRuntime.getPrimitiveDefaultValue(toType); } else if (preventNulls && toType == Boolean.class) { result = Boolean.FALSE; } else if (preventNulls && Number.class.isAssignableFrom(toType)){ result = OgnlRuntime.getNumericDefaultValue(toType); } } if (result == null && preventNulls) return value; if (value != null && result == null) { throw new IllegalArgumentException("Unable to convert type " + value.getClass().getName() + " of " + value + " to type of " + toType.getName()); } return result; }

Struts2中也有一个DefaultTypeConverter，该类实现了ognl.TypeConverter接口，并且实现了一些常用数据类型的转换。XWorkConverter类继承了DefaultTypconvertor类，并在其中做了一些扩展，正式这些扩展实现了Strtus2特色的自定义类型转换功能。在XworkConverter类中重写了DefaultTypeConverter类的convertValue方法。（具体的细节可以查看XworkConverter类的源码）

public Object convertValue(Map<String, Object> context, Object target, Member member, String property, Object value, Class toClass) { // // Process the conversion using the default mappings, if one exists // TypeConverter tc = null; if ((value != null) && (toClass == value.getClass())) { return value; } // allow this method to be called without any context // i.e. it can be called with as little as "Object value" and "Class toClass" if (target != null) { Class clazz = target.getClass(); Object[] classProp = null; // this is to handle weird issues with setValue with a different type if ((target instanceof CompoundRoot) && (context != null)) { classProp = getClassProperty(context); } if (classProp != null) { clazz = (Class) classProp[0]; property = (String) classProp[1]; } tc = (TypeConverter) getConverter(clazz, property); if (LOG.isDebugEnabled()) LOG.debug("field-level type converter for property [" + property + "] = " + (tc == null ? "none found" : tc)); } if (tc == null && context != null) { // ok, let's see if we can look it up by path as requested in XW-297 Object lastPropertyPath = context.get(ReflectionContextState.CURRENT_PROPERTY_PATH); Class clazz = (Class) context.get(XWorkConverter.LAST_BEAN_CLASS_ACCESSED); if (lastPropertyPath != null && clazz != null) { String path = lastPropertyPath + "." + property; tc = (TypeConverter) getConverter(clazz, path); } } if (tc == null) { if (toClass.equals(String.class) && (value != null) && !(value.getClass().equals(String.class) || value.getClass().equals(String[].class))) { // when converting to a string, use the source target's class's converter tc = lookup(value.getClass()); } else { // when converting from a string, use the toClass's converter tc = lookup(toClass); } if (LOG.isDebugEnabled()) LOG.debug("global-level type converter for property [" + property + "] = " + (tc == null ? "none found" : tc)); } if (tc != null) { try { return tc.convertValue(context, target, member, property, value, toClass); } catch (Exception e) { if (LOG.isDebugEnabled()) LOG.debug("unable to convert value using type converter [#0]", e, tc.getClass().getName()); handleConversionException(context, property, value, target); return TypeConverter.NO_CONVERSION_POSSIBLE; } } if (defaultTypeConverter != null) { try { if (LOG.isDebugEnabled()) LOG.debug("falling back to default type converter [" + defaultTypeConverter + "]"); return defaultTypeConverter.convertValue(context, target, member, property, value, toClass); } catch (Exception e) { if (LOG.isDebugEnabled()) LOG.debug("unable to convert value using type converter [#0]", e, defaultTypeConverter.getClass().getName()); handleConversionException(context, property, value, target); return TypeConverter.NO_CONVERSION_POSSIBLE; } } else { try { if (LOG.isDebugEnabled()) LOG.debug("falling back to Ognl's default type conversion"); return super.convertValue(value, toClass); } catch (Exception e) { if (LOG.isDebugEnabled()) LOG.debug("unable to convert value using type converter [#0]", e, super.getClass().getName()); handleConversionException(context, property, value, target); return TypeConverter.NO_CONVERSION_POSSIBLE; } } } protected void addConverterMapping(Map<String, Object> mapping, Class clazz) { try { String converterFilename = buildConverterFilename(clazz); InputStream is = FileManager.loadFile(converterFilename, clazz); if (is != null) { if (LOG.isDebugEnabled()) { LOG.debug("processing conversion file [" + converterFilename + "] [class=" + clazz + "]"); } Properties prop = new Properties(); prop.load(is); for (Map.Entry<Object, Object> entry : prop.entrySet()) { String key = (String) entry.getKey(); if (mapping.containsKey(key)) { break; } // for keyProperty of Set if (key.startsWith(DefaultObjectTypeDeterminer.KEY_PROPERTY_PREFIX) || key.startsWith(DefaultObjectTypeDeterminer.CREATE_IF_NULL_PREFIX)) { if (LOG.isDebugEnabled()) { LOG.debug("\t" + key + ":" + entry.getValue() + "[treated as String]"); } mapping.put(key, entry.getValue()); } //for properties of classes else if (!(key.startsWith(DefaultObjectTypeDeterminer.ELEMENT_PREFIX) || key.startsWith(DefaultObjectTypeDeterminer.KEY_PREFIX) || key.startsWith(DefaultObjectTypeDeterminer.DEPRECATED_ELEMENT_PREFIX)) ) { TypeConverter _typeConverter = createTypeConverter((String) entry.getValue()); if (LOG.isDebugEnabled()) { LOG.debug("\t" + key + ":" + entry.getValue() + "[treated as TypeConverter " + _typeConverter + "]"); } mapping.put(key, _typeConverter); } //for keys of Maps else if (key.startsWith(DefaultObjectTypeDeterminer.KEY_PREFIX)) { Class converterClass = Thread.currentThread().getContextClassLoader().loadClass((String) entry.getValue()); //check if the converter is a type converter if it is one //then just put it in the map as is. Otherwise //put a value in for the type converter of the class if (converterClass.isAssignableFrom(TypeConverter.class)) { TypeConverter _typeConverter = createTypeConverter((String) entry.getValue()); if (LOG.isDebugEnabled()) { LOG.debug("\t" + key + ":" + entry.getValue() + "[treated as TypeConverter " + _typeConverter + "]"); } mapping.put(key, _typeConverter); } else { if (LOG.isDebugEnabled()) { LOG.debug("\t" + key + ":" + entry.getValue() + "[treated as Class " + converterClass + "]"); } mapping.put(key, converterClass); } } //elements(values) of maps / lists else { Class _c = Thread.currentThread().getContextClassLoader().loadClass((String) entry.getValue()); if (LOG.isDebugEnabled()) { LOG.debug("\t" + key + ":" + entry.getValue() + "[treated as Class " + _c + "]"); } mapping.put(key, _c); } } } } catch (Exception ex) { LOG.error("Problem loading properties for " + clazz.getName(), ex); } // Process annotations Annotation[] annotations = clazz.getAnnotations(); for (Annotation annotation : annotations) { if (annotation instanceof Conversion) { Conversion conversion = (Conversion) annotation; for (TypeConversion tc : conversion.conversions()) { String key = tc.key(); if (mapping.containsKey(key)) { break; } if (LOG.isDebugEnabled()) { LOG.debug(key + ":" + key); } if (key != null) { try { if (tc.type() == ConversionType.APPLICATION) { defaultMappings.put(key, createTypeConverter(tc.converter())); } else { if (tc.rule().toString().equals(ConversionRule.KEY_PROPERTY) || tc.rule().toString().equals(ConversionRule.CREATE_IF_NULL)) { mapping.put(key, tc.value()); } //for properties of classes else if (!(tc.rule().toString().equals(ConversionRule.ELEMENT.toString())) || tc.rule().toString().equals(ConversionRule.KEY.toString()) || tc.rule().toString().equals(ConversionRule.COLLECTION.toString()) ) { mapping.put(key, createTypeConverter(tc.converter())); } //for keys of Maps else if (tc.rule().toString().equals(ConversionRule.KEY.toString())) { Class converterClass = Thread.currentThread().getContextClassLoader().loadClass(tc.converter()); if (LOG.isDebugEnabled()) { LOG.debug("Converter class: " + converterClass); } //check if the converter is a type converter if it is one //then just put it in the map as is. Otherwise //put a value in for the type converter of the class if (converterClass.isAssignableFrom(TypeConverter.class)) { mapping.put(key, createTypeConverter(tc.converter())); } else { mapping.put(key, converterClass); if (LOG.isDebugEnabled()) { LOG.debug("Object placed in mapping for key " + key + " is " + mapping.get(key)); } } } //elements(values) of maps / lists else { mapping.put(key, Thread.currentThread().getContextClassLoader().loadClass(tc.converter())); } } } catch (Exception e) { } } } } } Method[] methods = clazz.getMethods(); for (Method method : methods) { annotations = method.getAnnotations(); for (Annotation annotation : annotations) { if (annotation instanceof TypeConversion) { TypeConversion tc = (TypeConversion) annotation; String key = tc.key(); if (mapping.containsKey(key)) { break; } // Default to the property name if (key != null && key.length() == 0) { key = AnnotationUtils.resolvePropertyName(method); LOG.debug("key from method name... " + key + " - " + method.getName()); } if (LOG.isDebugEnabled()) { LOG.debug(key + ":" + key); } if (key != null) { try { if (tc.type() == ConversionType.APPLICATION) { defaultMappings.put(key, createTypeConverter(tc.converter())); } else { if (tc.rule().toString().equals(ConversionRule.KEY_PROPERTY)) { mapping.put(key, tc.value()); } //for properties of classes else if (!(tc.rule().toString().equals(ConversionRule.ELEMENT.toString())) || tc.rule().toString().equals(ConversionRule.KEY.toString()) || tc.rule().toString().equals(ConversionRule.COLLECTION.toString()) ) { mapping.put(key, createTypeConverter(tc.converter())); } //for keys of Maps else if (tc.rule().toString().equals(ConversionRule.KEY.toString())) { Class converterClass = Thread.currentThread().getContextClassLoader().loadClass(tc.converter()); if (LOG.isDebugEnabled()) { LOG.debug("Converter class: " + converterClass); } //check if the converter is a type converter if it is one //then just put it in the map as is. Otherwise //put a value in for the type converter of the class if (converterClass.isAssignableFrom(TypeConverter.class)) { mapping.put(key, createTypeConverter(tc.converter())); } else { mapping.put(key, converterClass); if (LOG.isDebugEnabled()) { LOG.debug("Object placed in mapping for key " + key + " is " + mapping.get(key)); } } } //elements(values) of maps / lists else { mapping.put(key, Thread.currentThread().getContextClassLoader().loadClass(tc.converter())); } } } catch (Exception e) { } } } } } }

Strtus2通过这个类来实现它特有的类型转换器配置功能，对OGNL做了扩展。OGNL在进行类型转换时会调用OgnlContetxt的getTypeConverter方法来获取类型转换器，通常情况下是Ognl自带的默认类型转换器，Struts2将自己的XWorkConverter设置为OGNL使用的类型转换器，一次来实现对OGNL类型转换的扩展。

类型转换器的查找调用顺序：

(1)检测我们是否设置了自定义类型转换器，如果找到自定义类型转换器，则使用自定义的类型转换器，否则进行下一步

(2)检查defaultTypeConverter(默认类型转换器)属性是否可用，如果可用，则使用默认类型转换器进行转换，否则进行下一步

(3)调用父类DefaultTypeConverter进行类型转换

注：这些调用顺序是覆盖的关系，即执行了(1)就不会再执行(2)，比如我们自定义了int类型的类型转换器，那么不管我们是否能够实现类型转换，它都不会再去使用系统内建的类型转换器了。

内建的类型转换器

Strtus2内建的类型转换器能处理绝大多数的需求，只有在少数情况下需要我们自己自定义类型转换器。关系系统内建的类型转换器的实现可以查看XworkBasicConverter类和EnumTypeConverter类的源码。下面我们就来看看这些内建的类型转换器能够完成哪些工作。

简单类型

Struts2已经内置了基本数据类型及其包装类和其他一些常见的用于表示数字/日期类型的类型转换器，包括：

int/Integer：整数型

short/Short：短整数型

long/Long：长整型

float/Float：浮点型

double/Double：双精度型

boolean/Boolean：布尔型

byte/Byte：字节型

char/Character：字符型

BigInteger：大整数型

BigDecimal：大浮点数型

Date：日期型

Array和List

数组和List在表单提交页面的表示方法并没有差别，只是在Action中声明时有点差别。

HelloWorld.java

public class HelloWorld extends ActionSupport {

private String[] names;

private List<String> list;

//省去set和get方法的定义

public String execute() throws Exception {

return "success";

}

}

input.jsp

<form action="hello.action" method="post">

name1 : <input type="text" name="names"/><br/>

name2 :<input type="text" name="names"><br/>

list:<input type="text" name="list[0]"><br/>

list:<input type="text" name="list[1]"><br/>

<input type="submit" value="submit"/>

</form>

数组和List表单提交页面的表示方式使用上面的两种方式均可。

Map类型

使用Map类型的方式和List相似，区别就是我们需要为Map类型指定key值，即在表单输入界面的表示形式如下：

map:<input type="text" name="map[‘name1’]"><br/>

map:<input type="text" name="map[‘name2’]"><br/>

枚举类型

枚举类型的使用方式和基本数据类型相同，只是限定了只可以输入指定的数据。

普通JaveBean

这个我们在学习Action的时候已经学习过了，就是当我们在Action中使用一个自定的类对象来接收请求参数。那么我只需要在表单提交页面做一些修改就可以让Struts2自动将请求中的参数转移到我们的JavaBean对象上了，这其实就是将复杂对象的属性分开来进行类型转换并填充。这里就不做演示了。

注：这里我们所说的数组、List、Map以及JavaBean的自动类型转换，仅仅限制在他们所包含的对象或属性都是Struts2内建拦截器能够实现类型转换的前提下。如果我们的List中的对象的类型无法使用框架内建的类型转换器来完成，那么还得需要我们自定义类型转换器才行。



zhangll98
关注
Struts2类型转换TypeConverter源码阅读笔记
Joseph_Geeker的博客
01-02 645
在之前值栈的学习中，遗留的一个问题，值栈中保存了action的一些信息，而页面要从值栈取action中的数据，这个过程是怎样实现的？页面上的信息全部都是字符串，而在实际运行中变量的类型是多种多样的，他们之间是怎样完成类型转换的？首先我们要知道，ognl的jar包中的一个接口ognl.TypeConverter，它是做什么的？这个接口的实现类ognl.DefaultTypeConverter是实现og
超全面 struts2 复习总结笔记
宇不语的博客
03-22 7263
前言What ? 最近怎么开始写后端的博客了？ 从去年开始就经常看到别人提“移动开发寒冬”，而年初投简历的时候更是亲身体会，不写3年经验连面试机会都没有，那么没有经验或经验少的人能怎么办呢，从一开就找不到工作怎么可能会有经验？ 然而绝望并没有用，我算运气好，勉强找到一份工作。从趋势来看，近几年移动开发待遇不会很好，今年发现到处缺后端，于是决定还是搞后端吧，因为搞安卓不过一年，后端的知识还没忘完（
StrutsTypeConverter的使用
java_min的专栏
07-03 4466
此类是一个抽象类，使用时需要继承，继承会覆盖此抽象类中的两个方法，使用如下： 输出： 控制台上： 页面上：
Struts2 类型转换
该懂的
07-24 452
1. Struts2  的类型转换，对于8 个原生数据类型以及Date，String  等 常见类型，Struts2可以使用内建的类型转换器实现自动的转换,但对于自定义的对象类型来说，就需要我们自己指定类型转换的方式了。 2. 对于自定义的类型转换器来说需要提供3 个信息：Act
Struts自定义类型转换器
陈铁锋的博客
02-27 457
自定义类型转换器 在处理某些类型时，我们需要自定义类型转换，如：日期（Date）。 转换器类 （1）继承DefaultTypeConverter类 示例如下： 编写类型转化器DateConverter（可以自己定义名称），需要继承DefaultTypeConverter类。 publicclass DateConverter extends DefaultTypeConverte
类型转换Type Conversion
weixin_46471817的博客
06-13 415
类型转换Type Conversion 1.分类：隐式转换、强制转换 2.隐式转换 (1)byte, short, char —> int —>long —> float —> double (2)boolean类型不参与这样的运算 (3)注意：byte, short, char在做运算时，无论遇没遇到int，都会首先提升为int，再参与运算。 (4)byte b = 3 + 4;//这里3和4都是常量，而常量会优先做运算，按int型计算编程7，再参与运算。 3.强制转换 (1)格
第一次学习typescript的基础笔记（1）
怎样过不是过的博客
06-01 360
首先先建一个页Runbood.ts （Tips: 是以.ts） 然后就可以直接在里面写，会有各种写法错误时候的提示，可以直接把我写的文件复制过去 就会看到有想过的错误提示了 // 任意类型 let hht: any = 1; hht = 'I am who I am'; hht = false; let arrayList: any[] = [1, false, 'fine']; // 字符串的使用 let myname: string = "Runoob"; let ...
struts2学习笔记三（第3讲.Struts2的类型转换）
03-20
在本篇“Struts2学习笔记三”中，我们将聚焦于Struts2的类型转换这一核心特性。类型转换在处理用户提交的数据时非常关键，它允许Struts2自动将请求参数转换为Java对象的属性。 在Struts2中，类型转换主要由`...
学习笔记
blessnh的博客
07-21 816
Java笔记1MD5 加密 机密功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 #MD5 -加密 解密 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细
2-1-5 TS日常类型
m0_38066007的博客
04-30 695
基础类型 string, number, boolean, null, undefined 数组类型 Array<T>，T代表数组中的元素类型。 any/unkown/noImplictAny let obj: any = { x: 0 }; // 后续都不会被检查. // `any`屏蔽了所有类型检查，相当于你相信你对程序的理解是高于TS的 obj.foo(); obj(); // 运行时会报错 obj.bar = 100; obj = "hello"; const...
html input null,类型“ null”不可分配给类型“ HTMLInputElement”的ReactJs
weixin_32563347的博客
06-11 1568
我正在尝试将数据与打字稿一起引用到reactJS中。在这样做时，我得到以下错误Type 'null' is not assignable to type 'HTMLInputElement'请让我知道这里到底有什么不正确，我使用了来自React https://reactjs.org/docs/refs-and-the-dom.html的 documentaiton，但我认为我在这里做错了什么。以...
Tornado数据库与表单操作
markshui的博客
08-24 436
Tornado数据库与接口 一、Tornado数据库的操作 tornado torndb是torndb携带的一个数据库操作工具，但是对python3的支持还是有问题，我们 在这里做了一个简单了解 二、torndb使用 安装torndb pip install torndb 安装pymysql pip install pymysql 修改源代码: 在虚拟环境site- packages包打开torndb.py模块文件 Ctrl+r 将所有的MySQLdb 改成pymsyql Ctrl+f
python通过connect对象连接数据库对吗_python-MySQLdb的二三事
weixin_39669147的博客
11-26 269
介绍mysqldb是python操作mysql数据库的一个库．mysql的几乎所有的操作都可以实现，另外，mysqldb的一些比较的option让数据操作更符合pythonic风格．在python2系列使用Mysqldb,在python3系列使用pymysql和mysql.connect.Mysqldb的安装下面按python2系列安装1. pip方式安装pip install MySQL-pyt...
浅学TypeScript（3）——类型机制
衡与墨的博客
12-05 1654
TypeScript 支持的基础类型有这些： Introduction Boolean Number String Array Tuple Enum Any Void Null and Undefined Never Object 具体的使用可以参考Basic Types 写一个demo来测试这些类型 class Types { // boolean private aBoole...
Java---通过属性名反射获取get和set方法
热门推荐
IT云清
01-09 5万+
最近有此需求：拿到name，需要执行setName()方法，这里记录一下，可以当做工具类直接使用:package test; import java.lang.annotation.Annotation; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.math.BigDecimal; i...
修改torndb的源码
change_world_program的博客
08-09 639
连接mysql数据库，首先去百度（python win库）或者进去https://www.lfd.uci.edu/~gohlke/pythonlibs/ 这个连接；搜索到mysqlclient，然后跟你你自己电脑的版本下载需要的版本，进pycharm命令窗输入 pip install +下载好的mysqlclient的路径，安装好之后进入torndb改源码，之后再安装一下pip install p...
typescript报错：类型“ReactNode”的参数不能赋给类型“ReactElement＜any, string | JSXElementConstructor＜any＞＞”的参数，如何解决？
m0_47670683的博客
04-10 1万+
最近在做antd项目，使用typescript写layout组件，通过cloneElement给子组件的props添加initialState中的数据遇到飘红： 类型“ReactNode”的参数不能赋给类型“ReactElement<any, string | JSXElementConstructor<any>>”的参数。 这里涉及到下面两个知识点： ReactNode 这是一种联合类型，可以是string、number、ReactElement、{}、boolean、React
Type Conversion（类型转换）
SeriousLose
01-19 1329
目录一、强制类型转换 和 隐式类型转换二、强制类型转换三、隐式类型转换 一、强制类型转换 和 隐式类型转换 '123' == 123; // true '' == null; // false '' == 0; // true [] == 0; // true [] == ''; // true [] == []; // false [] == ![]; // true [] -> 0 ; ![] -> false -> 0 null == undefin
Struts2类型转换详解：内置转换器与注解使用
在Struts2框架中，类型转换是一个核心功能，因为用户在网页上输入的数据通常以字符串形式存在，而处理这些数据时通常需要将其转换为不同的数据类型。Struts2为此提供了一套便捷的数据类型转换机制，避免了开发者手动...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值