Struts2中的参数传递

【转自】
本篇主要通过实例来讲述Struts2中各种各样的参数传递。这个参数传递的过程主要指数据从View层传递到Control层时Struts2的工作方式。根据前两篇文章的知识，我们知道，Struts2完成参数传递处理工作的基础是OGNL和ValueStack。而在这个过程中，我也把Struts2所要做的工作大致归纳为两个方面：  

1. 对OGNL操作进行封装，完成OGNL表达式所表示的值到Java对象的值传递机制 

2. 在参数传递的过程中，做恰当的类型转化，保证页面上的字符串能够转化成各式各样的Java对象  

接下来，通过四个不同的角度，来具体讲述Struts2在这两个方面的工作。

最简单的参数传递 

使用OGNL的最基本的功能，就能完成普通的Java对象的赋值工作。Struts2在内部已经完成了OGNL的基本封装。这些封装包括对OGNL表达式到Java对象的赋值机制，以及对基本的Java类型的类型转化支持。这些基本类型包括String、Number（以及其基本类型int、float、double等）、Boolean（boolean）、数组、Class、Date等类型。  

在这里我想额外强调的是XWork对JDK5.0中的Enum类型和Date类型的支持。  

Enum类型  

枚举类型是JDK5.0引入的新特性。枚举类型也能解决很多实际问题，是J2EE编程中的最佳实践之一。XWork中，有一个专门的EnumTypeConverter负责对Enum类型的数据进行转化。  

Java代码   
  1. public class EnumTypeConverter extends DefaultTypeConverter {  
  2.   
  3.     /** 
  4.      * Converts the given object to a given type. How this is to be done is implemented in toClass. The OGNL context, o 
  5.      * and toClass are given. This method should be able to handle conversion in general without any context or object 
  6.      * specified. 
  7.      * 
  8.      * @param context - OGNL context under which the conversion is being done 
  9.      * @param o       - the object to be converted 
  10.      * @param toClass - the class that contains the code to convert to enumeration 
  11.      * @return Converted value of type declared in toClass or TypeConverter.NoConversionPossible to indicate that the 
  12.      *         conversion was not possible. 
  13.      */  
  14.     public Object convertValue(Map context, Object o, Class toClass) {  
  15.         if (o instanceof String[]) {  
  16.             return convertFromString(((String[]) o)[0], toClass);  
  17.         } else if (o instanceof String) {  
  18.             return convertFromString((String) o, toClass);  
  19.         }  
  20.   
  21.         return super.convertValue(context, o, toClass);  
  22.     }  
  23.   
  24.     /** 
  25.      * Converts one or more String values to the specified class. 
  26.      * @param value - the String values to be converted, such as those submitted from an HTML form 
  27.      * @param toClass - the class to convert to 
  28.      * @return the converted object 
  29.      */  
  30.     public java.lang.Enum convertFromString(String value, Class toClass) {  
  31.         return Enum.valueOf(toClass, value);  
  32.     }  
  33.   
  34. }  


有了这个类，我们就可以比较轻松的对枚举类型进行数据赋值了。  

Java代码   
  1. public enum Gender {  
  2.       
  3.     MALE, FEMALE  
  4.   
  5. }  


Html代码   
  1. <form method="post" action="/struts-example/enum-conversion.action">  
  2.     <input type="text" name="user.name" value="downpour" />  
  3.     <select name="user.gender">  
  4.        <option value="MALE">男</option>  
  5.        <option value="FEMALE">女</option>  
  6.     </select>  
  7.     <input type="submit" value="submit" />  
  8. </form>  


Java代码   
  1. public class EnumConversionAction extends ActionSupport {  
  2.   
  3.     private static final Log logger = LogFactory.getLog(Policy.class);  
  4.       
  5.     private User user;  
  6.       
  7.     /* (non-Javadoc) 
  8.      * @see com.opensymphony.xwork2.ActionSupport#execute() 
  9.      */  
  10.     @Override  
  11.     public String execute() throws Exception {  
  12.         logger.info("user's gender:" + user.getGender());  
  13.         return super.execute();  
  14.     }  
  15.       
  16.     // setters and getters  
  17. }  


通过上面的代码，就完成了对枚举类型的赋值。不过这里有一点需要特别指出：那就是XWork在XWork-2.1.X的版本之前，枚举类型不被默认支持。如果你需要获得枚举类型的自动赋值，还需要增加一个配置文件xwork-conversion.properties到classpath下：  
Java代码   
  1. java.lang.Enum=com.opensymphony.xwork2.util.EnumTypeConverter  

对于使用新的版本的XWork的朋友，则不需要增加这个配置文件。  

Date类型  

XWork默认是支持Date类型的转化的。不过从源码上来看，貌似我们很难用上它默认的类型转化。  

Java代码   
  1. private Object doConvertToDate(Map context, Object value, Class toType) {  
  2.         Date result = null;  
  3.   
  4.         if (value instanceof String && value != null && ((String) value).length() > 0) {  
  5.             String sa = (String) value;  
  6.             Locale locale = getLocale(context);  
  7.   
  8.             DateFormat df = null;  
  9.             if (java.sql.Time.class == toType) {  
  10.                 df = DateFormat.getTimeInstance(DateFormat.MEDIUM, locale);  
  11.             } else if (java.sql.Timestamp.class == toType) {  
  12.                 Date check = null;  
  13.                 SimpleDateFormat dtfmt = (SimpleDateFormat) DateFormat.getDateTimeInstance(DateFormat.SHORT,  
  14.                         DateFormat.MEDIUM,  
  15.                         locale);  
  16.                 SimpleDateFormat fullfmt = new SimpleDateFormat(dtfmt.toPattern() + MILLISECOND_FORMAT,  
  17.                         locale);  
  18.   
  19.                 SimpleDateFormat dfmt = (SimpleDateFormat) DateFormat.getDateInstance(DateFormat.SHORT,  
  20.                         locale);  
  21.   
  22.                 SimpleDateFormat[] fmts = {fullfmt, dtfmt, dfmt};  
  23.                 for (int i = 0; i < fmts.length; i++) {  
  24.                     try {  
  25.                         check = fmts[i].parse(sa);  
  26.                         df = fmts[i];  
  27.                         if (check != null) {  
  28.                             break;  
  29.                         }  
  30.                     } catch (ParseException ignore) {  
  31.                     }  
  32.                 }  
  33.             } else if (java.util.Date.class == toType) {  
  34.                 Date check = null;  
  35.                 SimpleDateFormat d1 = (SimpleDateFormat) DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.LONG, locale);  
  36.                 SimpleDateFormat d2 = (SimpleDateFormat) DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM, locale);  
  37.                 SimpleDateFormat d3 = (SimpleDateFormat) DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, locale);  
  38.                 SimpleDateFormat rfc3399 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");  
  39.                 SimpleDateFormat[] dfs = {d1, d2, d3, rfc3399}; //added RFC 3339 date format (XW-473)  
  40.                 for (int i = 0; i < dfs.length; i++) {  
  41.                     try {  
  42.                         check = dfs[i].parse(sa);  
  43.                         df = dfs[i];  
  44.                         if (check != null) {  
  45.                             break;  
  46.                         }  
  47.                     }  
  48.                     catch (ParseException ignore) {  
  49.                     }  
  50.                 }  
  51.             }  
  52.             //final fallback for dates without time  
  53.             if (df == null) {  
  54.                 df = DateFormat.getDateInstance(DateFormat.SHORT, locale);  
  55.             }  
  56.             try {  
  57.                 df.setLenient(false); // let's use strict parsing (XW-341)  
  58.                 result = df.parse(sa);  
  59.                 if (!(Date.class == toType)) {  
  60.                     try {  
  61.                         Constructor constructor = toType.getConstructor(new Class[]{long.class});  
  62.                         return constructor.newInstance(new Object[]{new Long(result.getTime())});  
  63.                     } catch (Exception e) {  
  64.                         throw new XWorkException("Couldn't create class " + toType + " using default (long) constructor", e);  
  65.                     }  
  66.                 }  
  67.             } catch (ParseException e) {  
  68.                 throw new XWorkException("Could not parse date", e);  
  69.             }  
  70.         } else if (Date.class.isAssignableFrom(value.getClass())) {  
  71.             result = (Date) value;  
  72.         }  
  73.         return result;  
  74.     }  


这段代码就是XWork处理将String转成Date类型的过程，从整个过程上来看，我们很难用上这段代码，因为我们在界面上的Date类型的表现形式往往是：'yyyy-MM-dd'或者相关的形式，很明显，上面的流程无法匹配这样的日期类型。  

所以，针对Date，我们往往会自定义一个日期转化的类进行处理，这个在下面会有具体的介绍。

Array、List、Map等容器类型的参数传递 

除了简单的基于JavaBean方式的参数传递支持，Struts2还支持对Array、List、Map等容器类型的数据结构做数据赋值。不过历史一路走来，XWork针对容器类型的数据赋值一直有变化，让我们慢慢解读这些变化，从而也来看看编程思路是如何改变的。  

1. 2004年，XWork-1.0.X的年代  

当时XWork所支持的针对容器的数据赋值还比较土。这方面moxie在论坛上有一篇文章专门来讲述： http://www.iteye.com/topic/8770。  

总的来说，那个年代对于容器的数据赋值，需要依赖于XWork的辅助类。我们可以看到，如果你要对List进行赋值，需要新建一个XWorkList的实现类，并把所需要进行数据赋值的Java类传递到XWorkList的构造函数中。而对Map等对象的赋值，也同理可得。  

这种数据赋值的方式的优缺点都非常明显。优点在于 简单，你不需要额外定义任何其他的内容，而是直接使用XWork的辅助类来实现类型转化。缺点在于 扩展性很弱，很明显，针对某一个具体的容器，就需要一个XWork的实现类，List有XWorkList对应，Map有XWorkMap对应。甚至在那个时候，还没有Set的支持，因为没有XWorkSet的实现。所以使用这种方式，在扩展性方面需要遭受严重的考验。  

2. 2006年，XWork-2.0.X的年代  

也许是XWork团队看到了扩展性上的问题，所以在XWork和Webwork同时升级以后，采用了新的方式来处理容器赋值。而此时，Javaeye上也涌现出了新的文章，Tin同学对新的方式做了详细的表述： http://www.iteye.com/topic/17939。  

不过这个新的整合方式似乎并不被大家所看好。  

lllyq 写道
我觉得XWorkList, XWorkMap还是很有用的，挺好的设计，其实没有必要deprecated。


moxie 写道
集合支持不向下兼容。XWorkList已经是@deprecated，用它就错，还不如直接删除掉。在webwork2.2中，它需要为集合另外配置一个conversion.properties文件。真不明白，这样有什么优点？


这种新的整合方式，实际上只是解决了针对容器赋值，不需要依赖XWork的辅助类这样的一个问题，不过其付出的代价，却是多了一个配置文件，这也让人非常郁闷。好好的类型转化，平白无故多出了一个同package下的配置文件，这也无形中增加了编程的复杂度。  

3. 现在，拥抱了泛型和Annotation的年代  

实际上，在XWork发展到XWork-2.0.X之后，也开始注重了对泛型和Annotation的支持。所以，容器类型的转化，我们也可以尝试一下使用JDK的新特性来进行，当然这也是目前最为推荐的做法。  

下面分别给出使用泛型和Annotation的代码示例：  

Html代码   
  1. <form method="post" action="/struts-example/ognl-collection-conversion.action">  
  2.     <input type="text" name="users[0].name" value="aaa" />  
  3.     <input type="text" name="users[1].name" value="bbb" />  
  4.     <input type="text" name="users2[0].name" value="ccc" />  
  5.     <input type="text" name="users2[1].name" value="ddd" />  
  6.     <input type="text" name="userMap['user1'].name" value="eee" />  
  7.     <input type="text" name="userMap['user2'].name" value="fff" />  
  8.     <input type="text" name="userMap2['user3'].name" value="ggg" />  
  9.     <input type="text" name="userMap2['user4'].name" value="hhh" />  
  10.     <input type="submit" value="submit" />  
  11. </form>  


Java代码   
  1. public class OgnlConversionAction extends ActionSupport {  
  2.   
  3.     private static final long serialVersionUID = 4396125455881691845L;  
  4.   
  5.     private static final Log logger = LogFactory.getLog(Policy.class);  
  6.       
  7.     private List<User> users;  
  8.       
  9.     @Element(value = User.class)  
  10.     private List users2;  
  11.       
  12.     private Map<String, User> userMap;  
  13.       
  14.     @Element(value = User.class)  
  15.     private Map userMap2;  
  16.       
  17.     /* (non-Javadoc) 
  18.      * @see com.opensymphony.xwork2.ActionSupport#execute() 
  19.      */  
  20.     @Override  
  21.     public String execute() throws Exception {  
  22.           
  23.         // -> aaa  
  24.         logger.info("users[0].name : " + users.get(0).getName());  
  25.         // -> bbb  
  26.         logger.info("users[1].name : " + users.get(1).getName());  
  27.         // -> ccc  
  28.         logger.info("users2[0].name : " + ((User)users2.get(0)).getName());  
  29.         // -> ddd  
  30.         logger.info("users2[1].name : " + ((User)users2.get(1)).getName());  
  31.           
  32.         // -> [user1, user2]  
  33.         logger.info("userMap.key : " + userMap.keySet());  
  34.         // -> eee  
  35.         logger.info("userMap.key = " + "user1" + " : " + "userMap.value(user1's name) = " + userMap.get("user1").getName());  
  36.         // -> fff  
  37.         logger.info("userMap.key = " + "user2" + " : " + "userMap.value(user2's name) = " + userMap.get("user2").getName());  
  38.         // -> [user3, user4]  
  39.         logger.info("userMap2.key : " + userMap2.keySet());  
  40.         // -> ggg  
  41.         logger.info("userMap2.key = " + "user3" + " : " + "userMap.value(user3's name) = " + ((User)userMap2.get("user3")).getName());  
  42.         // -> hhh  
  43.         logger.info("userMap2.key = " + "user4" + " : " + "userMap.value(user4's name) = " + ((User)userMap2.get("user4")).getName());  
  44.           
  45.         return super.execute();  
  46.     }  
  47.       
  48.     // setters and getters  
  49. }  


上面的代码中，我们可以看到，如果你使用泛型，那么你无需再使用任何额外的配置文件或者Annotation，XWork会把一切都为你准备好。如果你没有使用泛型，那么你可以使用Annotation来指定你需要进行转化的对象类型。其中，对Map对象使用Annotation时，Element中的value所对应的值，是Map中的value所对应的class。  

由此可见，泛型和Annotation，在一定程度上，还是可以简化我们很多工作的。  

文件上传 

文件上传其实也是参数传递的一种，所以从方案上来讲，Struts2同样使用了一个拦截器来处理。而这个拦截器，同样来自于原来的Webwork，基本上没有做什么很大的改变。有关这个拦截器的详细内容，我们也留一个悬念，在后续章节中详细讲解。目前，你只要知晓，这个拦截器能帮助你完成一切文件上传相关的机制。  

早在2005年，Quake Wang就对Webwork的文件上传机制有了详细的讲解： http://www.iteye.com/topic/10697  

在这里我简单小结一下在进行文件上传时的三大要点：  

1. 在配置文件上传时，拦截器的顺序非常关键  

Xml代码   
  1. <interceptor-stack name="uploadStack">    
  2.     <interceptor-ref name="upload"/>                    
  3.     <interceptor-ref name="defaultStack"/>    
  4. </interceptor-stack>  


具体来说， upload的拦截器，必须在params的拦截器之前  

2. 拦截器额外提供了一些额外的文件信息  

Quake Wang 写道
ContentType: 文件的ContentType(可以用在做download的时候)  
FileName: 实际的文件名  
在上面的action例子里, 那么有uploadFilesContentType和uploadFilesFileName这2个属性, 也能够被自动绑定


3. 拦截器提供的文件上传功能，你得到的是一个临时文件  

robbin 写道
在webwork的file upload 拦截器功能中，它提供的File只是一个临时文件，Action执行之后就会被自动删除，因此你必须在Action中自己出来文件的存储问题，或者写到服务器的某个目录，或者保存到数据库中。如果你准备写到服务器的某个目录下面的话，你必须自己面临着处理文件同名的问题


而时代发展到Struts2的年代，对于文件上传的整体机制没有做什么改变。只是Struts2将apache的common-fileupload作为了其默认的文件上传的机制。  

例子归例子，实际情况中，我们还是会遇到一些问题：  

1. 默认实现中，文件和文件信息是分开表述的，对于后台处理来说，不是非常方便  

2. common-fileupload的实现，虽然提供了文件上传的机制，也可以让你得到文件的一些属性信息，但是它无法得到客户端的上传路径  

对于第一个问题，我们可以使用OGNL的特性，将这些文件和文件名等文件信息做封装：  

Java代码   
  1. public class FileComponent implements Serializable {  
  2.   
  3.     private static final long serialVersionUID = 4594003082271182188L;  
  4.   
  5.     private File upload;  
  6.   
  7.     private String fileName;  
  8.       
  9.     /** 
  10.      * The default constructor 
  11.      */  
  12.     public FileComponent() {  
  13.   
  14.     }  
  15.   
  16.     /** 
  17.      * @return Returns the upload. 
  18.      */  
  19.     public File getUpload() {  
  20.         return upload;  
  21.     }  
  22.   
  23.     /** 
  24.      * @return Returns the fileName. 
  25.      */  
  26.     public String getFileName() {  
  27.         return fileName;  
  28.     }  
  29.       
  30.     /** 
  31.      * @param upload 
  32.      *            The upload to set. 
  33.      */  
  34.     public void setUpload(File upload) {  
  35.         this.upload = upload;  
  36.     }  
  37.   
  38.     /** 
  39.      * @param fileName 
  40.      *            The fileName to set. 
  41.      */  
  42.     public void setFileName(String fileName) {  
  43.         this.fileName = fileName;  
  44.     }  
  45.   
  46.     /** 
  47.      * @param fileName 
  48.      *            The fileName to set. 
  49.      */  
  50.     public void setUploadFileName(String uploadFileName) {  
  51.         this.fileName = uploadFileName;  
  52.     }  
  53. }  


在这个类中，我定义了upload表示上传的文件，fileName表示上传文件的文件名。请注意我整个文件中的最后一个方法：setUploadFileName。这个方法将保证FileUploadInterceptor在运行时，能够正确设置上传的文件名。  

Java代码   
  1. /** 
  2.  * @param fileName 
  3.  *            The fileName to set. 
  4.  */  
  5. public void setUploadFileName(String uploadFileName) {  
  6.     this.fileName = uploadFileName;  
  7. }  


这样，在Action中，我们将面对一个个完整的fileComponent对象，其中包括文件的引用、文件名称和其他文件信息。这样就不会因为上传多个文件而手足无措，你只需要使用fileComponent数组，就能轻松对上传的文件进行管理，而避免了在Action中书写许多个文件、文件名等属性了。  

对于第二个问题，目前我也没有找到很好的方法。我所采用的方式与Yulimin是一致的：  

Yulimin 写道
我现在的做法是表单中增加了一个隐藏域，当用户文件选择后，利用JS截取到用户选择的文件名，然后一起提交上去。  
不知道有没有最终的解决方法？

自定义的类型转化实现 

Struts2在处理参数传递的过程中，需要完成类型转化，保证页面上的字符串能够转化成各式各样的Java对象。而这一点，其实也是由OGNL完成的。还记得我们在讲述OGNL的基础知识的时候列出来过的一个接口嘛？  

Java代码   
  1. /** 
  2.  * Appends the standard naming context for evaluating an OGNL expression 
  3.  * into the context given so that cached maps can be used as a context. 
  4.  * 
  5.  * @param root the root of the object graph 
  6.  * @param context the context to which OGNL context will be added. 
  7.  * @return Context Map with the keys <CODE>root</CODE> and <CODE>context</CODE> 
  8.  *         set appropriately 
  9.  */  
  10. public static Map addDefaultContext( Object root, ClassResolver classResolver, TypeConverter converter, MemberAccess memberAccess, Map context );  


在这个接口中，我们可以在使用OGNL的时候，注册针对某个Class级别的自己实现的TypeConverter，这样，OGNL就会在进行设值计算和取值计算的时候，使用自定义的类型转化方式了。让我们来看看TypeConverter的接口定义：  

Java代码   
  1. /** 
  2.  *  context - OGNL context under which the conversion is being done 
  3.  *  target - target object in which the property is being set 
  4.  *  member - member (Constructor, Method or Field) being set 
  5.  *  propertyName - property name being set 
  6.  *  value - value to be converted 
  7.  *  toType - type to which value is converted  
  8.  */  
  9. public Object convertValue(Map context, Object target, Member member, String propertyName, Object value, Class toType);  


知道了原理，就简单了，我们可以自己实现一个TypeConverter的实现类，并且在Struts2中注册一下使用这个TypeConverter的Java类型的对应关系，我们就可以完成自定义的类型转化了。  

具体的例子，可以参考一下Quake Wang同学在2005年时的一篇文章： http://www.iteye.com/topic/10507。文章针对的是Webwork2，但是无论是实现方式还是操作步骤，与Struts2是完全相同的。值得提醒的是，这篇文章的回复也非常有价值，在看文章的同时，不要忘记看回复。  

不过针对Quake Wang的例子，我也想做一些补充。它的例子中，主要讲述了Struts2中如何去做java.utils.Date的自动类型转化，也正如后面回复中有人提到：  
wolfsquare 写道
如果我在界面上有两种格式的日期怎么办?  
例如一种短格式: SimpleDateFormat("yyyy-mm-dd"),一种长格式SimpleDateFormat("yyyy-mm-dd hh:MM:ss")

而Quake Wang对此是这样解决的：  
Quake Wang 写道
可以根据你的应用情况，看哪种方式是比较常见的转换规则，那么把这个规则定成Application-wide conversion rules：  
Java代码   
  1. 在classpath root下面写一个xwork-conversion.properties:  
  2. java.util.Date=com.javaeye.core.webwork.converter.DateConverter   

另外的一个转换，可以写成Class-specific conversion rules :  
otherDate=com.javaeye.core.webwork.converter.OtherDateConverter


我在这里提供一个我在实际项目中采用的方式：  

Java代码   
  1. public class DateConverter extends DefaultTypeConverter {  
  2.   
  3.     private static final Log logger = LogFactory.getLog(DateConverter.class);  
  4.   
  5.     private static final String DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";  
  6.   
  7.     private static final String DATE_PATTERN = "yyyy-MM-dd";  
  8.       
  9.     private static final String MONTH_PATTERN = "yyyy-MM";  
  10.   
  11.     /** 
  12.      * Convert value between types 
  13.      */  
  14.     public Object convertValue(Map ognlContext, Object value, Class toType) {  
  15.         Object result = null;  
  16.         if (toType == Date.class) {  
  17.             result = doConvertToDate(value);  
  18.         } else if (toType == String.class) {  
  19.             result = doConvertToString(value);  
  20.         }  
  21.         return result;  
  22.     }  
  23.   
  24.     /** 
  25.      * Convert String to Date 
  26.      *  
  27.      * @param value 
  28.      * @return 
  29.      */  
  30.     private Date doConvertToDate(Object value) {  
  31.         Date result = null;  
  32.   
  33.         if (value instanceof String) {  
  34.   
  35.             // TODO add date converter parse order here  
  36.             result = DateUtils.parseDate((String) value, new String[] { DATE_PATTERN, DATETIME_PATTERN, MONTH_PATTERN });  
  37.   
  38.             // all patterns failed, try a milliseconds constructor  
  39.             if (result == null && StringUtils.isNotEmpty((String)value)) {  
  40.   
  41.                 try {  
  42.                     result = new Date(new Long((String) value).longValue());  
  43.                 } catch (Exception e) {  
  44.                     logger.error("Converting from milliseconds to Date fails!");  
  45.                     e.printStackTrace();  
  46.                 }  
  47.   
  48.             }  
  49.   
  50.         } else if (value instanceof Object[]) {  
  51.             // let's try to convert the first element only  
  52.             Object[] array = (Object[]) value;  
  53.   
  54.             if ((array != null) && (array.length >= 1)) {  
  55.                 value = array[0];  
  56.                 result = doConvertToDate(value);  
  57.             }  
  58.   
  59.         } else if (Date.class.isAssignableFrom(value.getClass())) {  
  60.             result = (Date) value;  
  61.         }  
  62.         return result;  
  63.     }  
  64.   
  65.     /** 
  66.      * Convert Date to String 
  67.      *  
  68.      * @param value 
  69.      * @return 
  70.      */  
  71.     private String doConvertToString(Object value) {  
  72.         SimpleDateFormat simpleDateFormat = new SimpleDateFormat(DATETIME_PATTERN);  
  73.         String result = null;  
  74.         if (value instanceof Date) {  
  75.             result = simpleDateFormat.format(value);  
  76.         }  
  77.         return result;  
  78.     }  
  79. }  


在我采用的方式中，依然采用Application-wide conversion rules，只是在自定义的Converter中，根据不同的日期形式进行逐个匹配，找到第一个匹配的日期类型进行转化。当然，这是一种投机取巧的办法，不过比较实用，适用于项目中不太使用国际化，日期的形式不太复杂的情况。

你可能感兴趣的:(struts2)

  • SpringMVC架构介绍 丹_妮 spring
    MVC框架要做的事情？1)将url映射到java类或java类的方法2)封装用户提交的数据3)处理请求-调用相关的业务处理-封装响应数据4)将响应的数据进行渲染jsphtml为什么要学习SpringMVC？性能较struts2好简单、便捷、易学天生和Spring无缝集成，使用Spring的IOC和AOP还有事务使用约定由于配置能够进行简单的junit测试支持restful风格异常处理本地化、国际化
  • 如何进行架构技术方案选型? 猫咪张 系统架构设计strutsspringmvcjsf架构设计ejb
    在架构设计时,通常面临的一个难题是,如何选择架构的技术方案.这也是各种项目都会碰到的问题.我们到底是选择C/S，B/S模式，如果选择C/S,那么到底是三层C/S还是两层，到底要不要分布式，B/S的展示层是自己写MVC，还是应用已有的开源的如SpringMVC，Struts2.0,JSF技术。总之，可选的确实是太多了。那么怎么去选择呢？这个问题确实有点难，但也有解决方法的。首先，我们需要研究我们项目
  • Apache Struts2 S2-005 远程代码执行漏洞 夭-夜 strutsapachejava
    文章目录基础知识一、通过BUMP构造数据包1.repeater模块构造post包2.浏览器访问以下链接二、反弹shell1.开启监听2.构造数据包总结基础知识ApacheStruts2ApacheStruts2框架是一个用于开发JavaEE网络应用程序的Web框架，质上相当于一个servlet，在MVC设计模式中，Struts2作为控制器(Controller)来建立模型与视图的数据交互。Stru
  • Java编程开发新手学习：数组方法的应用猜字母游戏 Java小辰
    Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。给你学习路线：html-css-js-jq-javase-数据库-jsp-servlet-Struts2-hibernate-mybatis-spring4-springmv
  • 现在程序员这么多，我学习java这块应该学到什么程度才能不被淘汰呢？ 渡你眉间山河
    一、夯实基础JavaSE这是基础，一定要好好学习！Java语法，面向对象（包括类、对象、方法、继承、封装、抽象、多态、消息解析等），常见API，数据结构，集合框架，设计模式（包括创建型、结构型、行为型），多线程和并发，I/O流，Stream，网络编程。JavaEEJavaEE是在JavaSE的基础上构建的，JavaEE容器，Web容器，常用框架（包括Struts2、Hibernate、Mybati
  • JAVA Web学习(20)___第14章Struts2基础 岁月静好浅笑安然
    第14章Struts2基础14.1Struts2概述14.1.1理解MVC原理14.1.2Struts2框架的产生14.1.3Struts2的结构体系14.2Struts2入门14.2.1Struts2的获取与放置开发struts项目必须添加的类库文件名称说明struts2-core-2.5.20.jarStruts2的核心类库xwork-core-2.1.6.jarXworkd的核心类库ognl
  • struts2_ognl入门 小漫画ing
    ognl的概述：1、之前在web阶段，学过el表达式，el表达式在jsp中获取域对象中的值。2、ognl也是一种表达式，而这个种表达式的功能更加强大。（1）在struts里面操作只栈数据。（2）一般把OGNL在Struts2操作，和Struts2标签一起使用操作值栈。3、OGNL不是Struts2的一部分，单独项目，经常和Struts2一起使用而已。（1）使用OGNL时候首先导入jar包，Stru
  • SSH框架之Spring+Struts2+Hibernate整合篇 小小一技术驿站
    回顾-Hibernate框架ORM:对象关系映射.把数据库表和JavaBean通过映射的配置文件映射起来,操作JavaBean对象,通过映射的配置文件生成SQL语句,自动执行.操作数据库.1:类名.hbm.xml映射配置文件.2:hibernate.cfg.xml核心配置文件.3:使用Hibernate提供的API操作.Struts2框架:和客户端进行交互1.在web.xml配置过滤器.2.str
  • Struts2中的action中result中的type有哪些类型 阿立聊代码 strutsstruts2.0
    Struts2框架默认配置中已经提供了很多的result类型，可以打开struts-default.xml配置文件来查看。chain：Action链式处理的结果类型，也就是将结果转发到这个action中。chart：整合JFreeChart的结果类型dispatcher：用于整合JSP的结果类型freemarker：用于整合freemarker结果类型。httpheader：用于控制特殊的HTTP
  • java进阶学习第一天_Java全栈开发springmvc学习笔记第一天 35612123 java进阶学习第一天
    SpringmvcJavaEE体系结构什么是mvc？原始的mvc：Mvc：什么springmvc？Springmvc是一个web层mvc框架，类似struts2.Springmvc和spring关系？Springmvc是spring的一部分。Springmvc执行原理(流程)Struts2:控制层：strutsPrepareAndExcuteFilter–前端控制器/*l接受请求l转发请求前端控制
  • Strust2远程代码执行漏洞（S2-033） 锋刃科技 安全安全
    前言ApacheStrut2REST插件存在漏洞，可以远程执行任意指令影响版本Struts2.3.20–Struts2.3.28(不包括2.3.20.3和2.3.24.3)。环境搭建dockerpullmedicean/vulapps:s_struts2_s2-033dockerrun-d-p80:8080medicean/vulapps:s_struts2_s2-033打开your-IP:80/
  • [旧文系列] Struts2历史高危漏洞系列-part2：S2-007/S2-008/S2-009 xc8qanAFenlka@x1 struts安全web安全java
    文章目录关于前言S2-007漏洞复现与分析可回显PoC漏洞修复S2-008漏洞复现与分析Vuln-1：RemotecommandexecutioninCookieInterceptorVuln-2：RemotecommandexecutioninDebuggingInterceptorVuln-2：可回显PoC漏洞修复S2-009漏洞复现与分析可回显PoC漏洞修复Reference关于系列是笔者将
  • 0x26.Apache Struts2远程代码执行漏洞(S2-019)复现 半情调 墨者学院墨者学院S2-019
    s2-019：动态方法调用是一种已知会施加可能的安全漏洞的机制，但到目前为止，它默认启用，警告用户应尽可能将其关闭；构造poc：?debug=command&expression=#f=#_memberAccess.getClass().getDeclaredField('allowStaticMethodAccess'),#f.setAccessible(true),#f.set(#_membe
  • Struts2 S2-045漏洞复现 你能拿我咋的 渗透测试漏洞复现strutsjavaweb安全
    1.漏洞概述OGNL是ObjectGraphicNavigationLanguage(对象图导航语言)的缩写，它是一个开源项目。Struts框架使用OGNL作为默认的表达式语言。struts2的rce本质都是一样的(除了S2-052以外)，都是Struts2框架执行了恶意用户传进来的OGNL表达式，造成远程代码执行。可以造成“命令执行、服务器文件操作、打印回显、获取系统属性、危险代码执行”等，只不
  • JavaWeb编程实战宝典(5)___ 第5章 编写Struts2第一个程序 岁月静好浅笑安然
    第5章编写Struts2第一个程序5.1Struts2的MVC模式Struts2中的控制器主要有如下4个功能简单验证复制验证商业逻辑流控制Struts2框架结构可分为以下4部分JSP/Struts2标签(视图层V层)ActionSupport的子类(控制层C层)处理业务逻辑和数据逻辑的JavaBean(模型层M层)用于保存Struts2配置的struts.xml文件5.2Struts2的结构体系5
  • OGNL 虫儿飞ZLEI
    layout:posttitle:OGNLsubtitle:OGNLdate:2018-05-31author:ZLheader-img:img/20180531.jpgcatalog:truetags:-OGNLOGNL（对象视图导航语言）${user.addr.name}这种写法就叫对象视图导航.OGNL不仅仅可以视图导航.支持比EL表达式更加丰富的功能.使用导包在struts2的包中就已经包
  • 2018年java编程发展空间大吗？ Java小辰
    Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。给你学习路线：html-css-js-jq-javase-数据库-jsp-servlet-Struts2-hibernate-mybatis-spring4-springmv
  • 墨者学院-Apache Struts2远程代码执行漏洞(S2-032)复现 nohands_noob
    靶场地址：https://www.mozhe.cn/bug/detail/NWZ1OHFUbDgxV3JNdDhMa0RHQ3BnZz09bW96aGUmozhe漏洞编号：CVE-2016-3081影响范围：Struts2.3.20-StrutsStruts2.3.28（2.3.20.3和2.3.24.3除外）漏洞原理：当启用动态方法调用时，可以传递可用于在服务器端执行任意代码的恶意表达式任意命令
  • struts2简介 活着_3840
    Struts2是一个基于MVC设计模式的Web应用框架，它本质上相当于一个servlet，在MVC设计模式中，Struts2作为控制器(Controller)来建立模型与视图的数据交互。struts2使用的是拦截器的概念，结合各种过滤器获取url，与struts1最大的区别在于1是单例的（所有请求共享一个实例），2是多例的（一个请求一个实例），还引入“值栈”概念，可以达到与servletAPI完全
  • 当Struts2遇到防火墙，你的思路够骚吗？ CanMeng
    一、背景偶然碰到一个小站存在st2-046代码远程执行漏洞，心里美滋滋。执行whoami查看自己是什么权限已经是root了，就尝试上传一个webshell但是却提示上传失败，页面不存在上传txt显示成功经过测试，服务器装有一些防火墙之类的东西或者是安全策略，只要上传的文件里包含可执行代码就上传失败但是转念一想我为什么非要传webshell，传上去之后不还是要提权，弄到他的ssh权限。于是冷静思考了
  • CVE-2017-12149漏洞复现 黑客大佬 漏洞复现web安全安全网络python
    服务攻防-中间件安全&CVE复现&Weblogic&Jenkins&GlassFish漏洞复现中间件及框架列表：IIS，Apache，Nginx，Tomcat，Docker，Weblogic，JBoos，WebSphere，Jenkins，GlassFish，Jira，Struts2，Laravel，Solr，Shiro，Thinkphp，Spring，Flask，jQuery等1、中间件-Web
  • 过滤器和拦截器的区别 苦风
    过滤器（Filter）过滤器，是在javaweb中将你传入的request、response提前过滤掉一些信息，或者提前设置一些参数。然后再传入Servlet或Struts2的action进行业务逻辑处理。比如过滤掉非法url（不是login.do的地址请求，如果用户没有登陆都过滤掉），或者在传入Servlet或Struts2的action前统一设置字符集，或者去除掉一些非法字符。拦截器（Inte
  • Java编程学习：集合框架详解 Java小辰
    Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。给你学习路线：html-css-js-jq-javase-数据库-jsp-servlet-Struts2-hibernate-mybatis-spring4-springmv
  • struts2 向值栈中放数据的三种方式 DouDouZH
    一、获取值栈的对象，调用值栈的set方法1、代码ValuesStackAction1.javapackagework.zhangdoudou.Action;importcom.opensymphony.xwork2.ActionContext;importcom.opensymphony.xwork2.ActionSupport;importcom.opensymphony.xwork2.util
  • POI异步导入Excel兼容xsl和xlsx weixin_33775572 数据库jsonjava
    项目架构：spring+struts2+hibernate4+oracle需求：用户导入excel文件，导入到相应的数据表中，要求提供导入模板，支持xls和xlsx文件思路分析：1、提供一个下载链接，点击下载，可以使超链接，src直接是项目路径加文件名。2、通过上传文件，服务器接收上传，返回一个上传后的服务器本地路径，通过ajax异步赋值到jsp的路径隐藏域。3、ajax异步提交导入请求，后台处理
  • 定制datatable ajax发送给服务端的数据 金刚_30bf
    官网描述http://www.datatables.club/manual/server-side.html#initdtDT自动请求的参数(Sentparameters)当开启了服务器模式时，DataTables会发送如下参数到服务器ps:需要说明的是如果你是Java开发者，那么使用struts2的需要注意，会有错误抛出，因为处理不了类似columns[i][search][regex]的变量如
  • Apache Log4j2漏洞复现（反弹shell） 安全菜 apache
    0x01漏洞描述ApacheLog4j2是一款优秀的Java日志框架。2021年11月24日，阿里云安全团队向Apache官方报告了ApacheLog4j2远程代码执行漏洞。由于ApacheLog4j2某些功能存在递归解析功能，攻击者可直接构造恶意请求，触发远程代码执行漏洞。漏洞利用无需特殊配置，经阿里云安全团队验证，ApacheStruts2、ApacheSolr、ApacheDruid、Apa
  • java编程新手入门基础知识学习 Java小辰
    Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。给你学习路线：html-css-js-jq-javase-数据库-jsp-servlet-Struts2-hibernate-mybatis-spring4-springmv
  • Spring、Spring MVC、Struts2、、优缺点整理大纲 冯匿
    Spring及其优点大部分项目都少不了Spring的身影，为什么大家对他如此青睐，而且对他的追捧丝毫没有减退之势呢Spring是什么：Spring是一个轻量级的DI和AOP容器框架。说它轻量级有一大部分原因是相对与EJB的（虽然本人从没有接触过EJB的应用），重要的是，Spring是非侵入式的，基于spring开发的应用一般不依赖于spring的类。DI：称作依赖注入(DependencyInje
  • BUUCTF-Real-[struts2]s2-001 真的学不了一点。。。 漏洞复现与研究javastruts
    漏洞描述struts2漏洞S2-001是当用户提交表单数据且验证失败时，服务器使用OGNL表达式解析用户先前提交的参数值，%{value}并重新填充相应的表单数据。例如，在注册或登录页面中，如果提交失败，则服务器通常默认情况下将返回先前提交的数据。由于服务器用于%{value}对提交的数据执行OGNL表达式解析，因此服务器可以直接发送有效载荷来执行命令。漏洞poc验证经过poc验证，我们发现[st
  • java类加载顺序 3213213333332132 java
    package com.demo; /** * @Description 类加载顺序 * @author FuJianyong * 2015-2-6上午11:21:37 */ public class ClassLoaderSequence { String s1 = "成员属性"; static String s2 = "
  • Hibernate与mybitas的比较 BlueSkator sqlHibernate框架ibatisorm
    第一章     Hibernate与MyBatis Hibernate 是当前最流行的O/R mapping框架，它出身于sf.net，现在已经成为Jboss的一部分。 Mybatis 是另外一种优秀的O/R mapping框架。目前属于apache的一个子项目。 MyBatis 参考资料官网：http:
  • php多维数组排序以及实际工作中的应用 dcj3sjt126com PHPusortuasort
    自定义排序函数返回false或负数意味着第一个参数应该排在第二个参数的前面, 正数或true反之, 0相等usort不保存键名uasort 键名会保存下来uksort 排序是对键名进行的 <!doctype html> <html lang="en"> <head> <meta charset="utf-8&q
  • DOM改变字体大小 周华华 前端
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
  • c3p0的配置 g21121 c3p0
    c3p0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。c3p0的下载地址是：http://sourceforge.net/projects/c3p0/这里可以下载到c3p0最新版本。 以在spring中配置dataSource为例： <!-- spring加载资源文件 --> <bean name="prope
  • Java获取工程路径的几种方法 510888780 java
    第一种： File f = new File(this.getClass().getResource("/").getPath()); System.out.println(f); 结果: C:\Documents%20and%20Settings\Administrator\workspace\projectName\bin 获取当前类的所在工程路径; 如果不加“
  • 在类Unix系统下实现SSH免密码登录服务器 Harry642 免密ssh
    1.客户机     (1)执行ssh-keygen -t rsa -C "[email protected]"生成公钥，xxx为自定义大email地址     (2)执行scp ~/.ssh/id_rsa.pub root@xxxxxxxxx:/tmp将公钥拷贝到服务器上，xxx为服务器地址     (3)执行cat
  • Java新手入门的30个基本概念一 aijuans javajava 入门新手
    在我们学习Java的过程中,掌握其中的基本概念对我们的学习无论是J2SE,J2EE,J2ME都是很重要的,J2SE是Java的基础,所以有必要对其中的基本概念做以归纳,以便大家在以后的学习过程中更好的理解java的精髓,在此我总结了30条基本的概念。　　Java概述:　　目前Java主要应用于中间件的开发(middleware)---处理客户机于服务器之间的通信技术,早期的实践证明,Java不适合
  • Memcached for windows 简单介绍 antlove javaWebwindowscachememcached
    1. 安装memcached server a. 下载memcached-1.2.6-win32-bin.zip b. 解压缩，dos 窗口切换到 memcached.exe所在目录，运行memcached.exe -d install c.启动memcached Server,直接在dos窗口键入 net start "memcached Server&quo
  • 数据库对象的视图和索引 百合不是茶 索引oeacle数据库视图
      视图     视图是从一个表或视图导出的表，也可以是从多个表或视图导出的表。视图是一个虚表，数据库不对视图所对应的数据进行实际存储，只存储视图的定义，对视图的数据进行操作时,只能将字段定义为视图,不能将具体的数据定义为视图       为什么oracle需要视图;    &
  • Mockito(一) --入门篇 bijian1013 持续集成mockito单元测试
            Mockito是一个针对Java的mocking框架，它与EasyMock和jMock很相似，但是通过在执行后校验什么已经被调用，它消除了对期望 行为（expectations）的需要。其它的mocking库需要你在执行前记录期望行为（expectations），而这导致了丑陋的初始化代码。  &nb
  • 精通Oracle10编程SQL(5)SQL函数 bijian1013 oracle数据库plsql
    /* * SQL函数 */ --数字函数 --ABS(n):返回数字n的绝对值 declare v_abs number(6,2); begin v_abs:=abs(&no); dbms_output.put_line('绝对值：'||v_abs); end; --ACOS(n):返回数字n的反余弦值，输入值的范围是-1~1，输出值的单位为弧度
  • 【Log4j一】Log4j总体介绍 bit1129 log4j
    Log4j组件：Logger、Appender、Layout   Log4j核心包含三个组件：logger、appender和layout。这三个组件协作提供日志功能： 日志的输出目标 日志的输出格式 日志的输出级别(是否抑制日志的输出)  logger继承特性 A logger is said to be an ancestor of anothe
  • Java IO笔记 白糖_ java
    public static void main(String[] args) throws IOException { //输入流 InputStream in = Test.class.getResourceAsStream("/test"); InputStreamReader isr = new InputStreamReader(in); Bu
  • Docker 监控 ronin47 docker监控
             目前项目内部署了docker，于是涉及到关于监控的事情，参考一些经典实例以及一些自己的想法，总结一下思路。 1、关于监控的内容 监控宿主机本身 监控宿主机本身还是比较简单的，同其他服务器监控类似，对cpu、network、io、disk等做通用的检查，这里不再细说。 额外的，因为是docker的
  • java-顺时针打印图形 bylijinnan java
    一个画图程序 要求打印出： 1.int i=5; 2.1 2 3 4 5 3.16 17 18 19 6 4.15 24 25 20 7 5.14 23 22 21 8 6.13 12 11 10 9 7. 8.int i=6 9.1 2 3 4 5 6 10.20 21 22 23 24 7 11.19
  • 关于iReport汉化版强制使用英文的配置方法 Kai_Ge iReport汉化英文版
    对于那些具有强迫症的工程师来说，软件汉化固然好用，但是汉化不完整却极为头疼，本方法针对iReport汉化不完整的情况，强制使用英文版，方法如下： 在 iReport 安装路径下的 etc/ireport.conf 里增加红色部分启动参数，即可变为英文版。   # ${HOME} will be replaced by user home directory accordin
  • [并行计算]论宇宙的可计算性 comsci 并行计算
          现在我们知道,一个涡旋系统具有并行计算能力.按照自然运动理论,这个系统也同时具有存储能力,同时具备计算和存储能力的系统,在某种条件下一般都会产生意识......       那么,这种概念让我们推论出一个结论     &nb
  • 用OpenGL实现无限循环的coverflow dai_lm androidcoverflow
    网上找了很久，都是用Gallery实现的，效果不是很满意，结果发现这个用OpenGL实现的，稍微修改了一下源码，实现了无限循环功能 源码地址： https://github.com/jackfengji/glcoverflow public class CoverFlowOpenGL extends GLSurfaceView implements GLSurfaceV
  • JAVA数据计算的几个解决方案1 datamachine javaHibernate计算
    老大丢过来的软件跑了10天，摸到点门道，正好跟以前攒的私房有关联，整理存档。 -----------------------------华丽的分割线-------------------------------------     数据计算层是指介于数据存储和应用程序之间，负责计算数据存储层的数据，并将计算结果返回应用程序的层次。J  &nbs
  • 简单的用户授权系统,利用给user表添加一个字段标识管理员的方式 dcj3sjt126com yii
    怎么创建一个简单的(非 RBAC)用户授权系统 通过查看论坛，我发现这是一个常见的问题，所以我决定写这篇文章。 本文只包括授权系统.假设你已经知道怎么创建身份验证系统(登录)。 数据库 首先在 user 表创建一个新的字段(integer 类型),字段名 'accessLevel',它定义了用户的访问权限 扩展 CWebUser 类 在配置文件(一般为 protecte
  • 未选之路 dcj3sjt126com 诗
    作者:罗伯特*费罗斯特   黄色的树林里分出两条路, 可惜我不能同时去涉足, 我在那路口久久伫立, 我向着一条路极目望去, 直到它消失在丛林深处.   但我却选了另外一条路, 它荒草萋萋,十分幽寂; 显得更诱人,更美丽, 虽然在这两条小路上, 都很少留下旅人的足迹.   那天清晨落叶满地, 两条路都未见脚印痕迹. 呵,留下一条路等改日再
  • Java处理15位身份证变18位 蕃薯耀 18位身份证变15位15位身份证变18位身份证转换
      15位身份证变18位，18位身份证变15位 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 201
  • SpringMVC4零配置--应用上下文配置【AppConfig】 hanqunfeng springmvc4
    从spring3.0开始，Spring将JavaConfig整合到核心模块，普通的POJO只需要标注@Configuration注解，就可以成为spring配置类，并通过在方法上标注@Bean注解的方式注入bean。   Xml配置和Java类配置对比如下： applicationContext-AppConfig.xml   <!-- 激活自动代理功能 参看：
  • Android中webview跟JAVASCRIPT中的交互 jackyrong JavaScripthtmlandroid脚本
      在android的应用程序中,可以直接调用webview中的javascript代码,而webview中的javascript代码,也可以去调用ANDROID应用程序(也就是JAVA部分的代码).下面举例说明之: 1 JAVASCRIPT脚本调用android程序    要在webview中,调用addJavascriptInterface(OBJ,int
  • 8个最佳Web开发资源推荐 lampcy 编程Web程序员
    Web开发对程序员来说是一项较为复杂的工作，程序员需要快速地满足用户需求。如今很多的在线资源可以给程序员提供帮助，比如指导手册、在线课程和一些参考资料，而且这些资源基本都是免费和适合初学者的。无论你是需要选择一门新的编程语言，或是了解最新的标准，还是需要从其他地方找到一些灵感，我们这里为你整理了一些很好的Web开发资源，帮助你更成功地进行Web开发。 这里列出10个最佳Web开发资源，它们都是受
  • 架构师之面试------jdk的hashMap实现 nannan408 HashMap
    1.前言。   如题。 2.详述。   (1)hashMap算法就是数组链表。数组存放的元素是键值对。jdk通过移位算法（其实也就是简单的加乘算法），如下代码来生成数组下标(生成后indexFor一下就成下标了）。 static int hash(int h) { h ^= (h >>> 20) ^ (h >>>
  • html禁止清除input文本输入缓存 Rainbow702 html缓存input输入框change
    多数浏览器默认会缓存input的值，只有使用ctl+F5强制刷新的才可以清除缓存记录。 如果不想让浏览器缓存input的值，有2种方法： 方法一： 在不想使用缓存的input中添加 autocomplete="off";  <input type="text" autocomplete="off" n
  • POJO和JavaBean的区别和联系 tjmljw POJOjava beans
    POJO 和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Pure Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比 POJO复杂很多， Java Bean 是可复用的组件，对 Java Bean 并没有严格的规
  • java中单例的五种写法 liuxiaoling java单例
    /** * 单例模式的五种写法： * 1、懒汉 * 2、恶汉 * 3、静态内部类 * 4、枚举 * 5、双重校验锁 */ /** * 五、 双重校验锁，在当前的内存模型中无效 */ class LockSingleton { private volatile static LockSingleton singleton; pri
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他