2010年3月9日
【转】Java反射经典实例 Java Reflection Cookbook
关键字: 反射

Java提供了一套机制来动态执行方法和构造方法，以及数组操作等，这套机制就叫——反射。反射机制是如今很多流行框架的实现基础，其中包括Spring、Hibernate等。原理性的问题不是本文的重点，接下来让我们在实例中学习这套精彩的机制。

1. 得到某个对象的属性

  1. public Object getProperty(Object owner, String fieldName) throws Exception {      
  2.     Class ownerClass = owner.getClass();                                          
  3.                                                                                   
  4.     Field field = ownerClass.getField(fieldName);                                 
  5.                                                                                   
  6.     Object property = field.get(owner);                                           
  7.                                                                                   
  8.     return property;                                                              
  9. }                                                                                 


Class ownerClass = owner.getClass()：得到该对象的Class。

Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。

Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。

 

2. 得到某个类的静态属性

  1. public Object getStaticProperty(String className, String fieldName)    
  2.             throws Exception {                                         
  3.     Class ownerClass = Class.forName(className);                       
  4.                                                                        
  5.     Field field = ownerClass.getField(fieldName);                      
  6.                                                                        
  7.     Object property = field.get(ownerClass);                           
  8.                                                                        
  9.     return property;                                                   
  10. }                                                                      

Class ownerClass = Class.forName(className) ：首先得到这个类的Class。

Field field = ownerClass.getField(fieldName)：和上面一样，通过Class得到类声明的属性。

Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。


3. 执行某对象的方法

  1. public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {   
  2.     Class ownerClass = owner.getClass();   
  3.     Class[] argsClass = new Class[args.length];   
  4.     for (int i = 0, j = args.length; i < j; i++) {   
  5.         argsClass[i] = args[i].getClass();   
  6.     }    
  7.     Method method = ownerClass.getMethod(methodName, argsClass);      
  8.     return method.invoke(owner, args);    
  9. }  

Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。

3～6行：配置参数的Class数组，作为寻找Method的条件。

Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。

method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。


4. 执行某个类的静态方法

  1. public Object invokeStaticMethod(String className, String methodName,            
  2.             Object[] args) throws Exception {                                    
  3.     Class ownerClass = Class.forName(className);                                 
  4.                                                                                  
  5.     Class[] argsClass = new Class[args.length];                                  
  6.                                                                                  
  7.     for (int i = 0, j = args.length; i < j; i++) {                               
  8.         argsClass[i] = args[i].getClass();                                       
  9.     }                                                                            
  10.                                                                                  
  11.     Method method = ownerClass.getMethod(methodName, argsClass);                 
  12.                                                                                  
  13.     return method.invoke(null, args);                                            
  14. }                                                                                

基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。

 

5. 新建实例

  1. public Object newInstance(String className, Object[] args) throws Exception {    
  2.     Class newoneClass = Class.forName(className);                                
  3.                                                                                  
  4.     Class[] argsClass = new Class[args.length];                                  
  5.                                                                                  
  6.     for (int i = 0, j = args.length; i < j; i++) {                               
  7.         argsClass[i] = args[i].getClass();                                       
  8.     }                                                                            
  9.                                                                                  
  10.     Constructor cons = newoneClass.getConstructor(argsClass);                    
  11.                                                                                  
  12.     return cons.newInstance(args);                                               
  13.                                                                                  
  14. }                                                                                

这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。

Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。

第6～第10行：得到参数的Class数组。

Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。

cons.newInstance(args)：新建实例。


6. 判断是否为某个类的实例

  1. public boolean isInstance(Object obj, Class cls) {        
  2.     return cls.isInstance(obj);                           
  3. }                                                         


7. 得到数组中的某个元素

  1. public Object getByArray(Object array, int index) {       
  2.     return Array.get(array,index);                        
  3. }                                                         


附完整源码：

  1. import java.lang.reflect.Array;   
  2. import java.lang.reflect.Constructor;   
  3. import java.lang.reflect.Field;   
  4. import java.lang.reflect.Method;   
  5.   
  6.   
  7. /**  
  8.  * Java Reflection Cookbook  
  9.  *  
  10.  * @author Michael Lee  
  11.  * @since 2006-8-23  
  12.  * @version 0.1a  
  13.  */  
  14.   
  15. public class Reflection {   
  16.     /**  
  17.      * 得到某个对象的公共属性  
  18.      *  
  19.      * @param owner, fieldName  
  20.      * @return 该属性对象  
  21.      * @throws Exception  
  22.      *  
  23.      */  
  24.     public Object getProperty(Object owner, String fieldName) throws Exception {   
  25.         Class ownerClass = owner.getClass();   
  26.   
  27.         Field field = ownerClass.getField(fieldName);   
  28.   
  29.         Object property = field.get(owner);   
  30.   
  31.         return property;   
  32.     }   
  33.   
  34.     /**  
  35.      * 得到某类的静态公共属性  
  36.      *  
  37.      * @param className   类名  
  38.      * @param fieldName   属性名  
  39.      * @return 该属性对象  
  40.      * @throws Exception  
  41.      */  
  42.     public Object getStaticProperty(String className, String fieldName)   
  43.             throws Exception {   
  44.         Class ownerClass = Class.forName(className);   
  45.   
  46.         Field field = ownerClass.getField(fieldName);   
  47.   
  48.         Object property = field.get(ownerClass);   
  49.   
  50.         return property;   
  51.     }   
  52.   
  53.   
  54.     /**  
  55.      * 执行某对象方法  
  56.      *  
  57.      * @param owner  
  58.      *            对象  
  59.      * @param methodName  
  60.      *            方法名  
  61.      * @param args  
  62.      *            参数  
  63.      * @return 方法返回值  
  64.      * @throws Exception  
  65.      */  
  66.     public Object invokeMethod(Object owner, String methodName, Object[] args)   
  67.             throws Exception {   
  68.   
  69.         Class ownerClass = owner.getClass();   
  70.   
  71.         Class[] argsClass = new Class[args.length];   
  72.   
  73.         for (int i = 0, j = args.length; i < j; i++) {   
  74.             argsClass[i] = args[i].getClass();   
  75.         }   
  76.   
  77.         Method method = ownerClass.getMethod(methodName, argsClass);   
  78.   
  79.         return method.invoke(owner, args);   
  80.     }   
  81.   
  82.   
  83.       /**  
  84.      * 执行某类的静态方法  
  85.      *  
  86.      * @param className  
  87.      *            类名  
  88.      * @param methodName  
  89.      *            方法名  
  90.      * @param args  
  91.      *            参数数组  
  92.      * @return 执行方法返回的结果  
  93.      * @throws Exception  
  94.      */  
  95.     public Object invokeStaticMethod(String className, String methodName,   
  96.             Object[] args) throws Exception {   
  97.         Class ownerClass = Class.forName(className);   
  98.   
  99.         Class[] argsClass = new Class[args.length];   
  100.   
  101.         for (int i = 0, j = args.length; i < j; i++) {   
  102.             argsClass[i] = args[i].getClass();   
  103.         }   
  104.   
  105.         Method method = ownerClass.getMethod(methodName, argsClass);   
  106.   
  107.         return method.invoke(null, args);   
  108.     }   
  109.   
  110.   
  111.   
  112.     /**  
  113.      * 新建实例  
  114.      *  
  115.      * @param className  
  116.      *            类名  
  117.      * @param args  
  118.      *            构造函数的参数  
  119.      * @return 新建的实例  
  120.      * @throws Exception  
  121.      */  
  122.     public Object newInstance(String className, Object[] args) throws Exception {   
  123.         Class newoneClass = Class.forName(className);   
  124.   
  125.         Class[] argsClass = new Class[args.length];   
  126.   
  127.         for (int i = 0, j = args.length; i < j; i++) {   
  128.             argsClass[i] = args[i].getClass();   
  129.         }   
  130.   
  131.         Constructor cons = newoneClass.getConstructor(argsClass);   
  132.   
  133.         return cons.newInstance(args);   
  134.   
  135.     }   
  136.   
  137.   
  138.        
  139.     /**  
  140.      * 是不是某个类的实例  
  141.      * @param obj 实例  
  142.      * @param cls 类  
  143.      * @return 如果 obj 是此类的实例，则返回 true  
  144.      */  
  145.     public boolean isInstance(Object obj, Class cls) {   
  146.         return cls.isInstance(obj);   
  147.     }   
  148.        
  149.     /**  
  150.      * 得到数组中的某个元素  
  151.      * @param array 数组  
  152.      * @param index 索引  
  153.      * @return 返回指定数组对象中索引组件的值  
  154.      */  
  155.     public Object getByArray(Object array, int index) {   
  156.         return Array.get(array,index);   
  157.     }   
  158. }  
posted @ 2010-03-09 13:13 刘皇叔 阅读(27) 评论(0) 编辑
2008年8月20日
忘记SEO（一）：静下心来做网站

 

    在迷茫了几乎整整两个月后，我开始逐渐感受到初学SEO时，朋友告诉我的一句话——“遗忘SEO”。

    最近一段时间因为一些项目的原因，接触了很多不同类型的网站，这里包括企业站，论坛，交友站等，而且最近自己也因为实验SEO插件，做了不少试验站，最终慢慢感觉到，其实SEO就是那么回事。

    举个例子，假如你现在要做一个网站，那么之前在你想到要做这个站的时候你会考虑什么？

    拿我来说，过去我做网站的时候，首先我会白日做梦很久，考虑到我做这个网站，会给我带来不少的收入，人气会有多么旺，等等之类，可是真正网站做起来的时候，我却发现事实并不是我想象的那样，因为网站根本就没有访问，那时候我还不知道SEO这回事，于是完全豁出去自己，在百度贴吧，在各个论坛疯了一样的发帖子，引流量，可是用户还是少的可怜。

   到开始学SEO的时候，我意识到自己的想法是错误的，于是开始依赖SEO，并把所有的SEO技巧一口气全部使用在一个网站上，结果导致的后果就是，网站被K，心血付诸东流。

    在经过了那么多的失败后，我发现，原来我的错误不是使用SEO，而是错在我本身对网站流量来源的思考上面，细想一下，如果我们真的做了一个网站，你依靠SEO让你的网站排在了第一位，可是三个月后你发现你的网站90%以上的流量还是来自搜索引擎，这就有些不合理了。假如有一天，搜索引擎公司全部倒闭，或者说你的网站被搜索引擎全部K光，那不是依旧是回到零点？

    网站成为常青树才是王道。

    那么SEO是不是就因为这样而不考虑了呢？不，不但要考虑，而且还要细致的考虑。现在，我们做网站早已不是一时的兴趣所致，而是在经过对整个同类网站的分析、并对自己即将建设的网站做了全面细致的布局后，才可以开始做站，而这样的网站才可以被搜索引擎喜欢，同时被用户喜欢。

    说相声的有句话，叫做“观众就是我们的衣食父母”。我们做网站也一样，用户就是我们的衣食父母，包括搜索引擎也是，没有了人去搜索，自然也就没有效益产生，所以，我们必须考虑到浏览者的感觉。拿百度来说，你能说他是因为忘本了而去给你的网站拔毛么？我想不是，因为他也要讨好他的使用者，他希望把最好的东西呈现给使用者，让使用者能够下次再来，百度尚且如此，何况我们提供基础服务的网站所有者呢？

    我个人感觉，在做一个网站之前，因为SEO的因素，你必须做以下的准备：

    1、你需要考虑你做的网站上线后，到底能有多少浏览者？并不是所有的热门词都对你有好处，有些冷门关键词的定向性很高，IP质量也非常高，如果你能让你的100个IP转化率达到90%以上，那么你的网站要比每天几千上万ip的垃圾站更值钱。冷门并不是绝对的，因为相当多的冷门词可以直接带给你经济效益，哪怕你是做GGAD，单价都要比你做垃圾站的单价要高很多。

    2、竞争对手如何做的，为什么人家有那么多的回头客，为什么他们的搜索引擎排名会那么高？原因很简单，因为他们不但在内容方面吸引了大多数的用户和SE的喜好，更多时候，他们在用户体验上花费了很多的功夫。举个很简单的例子，你的网站的很多内都是需要在新窗口打开，如果这仅仅是首页，或者是栏目页的话，无可非议，但是要是你为了找到一个内容打开三个以上的新窗口，这就很可怕了，遇到一个机器运行速度很慢的浏览者，他会毫不犹豫的关掉你的网站。这虽然是个很小的细节，但是对于提高用户体验有相当大的作用，有时候，你的竞争对手做到了想用户所想，他的网站自然就收到欢迎，流量随之增高，浏览者的回头率也随之上升。接着，你还担心你的网站没有流量？还有很重要的一点，根据我的观察，对于用户喜欢的网站，搜索引擎也是同样喜欢的，不要忘记，搜索引擎发展的原则，就是让用户取得更有效的内容，也就是“取悦于人”。用户都喜欢，他百度有什么理由不喜欢你的网站？

    3、尽管我们要避免SEO优化的痕迹，但是你依然要考虑搜索引擎的感受，我在做一个网站的时候，我会把整个一个网站的结构，甚至内部链接，包括目录结构都列出来，然后一个个的分析，那一个结构最适合搜索引擎抓取。为什么搜索引擎会不喜欢DIV超过三层的结构？为什么搜索引擎不喜欢动态的网页？为什么不喜欢超过三层的目录？站在一个浏览者的角度，你去考虑搜索引擎蜘蛛，人打开网页都要很辛苦的等待很久，何况是没有感情的蜘蛛呢？他要是因为动态，因为结构半天打不开你的网页，他就会反馈给他的老家，这网页不怎么样！那排名能高么？所以，我最提倡的部分，就是消除SEO优化痕迹的代码优化和整站结构优化。

    4、摆正心态，我们做网站，不仅仅是为了赚钱，万维网的出现，很大一部分的意义是为了信息传输的便利，而不是为了赚钱，尽管这些年很多人通过网络获取了第一桶金，但是你必须给网络代价，他才可以回报给你更多的价值，为互联网的信息资源做一件事情，不要仅仅去考虑采集，网络的资源需要我们的补充，而不是互相之间盗取盗用，当然，我们也没有必要一天充实N篇原创的，具有极高价值的内容，我们需要的是质量，而不是数量。我想，一篇真正让用户喜欢的、独家的资料，给你带来的搜索引擎权重和用户信誉要远远高于你采集十万没有价值文章。

    说了这么多，我没有别的意思，只是想让各位在做网站的时候，去思考和整理一下，问问自己，到底为什么要做这个站，有多大的价值，既然决定要去做，那么到底做到什么程度算是好，对于搜索引擎如何对待才可以获得更高的排名。

    不要让自己陷入SEO的陷阱，那样会很累，不是吗？

 

本文原载：飘渺蝶舞的SEO梦想（http://www.piaomiaodiewu.cn/）

posted @ 2008-08-20 14:12 刘皇叔 阅读(32) 评论(0) 编辑
2008年6月30日
菩提本无树，明镜亦非台，本来无一物，何处惹尘埃
菩提原本就没有树,明亮的镜子也并非是台,本来就虚无一物,那里会
染上什么尘埃?

这是我非常喜欢得一句话，它的内涵也是值得每一个人学习。 这是
南北朝时候 一个叫慧能得和尚所说

大意为：
世上本来就是空的，看世间万物无不是一个空字，心本来就是空的话
，就无所谓抗拒 外面的诱惑，任何事物从心而过，不留痕迹。这是
禅宗的一种很高的境界，领略到这 层境界的人，就是所谓的开悟了。
posted @ 2008-06-30 12:43 刘皇叔 阅读(121) 评论(0) 编辑
2008年6月23日
世界最著名大学教育向我们开放了

一、伯克利

加州大学伯克利分校 http://webcast.berkeley.edu/courses.php

作为美国第一的公立大学，伯克利分校提供了，可以跟踪最新的讲座。想看教授布置的作业和课堂笔记，可以点击该教授的网页，通常，他/她都会第一堂课留下网址。实在不行，用google搜搜吧！

　　伯克利的视频都是.rm格式，请注意转换

　　二、麻省

麻省理工学院 http://ocw.mit.edu/OcwWeb/web/courses/courses/index.htm

麻省理工是免费开放教育课件的先驱，计划在今年把１８００门课程的课件都放在网站上，提供课程与作业的ＰＤＦ格式下载。三是，

posted @ 2008-06-23 22:35 刘皇叔 阅读(76) 评论(0) 编辑
2008年6月17日
什么编程语言最有前途

程序员，我指的是那些还没有精通一门编程语言，包括那些学过多门语言自以为已经“精通”的程序员、还有那些正准备当一名了不起的程序员却还不会一门语言的人，可能大家最需要的是找到一门好的语言，最大的疑惑是该选择哪一门语言？

首先肯定是想什么语言最有前途就选择那门语言吧，这种想法符合时代的发展，也无可厚非。就像现在已经流行.net了，你就不必去啃晦涩难懂的pascal，但是谁能告诉你什么语言最有前途呢？你问10个人可能有10种答案，有的会告诉你学C++好，说C＋＋效率高，而且做游戏都用C＋＋；有的会告诉你学java好，java程序员工资高，据说是因为java平台的项目报价比较高；有人告诉你学vb吧，说世界上用的人最多的语言就是vb了；有人告诉你，学好C什么都不怕了，C做嵌入式系统一流；有人说学delphi吧，delphi功能强大，编译器效率比微软的还厉害……

这下疑惑了，到底该怎么选择呢？

可以说没有哪一个程序员入门的时候没有这个困惑，笔者大学前面三年一直被这个问题困扰着。于是那几年学了很多编程语言，包括vb，c，c＋＋，ActionScript，javascript，asp，asp.Net，C＃。有人可能不知道ActionScript是什么，ActionScript是flash里面的编程脚本，跟java是一个血统的，当时听说有人做flash是以十万每秒来算价钱的，令我痴迷不已。最后发现自己虽然能使用很多门语言，却只是掌握了这些语言中最浅显的应用，用一句话就是“明显的底气不足”。

好的程序语言好比一把武器，有人说java是剑，C＃是刀，那问题显然很简单了，是否能杀人不在乎你是用刀还是用剑，而在乎你是否是一个优秀的刀客或是剑客。如果你会使用很多种语言，就像左手拿刀，右手握剑，臂湾夹一根枪，嘴里还含一枚小李飞刀，也未必是一个刀客的对手。呵呵。

程序员本来就要耐得住孤单寂寞，走自己的路，让别人无路可走。

到文章的结尾笔者还没告诉你学什么语言好，但是却告诉了你与其博而不精，不如精通一门。

posted @ 2008-06-17 15:08 刘皇叔 阅读(1472) 评论(1) 编辑
仅列出标题