cnhzliye 性格决定命运，气度影响格局！ http://cnhzliye.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 知识点 cnhzliye 作者: cnhzliye  链接：http://cnhzliye.javaeye.com/blog/155561  发表时间: 2008年01月14日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1,组合与继承的区别。
优先使用对象组合，而不是类继承。
类继承被认为“破坏了封装性”，因为对子类而言，父类的内部细节是可见的！
父类与子类之间的强耦合关系也不符合面向对象设计的思想。

对象组合技术认为，你只需要通过组装已有的构件就能获得你要的功能。但事实是，因为可用构件的集合并不足够丰富。这时候，使用继承的复用来获得新的构件比组装旧的构件来得容易，所以继承和对象组合常常一起使用。

2,策略模式和模板模式的区别。
3,webwork和struts的体系结构。
4,oracle删除重复记录。
5,truncate与delete的区别。
相同点：truncate是不带where的delete语句。
不同点：truncate是DDL，不会回滚，而delete会产生log，所以，在删除大量的数据时，用truncate效率会更高。
6,什么是webservice，其优缺点。

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Mon, 14 Jan 2008 10:02:51 +0800 http://cnhzliye.javaeye.com/blog/155561 http://cnhzliye.javaeye.com/blog/155561 个人知识点map cnhzliye 作者: cnhzliye  链接：http://cnhzliye.javaeye.com/blog/145587  发表时间: 2007年12月03日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1.google android

2.struts2/struts2与jsonplug

3.BeanShell and antlr

4.flex

 

。。。。



已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Mon, 03 Dec 2007 13:55:04 +0800 http://cnhzliye.javaeye.com/blog/145587 http://cnhzliye.javaeye.com/blog/145587 java垃圾收集算法 cnhzliye 作者: cnhzliye  链接：http://cnhzliye.javaeye.com/blog/144859  发表时间: 2007年11月29日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1.垃圾收集算法的核心思想

　　Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用(引用)的对象。该机制可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽，以及不恰当的内存释放所造成的内存非法引用。

　　垃圾收集算法的核心思想是：对虚拟机可用内存空间，即堆空间中的对象进行识别，如果对象正在被引用，那么称其为存活对象，反之，如果对象不再被引用，则为垃圾对象，可以回收其占据的空间，用于再分配。垃圾收集算法的选择和垃圾收集系统参数的合理调节直接影响着系统性能，因此需要开发人员做比较深入的了解。

2.触发主GC(Garbage Collector)的条件

　　JVM进行次GC的频率很高,但因为这种GC占用时间极短,所以对系统产生的影响不大。更值得关注的是主GC的触发条件,因为它对系统影响很明显。总的来说,有两个条件会触发主GC:
 

　　①当应用程序空闲时,即没有应用线程在运行时,GC会被调用。因为GC在优先级最低的线程中进行,所以当应用忙时,GC线程就不会被调用,但以下条件除外。

　　②Java堆内存不足时,GC会被调用。当应用线程在运行,并在运行过程中创建新对象,若这时内存空间不足,JVM就会强制地调用GC线程,以便回收内存用于新的分配。若GC一次之后仍不能满足内存分配的要求,JVM会再进行两次GC作进一步的尝试,若仍无法满足要求,则 JVM将报“out of memory”的错误,Java应用将停止。

　　由于是否进行主GC由JVM根据系统环境决定,而系统环境在不断的变化当中,所以主GC的运行具有不确定性,无法预计它何时必然出现,但可以确定的是对一个长期运行的应用来说,其主GC是反复进行的。

3.减少GC开销的措施

　　根据上述GC的机制,程序的运行会直接影响系统环境的变化,从而影响GC的触发。若不针对GC的特点进行设计和编码,就会出现内存驻留等一系列负面影响。为了避免这些影响,基本的原则就是尽可能地减少垃圾和减少GC过程中的开销。具体措施包括以下几个方面:

　　(1)不要显式调用System.gc()

　　此函数建议JVM进行主GC,虽然只是建议而非一定,但很多情况下它会触发主GC,从而增加主GC的频率,也即增加了间歇性停顿的次数。

　　(2)尽量减少临时对象的使用

　　临时对象在跳出函数调用后,会成为垃圾,少用临时变量就相当于减少了垃圾的产生,从而延长了出现上述第二个触发条件出现的时间,减少了主GC的机会。

　　(3)对象不用时最好显式置为Null

　　一般而言,为Null的对象都会被作为垃圾处理,所以将不用的对象显式地设为Null,有利于GC收集器判定垃圾,从而提高了GC的效率。

　　(4)尽量使用StringBuffer,而不用String来累加字符串(详见blog另一篇文章JAVA中String与StringBuffer)

　　由于String是固定长的字符串对象,累加String对象时,并非在一个String对象中扩增,而是重新创建新的String对象,如Str5=Str1+Str2+Str3+Str4,这条语句执行过程中会产生多个垃圾对象,因为对次作“+”操作时都必须创建新的String对象,但这些过渡对象对系统来说是没有实际意义的,只会增加更多的垃圾。避免这种情况可以改用StringBuffer来累加字符串,因StringBuffer是可变长的,它在原有基础上进行扩增,不会产生中间对象。

　　(5)能用基本类型如Int,Long,就不用Integer,Long对象

　　基本类型变量占用的内存资源比相应对象占用的少得多,如果没有必要,最好使用基本变量。

　　(6)尽量少用静态对象变量

　　静态变量属于全局变量,不会被GC回收,它们会一直占用内存。

　　(7)分散对象创建或删除的时间

　　集中在短时间内大量创建新对象,特别是大对象,会导致突然需要大量内存,JVM在面临这种情况时,只能进行主GC,以回收内存或整合内存碎片,从而增加主GC的频率。集中删除对象,道理也是一样的。它使得突然出现了大量的垃圾对象,空闲空间必然减少,从而大大增加了下一次创建新对象时强制主GC的机会。

4.gc与finalize方法

　　⑴gc方法请求垃圾回收

　　使用System.gc()可以不管JVM使用的是哪一种垃圾回收的算法，都可以请求Java的垃圾回收。需要注意的是，调用System.gc()也仅仅是一个请求。JVM接受这个消息后，并不是立即做垃圾回收，而只是对几个垃圾回收算法做了加权，使垃圾回收操作容易发生，或提早发生，或回收较多而已。

　　⑵finalize方法透视垃圾收集器的运行

　　在JVM垃圾收集器收集一个对象之前 ，一般要求程序调用适当的方法释放资源，但在没有明确释放资源的情况下，Java提供了缺省机制来终止化该对象释放资源，这个方法就是finalize()。它的原型为：

　　protected void finalize() throws Throwable

　　在finalize()方法返回之后，对象消失，垃圾收集开始执行。原型中的throws Throwable表示它可以抛出任何类型的异常。

　　因此，当对象即将被销毁时，有时需要做一些善后工作。可以把这些操作写在finalize()方法里。

 

java 代码
  1. protected void finalize()    
  2. 　　 {    
  3. 　　 // finalization code here    
  4. 　　 }  

 

⑶代码示例

java 代码
  1. class Garbage{    
  2. 　　 int index;    
  3. 　　 static int count;    
  4.   
  5. 　　 Garbage() {    
  6. 　　 count++;    
  7. 　　 System.out.println("object "+count+" construct");    
  8. 　　 setID(count);    
  9. 　　 }    
  10.   
  11. 　　 void setID(int id) {    
  12. 　　 index=id;    
  13. 　　 }    
  14.   
  15. 　　 protected void finalize() //重写finalize方法    
  16. 　　 {    
  17. 　　 System.out.println("object "+index+" is reclaimed");    
  18. 　　 }    
  19.   
  20. 　　 public static void main(String[] args)    
  21. 　　 {    
  22. 　　 new Garbage();    
  23. 　　 new Garbage();    
  24. 　　 new Garbage();    
  25. 　　 new Garbage();    
  26. 　　 System.gc(); //请求运行垃圾收集器    
  27. 　　 }    
  28.   
  29. 　}  

5.Java 内存泄漏
　　由于采用了垃圾回收机制，任何不可达对象(对象不再被引用)都可以由垃圾收集线程回收。因此通常说的Java 内存泄漏其实是指无意识的、非故意的对象引用，或者无意识的对象保持。无意识的对象引用是指代码的开发人员本来已经对对象使用完毕，却因为编码的错误而意外地保存了对该对象的引用(这个引用的存在并不是编码人员的主观意愿)，从而使得该对象一直无法被垃圾回收器回收掉，这种本来以为可以释放掉的却最终未能被释放的空间可以认为是被“泄漏了”。

　　考虑下面的程序,在ObjStack类中,使用push和pop方法来管理堆栈中的对象。两个方法中的索引(index)用于指示堆栈中下一个可用位置。push方法存储对新对象的引用并增加索引值,而pop方法减小索引值并返回堆栈最上面的元素。在main方法中,创建了容量为64的栈,并64次调用push方法向它添加对象,此时index的值为64,随后又32次调用pop方法,则index的值变为32,出栈意味着在堆栈中的空间应该被收集。但事实上,pop方法只是减小了索引值,堆栈仍然保持着对那些对象的引用。故32个无用对象不会被GC回收,造成了内存渗漏。

 

java 代码
  1. public class ObjStack {    
  2. 　　 private Object[] stack;    
  3. 　　 private int index;    
  4. 　　 ObjStack(int indexcount) {    
  5. 　　 stack = new Object[indexcount];    
  6. 　　 index = 0;    
  7. 　　 }    
  8. 　　 public void push(Object obj) {    
  9. 　　 stack[index] = obj;    
  10. 　　 index++;    
  11. 　　 }    
  12. 　　 public Object pop() {    
  13. 　　 index--;    
  14. 　　 return stack[index];    
  15. 　　 }    
  16. 　　 }    
  17. 　　 public class Pushpop {    
  18. 　　 public static void main(String[] args) {    
  19. 　　 int i = 0;    
  20. 　　 Object tempobj;    
  21.   
  22. //new一个ObjStack对象，并调用有参构造函数。分配stack Obj数组的空间大小为64，可以存64个对象，从0开始存储   
  23. 　　 ObjStack stack1 = new ObjStack(64);   
  24.   
  25. 　　 while (i < 64)    
  26. 　　 {    
  27. 　　 tempobj = new Object();//循环new Obj对象，把每次循环的对象一一存放在stack Obj数组中。    
  28. 　　 stack1.push(tempobj);    
  29. 　　 i++;    
  30. 　　 System.out.println("第" + i + "次进栈" + "\t");    
  31. 　　 }    
  32.   
  33. 　　 while (i > 32)    
  34. 　　 {    
  35. 　　 tempobj = stack1.pop();//这里造成了空间的浪费。    
  36. 　　 //正确的pop方法可改成如下所指示,当引用被返回后,堆栈删除对他们的引用,因此垃圾收集器在以后可以回收他们。    
  37. 　　 /*   
  38. 　　 * public Object pop() {index - -;Object temp = stack [index];stack [index]=null;return temp;}   
  39. 　　 */    
  40. 　　 i--;    
  41. 　　 System.out.println("第" + (64 - i) + "次出栈" + "\t");    
  42. 　　 }    
  43. 　　 }    
  44. 　　 }  

 

6.如何消除内存泄漏

　　虽然Java虚拟机(JVM)及其垃圾收集器(garbage collector，GC)负责管理大多数的内存任务，Java软件程序中还是有可能出现内存泄漏。实际上，这在大型项目中是一个常见的问题。避免内存泄漏的第一步是要弄清楚它是如何发生的。本文介绍了编写Java代码的一些常见的内存泄漏陷阱，以及编写不泄漏代码的一些最佳实践。一旦发生了内存泄漏，要指出造成泄漏的代码是非常困难的。因此本文还介绍了一种新工具，用来诊断泄漏并指出根本原因。该工具的开销非常小，因此可以使用它来寻找处于生产中的系统的内存泄漏。

　　垃圾收集器的作用

　　虽然垃圾收集器处理了大多数内存管理问题，从而使编程人员的生活变得更轻松了，但是编程人员还是可能犯错而导致出现内存问题。简单地说，GC循环地跟踪所有来自“根”对象(堆栈对象、静态对象、JNI句柄指向的对象，诸如此类)的引用，并将所有它所能到达的对象标记为活动的。程序只可以操纵这些对象;其他的对象都被删除了。因为GC使程序不可能到达已被删除的对象，这么做就是安全的。

　　虽然内存管理可以说是自动化的，但是这并不能使编程人员免受思考内存管理问题之苦。例如，分配(以及释放)内存总会有开销，虽然这种开销对编程人员来说是不可见的。创建了太多对象的程序将会比完成同样的功能而创建的对象却比较少的程序更慢一些(在其他条件相同的情况下)。

　　而且，与本文更为密切相关的是，如果忘记“释放”先前分配的内存，就可能造成内存泄漏。如果程序保留对永远不再使用的对象的引用，这些对象将会占用并耗尽内存，这是因为自动化的垃圾收集器无法证明这些对象将不再使用。正如我们先前所说的，如果存在一个对对象的引用，对象就被定义为活动的，因此不能删除。为了确保能回收对象占用的内存，编程人员必须确保该对象不能到达。这通常是通过将对象字段设置为null或者从集合(collection)中移除对象而完成的。但是，注意，当局部变量不再使用时，没有必要将其显式地设置为null。对这些变量的引用将随着方法的退出而自动清除。

　　概括地说，这就是内存托管语言中的内存泄漏产生的主要原因：保留下来却永远不再使用的对象引用。

　　典型泄漏

　　既然我们知道了在Java中确实有可能发生内存泄漏，就让我们来看一些典型的内存泄漏及其原因。

　　全局集合

　　在大的应用程序中有某种全局的数据储存库是很常见的，例如一个JNDI树或一个会话表。在这些情况下，必须注意管理储存库的大小。必须有某种机制从储存库中移除不再需要的数据。

　　这可能有多种方法，但是最常见的一种是周期性运行的某种清除任务。该任务将验证储存库中的数据，并移除任何不再需要的数据。

　　另一种管理储存库的方法是使用反向链接(referrer)计数。然后集合负责统计集合中每个入口的反向链接的数目。这要求反向链接告诉集合何时会退出入口。当反向链接数目为零时，该元素就可以从集合中移除了。

　　缓存

　　缓存是一种数据结构，用于快速查找已经执行的操作的结果。因此，如果一个操作执行起来很慢，对于常用的输入数据，就可以将操作的结果缓存，并在下次调用该操作时使用缓存的数据。

　　缓存通常都是以动态方式实现的，其中新的结果是在执行时添加到缓存中的。典型的算法是：

　　检查结果是否在缓存中，如果在，就返回结果。

　　如果结果不在缓存中，就进行计算。

　　将计算出来的结果添加到缓存中，以便以后对该操作的调用可以使用。

　　该算法的问题(或者说是潜在的内存泄漏)出在最后一步。如果调用该操作时有相当多的不同输入，就将有相当多的结果存储在缓存中。很明显这不是正确的方法。

　　为了预防这种具有潜在破坏性的设计，程序必须确保对于缓存所使用的内存容量有一个上限。因此，更好的算法是：

　　检查结果是否在缓存中，如果在，就返回结果。

　　如果结果不在缓存中，就进行计算。

　　如果缓存所占的空间过大，就移除缓存最久的结果。

　　将计算出来的结果添加到缓存中，以便以后对该操作的调用可以使用。

　　通过始终移除缓存最久的结果，我们实际上进行了这样的假设：在将来，比起缓存最久的数据，最近输入的数据更有可能用到。这通常是一个不错的假设。

　　新算法将确保缓存的容量处于预定义的内存范围之内。确切的范围可能很难计算，因为缓存中的对象在不断变化，而且它们的引用包罗万象。为缓存设置正确的大小是一项非常复杂的任务，需要将所使用的内存容量与检索数据的速度加以平衡。

　　解决这个问题的另一种方法是使用java.lang.ref.SoftReference类跟踪缓存中的对象。这种方法保证这些引用能够被移除，如果虚拟机的内存用尽而需要更多堆的话。

　　ClassLoader

　　Java ClassLoader结构的使用为内存泄漏提供了许多可乘之机。正是该结构本身的复杂性使ClassLoader在内存泄漏方面存在如此多的问题。ClassLoader的特别之处在于它不仅涉及“常规”的对象引用，还涉及元对象引用，比如：字段、方法和类。这意味着只要有对字段、方法、类或ClassLoader的对象的引用，ClassLoader就会驻留在JVM中。因为ClassLoader本身可以关联许多类及其静态字段，所以就有许多内存被泄漏了。

　　确定泄漏的位置

　　通常发生内存泄漏的第一个迹象是：在应用程序中出现了OutOfMemoryError。这通常发生在您最不愿意它发生的生产环境中，此时几乎不能进行调试。有可能是因为测试环境运行应用程序的方式与生产系统不完全相同，因而导致泄漏只出现在生产中。在这种情况下，需要使用一些开销较低的工具来监控和查找内存泄漏。还需要能够无需重启系统或修改代码就可以将这些工具连接到正在运行的系统上。可能最重要的是，当进行分析时，需要能够断开工具而保持系统不受干扰。

　　虽然OutOfMemoryError通常都是内存泄漏的信号，但是也有可能应用程序确实正在使用这么多的内存;对于后者，或者必须增加JVM可用的堆的数量，或者对应用程序进行某种更改，使它使用较少的内存。但是，在许多情况下，OutOfMemoryError都是内存泄漏的信号。一种查明方法是不间断地监控GC的活动，确定内存使用量是否随着时间增加。如果确实如此，就可能发生了内存泄漏。

 



已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Thu, 29 Nov 2007 15:20:28 +0800 http://cnhzliye.javaeye.com/blog/144859 http://cnhzliye.javaeye.com/blog/144859 db4o入门实例 cnhzliye 作者: cnhzliye  链接：http://cnhzliye.javaeye.com/blog/144851  发表时间: 2007年11月29日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

一、db4o简介：
    简单的说，就是可以用对象的方式存储数据，比如java的集合对象，javabean,pojo对象等。
    开源,可以基于dboGPL协议免费使用，最新版本目前到了6.1版本（java）。官方网站有基于MySql数据库和其他存取方式性能比较的数据，性能十分不错。传闻应用十分广泛，从金融系统到战斗机控制系统都有使用。

db4o 为我们带来的是这样一种面向对象的查询方式:
1.完全原生，目前查询语言能用Java和.NET表达
2.100% 面向对象, 抛开对象-关系映射
3.100% 的类型安全 查询语言能完全获取现代IDE的特性，
    比如语法检测、类型检测、重构，等等。

二、安装
只要将jar文件加到classpath中即可。

下载了之后，有PDF格式和HTML格式的指南文档。
 
三、入门实例：(运行以后将在当前目录中产生db.data数据库文件)

java 代码
  1. import com.db4o.Db4o;   
  2. import com.db4o.ObjectContainer;   
  3. import com.db4o.ObjectSet;   
  4. public class FirstStepsExample{       
  5.     public static void main(String[] args) {   
  6.            
  7.                  
  8.         ObjectContainer db=Db4o.openFile("db.data");   
  9.         try {   
  10.             storeFirstPilot(db);   
  11.             storeSecondPilot(db);   
  12.             retrieveAllPilots(db);   
  13.             retrievePilotByName(db);   
  14.             retrievePilotByExactPoints(db);   
  15.             updatePilot(db);   
  16.             deleteFirstPilotByName(db);   
  17.             deleteSecondPilotByName(db);   
  18.         }   
  19.         finally {   
  20.             db.close();   
  21.         }   
  22.     }   
  23.        
  24.     public static void accessDb4o() {   
  25.         ObjectContainer db=Db4o.openFile("db.data");   
  26.         try {   
  27.             // do something with db4o   
  28.         }   
  29.         finally {   
  30.             db.close();   
  31.         }   
  32.     }   
  33.        
  34.     public static void storeFirstPilot(ObjectContainer db) {   
  35.         Pilot pilot1=new Pilot("Michael Schumacher",100);   
  36.         db.set(pilot1);   
  37.         System.out.println("Stored "+pilot1);   
  38.     }   
  39.     public static void storeSecondPilot(ObjectContainer db) {   
  40.         Pilot pilot2=new Pilot("Rubens Barrichello",99);   
  41.         db.set(pilot2);   
  42.         System.out.println("Stored "+pilot2);   
  43.     }   
  44.     public static void retrieveAllPilotQBE(ObjectContainer db) {   
  45.         Pilot proto=new Pilot(null,0);   
  46.         ObjectSet result=db.get(proto);   
  47.         listResult(result);   
  48.     }   
  49.        
  50.     public static void retrieveAllPilots(ObjectContainer db) {   
  51.         ObjectSet result=db.get(Pilot.class);   
  52.         listResult(result);   
  53.     }   
  54.     public static void retrievePilotByName(ObjectContainer db) {   
  55.         Pilot proto=new Pilot("Michael Schumacher",0);   
  56.         ObjectSet result=db.get(proto);   
  57.         listResult(result);   
  58.     }   
  59.        
  60.     public static void retrievePilotByExactPoints(ObjectContainer db) {   
  61.         Pilot proto=new Pilot(null,100);   
  62.         ObjectSet result=db.get(proto);   
  63.         listResult(result);   
  64.     }   
  65.     public static void updatePilot(ObjectContainer db) {   
  66.         ObjectSet result=db.get(new Pilot("Michael Schumacher",0));   
  67.         Pilot found=(Pilot)result.next();   
  68.         found.addPoints(11);   
  69.         db.set(found);   
  70.         System.out.println("Added 11 points for "+found);   
  71.         retrieveAllPilots(db);   
  72.     }   
  73.     public static void deleteFirstPilotByName(ObjectContainer db) {   
  74.         ObjectSet result=db.get(new Pilot("Michael Schumacher",0));   
  75.         Pilot found=(Pilot)result.next();   
  76.         db.delete(found);   
  77.         System.out.println("Deleted "+found);   
  78.         retrieveAllPilots(db);   
  79.     }   
  80.     public static void deleteSecondPilotByName(ObjectContainer db) {   
  81.         ObjectSet result=db.get(new Pilot("Rubens Barrichello",0));   
  82.         Pilot found=(Pilot)result.next();   
  83.         db.delete(found);   
  84.         System.out.println("Deleted "+found);   
  85.         retrieveAllPilots(db);   
  86.     }   
  87.    public static void listResult(ObjectSet result) {   
  88.     System.out.println(result.size());   
  89.     while(result.hasNext()) {   
  90.         System.out.println(result.next());   
  91.     }   
  92.   }   
  93. }   
  94. public class Pilot {       
  95.     private String name;   
  96.     private int points;     
  97.        
  98.     public Pilot(String name,int points) {   
  99.         this.name=name;   
  100.         this.points=points;   
  101.     }   
  102.            
  103.     public int getPoints() {   
  104.         return points;   
  105.     }   
  106.        
  107.     public void addPoints(int points) {   
  108.         this.points+=points;   
  109.     }   
  110.        
  111.     public String getName() {   
  112.         return name;   
  113.     }   
  114.        
  115.     public String toString() {   
  116.         return name+"/"+points;   
  117.     }   
  118. }   

 

运行结果： C:\Test>java FirstStepsExample
Stored Michael Schumacher/100
Stored Rubens Barrichello/99
2
Michael Schumacher/100
Rubens Barrichello/99
1
Michael Schumacher/100
1
Michael Schumacher/100
Added 11 points for Michael Schumacher/111
2
Michael Schumacher/111
Rubens Barrichello/99
Deleted Michael Schumacher/111
1
Rubens Barrichello/99
Deleted Rubens Barrichello/99
0



已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Thu, 29 Nov 2007 15:06:00 +0800 http://cnhzliye.javaeye.com/blog/144851 http://cnhzliye.javaeye.com/blog/144851 修饰符的一点迷惑。。。 cnhzliye 作者: cnhzliye  链接：http://cnhzliye.javaeye.com/blog/144740  发表时间: 2007年11月29日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

在类的方法或成员变量前加修饰符pirvate，表示该方法只能在该类中被访问。。。

但是，我在别的类中，通过反射，可以“暴力”的执行加private的方法或者得到加private的成员变量。。。

 

是不是“自相矛盾”啊？那位牛人可否解释一下。。。谢谢



已有 2 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Thu, 29 Nov 2007 10:11:56 +0800 http://cnhzliye.javaeye.com/blog/144740 http://cnhzliye.javaeye.com/blog/144740 建立Android中文网, 正在文档中文化 [收藏] cnhzliye 作者: cnhzliye  链接：http://cnhzliye.javaeye.com/blog/143507  发表时间: 2007年11月26日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

http://www.javaeye.com/topic/140725

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Mon, 26 Nov 2007 09:09:43 +0800 http://cnhzliye.javaeye.com/blog/143507 http://cnhzliye.javaeye.com/blog/143507 google android 初体验两个不爽【ZT】 cnhzliye 作者: cnhzliye  链接：http://cnhzliye.javaeye.com/blog/143505  发表时间: 2007年11月26日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

http://www.javaeye.com/topic/141854?page=1

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Mon, 26 Nov 2007 09:03:54 +0800 http://cnhzliye.javaeye.com/blog/143505 http://cnhzliye.javaeye.com/blog/143505 在WebWork中实现自己的Result Type cnhzliye 作者: cnhzliye  链接：http://cnhzliye.javaeye.com/blog/131283  发表时间: 2007年10月12日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

飞云小侠 2005-7-27 http://www.jscud.com 转载请注明作者


我在项目中经常用到这样的功能:例如添加完一个文章,我通常会提示用户"操作完成",然后转向到文章列表页面或者文章详情页面.以前的做法是使用WebWork本身的dispatcher结果类型,设置结果页面为信息提示页面,在程序中设置目标页面和提示信息.这样虽然也可以完成我的目标,但是目标页面是在程序里面写死的,无法放在配置里.

这几天研究了一下WebWork的Result Type,发现写一个新的Result Type很容易,于是诞生了我的一个新的Result Type:

功能:信息提示并转向到目标页面
流程:在Action中设置提示信息(当然也可以改到配置文件里,但是配置起来略麻烦,所以还是写在程序里了),然后使用我的结果类型msgto,在配置文件里面配置目标页面.


代码如下

1.页面信息提示类(包含页面提示信息和目标页面,停留时间)


package com.jscud.www.support.web;


/*
* Created Date 2004-11-23
*
*/

/**
* 用于页面提示的信息类.
*
* @author scud
*
*/
public class PageMessage
{
/**标题*/
private String msgTitle;

/**内容体*/
private String msgContent;

/**要转向到的网址*/
private String msgToURL;

/**停留时间*/
private int msgToTime = 1 ;


public String getMsgContent()
{
return msgContent;
}

public void setMsgContent(String msgContent)
{
this.msgContent = msgContent;
}

public String getMsgTitle()
{
return msgTitle;
}

public void setMsgTitle(String msgTitle)
{
this.msgTitle = msgTitle;
}

public int getMsgToTime()
{

return msgToTime;
}

public void setMsgToTime(int msgToTime)
{
this.msgToTime = msgToTime;
}

public String getMsgToURL()
{
return msgToURL;
}

public void setMsgToURL(String msgToURL)
{
this.msgToURL = msgToURL;
}
}





2."msgto" Result Type ,借鉴了WebWork本身的几个ResultType,部分代码是copy过来的

package com.jscud.www.support.web;

//import com.jscud.util.LogMan;
import com.opensymphony.webwork.config.Configuration;
import com.opensymphony.webwork.dispatcher.ServletDispatcher;
import com.opensymphony.webwork.dispatcher.WebWorkResultSupport;

import com.opensymphony.webwork.ServletActionContext;
import com.opensymphony.xwork.ActionContext;
import com.opensymphony.xwork.ActionInvocation;
import com.opensymphony.xwork.util.OgnlValueStack;

import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/*
* Created on 2005-7-26
*
*/

/**
* WebWork Result Type for "msgto".
*
* Message Hint to User then Refresh to another Page.
*
* @author scud.
*
*/
public class ServletMessageToResult extends WebWorkResultSupport
{

//~ Static fields/initializers /////////////////////////////////////////////

private static final String DefaultMessagePage = "/WEB-INF/public/page/msgto.jsp";

protected String messagePage;

protected boolean prependServletContext = true;


//~ Methods ////////////////////////////////////////////////////////////////

public void setMessagePage(String sPagePath)
{
this.messagePage = sPagePath;
}

public String getMessagePage()
{
if (null == messagePage)
{
if (Configuration.isSet("jscud.page.messageto"))
{
this.messagePage = Configuration.getString("jscud.page.messageto");
}
else
{
this.messagePage = DefaultMessagePage;
}
}

return messagePage;
}


/**
* Sets whether or not to prepend the servlet context path to the redirected URL.
*
* @param prependServletContext <tt>true</tt> to prepend the location with the servlet context path,
* <tt>false</tt> otherwise.
*/
public void setPrependServletContext(boolean prependServletContext) {
this.prependServletContext = prependServletContext;
}

/**
* Dispatches to the Message Page. Does its forward via a RequestDispatcher. If the
* dispatch fails a 404 error will be sent back in the http response.
*
* @param finalLocation the location to dispatch to.
* @param invocation the execution state of the action
* @throws Exception if an error occurs. If the dispatch fails the error will go back via the
* HTTP request.
*/
public void doExecute(String finalLocation, ActionInvocation invocation)
throws Exception
{
String messageLocation = getMessagePage();

HttpServletRequest request = ServletActionContext.getRequest();
HttpServletResponse response = ServletActionContext.getResponse();

RequestDispatcher dispatcher = request.getRequestDispatcher(messageLocation);

// if the view doesn't exist, let's do a 404
if (dispatcher == null)
{
response.sendError(404, "message page '" + messageLocation + "' not found");

return;
}

request.setAttribute("webwork.view_uri", messageLocation);
request.setAttribute("webwork.request_uri", request.getRequestURI());

//set refresh target url
if (isPathUrl(finalLocation))
{
if (!finalLocation.startsWith("/"))
{
String actionPath = request.getServletPath();
String namespace = ServletDispatcher
.getNamespaceFromServletPath(actionPath);

if ((namespace != null) && (namespace.length() > 0))
{
finalLocation = namespace + "/" + finalLocation;
}
else
{
finalLocation = "/" + finalLocation;
}
}

// if the URL's are relative to the servlet context, append the servlet context path
if (prependServletContext && (request.getContextPath() != null)
&& (request.getContextPath().length() > 0))
{
finalLocation = request.getContextPath() + finalLocation;
}

finalLocation = response.encodeRedirectURL(finalLocation);
}

//LogMan.debug("Refreshing to finalLocation " + finalLocation);

//设置属性
OgnlValueStack stack = ActionContext.getContext().getValueStack();

PageMessage aPageMessage = (PageMessage)stack.findValue("pagemessage",PageMessage.class);

if(null!=aPageMessage)
{
aPageMessage.setMsgToURL(finalLocation);
}

dispatcher.forward(request, response);
}

//copy from ServletRedirectResult
private static boolean isPathUrl(String url)
{
// filter out "http:", "https:", "mailto:", "file:", "ftp:"
// since the only valid places for : in URL's is before the path specification
// either before the port, or after the protocol
return (url.indexOf(':') == -1);
}
}





3.信息提示页面

缺省为/WEB-INF/public/page/msgto.jsp,可以在webwork.properties里面配置"jscud.page.messageto",还可以通过配置文件配置.

可以根据自己需要更改页面内容.

<%@ page contentType="text/html; charset=GBK" %>
<%@ taglib uri="webwork" prefix="ww" %>

<html>
<head>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="Cache-Control" content="no-cache, must-revalidate">
<meta http-equiv="expires" content="0">

<meta http-equiv="Content-Type" content="text/html; charset=GBK">

<meta http-equiv="refresh" content="<ww:property value="pagemessage.msgToTime" />;URL=<ww:property value="pagemessage.msgToURL" />">

<title><ww:property value="pagemessage.msgTitle" /></title>
</head>
<body >
<div align=center>
<table width=90% border="0" cellspacing="0" cellpadding="0" align="center" bgcolor=#ffffff>
<tr valign="top">
<td width="2"> 　
</td>
<td width="5"></td>
<td colspan="3">
<center><br><br>
<table align="center" border="0" cellpadding="5" cellspacing="0" width="100%">
<tbody>
<tr>
<td><ww:property value="pagemessage.msgTitle" />
<hr noshade size="1" color="#808000">
</td>
</tr>
<tr>
<td><ww:property value="pagemessage.msgContent" /><br><br><br>
请稍后......<br>
</td>
</tr>
</tbody>
</table>
</center>

</td>
</tr>
</table>

</div>
</body>
</html>






4.配置示例

<result-types>
<result-type name="msgto" class="com.jscud.www.support.web.ServletMessageToResult" />
</result-types>


<action name="doAddCata" class="catagoryAction" method="doSet">
<result name="input" type="dispatcher">
<param name="location">/WEB-INF/jsp/news/catagory_add.jsp</param>
</result>
<result name="success" type="msgto">
<param name="location">/news/admin/admin.jspa</param>
</result>
</action>





5.Action中的代码示例



/**
* 增加/编辑类别
*
* @return 结果
*/
public String doSet()
{
//输入界面
if (null == catagory)
{
return INPUT;
}
catagoryManager.updateCatagory(getCatagory(), getWork());
//return goException("设置分类时发生了错误",ex);

setPageMessageProp("操作成功", "操作成功");

return SUCCESS;
}









以下代码放在基础Action里:(自己要做适当修改)


/**
* 设置信息提示的内容.
*
* @param sTitle
* @param sHintMsg
*/
protected void setPageMessageProp(String sTitle, String sHintMsg)
{
PageMessage apm = new PageMessage();
if ((null == sTitle) || (sTitle.equals("")))
{
sTitle = getText("core.errorhint.title.default");
}

apm.setMsgTitle(sTitle);
apm.setMsgContent(sHintMsg);

setPagemessage(apm);
}

/**
* 设置信息提示的参数.(转向)
*
* @param sTitle
* @param sHintMsg
* @param toURL
* @param nToTime
*/
protected void setPageMessageProp(String sTitle, String sHintMsg,int nToTime)
{
PageMessage apm = new PageMessage();

if ((null == sTitle) || (sTitle.equals("")))
{
sTitle = getText("core.errorhint.title.default");
}

apm.setMsgTitle(sTitle);
apm.setMsgContent(sHintMsg);
//apm.setMsgToURL(toURL);
apm.setMsgToTime(nToTime);

setPagemessage(apm);
}


public PageMessage getPagemessage()
{
return pagemessage;
}

public void setPagemessage(PageMessage pagemessage)
{
this.pagemessage = pagemessage;
}




ok,很简单,不是吗?

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 12 Oct 2007 10:15:47 +0800 http://cnhzliye.javaeye.com/blog/131283 http://cnhzliye.javaeye.com/blog/131283 时区转换代码 cnhzliye 作者: cnhzliye  链接：http://cnhzliye.javaeye.com/blog/127969  发表时间: 2007年09月28日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

java 代码
  1. timeZone_digital = new Date().getTimezoneOffset() 得到时区时间差值      
  2.      
  3. 以上是JS得到的       
  4.     public static TimeZone getTimeZone(String timeZone_digital) {      
  5.         String gmt = "";      
  6.         if (timeZone_digital != null) {      
  7.             int length = timeZone_digital.length();      
  8.             String d = "";      
  9.             String f = "";      
  10.             if (length == 1) {      
  11.                 gmt = "GMT";      
  12.             } else if (timeZone_digital.startsWith("-")) {      
  13.                 d = timeZone_digital.substring(0, 1);      
  14.                 f = timeZone_digital.substring(1, length);      
  15.                 gmt = "GMT+" + Integer.parseInt(f) / 60;      
  16.             } else {      
  17.                 gmt = "GMT-" + Integer.parseInt(timeZone_digital) / 60;      
  18.             }      
  19.      
  20.         } else {      
  21.             // 北京时区      
  22.             return TimeZone.getTimeZone("GMT+8");      
  23.         }      
  24.      
  25.         return TimeZone.getTimeZone(gmt);      
  26.     }      
  27.      


已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 28 Sep 2007 17:07:51 +0800 http://cnhzliye.javaeye.com/blog/127969 http://cnhzliye.javaeye.com/blog/127969 Spring 的优秀工具类盘点，第 2 部分: 特殊字符转义和方法入参检测工具类 cnhzliye 作者: cnhzliye  链接：http://cnhzliye.javaeye.com/blog/127809  发表时间: 2007年09月28日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

级别： 初级

陈 雄华 (quickselect@163.com), 技术总监, 宝宝淘网络科技有限公司


2007 年 8 月 31 日

Spring 不但提供了一个功能全面的应用开发框架，本身还拥有众多可以在程序编写时直接使用的工具类，您不但可以在 Spring 应用中使用这些工具类，也可以在其它的应用中使用，这些工具类中的大部分是可以在脱离 Spring 框架时使用的。了解 Spring 中有哪些好用的工具类并在程序编写时适当使用，将有助于提高开发效率、增强代码质量。

在这个分为两部分的文章中，我们将从众多的 Spring 工具类中遴选出那些好用的工具类介绍给大家。第 1 部分 介绍了与文件资源操作和 Web 相关的工具类。在第 2 部分中将介绍特殊字符转义和方法入参检测工具类。

特殊字符转义

由于 Web 应用程序需要联合使用到多种语言，每种语言都包含一些特殊的字符，对于动态语言或标签式的语言而言，如果需要动态构造语言的内容时，一个我们经常会碰到的问题就是特殊字符转义的问题。下面是 Web 开发者最常面对需要转义的特殊字符类型：

HTML 特殊字符；
JavaScript 特殊字符；
SQL 特殊字符；
如果不对这些特殊字符进行转义处理，则不但可能破坏文档结构，还可以引发潜在的安全问题。Spring 为 HTML 和 JavaScript 特殊字符提供了转义操作工具类，它们分别是 HtmlUtils 和 JavaScriptUtils。

HTML 特殊字符转义

HTML 中 <，>，& 等字符有特殊含义，它们是 HTML 语言的保留字，因此不能直接使用。使用这些个字符时，应使用它们的转义序列：

&：&
" ："
< ：<
> ：>
由于 HTML 网页本身就是一个文本型结构化文档，如果直接将这些包含了 HTML 特殊字符的内容输出到网页中，极有可能破坏整个 HTML 文档的结构。所以，一般情况下需要对动态数据进行转义处理，使用转义序列表示 HTML 特殊字符。下面的 JSP 网页将一些变量动态输出到 HTML 网页中：


清单 1. 未进行 HTML 特殊字符转义处理网页

<%@ page language="java" contentType="text/html; charset=utf-8"%>
<%!
String userName = "</td><tr></table>";
String address = " \" type=\"button";
%>
<table border="1">
<tr>
<td>姓名：</td><td><%=userName%></td> ①
</tr>
<tr>
<td>年龄：</td><td>28</td>
</tr>
</table>
<input value="<%=address%>" type="text" /> ②



在 ① 和 ② 处，我们未经任何转义处理就直接将变量输出到 HTML 网页中，由于这些变量可能包含一些特殊的 HTML 的字符，它们将可能破坏整个 HTML 文档的结构。我们可以从以上 JSP 页面的一个具体输出中了解这一问题：

<table border="1">
<tr>
<td>姓名：</td><td></td><tr></table></td>
① 破坏了 <table> 的结构
</tr>
<tr>
<td>年龄：</td><td>28</td>
</tr>
</table>
<input value=" " type="button" type="text" />
② 将本来是输入框组件偷梁换柱为按钮组件



融合动态数据后的 HTML 网页已经面目全非，首先 ① 处的 <table> 结构被包含 HTML 特殊字符的 userName 变量截断了，造成其后的 <table> 代码变成无效的内容；其次，② 处 <input> 被动态数据改换为按钮类型的组件（type="button"）。为了避免这一问题，我们需要事先对可能破坏 HTML 文档结构的动态数据进行转义处理。Spring 为我们提供了一个简单适用的 HTML 特殊字符转义工具类，它就是 HtmlUtils。下面，我们通过一个简单的例子了解 HtmlUtils 的具体用法：


清单 2. HtmpEscapeExample

package com.baobaotao.escape;
import org.springframework.web.util.HtmlUtils;
public class HtmpEscapeExample {
public static void main(String[] args) {
String specialStr = "<div id=\"testDiv\">test1;test2</div>";
String str1 = HtmlUtils.htmlEscape(specialStr); ①转换为HTML转义字符表示
System.out.println(str1);

String str2 = HtmlUtils.htmlEscapeDecimal(specialStr); ②转换为数据转义表示
System.out.println(str2);

String str3 = HtmlUtils.htmlEscapeHex(specialStr); ③转换为十六进制数据转义表示
System.out.println(str3);

④下面对转义后字符串进行反向操作
System.out.println(HtmlUtils.htmlUnescape(str1));
System.out.println(HtmlUtils.htmlUnescape(str2));
System.out.println(HtmlUtils.htmlUnescape(str3));
}
}



HTML 不但可以使用通用的转义序列表示 HTML 特殊字符，还可以使用以 # 为前缀的数字序列表示 HTML 特殊字符，它们在最终的显示效果上是一样的。HtmlUtils 提供了三个转义方法：

方法 说明
static String htmlEscape(String input) 将 HTML 特殊字符转义为 HTML 通用转义序列；
static String htmlEscapeDecimal(String input) 将 HTML 特殊字符转义为带 # 的十进制数据转义序列；
static String htmlEscapeHex(String input) 将 HTML 特殊字符转义为带 # 的十六进制数据转义序列；

此外，HtmlUtils 还提供了一个能够将经过转义内容还原的方法：htmlUnescape(String input)，它可以还原以上三种转义序列的内容。运行以上代码，您将可以看到以下的输出：

str1:<div id="testDiv">test1;test2</div>
str2:<div id="testDiv">test1;test2</div>
str3:<div id="testDiv">test1;test2</div>
<div id="testDiv">test1;test2</div>
<div id="testDiv">test1;test2</div>
<div id="testDiv">test1;test2</div>



您只要使用 HtmlUtils 对代码 清单 1 的 userName 和 address 进行转义处理，最终输出的 HTML 页面就不会遭受破坏了。

JavaScript 特殊字符转义

JavaScript 中也有一些需要特殊处理的字符，如果直接将它们嵌入 JavaScript 代码中，JavaScript 程序结构将会遭受破坏，甚至被嵌入一些恶意的程序。下面列出了需要转义的特殊 JavaScript 字符：

' ：\'
" ：\"
\ ：\\
走纸换页： \f
换行：\n
换栏符：\t
回车：\r
回退符：\b

我们通过一个具体例子演示动态变量是如何对 JavaScript 程序进行破坏的。假设我们有一个 JavaScript 数组变量，其元素值通过一个 Java List 对象提供，下面是完成这一操作的 JSP 代码片断：


清单 3. jsTest.jsp：未对 JavaScript 特殊字符进行处理

<%@ page language="java" contentType="text/html; charset=utf-8"%>
<jsp:directive.page import="java.util.*"/>
<%
List textList = new ArrayList();
textList.add("\";alert();j=\"");
%>
<script>
var txtList = new Array();
<% for ( int i = 0 ; i < textList.size() ; i++) { %>
txtList[<%=i%>] = "<%=textList.get(i)%>";
① 未对可能包含特殊 JavaScript 字符的变量进行处理
<% } %>
</script>



当客户端调用这个 JSP 页面后，将得到以下的 HTML 输出页面：

<script>
var txtList = new Array();
txtList[0] = "";alert();j=""; ① 本来是希望接受一个字符串，结果被植入了一段JavaScript代码
</script>



由于包含 JavaScript 特殊字符的 Java 变量直接合并到 JavaScript 代码中，我们本来期望 ① 处所示部分是一个普通的字符串，但结果变成了一段 JavaScript 代码，网页将弹出一个 alert 窗口。想像一下如果粗体部分的字符串是“";while(true)alert();j="”时会产生什么后果呢？

因此，如果网页中的 JavaScript 代码需要通过拼接 Java 变量动态产生时，一般需要对变量的内容进行转义处理，可以通过 Spring 的 JavaScriptUtils 完成这件工作。下面，我们使用 JavaScriptUtils 对以上代码进行改造：

<%@ page language="java" contentType="text/html; charset=utf-8"%>
<jsp:directive.page import="java.util.*"/>
<jsp:directive.page import="org.springframework.web.util.JavaScriptUtils"/>
<%
List textList = new ArrayList();
textList.add("\";alert();j=\"");
%>
<script>
var txtList = new Array();
<% for ( int i = 0 ; i < textList.size() ; i++) { %>
① 在输出动态内容前事先进行转义处理
txtList[<%=i%>] = "<%=JavaScriptUtils.javaScriptEscape(""+textList.get(i))%>";
<% } %>
</script>



通过转义处理后，这个 JSP 页面输出的结果网页的 JavaScript 代码就不会产生问题了：

<script>
var txtList = new Array();
txtList[0] = "\";alert();j=\"";
① 粗体部分仅是一个普通的字符串，而非一段 JavaScript 的语句了
</script>



SQL特殊字符转义

应该说，您即使没有处理 HTML 或 JavaScript 的特殊字符，也不会带来灾难性的后果，但是如果不在动态构造 SQL 语句时对变量中特殊字符进行处理，将可能导致程序漏洞、数据盗取、数据破坏等严重的安全问题。网络中有大量讲解 SQL 注入的文章，感兴趣的读者可以搜索相关的资料深入研究。

虽然 SQL 注入的后果很严重，但是只要对动态构造的 SQL 语句的变量进行特殊字符转义处理，就可以避免这一问题的发生了。来看一个存在安全漏洞的经典例子：

SELECT COUNT(userId)
FROM t_user
WHERE userName='"+userName+"' AND password ='"+password+"';



以上 SQL 语句根据返回的结果数判断用户提供的登录信息是否正确，如果 userName 变量不经过特殊字符转义处理就直接合并到 SQL 语句中，黑客就可以通过将 userName 设置为 “1' or '1'='1”绕过用户名/密码的检查直接进入系统了。

所以除非必要，一般建议通过 PreparedStatement 参数绑定的方式构造动态 SQL 语句，因为这种方式可以避免 SQL 注入的潜在安全问题。但是往往很难在应用中完全避免通过拼接字符串构造动态 SQL 语句的方式。为了防止他人使用特殊 SQL 字符破坏 SQL 的语句结构或植入恶意操作，必须在变量拼接到 SQL 语句之前对其中的特殊字符进行转义处理。Spring 并没有提供相应的工具类，您可以通过 jakarta commons lang 通用类包中（spring/lib/jakarta-commons/commons-lang.jar）的 StringEscapeUtils 完成这一工作：


清单 4. SqlEscapeExample

package com.baobaotao.escape;
import org.apache.commons.lang.StringEscapeUtils;
public class SqlEscapeExample {
public static void main(String[] args) {
String userName = "1' or '1'='1";
String password = "123456";
userName = StringEscapeUtils.escapeSql(userName);
password = StringEscapeUtils.escapeSql(password);
String sql = "SELECT COUNT(userId) FROM t_user WHERE userName='"
+ userName + "' AND password ='" + password + "'";
System.out.println(sql);
}
}



事实上，StringEscapeUtils 不但提供了 SQL 特殊字符转义处理的功能，还提供了 HTML、XML、JavaScript、Java 特殊字符的转义和还原的方法。如果您不介意引入 jakarta commons lang 类包，我们更推荐您使用 StringEscapeUtils 工具类完成特殊字符转义处理的工作。






回页首




方法入参检测工具类

Web 应用在接受表单提交的数据后都需要对其进行合法性检查，如果表单数据不合法，请求将被驳回。类似的，当我们在编写类的方法时，也常常需要对方法入参进行合法性检查，如果入参不符合要求，方法将通过抛出异常的方式拒绝后续处理。举一个例子：有一个根据文件名获取输入流的方法：InputStream getData(String file)，为了使方法能够成功执行，必须保证 file 入参不能为 null 或空白字符，否则根本无须进行后继的处理。这时方法的编写者通常会在方法体的最前面编写一段对入参进行检测的代码，如下所示：

public InputStream getData(String file) {
if (file == null || file.length() == 0|| file.replaceAll("\\s", "").length() == 0) {
throw new IllegalArgumentException("file入参不是有效的文件地址");
}
…
}



类似以上检测方法入参的代码是非常常见，但是在每个方法中都使用手工编写检测逻辑的方式并不是一个好主意。阅读 Spring 源码，您会发现 Spring 采用一个 org.springframework.util.Assert 通用类完成这一任务。

Assert 翻译为中文为“断言”，使用过 JUnit 的读者都熟知这个概念，它断定某一个实际的运行值和预期想一样，否则就抛出异常。Spring 对方法入参的检测借用了这个概念，其提供的 Assert 类拥有众多按规则对方法入参进行断言的方法，可以满足大部分方法入参检测的要求。这些断言方法在入参不满足要求时就会抛出 IllegalArgumentException。下面，我们来认识一下 Assert 类中的常用断言方法：

断言方法 说明
notNull(Object object) 当 object 不为 null 时抛出异常，notNull(Object object, String message) 方法允许您通过 message 定制异常信息。和 notNull() 方法断言规则相反的方法是 isNull(Object object)/isNull(Object object, String message)，它要求入参一定是 null；
isTrue(boolean expression) / isTrue(boolean expression, String message) 当 expression 不为 true 抛出异常；
notEmpty(Collection collection) / notEmpty(Collection collection, String message) 当集合未包含元素时抛出异常。notEmpty(Map map) / notEmpty(Map map, String message) 和 notEmpty(Object[] array, String message) / notEmpty(Object[] array, String message) 分别对 Map 和 Object[] 类型的入参进行判断；
hasLength(String text) / hasLength(String text, String message) 当 text 为 null 或长度为 0 时抛出异常；
hasText(String text) / hasText(String text, String message) text 不能为 null 且必须至少包含一个非空格的字符，否则抛出异常；
isInstanceOf(Class clazz, Object obj) / isInstanceOf(Class type, Object obj, String message) 如果 obj 不能被正确造型为 clazz 指定的类将抛出异常；
isAssignable(Class superType, Class subType) / isAssignable(Class superType, Class subType, String message) subType 必须可以按类型匹配于 superType，否则将抛出异常；

使用 Assert 断言类可以简化方法入参检测的代码，如 InputStream getData(String file) 在应用 Assert 断言类后，其代码可以简化为以下的形式：

public InputStream getData(String file){
Assert.hasText(file,"file入参不是有效的文件地址");
① 使用 Spring 断言类进行方法入参检测
…
}



可见使用 Spring 的 Assert 替代自编码实现的入参检测逻辑后，方法的简洁性得到了不少的提高。Assert 不依赖于 Spring 容器，您可以大胆地在自己的应用中使用这个工具类。






回页首




小结

本文介绍了一些常用的 Spring 工具类，其中大部分 Spring 工具类不但可以在基于 Spring 的应用中使用，还可以在其它的应用中使用。

对于 Web 应用来说，由于有很多关联的脚本代码，如果这些代码通过拼接字符串的方式动态产生，就需要对动态内容中特殊的字符进行转义处理，否则就有可能产生意想不到的后果。Spring 为此提供了 HtmlUtils 和 JavaScriptUtils 工具类，只要将动态内容在拼接之前使用工具类进行转义处理，就可以避免类似问题的发生了。如果您不介意引入一个第三方类包，那么 jakarta commons lang 通用类包中的 StringEscapeUtils 工具类可能更加适合，因为它提供了更加全面的转义功能。

最后我们还介绍了 Spring 的 Assert 工具类，Assert 工具类是通用性很强的工具类，它使用面向对象的方式解决方法入参检测的问题，您可以在自己的应用中使用 Assert 对方法入参进行检查。

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 28 Sep 2007 10:33:20 +0800 http://cnhzliye.javaeye.com/blog/127809 http://cnhzliye.javaeye.com/blog/127809 webwork + ajax 整合实例 cnhzliye 作者: cnhzliye  链接：http://cnhzliye.javaeye.com/blog/127252  发表时间: 2007年09月26日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

首先, 配置好webwork环境.


在webwork中应用ajax技术,只要在webwork的返回值上加以区别就可以把 动态取得的值,返回给前台浏览器.


在这个实例中,我们有一个html页面,一个java文件,然后再配置文件中写上相关映射就OK了.

代码如下:

dynamicUpdate.html


<html>
<head>
<title>update of ajax</title>
<script type="text/javascript">...
var xmlHttp;
var dom;
function createXMLHttpRequest()...{
if(window.ActiveXObject)...{
xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");
}else...{
xmlHttp = new XMLHttpRequest();
}
}

function doStart()...{
createXMLHttpRequest();
var url = "dynamicUpdate.action?task=reset";
xmlHttp.open("GET",url,true);
xmlHttp.onreadystatechange = startCallback;
xmlHttp.send(null);
}

function startCallback()...{
if(xmlHttp.readyState == 4)...{
if(xmlHttp.status == 200 )...{
setTimeout("pollServer()",5000);
refreshTime();
}
}
}

function pollServer()...{
createXMLHttpRequest();
var url = "dynamicUpdate.action?task=foo";
xmlHttp.open("GET",url,true);
xmlHttp.onreadystatechange = pollCallback;
xmlHttp.send(null);
}

function refreshTime()...{
var time_span = document.getElementById("time");
var time_val = time_span.innerHTML;
var int_val = parseInt(time_val);
var new_int_val = int_val -1;

if(new_int_val > -1)...{
setTimeout("refreshTime()",5000);
time_span.innerHTML = new_int_val;
}else...{
time_span.innerHTML = 5;
}
}

function pollCallback()...{
if(xmlHttp.readyState == 4)...{
if(xmlHttp.status == 200)...{
//alert(xmlHttp.responseText)
// alert(xmlHttp.responseXML.childNodes.length)
// alert(xmlHttp.responseXML.getElementsByTagName("message")[0]);
createXMLParser(xmlHttp.responseText);
var message = dom.getElementsByTagName("message")[0].firstChild.data;

if(message != "done")...{
var new_row = createRow(message);
var table = document.getElementById("dynamicUpdateArea");
var table_body = table.getElementsByTagName("tbody").item(0);
var first_row = table_body.getElementsByTagName("tr").item(1);
table_body.insertBefore(new_row,first_row);
setTimeout("pollServer()",5000);
}
}
}
}

function createRow(message)...{
var row = document.createElement("tr");
var cell = document.createElement("td");
var cell_data = document.createTextNode(message);
cell.appendChild(cell_data);
row.appendChild(cell);
return row;
}

//初始化XML解析器
function createXMLParser(text)...{
if(window.ActiveXObject)...{
dom = new ActiveXObject("Microsoft.XMLDOM");
dom.async = false;
dom.loadXML(text);
}else...{
var parser = new DOMParser();
dom = parser.parseFromString(text,"text/html");
}
}
</script>
</head>

<body>
<h1>Ajax Dynamic Update Example</h1>
This page will automatically update itself:
<input type="button" value="Launch" id="go" onclick="doStart()"/>
<p>
Page will refresh in <span id="time">5</span> seconds
</p>
<table id="dynamicUpdateArea" align="left">
<tbody>
<tr id="row0"><td></td></tr>
</tbody>
</table>
</body>
</html>



DynamicUpdate.java


package control;

import java.io.PrintWriter;
import java.math.*;
import javax.servlet.http.HttpServletResponse;

import com.opensymphony.webwork.ServletActionContext;

import core.BookActionSupport;

public class DynamicUpdate extends BookActionSupport...{
private int counter = 1;
private double random;
public String execute()...{
String res = "";
String task = getParameter("task");
String message = "";
random = Math.floor(Math.random()*100);
while(random > 7)...{
random = Math.sin(random)*10 ;
random = Math.abs(Math.floor(random));
System.out.println(random);
}
counter = (int)random;
if(task.equals("reset"))...{
counter = 1;
}else...{
switch(counter)...{
case 1: message = "Steve walks on stage"; break;
case 2: message = "iPods rock"; break;
case 3: message = "Steve says Macs rule"; break;
case 4: message = "Change is coming"; break;
case 5: message = "Yes,OS X runs on Intel-has for years"; break;
case 6: message = "Macs will soon have Intel chips"; break;
case 7: message = "done"; break;
}
}
res = "<message>" + message + "</message>";
try...{
HttpServletResponse response = ServletActionContext.getResponse();
PrintWriter out = response.getWriter();
response.setContentType("text/html");
response.setHeader("Cache-Control","no-cache");
out.write(res);
out.close();

}catch(Exception e)...{
System.out.println(e.getMessage());
}


return "";
}
}


xwork.xml
在此配文件需要注意你的包名,我的包名是helloWorld;
<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN" "X:WorkSpaceBFPPropertyconfigwebxwork-1.0.dtd">

<xwork>

<include file="webwork-default.xml"/>

<package name="helloWorld" extends="webwork-default">
<interceptors>
<interceptor name="params" class="com.opensymphony.xwork.interceptor.ParametersInterceptor"/>
</interceptors>

<default-interceptor-ref name="defaultStack"/>

<action name="dynamicUpdate" class="control.DynamicUpdate">
<result name="success">/jsp/domainS.jsp</result>
<interceptor-ref name="model-driven"/>
<interceptor-ref name="params"/>
</action>
</package>

</xwork>
OK,如果你是copy 的代码,在配置文件正确的情况下,应该可以运行了. 看看结果吧. 一定要注意配置文件和浏览器版本.在IE5以下的版本是不支持ajax的.


Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1799725

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Wed, 26 Sep 2007 12:23:20 +0800 http://cnhzliye.javaeye.com/blog/127252 http://cnhzliye.javaeye.com/blog/127252 eclipse启动参数 cnhzliye 作者: cnhzliye  链接：http://cnhzliye.javaeye.com/blog/125902  发表时间: 2007年09月21日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

@echo off
@start eclipse.exe -vmargs -Xms128M -Xmx512M -XX:PermSize=64M -XX:MaxPermSize=128M
@exit

 

ps：

安装eclipse+myeclipse开发环境：

1,解压eclipseSDK

2,安装myeclipse

3,将myeclipse 的plugins和features里的文件coby并覆盖eclipse的plugins和features的文件

4,卸载myeclipse



已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 21 Sep 2007 13:09:25 +0800 http://cnhzliye.javaeye.com/blog/125902 http://cnhzliye.javaeye.com/blog/125902 学习maven的使用，看到一篇很实用的入门教程(菜鸟级入门) cnhzliye 作者: cnhzliye  链接：http://cnhzliye.javaeye.com/blog/125871  发表时间: 2007年09月21日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

一、前言
        早就知道maven 在java 项目的管理方面名声显赫，于是就想着学习掌握之，于是查阅了大量文档。发现这些文档的作者都是java 的大腕，大多都是站在掌握了一定maven 基础的角度上进行介绍，让我这初学者看的云里雾里不知所云。于是又去查看maven 的官方网站，总算是有所了解，但一旦动手实际操作却又雾里看花。唉，没办法，就只有一遍一遍的动手尝试，经过种
种磨难总算是有一点眉目了。现在就将我的经验写出来，一来避免将来遗忘，二来也给和我一样的菜鸟们提供一点点的方便。呵呵。本文的主题在于实用操作，个中原理还是麻烦大家去查一下java大腕们的文章吧。这里推荐两篇文章：

Maven 2.0:编译、测试、部署、运行
http://www.ideagrace.com/html/doc/2006/06/14/00847.html

二、maven2安装
1、首先去官方网站下载之：http://maven.apache.org/download.html，我选择的是截至目前最新版本maven2.0.4版本
2、设置环境变量：Maven2下载完后，我将其解压到我的计算机的d:\maven204下，目录结构如下：
D:\
|--Maven204
|-- bin
|-- conf
|-- core
|-- lib
|-- local

环境变量：（操作系统windows2003）
        我的电脑----属性----高级----环境变量，点击“系统变量”下的新建，输入：变量名 MAVEN_HOME; 变量值d:\Maven204，在系统变量列表中找到系统变量path，打开之，在变量值中追加”;%MAVEN_HOME%\bin”，至此环境变量设置完毕。
        检查一下是否已经完成安装，打开dos窗口，输入mvn –v，如果出现以下信息则表示maven2已经安装成功：
X：〉mvn –v
Maven Version 2.0.4

我已经说得够详细了，还不行？那我只能说你比我还菜。
 
三、用maven2创建第一个java工程
1、选择一个根目录，我的java工作目录是D:\eclipse\workspace
2、打开dos窗口采用cd命令进入D:\eclipse\workspace目录下
3、输入下列指令
D:\eclipse\workspace>mvn archetype:create -DgroupId=com.efn -DartifactId=study
指令执行完毕会出现如下的目录结构：
study
|-- pom.xml
`-- src
|-- main
| `-- java
| `-- com
| `-- mycompany
| `-- app
| `-- App.java
`-- test
`-- java
`-- com
`-- mycompany
`-- app
`-- AppTest.java

四、生成eclipse工程文件
我采用的开发工具是eclipse,所以用maven的eclipse参数生成eclipse工程文件。输入如下
1、 采用dos的cd命令进入study目录
2、 输入指令：mvn eclipse:eclipse 如下所示：
D:\eclipse\workspace\study>mvn eclipse:eclipse
指令执行完毕后，发现多了两个文件：.classpath和.project

五、下载maven的eclipse插件
1、打开eclipse
2、打开菜单 help -Software updates-Find and Install
3、选择第二项，进入下一步
4、点击按钮“New Remote Site…”
5、在Name中输入：Maven2，在URL中输入http://m2eclipse.codehaus.org/
Ok,现在一切都是自动化的，你所需要做的就是等待并按提示按按钮。

六、导入工程
刚才已经生成了eclipse的工程文件，现在导入之。菜单File-import ，按“下一步”，选择工程文件导入完毕后，工程管理透视图就会出现study节点了，在工程节点上，按鼠标右键，打开弹出菜单，选择maven2菜单项，弹出子菜单->Enable，点击之打开，在Group Id中输入：study即可。

打开study的pom.xml文件，会有如下类似内容：

xml 代码
  1. <project  xmlns="http://maven.apache.org/POM/4.0.0"  xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
  2.   <modelVersion>4.0.0</modelVersion>  
  3.   <groupId>com.efn</groupId>  
  4.   <artifactId>study</artifactId>  
  5.   <packaging>jar</packaging>  
  6.   <version>1.0-SNAPSHOT</version>  
  7.   <name>Maven Quick Start Archetype</name>  
  8.   <url>http://maven.apache.org</url>  
  9. </project>  

注意：有关这个文件的作用和各节点的作用不是本文的描述重点，可以到maven的官方网站查阅http://maven.apache.org/目前为止，所有的准备工作都已经就绪，现在我们就以一个主main函数访问数据库为例介绍在实际开发中的使用。

七、搭建架包
每一个java工程都不免使用第三方的架包，Maven的好处就是可以统一管理这些架包，并使多个java工程共享这些架包。我们所需要做的就是按规则编辑pom.xml文件。Maven已经非常智能，使用maven的eclipse插件的向导，只要输入参数就可以将配置文件生成出来。我们的例子是用jdbc方式访问oracle的数据库。所以需要jdbc和oracle的架包的支持。下面我们就来搭建这两个架包到study工程里来。

有两种方式可以采用：
1、自动向导
第一种是采用向导方式并让向导直接去maven的服务器上下载你需要的架包，这种方式存在一定的风险，一来可能maven的服务器上并没有你需要的东东，二来每次智能的maven总是去寻找那并不存在的东东。抛出一大堆红字提示不说，达不到预期目标才是让人郁闷。不过为了保证文档的完整性，还是给出操作步骤。以junit为例（这个东东倒是没有问题，呵呵）当工程的maven被Enable后，弹出菜单的maven2子菜，选择子菜单的“Add Dependency”菜单项，在Query中输入“junit”，向导会自动列出相关列表供选择。选择你最需要的架包，按“OK” 按钮。
如果你的本地仓库已经存在该架包，则向导只在pom.xml加入依赖项信息，pom.xml文件的内容如下
xml 代码
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven."apache.org/maven-v4_0_0.xsd>  
  2. <modelVersion>4.0.0</modelVersion>  
  3. <groupId>com.efn</groupId>  
  4. <artifactId>study</artifactId>  
  5. <packaging>jar</packaging>  
  6. <version>1.0-SNAPSHOT</version>  
  7. <name>Maven Quick Start Archetype</name>  
  8. <url>