Java中的反射学习及反射解耦应用

这是转帖的

【原帖地址】

http://student.csdn.net/space.php?uid=972460&do=blog&id=42231

 

Java中的反射学习及反射解耦应用

热54已有 4421 次阅读  2010-08-30 16:57

反射是Java程序开发语言的特征之一。它允许动态地发现和绑定类、方法、字段，以及所有其他的由语言所产生的元素。反射可以做的不仅仅是简单地列举类、字段以及方法。通过反射，还能够在运行时完成创建实例、调用方法以及访问字段的工作。反射是 Java 被视为动态(或准动态)语言的关键。
归纳起来，Java反射机制主要提供了以下功能。
1.         在运行时判断任意一个对象所属的类；
2.         在运行时构造任意一个类的对象；
3.         在运行时判断任意一个类所具有的成员变量和方法；
4.         在运行时调用任意一个对象的方法。通过反射甚至可以调用到private的方法；
5.         生成动态代理。
Java反射所需要的类并不多，主要有java.lang.Class类和java.lang.reflect包中的Field、Constructor、Method、Array类，下面对这些类做一个简单的说明。
1.         Class类：Class类的实例表示正在运行的 Java 应用程序中的类和接口。
2.         Field类：提供有关类或接口的属性的信息，以及对它的动态访问权限。反射的字段可能是一个类属性或实例属性，简单的理解可以把它看成一个封装反射类的属性的类。
3.         Constructor类：提供关于类的单个构造方法的信息以及对它的访问权限。这个类和Field类不同，Field类封装了反射类的属性，而Constructor类则封装了反射类的构造方法。
4.         Method类：提供关于类或接口上单独某个方法的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。这个类不难理解，它是用来封装反射类方法的一个类。
5.         Array类：提供了动态创建数组和访问数组的静态方法。该类中的所有方法都是静态方法。
其中，Class类是Java反射的起源，针对任何一个你想探勘的类，只有先为它产生一个Class类的对象，接下来才能通过Class对象获取其他想要的信息。接下来就重点介绍一下Class类。
在实际开发中，为了达到各个类之间的依赖关系剥离（也就是经常说的解耦），在对类的调用和实例化的时候，通过在配置文件中配置相应的类名，在程序中读取类名，然后通过反射技术在程序中加载和实例化，如常见的数据库驱动程序类，为了达到不依赖特定数据库驱动类，将用到的数据库驱动类名放到配置文件中（常用的有XML文件、Properties文件和文本文件），然后在程序中加载驱动，来实现对数据库的解耦，也就是说只要修改配置文件，就可以方便地更改数据库类型。下面以Properties配置文件为例详细说明。
例：编写程序，利用配置文件实现松耦合。
TestReflectMain类
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class TestReflectMain extends JFrame implements ActionListener{
    private javax.swing.JButton b1;
    public TestReflectMain(){
        b1=new javax.swing.JButton("点击");
        this.setLayout(new FlowLayout());
        b1.addActionListener(this);
        this.add(b1);
        this.setSize(400,400);
        this.setVisible(true);      
       
    }
    public void actionPerformed(ActionEvent e) {
        OperateProperties operateProperties = new OperateProperties();
        String classname=
operateProperties.getValueByPropertyName("TestF.properties","class");
       try{       
           JFrame f=(JFrame)Class.forName(classname).newInstance();
       }catch(Exception ex){
              javax.swing.JOptionPane.showConfirmDialog(this, "生成失败！");
       }
    }
     public static void main(String[] args) {
        new TestReflectMain();
    }
}
class F1 extends JFrame{
    public F1(){
        super("这是F1");
        this.setLayout(new FlowLayout());
        JLabel l=new JLabel("现在显示的是类F1");
        this.add(l);
        this.setSize(200,200);
        this.setVisible(true);          
    }
}
class F2 extends JFrame{
    public F2(){
        super("这是F2");
        this.setLayout(new FlowLayout());
        JLabel l=new JLabel("现在显示的是类F2");
        this.add(l);
        this.setSize(200,200);
        this.setVisible(true);          
    }
}
然后在源程序文件所在的文件夹下定义一个TestF.properties的文件，文件内容如下：
class=F1
然后运行程序，当点击按钮时，出现如图1所示结果。



                                 图1配置文件内容为class=F1时程序运行结果
当我们修改配置文件的内容为class=F2后，再次点击按钮，出现了不同的运行结果，如图2所示。



                                  图2 配置文件内容为class=F2时程序运行结果
我们可以看出来，通过读取配置文件得到类名，然后利用反射机制来得到指定类的对象，程序不用编译，甚至程序正在运行过程中，更改属性文件后，得到的对象也是不同的，从而实现了动态更改程序运行的目的，也可以说通过配置文件更改了类和类之间的调用关系。
上面的反射例子，在Java企业级的应用、开源框架，如Stucts、Spring、Hibernate中应用广泛，实现了类和类之间的调用松耦合。
 
_____________________________________________________________________________
例：取java类属性名称及值
 
public class TestReflect {
 public static void main(String[] args){
  java.util.Calendar clndr = java.util.Calendar.getInstance();
  Class cls = clndr.getClass();
  System.out.println(cls.getName());
  
  java.lang.reflect.Field[] flds = cls.getFields();
  try{
   if(null != flds){
    for(int i=0; i < flds.length; i++){
     System.out.println(flds[i].getName()+ " - " + flds[i].get(clndr));
    }
   }
  }catch (IllegalAccessException e) {
   e.printStackTrace();
  }
  
 }
}
-----------------------------------------------------------------------------------
例二：
Class c=Class.forName("AbstractClassTest.Car"); //要包名+类名
  Object o=c.newInstance();
  Car car=(Car)o;
  Field[] fields=c.getDeclaredFields();//拿到数据成员
  Method[] methods=c.getMethods();//拿到函数成员
  /*System.out.println(fields.length);
  System.out.println(methods.length);*/
  for(Field f : fields){
   System.out.println("该类的内部变量有:"+f.getName());
  }
  for(Method m : methods) {
   System.out.println("该类的方法有:"+m.getName());
  }
--------------------------------------------------------------------------------------
例3：



 
图二


 
测试结果



--------------------------------------------------------------------------------
例三：
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
/**
 * 测试类2
 * @author
 *
 */
public class TestReflect2 {
 public void testReflect(Object cls) throws NoSuchMethodException,
   IllegalAccessException, IllegalArgumentException,
   InvocationTargetException {
  Field[] fields = cls.getClass().getDeclaredFields(); //获取实体类所有属性
  for(int i=0; null != fields && i<fields.length; i++){
   System.out.println(fields[i].getName()+" - "+fields[i].get(cls));
   String[] tmpArr = (String[])fields[i].get(cls);
   for(String str : tmpArr){
    System.out.println(str);
   }
  }
 }
 
 public static void main(String[] args){
  
  try{
   FzConstant fzPo = (FzConstant)Class.forName("包名+类名").newInstance();
   TestReflect2 refTest = new TestReflect2();
   refTest.testReflect(fzPo);
  }catch(ClassNotFoundException ec){
   ec.printStackTrace();
  }catch (IllegalAccessException ea) {
   ea.printStackTrace();
  }catch (InstantiationException ei) {
   ei.printStackTrace();
  }catch (NoSuchMethodException en) {
   en.printStackTrace();
  }catch (InvocationTargetException et) {
   et.printStackTrace();
  }
 }
}