java invoke 反射机制实现演练

1反射机制是什么

反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

2运用原理

在web转发时候可以根据前台传来的ServiceId 和 ServiceAction去寻找所对应的服务和方法名。从而寻找到处理业务逻辑的具体Service和具体方法实现去执行。

实战演练

package invoke;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/***
* java 反射机制实战
* @author Administrator
*
*/
public class TestIvoke {

public void doSomething(Map<String, Object> name1,String name2,Object name3){
System.out.println("doSomething");
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
//第一步 先得到TestIvoke 类的class  或者cls =	TestIvoke.class
Class   cls = 	TestIvoke.class ;
//					Class.forName("TestIvoke");
//模拟传入的参数
Map<String, Object> name1 = new HashMap<String, Object>();
String name2 = new String();
Object name3 = new Object();
//用来存放三个参数
List<Object> params = new ArrayList<Object>();
params.add(name1);
params.add(name2);
params.add(name3);
//用来存放三个参数的类型
List<Class<?>> parameterTypes = new ArrayList<Class<?>>();
Iterator<Object> it = params.iterator();
while (it.hasNext()) {
Object object = it.next();
if(object instanceof Map){//由于上面定义了name1 为HashMap 类型 这边要强制
parameterTypes.add(Map.class);
}else{
parameterTypes.add(object.getClass());
}

}
System.out.println(parameterTypes.toArray(new Class<?>[parameterTypes.size()])[1]);
//获得medhod class中的具体方法
Method method = cls.getDeclaredMethod("doSomething",
parameterTypes.toArray(new Class<?>[parameterTypes.size()]));
try {
//methon反射  构建新对象，传入参数

//或者 method.invoke( new TestIvoke() , params.toArray(new Object[params.size()]));
method.invoke(new TestIvoke(), params.toArray(new Object[params.size()]));
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

 最后输出为

doSomething

将反射机制应用于工厂模式

* 对于普通的工厂模式当我们在添加一个子类的时候，就需要对应的修改工厂类。 当我们添加很多的子类的时候，会很麻烦。
package net.xsoftlab.baike;
interface fruit {
    public abstract void eat();
}
class Apple implements fruit {
    public void eat() {
        System.out.println("Apple");
    }
}
class Orange implements fruit {
    public void eat() {
        System.out.println("Orange");
    }
}
class Factory {
    public static fruit getInstance(String ClassName) {
        fruit f = null;
        try {
            f = (fruit) Class.forName(ClassName).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return f;
    }
}
/**
 * 对于普通的工厂模式当我们在添加一个子类的时候，就需要对应的修改工厂类。 当我们添加很多的子类的时候，会很麻烦。
 * Java 工厂模式可以参考
 * http://baike.xsoftlab.net/view/java-factory-pattern  * 
 * 现在我们利用反射机制实现工厂模式，可以在不修改工厂类的情况下添加任意多个子类。
 * 
 * 但是有一点仍然很麻烦，就是需要知道完整的包名和类名，这里可以使用properties配置文件来完成。
 * 
 * java 读取 properties 配置文件 的方法可以参考
 * http://baike.xsoftlab.net/view/java-read-the-properties-configuration-file  * 
 * @author xsoftlab.net
 */
public class TestReflect {
    public static void main(String[] args) throws Exception {
        fruit f = Factory.getInstance("net.xsoftlab.baike.Apple");
        if (f != null) {
            f.eat();
        }
    }
}

代码和解释都是自己一个个敲出来的，如果大家觉得有用就请顶一下吧。