java反射技术的应用

JAVA 反射机制的简单应用

  开发的时候有时候会碰到这样的情况，我们在写程序的时候并不知道需要调用某个对象的哪个方法，只有程序运行后，我们才能够知道。或许我们需要根据客户端传过来的某个String 参数的值来判断我们应该执行哪个方法。在这种情况下JAVA 的反射执行就可以帮上忙了。下面是我做的一个简单的测试代码，提供给大家做个参考。

import  java.lang.reflect.InvocationTargetException;
import  java.lang.reflect.Method;

/**
 *  @author  Dong
 *  测试 JAVA reflect 机制 
 */ 
public   class  TestRef {
     /**
     *  @param  args
     */ 
     public   static   void  main(String[] args) {
            TestBean test =  new  TestBean();
            Method[] methods = test.getClass().getMethods();
            test.setAbc("---");
             for ( int  i=0;i<methods.length;i++) {
                 if (methods[i].getName().equalsIgnoreCase("getabc")) {
                     try   {
                        System.out.println(methods[i].invoke(test));
                    }  catch  (IllegalArgumentException e)  {
                        e.printStackTrace();
                    }  catch  (IllegalAccessException e)  {
                        e.printStackTrace();
                    }  catch  (InvocationTargetException e)  {
                        e.printStackTrace();
                    }
                }
            }
    }
}

 

 

 

 

JAVA 反射机制
    JAVA 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java 语言的反射机制。
Java 反射机制主要提供了以下功能：  在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
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 
 3     Class ownerClass = owner.getClass();
 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(owner, args);
14 }
Class owner_class = owner.getClass()  ：首先还是必须得到这个对象的Class 。

5 ～9 行：配置参数的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 
 2 public Object newInstance(String className, Object[] args) throws Exception {
 3     Class newoneClass = 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     Constructor cons = newoneClass.getConstructor(argsClass);
12 
13     return cons.newInstance(args);
14 
15 }

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

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

第5 ～第9 行：得到参数的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 }

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Java 反射机制深入研究

 

Java 反射是 Java 语言的一个很重要的特征，它使得 Java 具体了 “ 动态性 ” 。

 

在 Java 运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于 Java 语言的反射（ Reflection ）机制。

 

Java 反射机制主要提供了以下功能：

在运行时判断任意一个对象所属的类。

在运行时构造任意一个类的对象。

在运行时判断任意一个类所具有的成员变量和方法。

在运行时调用任意一个对象的方法。

 

Reflection 是 Java 被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过 Reflection APIs 取得任何一个已知名称的 class 的内部信息，包括其 modifiers （诸如 public, static 等等）、 superclass （例如 Object ）、实现之interfaces （例如 Serializable ），也包括 fields 和 methods 的所有信息，并可于运行时改变 fields 内容或调用 methods 。

 

一般而言，开发者社群说到动态语言，大致认同的一个定义是： “ 程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言” 。从这个观点看， Perl ， Python ， Ruby 是动态语言， C++ ， Java ， C# 不是动态语言。

 

尽管在这样的定义与分类下 Java 不是动态语言，它却有着一个非常突出的动态相关机制： Reflection 。这个字的意思是 “ 反射、映象、倒影 ” ，用在 Java 身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的 classes 。换句话说， Java 程序可以加载一个运行时才得知名称的 class ，获悉其完整构造（但不包括 methods 定义），并生成其对象实体、或对其 fields 设值、或唤起其 methods 。这种 “ 看透 class” 的能力（ the ability of the program to examine itself ）被称为 introspection （内省、内观、反省）。 Reflection 和 introspection 是常被并提的两个术语。

 

在 JDK 中，主要由以下类来实现 Java 反射机制，这些类都位于 java.lang.reflect 包中：

Class 类：代表一个类。

Field 类：代表类的成员变量（成员变量也称为类的属性）。

Method 类：代表类的方法。

Constructor 类：代表类的构造方法。

Array 类：提供了动态创建数组，以及访问数组的元素的静态方法。

 

下面给出几个例子看看 Reflection API 的实际运用：

 

一、通过 Class 类获取成员变量、成员方法、接口、超类、构造方法等

 

在 java.lang.Object 类中定义了 getClass() 方法，因此对于任意一个 Java 对象，都可以通过此方法获得对象的类型。 Class 类是Reflection API 中的核心类，它有以下方法

getName() ：获得类的完整名字。

getFields() ：获得类的 public 类型的属性。

getDeclaredFields() ：获得类的所有属性。

getMethods() ：获得类的 public 类型的方法。

getDeclaredMethods() ：获得类的所有方法。

getMethod(String name, Class[] parameterTypes) ：获得类的特定方法， name 参数指定方法的名字， parameterTypes 参数指定方法的参数类型。

getConstructors() ：获得类的 public 类型的构造方法。

getConstructor(Class[] parameterTypes) ：获得类的特定构造方法， parameterTypes 参数指定构造方法的参数类型。

newInstance() ：通过类的不带参数的构造方法创建这个类的一个对象。

 

下面给出一个综合运用的例子：

 

public class RefConstructor {

 

    public static void main(String args[]) throws Exception {

        RefConstructor ref = new RefConstructor();

        ref.getConstructor();

 

    }

 

    public void getConstructor() throws Exception {

        Class c = null;

        c = Class.forName("java.lang.Long");

        Class cs[] = {java.lang.String.class};

 

        System.out.println("/n-------------------------------/n");

 

        Constructor cst1 = c.getConstructor(cs);

        System.out.println("1 、通过参数获取指定 Class 对象的构造方法： ");

        System.out.println(cst1.toString());

 

        Constructor cst2 = c.getDeclaredConstructor(cs);

        System.out.println("2 、通过参数获取指定 Class 对象所表示的类或接口的构造方法： ");

        System.out.println(cst2.toString());

 

        Constructor cst3 = c.getEnclosingConstructor();

        System.out.println("3 、获取本地或匿名类 Constructor 对象，它表示基础类的立即封闭构造方法。 ");

        if (cst3 != null) System.out.println(cst3.toString());

        else System.out.println("-- 没有获取到任何构造方法！ ");

 

        Constructor[] csts = c.getConstructors();

        System.out.println("4 、获取指定 Class 对象的所有构造方法： ");

        for (int i = 0; i < csts.length; i++) {

            System.out.println(csts[i].toString());

        }

 

        System.out.println("/n-------------------------------/n");

 

        Type types1[] = c.getGenericInterfaces();

        System.out.println("1 、返回直接实现的接口： ");

        for (int i = 0; i < types1.length; i++) {

            System.out.println(types1[i].toString());

        }

 

        Type type1 = c.getGenericSuperclass();

        System.out.println("2 、返回直接超类： ");

        System.out.println(type1.toString());

 

        Class[] cis = c.getClasses();

        System.out.println("3 、返回超类和所有实现的接口： ");

        for (int i = 0; i < cis.length; i++) {

            System.out.println(cis[i].toString());

        }

 

        Class cs1[] = c.getInterfaces();

        System.out.println("4 、实现的接口 ");

        for (int i = 0; i < cs1.length; i++) {

            System.out.println(cs1[i].toString());

        }

 

        System.out.println("/n-------------------------------/n");

 

        Field fs1[] = c.getFields();

        System.out.println("1 、类或接口的所有可访问公共字段： ");

        for (int i = 0; i < fs1.length; i++) {

            System.out.println(fs1[i].toString());

        }

 

        Field f1 = c.getField("MIN_VALUE");

        System.out.println("2 、类或接口的指定已声明指定公共成员字段： ");

        System.out.println(f1.toString());

 

        Field fs2[] = c.getDeclaredFields();

        System.out.println("3 、类或接口所声明的所有字段： ");

        for (int i = 0; i < fs2.length; i++) {

            System.out.println(fs2[i].toString());

        }

 

        Field f2 = c.getDeclaredField("serialVersionUID");

        System.out.println("4 、类或接口的指定已声明指定字段： ");

        System.out.println(f2.toString());

 

        System.out.println("/n-------------------------------/n");

 

        Method m1[] = c.getMethods();

        System.out.println("1 、返回类所有的公共成员方法： ");

        for (int i = 0; i < m1.length; i++) {

            System.out.println(m1[i].toString());

        }

 

        Method m2 = c.getMethod("longValue", new Class[]{});

        System.out.println("2 、返回指定公共成员方法： ");

        System.out.println(m2.toString());

 

    }

}

输出结果：输出结果很长，这里不再给出。

 

 

二、运行时复制对象

 

例程 ReflectTester 类进一步演示了 Reflection API 的基本使用方法。 ReflectTester 类有一个 copy(Object object) 方法，这个方法能够创建一个和参数 object 同样类型的对象，然后把 object 对象中的所有属性拷贝到新建的对象中，并将它返回

这个例子只能复制简单的 JavaBean ，假定 JavaBean 的每个属性都有 public 类型的 getXXX() 和 setXXX() 方法。

 

public class ReflectTester {

    public Object copy(Object object) throws Exception {

        // 获得对象的类型

        Class<?> classType = object.getClass();

        System.out.println("Class:" + classType.getName());

 

        // 通过默认构造方法创建一个新的对象

        Object objectCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});

 

        // 获得对象的所有属性

        Field fields[] = classType.getDeclaredFields();

 

        for (int i = 0; i < fields.length; i++) {

            Field field = fields[i];

 

            String fieldName = field.getName();

            String firstLetter = fieldName.substring(0, 1).toUpperCase();

            // 获得和属性对应的 getXXX() 方法的名字

            String getMethodName = "get" + firstLetter + fieldName.substring(1);

            // 获得和属性对应的 setXXX() 方法的名字

            String setMethodName = "set" + firstLetter + fieldName.substring(1);

 

            // 获得和属性对应的 getXXX() 方法

            Method getMethod = classType.getMethod(getMethodName, new Class[]{});

            // 获得和属性对应的 setXXX() 方法

            Method setMethod = classType.getMethod(setMethodName, new Class[]{field.getType()});

 

            // 调用原对象的 getXXX() 方法

            Object value = getMethod.invoke(object, new Object[]{});

            System.out.println(fieldName + ":" + value);

            // 调用拷贝对象的 setXXX() 方法

            setMethod.invoke(objectCopy, new Object[]{value});

        }

        return objectCopy;

    }

 

    public static void main(String[] args) throws Exception {

        Customer customer = new Customer("Tom", 21);

        customer.setId(new Long(1));

 

        Customer customerCopy = (Customer) new ReflectTester().copy(customer);

        System.out.println("Copy information:" + customerCopy.getId() + " " + customerCopy.getName() + " "

                + customerCopy.getAge());

    }

}

 

class Customer {

    private Long id;

 

    private String name;

 

    private int age;

 

    public Customer() {

    }

 

    public Customer(String name, int age) {

        this.name = name;

        this.age = age;

    }

 

    public Long getId() {

        return id;

    }

 

    public void setId(Long id) {

        this.id = id;

    }

 

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

    public int getAge() {

        return age;

    }

 

    public void setAge(int age) {

        this.age = age;

    }

}

 

输出结果：

 

Class:com.langsin.reflection.Customer

id:1

name:Tom

age:21

Copy information:1 Tom 21

 

Process finished with exit code 0

 

解说：

ReflectTester 类的 copy(Object object) 方法依次执行以下步骤

（ 1 ）获得对象的类型：

Class classType=object.getClass();

System.out.println("Class:"+classType.getName());

 

（ 2 ）通过默认构造方法创建一个新对象：

Object objectCopy=classType.getConstructor(new Class[]{}).newInstance(new Object[]{});

以上代码先调用 Class 类的 getConstructor() 方法获得一个 Constructor 对象，它代表默认的构造方法，然后调用 Constructor 对象的 newInstance() 方法构造一个实例。

 

3 ）获得对象的所有属性：

Field fields[]=classType.getDeclaredFields();

Class 类的 getDeclaredFields() 方法返回类的所有属性，包括 public 、 protected 、默认和 private 访问级别的属性

 

（ 4 ）获得每个属性相应的 getXXX() 和 setXXX() 方法，然后执行这些方法，把原来对象的属性拷贝到新的对象中

 

 

三、用反射机制调用对象的方法

 

public class InvokeTester {

    public int add(int param1, int param2) {

        return param1 + param2;

    }

 

    public String echo(String msg) {

        return "echo: " + msg;

    }

 

    public static void main(String[] args) throws Exception {

        Class<?> classType = InvokeTester.class;

        Object invokeTester = classType.newInstance();

 

        // Object invokeTester = classType.getConstructor(new

        // Class[]{}).newInstance(new Object[]{});

 

 

        // 获取 InvokeTester 类的 add() 方法

        Method addMethod = classType.getMethod("add", new Class[]{int.class, int.class});

        // 调用 invokeTester 对象上的 add() 方法

        Object result = addMethod.invoke(invokeTester, new Object[]{new Integer(100), new Integer(200)});

        System.out.println((Integer) result);

 

 

        // 获取 InvokeTester 类的 echo() 方法

        Method echoMethod = classType.getMethod("echo", new Class[]{String.class});

        // 调用 invokeTester 对象的 echo() 方法

        result = echoMethod.invoke(invokeTester, new Object[]{"Hello"});

        System.out.println((String) result);

    }

}

 

 

在例程 InvokeTester 类的 main() 方法中，运用反射机制调用一个 InvokeTester 对象的 add() 和 echo() 方法

 

add() 方法的两个参数为 int 类型，获得表示 add() 方法的 Method 对象的代码如下：

Method addMethod=classType.getMethod("add",new Class[]{int.class,int.class});

Method 类的 invoke(Object obj,Object args[]) 方法接收的参数必须为对象，如果参数为基本类型数据，必须转换为相应的包装类型的对象。 invoke() 方法的返回值总是对象，如果实际被调用的方法的返回类型是基本类型数据，那么 invoke() 方法会把它转换为相应的包装类型的对象，再将其返回。

 

在本例中，尽管 InvokeTester 类的 add() 方法的两个参数以及返回值都是 int 类型，调用 add Method 对象的 invoke() 方法时，只能传递 Integer 类型的参数，并且 invoke() 方法的返回类型也是 Integer 类型， Integer 类是 int 基本类型的包装类：

 

Object result=addMethod.invoke(invokeTester,

new Object[]{new Integer(100),new Integer(200)});

System.out.println((Integer)result); //result 为 Integer 类型

 

 

四、动态创建和访问数组

 

java.lang.Array 类提供了动态创建和访问数组元素的各种静态方法。

 

例程 ArrayTester1 类的 main() 方法创建了一个长度为 10 的字符串数组，接着把索引位置为 5 的元素设为 “hello” ，然后再读取索引位置为 5 的元素的值

 

public class ArrayTester1 {

    public static void main(String args[]) throws Exception {

        Class<?> classType = Class.forName("java.lang.String");

        // 创建一个长度为 10 的字符串数组

        Object array = Array.newInstance(classType, 10);

        // 把索引位置为 5 的元素设为 "hello"

        Array.set(array, 5, "hello");

        // 获得索引位置为 5 的元素的值

        String s = (String) Array.get(array, 5);

        System.out.println(s);

    }

}

 

 

例程 ArrayTester2 类的 main() 方法创建了一个 5 x 10 x 15 的整型数组，并把索引位置为 [3][5][10] 的元素的值为设 37 。

 

public class ArrayTester2 {

    public static void main(String args[]) {

        int[] dims = new int[]{5, 10, 15};

        // 创建一个具有指定的组件类型和维度的新数组。

        Object array = Array.newInstance(Integer.TYPE, dims);

       

        Object arrayObj = Array.get(array, 3);

        Class<?> cls = arrayObj.getClass().getComponentType();

        System.out.println(cls);

 

        arrayObj = Array.get(arrayObj, 5);

        Array.setInt(arrayObj, 10, 37);

        int arrayCast[][][] = (int[][][]) array;

        System.out.println(arrayCast[3][5][10]);

    }

}

 

 

深入认识 Class 类

 

众所周知 Java 有个 Object 类，是所有 Java 类的继承根源，其内声明了数个应该在所有 Java 类中被改写的方法： hashCode() 、equals() 、 clone() 、 toString() 、 getClass() 等。其中 getClass() 返回一个 Class 类的对象。

 

Class 类十分特殊。它和一般 classes 一样继承自 Object ，其实体用以表达 Java 程序运行时的 classes 和 interfaces ，也用来表达 enum 、 array 、 primitive Java types

（ boolean, byte, char, short, int, long, float, double ）以及关键词 void 。当一个 class 被加载，或当加载器（ class loader ）的 defineClass() 被 JVM 调用， JVM 便自动产生一个 Class object 。如果您想借由 “ 修改 Java 标准库源码 ” 来观察Class object 的实际生成时机（例如在 Class 的 constructor 内添加一个 println() ），不能够！因为 Class 并没有 public constructor

 

Class 是 Reflection 起源。针对任何您想探勘的 class ，唯有先为它产生一个 Class object ，接下来才能经由后者唤起为数十多个的 Reflection APIs

 

Java 允许我们从多种途径为一个 class 生成对应的 Class 对象。参看本人的《 深入研究 java.long.Class 类 》一文。

 

欲生成对象实体，在 Reflection 动态机制中有两种作法，一个针对 “ 无自变量 ctor” ，一个针对 “ 带参数 ctor” 。如果欲调用的是 “带参数 ctor“ 就比较麻烦些，不再调用 Class 的 newInstance() ，而是调用 Constructor 的 newInstance() 。首先准备一个Class[] 做为 ctor 的参数类型（本例指定

为一个 double 和一个 int ），然后以此为自变量调用 getConstructor() ，获得一个专属 ctor 。接下来再准备一个 Object[] 做为ctor 实参值（本例指定 3.14159 和 125 ），调用上述专属 ctor 的 newInstance() 。

 

动态生成 “Class object 所对应之 class” 的对象实体；无自变量。

 

这个动作和上述调用 “ 带参数之 ctor” 相当类似。首先准备一个 Class[] 做为参数类型（本例指定其中一个是 String ，另一个是Hashtable ），然后以此为自变量调用 getMethod() ，获得特定的 Method object 。接下来准备一个 Object[] 放置自变量，然后调用上述所得之特定 Method object 的 invoke() 。

为什么获得 Method object 时不需指定回返类型？

 

因为 method overloading 机制要求 signature 必须唯一，而回返类型并非 signature 的一个成份。换句话说，只要指定了method 名称和参数列，就一定指出了一个独一无二的 method 。

 

 

四、运行时变更 field 内容

 

与先前两个动作相比， “ 变更 field 内容 ” 轻松多了，因为它不需要参数和自变量。首先调用 Class 的 getField() 并指定 field 名称。获得特定的 Field object 之后便可直接调用 Field 的 get() 和 set() 。

 

public class RefFiled {

    public double x;

    public Double y;

 

    public static void main(String args[]) throws NoSuchFieldException, IllegalAccessException {

        Class c = RefFiled.class;

        Field xf = c.getField("x");

        Field yf = c.getField("y");

 

        RefFiled obj = new RefFiled();

 

        System.out.println(" 变更前 x=" + xf.get(obj));

        // 变更成员 x 值

        xf.set(obj, 1.1);

        System.out.println(" 变更后 x=" + xf.get(obj));

 

        System.out.println(" 变更前 y=" + yf.get(obj));

        // 变更成员 y 值

        yf.set(obj, 2.1);

        System.out.println(" 变更后 y=" + yf.get(obj));

    }

}

 

运行结果：

 

变更前 x=0.0

变更后 x=1.1

变更前 y=null

变更后 y=2.1

 

Process finished with exit code 0

 

 

 

 

 

 

 

 

       private static Object check(Object obj,String flag) throws Exception

       {

              Class ts=obj.getClass();

              Field[] fs=ts.getDeclaredFields();

              Method[] ms=ts.getDeclaredMethods();

              StringBuffer fd=new StringBuffer();

              Map<String,Object> getMethodMap=new HashMap<String,Object>();

              Map<String,Method> setMethodMap=new HashMap<String,Method>();

              String methodName="";

              String value="";

              for(int i=0;i<fs.length;i++)

              {

                     if(java.lang.String.class!=fs[i].getType())

                     {

                            fd.append(fs[i].getName());

                     }

              }

              for(int i=0;i<ms.length;i++)

              {

                     methodName=ms[i].getName().toLowerCase();

                     if(methodName.indexOf("get")!=-1)

                     {

                            getMethodMap.put(methodName.substring(3), ms[i].invoke(obj, null));

                     }

                     else

                     {

                            setMethodMap.put(methodName.substring(3), ms[i]);

                     }

              }

              Set keySet=getMethodMap.keySet();

              Iterator it=keySet.iterator();

              String key="";

              while(it.hasNext())

              {

                     key=it.next().toString();

                     if(fd.indexOf(key)==-1&&getMethodMap.get(key)!=null)

                     {

                            value=getMethodMap.get(key).toString().replaceAll(",", "").replaceAll(" ", "");

                            if("".equals(value)||flag.equals(value))

                            {

                                   ((Method) setMethodMap.get(key)).invoke(obj, new Object[]{null});                              

                            }

                            else

                            {

                                   ((Method) setMethodMap.get(key)).invoke(obj, new Object[]{value});                                  

                            }

                     }

              }

              return obj;

       }