Java反射机制
继上篇文章
设计模式-
代理模式之后，今天来总结一下反射机制，因为动态代理中就是使用了反射机制跟代理模式的
融合，主要还是后面的
例子，
理解就好办了！
1.JAVA反射机制定义：
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种
动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
Java反射机制主要提供了以下功能：
- 在运行时判断任意一个对象所属的类；
- 在运行时构造任意一个类的对象；
- 在运行时判断任意一个类所具有的成员变量和方法；
- 在运行时调用任意一个对象的方法；
- 生成动态代理。
反射：Reflection。
用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的
classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields（成员变量）设值、或调用其methods。
2.两个Class
Object class，是所有Java classes的继承根源，其内声明了数个应该在所有Java class中被改写的methods：
hashCode()、equals()、clone()、toString()、getClass()等。其中getClass()返回一个Class object。
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。
注：个人认为类加载器产生class对象（类对象），当new一个对象是便调用类对象中的构造器或者静态方法；
3.运用实例 -- 其中（4）（5）比较重要，读者可以复制代码跑跑理解一下
（1）在运行时判断任意一个对象所属的类；
String s=new String("s");
System.out.println(s.getClass().getName())；
（2）在运行时构造任意一个类的对象；
运用static method------Class.forName()（最常被使用）
Class c1 = Class.forName ("java.lang.String");
Class c2 = Class.forName ("java.util.LinkedList$Entry");
运用getClass()【每个class 都有此函数】
String str = "abc";
Class c1 = str.getClass();
运用Class.getSuperclass()
Button b = new Button();
Class c1 = b.getClass();
Class c2 = c1.getSuperclass();
（3）在运行时判断任意一个类所具有的成员变量和方法；
package test.reflect;
import java.lang.reflect.*;
interface Hello{
public void say();
}
class HelloWorld implements Hello{
public String msg;
public HelloChina helloChina;
public void setMsg(String msg) {
this.msg=msg;
}
public void setHelloChina(Hello helloChina) {
this.helloChina=(HelloChina) helloChina;
}
@Override
public void say() {
System.out.println("Say Hello World!");
}
}
class HelloChina implements Hello{
@Override
public void say() {
System.out.println("Say Hello China!");
}
}
public class TestReflect{
public static void main(String[] args) {
Class<?> test= null;
try {
test = Class.forName("test.reflect.HelloWorld");
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("===============本类属性========================");
// 取得本类的全部属性
Field[] field = test.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 = test.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() + ";");
}
System.out.println("=========实现的方法===============");
Method[] methods=test.getMethods();
for (int i = 0; i < methods.length; i++) {
// 权限修饰符
int mo = methods[i].getModifiers();
String priv = Modifier.toString(mo);
// 属性类型
Class<?> type = methods[i].getReturnType();
System.out.println(priv + " " + type.getName() + " " + methods[i].getName() + ";");
}
}
}
//注：getDeclaredFields() 与 getFields()之间的区别在于前者只列出本类声明属性，后者除了列出本类属性之外还会列出继承属性！
（4）在运行时调用任意一个对象的方法；【Spring 中的DI（依赖注入）】
HelloWorld helloWorld=(HelloWorld) test.newInstance();
System.out.println("=========设置之前msg===============");
System.out.println(helloWorld.msg);
Method method=test.getMethod("setMsg", String.class);
method.invoke(helloWorld, "I am the Msg!! I will Set msg");
System.out.println("=========设置之后msg===============");
System.out.println(helloWorld.msg);
HelloChina helloChina=new HelloChina();
Method method1=test.getMethod("setHelloChina", HelloChina.class.getInterfaces());
method1.invoke(helloWorld, helloChina);
helloWorld.helloChina.say();
//下面就是spring中注入例子：
for(Element propertyElement : (List<Element>)element.getChildren("property")) {
String name = propertyElement.getAttributeValue("name"); //userDAO
String bean = propertyElement.getAttributeValue("bean"); //u
Object beanObject = beans.get(bean);//所需要的dao
//取得方法名称
String methodName = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);
System.out.println("method name = " + methodName);
//利用反射
Method m = o.getClass().getMethod(methodName, beanObject.getClass().getInterfaces()[0]);
m.invoke(o, beanObject);
}
例如在service中需要用到dao，这样我就需要在容器生成service时同时注入所需要的dao，就不用每次用到service时都去调用getBean方法，这个就是依赖注入。
（5）生成动态代理。
由于篇幅太长，所以动态代理将在下一篇中详细总结，感谢观看，祝您生活愉快！
相关文章
