记录反射技术的知识点

反射这个词在平常中我们并不常见,但是对于进阶java技术我们是不的不学习的.
java反射就是将类中的各个成分(构造函数,字段,方法)映射成一一对应的类.

反射的步骤:

1.获取到类的Class对象

2.通过Class对象获取构造函数对象(Constructor),字段对象(Field),方法对象(Method).

3.通过这些类某部分所映射出来的对象,结合某个具体的对象来获取对应对象该部分的值.

1)获取Class的方法用String类为例在(java.lang.String)包中

//获取class方法
Class a1 = Class.forName("java.lang.String");
Class a2 = String.class;
Class a3 = new String().getClass();
System.out.println(a1==a2);//true
System.out.println(a1==a3);//true

注意:

    得到的Class对象(字节码)在内存中没个类有且只有一份(类只会加载一次),所以上面会输出两个true.

2)通过反射获取构造方法以  String(StringBuffer sb);这个构造方法为例

Constructor<String> c = String.class.getConstructor(StringBuffer.class);
String sb = c.newInstance(new StringBuffer("abc"));
System.out.println(sb.charAt(1));//b

注：

第一句，首先获取到String对应的Class对象 之后通过getConstructor的方法获取到String类参数列表为StringBuffer的构造函数。

第二句，调用这个构造函数对象中的newInstance来实例化一个Sring对象。

第三句，利用我们刚创建的string对象来获取abc串中中的b

补充：

如果是想通过无参数的构造方法来创建string对象那么有更简便的方法：String.class.newInstance();类直接创建。

为了方便我创建AAA这个类放到com.ydcun包下

class AAA{
public int x;
private int y;
public String s1;
public String s2;
public String s3;
public AAA(){}
public AAA(int x, int y) {
super();
this.x = x;
this.y = y;
}
public AAA(String s1,String s2,String s3){
this.s1 = s1;
this.s2 = s2;
this.s3 = s3;
}
public static void main(String[] args) {
for(String s:args){
System.out.println(s);
}
}

}

3）通过反射获取AAA类的字段值

//反射方法获取变量
AAA a11 = new AAA(1,2);
Field fx = a11.getClass().getField("x");//获取AAA类所有对象的公共字段的值
System.out.println(fx.get(a11));//1
Field fy = a11.getClass().getDeclaredField("y");//获取私有的字段
fy.setAccessible(true);//强制访问
System.out.println(fy.get(a11));//2

注：第二是获取AAA这个类中所有对象的共有的x字段，第三行是制定获取AAA类中具体哪个对象中的x的值。

        第四和第五行同样的获取，只不过是获取的私有字段

4）通过反射修改该类对象中字段中的值

//修改对象中的字段值
AAA al2 = new AAA("ydcun123","hello123","abcde123");
Field[] fs = al2.getClass().getFields();
for(Field f: fs){
//因为是比较获取的这个字段是什么类型，string字节码在内存中有且只有一份
if(f.getType()==String.class){
String oldString = (String) f.get(al2);
String newString = oldString.replace('1', 'a');
f.set(al2, newString);
}
}
System.out.println(al2.s1+":"+al2.s2+":"+al2.s3);//ydcuna23:helloa23:abcdea23

5）通过反射获取到类中的方法以String类中的charAt方法为例：

String s2 = new String("abcde");
Method meth = s2.getClass().getMethod("charAt", int.class);//找charAt的方法参数是int型
System.out.println(meth.invoke(s2, 4));//e//第一个参数指定用那个对象执行，要是为null代表这个方法是静态的，第二个就是具体参数

6）调用AAA类中的main方法

String classp = "com.ydcun.AAA";//AAA类的完整路径
Class cp = Class.forName(classp);
Method methP = cp.getMethod("main", String[].class);
//为了兼容1.4版本中的new Object[]{} 来传递多个参数，他会吧我们要整体传入的参数给拆包
//methP.invoke(null,new Object[]{new String[]{"ydcun","abcdef","ggg"}});
methP.invoke(null, (Object)new String[]{"ydcun","abcdef","ggggg"});

7）数组反射

int[] arr1 = new int[]{1,2,3};
int[] arr2 = new int[4];
int[][] arr3 = new int[2][3];
String[] arr4 = new String[]{"123","abc","mnh","ggg"};
System.out.println(arr1.getClass() == arr2.getClass());
//下面两个直接不行
//System.out.println(arr1.getClass() == arr3.getClass());
//System.out.println(arr1.getClass() == arr3.getClass());

System.out.println(arr1.getClass().getName());//[I 整形的数组
System.out.println(arr1.getClass().getSuperclass().getName());//java.lang.Object
System.out.println(arr2.getClass().getName());//[I 整数数组
System.out.println(arr2.getClass().getSuperclass().getName());//java.lang.Object
System.out.println(arr3.getClass().getName());//[[I 二维数组int类型
System.out.println(arr3.getClass().getSuperclass().getName());//java.lang.Object
System.out.println(arr4.getClass().getName());//[Ljava.lang.String;string类
System.out.println(arr4.getClass().getSuperclass().getName());//java.lang.Object

Object aObj1 = arr1;
Object aObj2 = arr2;
//Object[] aObj3 = arr1;
Object[] aObj4 = arr3;
Object[] aObj5 = arr4;

System.out.println(arr1);//[I@1f33675
System.out.println(arr2);//[I@7c6768
//int[]
System.out.println(Arrays.asList(arr1));//[[I@1f33675]
System.out.println(Arrays.asList(arr4));//[123, abc, mnh, ggg]

Object obj = null;
//打印一个对象，可能是对象，
printObject(arr1);//1\n2\n3
printObject(arr4);//123\nabc\nmnh\nggg

注:

Constructor、Field、Method都是继承于AccessibleObject，对应实例调用setAccessible(true)就关闭私有保护

获取上述参数的方法有两种，一种是获取声明了的，一种是获取公开的对应的方法：

<Class>.getDeclaredConstructor()；
<CLass>.getConstructor();

<Class>.getDeclaredField();
<Class>.getField();

<Class>.getDeclaredMethod();
<Class>.getMethod();

这样好像java安全性就大大降低.如果你非常注重应用的安全性，java当然考虑到这方面，你可以在JVM启动参数增加
-Djava.security.manager 启用安全管理器，如果有该参数,它将检测正在关闭接入检测的代码是否许可了这样做,上述代码执行时会抛出java.security.AccessControlException异常。

8）反射机制大量的应用在框架的使用上。框架的方便是可以调用我们还没有定义的类，还有一些信息是我们通过配置文件来获得，从而提高了框架的灵活性。

下面就说下怎么读取配置文件以properties
这个config.properties配置文件我是直接放到项目的根目录下（eclipse中和src目录同级）
config2.properties 放在com.ydcun包下

//读取properties文件   从根目录读取
//InputStream inp = new FileInputStream("config.properties");
//通过类加载器来加载properties文件   在具体的包中
//InputStream inp = test.class.getClassLoader().getResourceAsStream("com/ydcun/config2.properties");
//直接通过class类来获取配置文件路径    相对于test这个类相对路径
//InputStream inp = test.class.getResourceAsStream("config2.properties");
//用绝对  和test类没太大关系
InputStream inp = test.class.getResourceAsStream("/com/ydcun/config2.properties");
Properties pro = new Properties();
pro.load(inp);
inp.close();//关闭流
//根据key读取value
String v = pro.getProperty("className");
System.out.println(v);

上面的反射是很基础的反射的应用。我们可以灵活运用设计出我们想设计的框架。

ydcun厚积薄发：
http://blog.csdn.net/ydcun/