概要：
java反射机制详解
1反射机制是什么
反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
2反射机制能做什么
反射机制主要提供了以下功能： 
在运行时判断任意一个对象所属的类；
在运行时构造任意一个类的对象；
在运行时判断任意一个类所具有的成员变量和方法；
在运行时调用任意一个对象的方法；
生成动态代理。
3反射机制的相关api
通过一个对象获得完整的包名和类名
java | 复制
package net.xsoftlab.baike; public class testreflect { public static void main(string[] args) throws exception { testreflect testreflect = new testreflect(); system.out.println(testreflect.getclass().getname()); // 结果 net.xsoftlab.baike.testreflect } }
实例化class类对象
java | 复制
package net.xsoftlab.baike; public class testreflect { public static void main(string[] args) throws exception { class<?> class1 = null; class<?> class2 = null; class<?> class3 = null; // 一般采用这种形式 class1 = class.forname("net.xsoftlab.baike.testreflect"); class2 = new testreflect().getclass(); class3 = testreflect.class; system.out.println("类名称 " + class1.getname()); system.out.println("类名称 " + class2.getname()); system.out.println("类名称 " + class3.getname()); } }
获取一个对象的父类与实现的接口
java | 复制
package net.xsoftlab.baike; import java.io.serializable; public class testreflect implements serializable { private static final long serialversionuid = -2862585049955236662l; public static void main(string[] args) throws exception { class<?> clazz = class.forname("net.xsoftlab.baike.testreflect"); // 取得父类 class<?> parentclass = clazz.getsuperclass(); system.out.println("clazz的父类为：" + parentclass.getname()); // clazz的父类为： java.lang.object // 获取所有的接口 class<?> intes[] = clazz.getinterfaces(); system.out.println("clazz实现的接口有："); for (int i = 0; i < intes.length; i++) { system.out.println((i + 1) + "：" + intes[i].getname()); } // clazz实现的接口有： // 1：java.io.serializable } }
获取某个类中的全部构造函数 - 详见下例
通过反射机制实例化一个类的对象
java | 复制
package net.xsoftlab.baike; import java.lang.reflect.constructor; public class testreflect { public static void main(string[] args) throws exception { class<?> class1 = null; class1 = class.forname("net.xsoftlab.baike.user"); // 第一种方法，实例化默认构造方法，调用set赋值 user user = (user) class1.newinstance(); user.setage(20); user.setname("rollen"); system.out.println(user); // 结果 user [age=20, name=rollen] // 第二种方法 取得全部的构造函数 使用构造函数赋值 constructor<?> cons[] = class1.getconstructors(); // 查看每个构造方法需要的参数 for (int i = 0; i < cons.length; i++) { class<?> clazzs[] = cons[i].getparametertypes(); system.out.print("cons[" + i + "] ("); for (int j = 0; j < clazzs.length; j++) { if (j == clazzs.length - 1) system.out.print(clazzs[j].getname()); else system.out.print(clazzs[j].getname() + ","); } system.out.println(")"); } // 结果 // cons[0] (java.lang.string) // cons[1] (int,java.lang.string) // cons[2] () user = (user) cons[0].newinstance("rollen"); system.out.println(user); // 结果 user [age=0, name=rollen] user = (user) cons[1].newinstance(20, "rollen"); system.out.println(user); // 结果 user [age=20, name=rollen] } } class user { private int age; private string name; public user() { super(); } public user(string name) { super(); this.name = name; } public user(int age, string name) { super(); this.age = age; this.name = name; } public int getage() { return age; } public void setage(int age) { this.age = age; } public string getname() { return name; } public void setname(string name) { this.name = name; } @override public string tostring() { return "user [age=" + age + ", name=" + name + "]"; } }
获取某个类的全部属性
java | 复制
package net.xsoftlab.baike; import java.io.serializable; import java.lang.reflect.field; import java.lang.reflect.modifier; public class testreflect implements serializable { private static final long serialversionuid = -2862585049955236662l; public static void main(string[] args) throws exception { class<?> clazz = class.forname("net.xsoftlab.baike.testreflect"); system.out.println("===============本类属性==============="); // 取得本类的全部属性 field[] field = clazz.getdeclaredfields(); for (int i = 0; i < field.length; i++) { // 权限修饰符 int mo = field[i].getmodifiers(); string priv = modifier.tostring(mo); // 属性类型 class<?> type = field[i].gettype(); system.out.println(priv + " " + type.getname() + " " + field[i].getname() + ";"); } system.out.println("==========实现的接口或者父类的属性=========="); // 取得实现的接口或者父类的属性 field[] filed1 = clazz.getfields(); for (int j = 0; j < filed1.length; j++) { // 权限修饰符 int mo = filed1[j].getmodifiers(); string priv = modifier.tostring(mo); // 属性类型 class<?> type = filed1[j].gettype(); system.out.println(priv + " " + type.getname() + " " + filed1[j].getname() + ";"); } } }
获取某个类的全部方法
java | 复制
package net.xsoftlab.baike; import java.io.serializable; import java.lang.reflect.method; import java.lang.reflect.modifier; public class testreflect implements serializable { private static final long serialversionuid = -2862585049955236662l; public static void main(string[] args) throws exception { class<?> clazz = class.forname("net.xsoftlab.baike.testreflect"); method method[] = clazz.getmethods(); for (int i = 0; i < method.length; ++i) { class<?> returntype = method[i].getreturntype(); class<?> para[] = method[i].getparametertypes(); int temp = method[i].getmodifiers(); system.out.print(modifier.tostring(temp) + " "); system.out.print(returntype.getname() + " "); system.out.print(method[i].getname() + " "); system.out.print("("); for (int j = 0; j < para.length; ++j) { system.out.print(para[j].getname() + " " + "arg" + j); if (j < para.length - 1) { system.out.print(","); } } class<?> exce[] = method[i].getexceptiontypes(); if (exce.length > 0) { system.out.print(") throws "); for (int k = 0; k < exce.length; ++k) { system.out.print(exce[k].getname() + " "); if (k < exce.length - 1) { system.out.print(","); } } } else { system.out.print(")"); } system.out.println(); } } }
通过反射机制调用某个类的方法
java | 复制
package net.xsoftlab.baike; import java.lang.reflect.method; public class testreflect { public static void main(string[] args) throws exception { class<?> clazz = class.forname("net.xsoftlab.baike.testreflect"); // 调用testreflect类中的reflect1方法 method method = clazz.getmethod("reflect1"); method.invoke(clazz.newinstance()); // java 反射机制 - 调用某个类的方法1. // 调用testreflect的reflect2方法 method = clazz.getmethod("reflect2", int.class, string.class); method.invoke(clazz.newinstance(), 20, "张三"); // java 反射机制 - 调用某个类的方法2. // age -> 20. name -> 张三 } public void reflect1() { system.out.println("java 反射机制 - 调用某个类的方法1."); } public void reflect2(int age, string name) { system.out.println("java 反射机制 - 调用某个类的方法2."); system.out.println("age -> " + age + ". name -> " + name); } }
通过反射机制操作某个类的属性
java | 复制
package net.xsoftlab.baike; import java.lang.reflect.field; public class testreflect { private string proprety = null; public static void main(string[] args) throws exception { class<?> clazz = class.forname("net.xsoftlab.baike.testreflect"); object obj = clazz.newinstance(); // 可以直接对 private 的属性赋值 field field = clazz.getdeclaredfield("proprety"); field.setaccessible(true); field.set(obj, "java反射机制"); system.out.println(field.get(obj)); } }
反射机制的动态代理
java | 复制
// 获取类加载器的方法 testreflect testreflect = new testreflect(); system.out.println("类加载器 " + testreflect.getclass().getclassloader().getclass().getname()); package net.xsoftlab.baike; import java.lang.reflect.invocationhandler; import java.lang.reflect.method; import java.lang.reflect.proxy; //定义项目接口 interface subject { public string say(string name, int age); } // 定义真实项目 class realsubject implements subject { public string say(string name, int age) { return name + " " + age; } } class myinvocationhandler implements invocationhandler { private object obj = null; public object bind(object obj) { this.obj = obj; return proxy.newproxyinstance(obj.getclass().getclassloader(), obj.getclass().getinterfaces(), this); } public object invoke(object proxy, method method, object[] args) throws throwable { object temp = method.invoke(this.obj, args); return temp; } } /** * 在java中有三种类类加载器。 * * 1）bootstrap classloader 此加载器采用c++编写，一般开发中很少见。 * * 2）extension classloader 用来进行扩展类的加载，一般对应的是jrelibext目录中的类 * * 3）appclassloader 加载classpath指定的类，是最常用的加载器。同时也是java中默认的加载器。 * * 如果想要完成动态代理，首先需要定义一个invocationhandler接口的子类，已完成代理的具体操作。 * * @author xsoftlab.net * */ public class testreflect { public static void main(string[] args) throws exception { myinvocationhandler demo = new myinvocationhandler(); subject sub = (subject) demo.bind(new realsubject()); string info = sub.say("rollen", 20); system.out.println(info); } }
4反射机制的应用实例
在泛型为integer的arraylist中存放一个string类型的对象。
java | 复制
package net.xsoftlab.baike; import java.lang.reflect.method; import java.util.arraylist; public class testreflect { public static void main(string[] args) throws exception { arraylist<integer> list = new arraylist<integer>(); method method = list.getclass().getmethod("add", object.class); method.invoke(list, "java反射机制实例。"); system.out.println(list.get(0)); } }
通过反射取得并修改数组的信息
java | 复制
package net.xsoftlab.baike; import java.lang.reflect.array; public class testreflect { public static void main(string[] args) throws exception { int[] temp = { 1, 2, 3, 4, 5 }; class<?> demo = temp.getclass().getcomponenttype(); system.out.println("数组类型： " + demo.getname()); system.out.println("数组长度 " + array.getlength(temp)); system.out.println("数组的第一个元素: " + array.get(temp, 0)); array.set(temp, 0, 100); system.out.println("修改之后数组第一个元素为： " + array.get(temp, 0)); } }
通过反射机制修改数组的大小
java | 复制
package net.xsoftlab.baike; import java.lang.reflect.array; public class testreflect { public static void main(string[] args) throws exception { int[] temp = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; int[] newtemp = (int[]) arrayinc(temp, 15); print(newtemp); string[] atr = { "a", "b", "c" }; string[] str1 = (string[]) arrayinc(atr, 8); print(str1); } // 修改数组大小 public static object arrayinc(object obj, int len) { class<?> arr = obj.getclass().getcomponenttype(); object newarr = array.newinstance(arr, len); int co = array.getlength(obj); system.arraycopy(obj, 0, newarr, 0, co); return newarr; } // 打印 public static void print(object obj) { class<?> c = obj.getclass(); if (!c.isarray()) { return; } system.out.println("数组长度为： " + array.getlength(obj)); for (int i = 0; i < array.getlength(obj); i++) { system.out.print(array.get(obj, i) + " "); } system.out.println(); } }
将反射机制应用于工厂模式
java | 复制
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(); } } }