目录：
- 什么是反射机制
- 反射机制能做什么
- 反射机制功能代码示例
- 反射机制的常见应用
1：什么是反射机制？
反射机制是Java语言提供的一种基础功能，赋予程序在运行时自省(introspect)的能力。通过反射我们可以直接操作类或者对象，比如获取某个对象的类定义，获取类声明的属性和方法，调用方法或者构造对象，甚至可以运行时修改类定义。
反射机制是在运行状态中，对于任何一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法称为Java语言的反射机制。
2：反射机制能做什么？
1:)运行时，判断任意对象所属的类
2:)运行时，构造任意类的对象
3:)运行时，判断任意类的所有成员变量与方法
4:)运行时，调用任意对象的方法，与操作属性
5:)运行时，生成动态代理
3：反射机制功能代码示例
1:)运行时，判断任意对象所属的类
interface Animal {
void run();
void eat();
}
/**
* Person 类
*/
class Person implements Animal {
private int age;
private float height;
private double weight;
public Person(){}
public Person(int age, float height, double weight) {
this.age = age;
this.height = height;
this.weight = weight;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public float getHeight() {
return height;
}
public void setHeight(float height) {
this.height = height;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
@Override
public String toString() {
return "Person [age=" + age + ", height=" + height + ", weight="
+ weight + "]";
}
@Override
public void run() {
System.out.println(getClass().getSimpleName()+" run.");
}
@Override
public void eat() {
System.out.println(getClass().getSimpleName()+" eat.");
}
public void eat(String food) {
System.out.println(getClass().getSimpleName()+" eat " + food);
}
}
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.getClass().getName());
System.out.println(p.getClass().getPackage());
System.out.println(p.getClass().getSimpleName());
}
输出为：
io.zhongan.xdy4.instal.pre.Person
package io.zhongan.xdy4.instal.pre
Person
判断类所实现的接口
public static void main(String[] args) {
Class<?> c = null;
try {
c = Class.forName("io.zhongan.xdy4.instal.pre.Person");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Class<?>[] interfaces = c.getInterfaces();
for(Class<?> t:interfaces) {
System.out.println(t.getName());
}
}
输出：
io.zhongan.xdy4.instal.pre.Animal
获取类的父类：
public static void main(String[] args) {
Class<?> c = null;
try {
c = Class.forName("io.zhongan.xdy4.instal.pre.Person");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//获取父类
Class<?> p = c.getSuperclass();
//输出java.lang.Object
System.out.println(p.getName());
//输出空指针，因为Object的父类为null
System.out.println(p.getSuperclass().getName());
}
2:)运行时，构造任意类的对象
实例化Class对象
public static void main(String[] args) {
Class<?> c1 = null, c2=null, c3=null;
try {
c1 = Class.forName("io.zhongan.xdy4.instal.pre.Person");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
c2 =new Person().getClass();
c3 =Person.class;
System.out.println(c1.getName());
System.out.println(c2.getName());
System.out.println(c3.getName());
}
输出：
io.zhongan.xdy4.instal.pre.Person
io.zhongan.xdy4.instal.pre.Person
io.zhongan.xdy4.instal.pre.Person
构造任意类的对象
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
Class<?> c1 =Person.class;
Constructor<?>[] constructors = c1.getConstructors();
Person man1 = null, man2=null, man3=null;
try {
man1 = (Person) constructors[0].newInstance();
} catch (Exception e) {
e.printStackTrace();
}
try {
man1 = (Person) constructors[0].newInstance();
man2 = (Person) constructors[1].newInstance(18, 180.1f, 66.6d);
//构造方法按代码顺序，共两个，所以下面这行代码会报数组越界
// man3 = (Person) constructors[2].newInstance(18, 180.1);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(man1);
System.out.println(man2);
}
输出：
Person [age=0, height=0.0, weight=0.0]
Person [age=18, height=180.1, weight=66.6]
3:) 运行时，判断任意类的所有成员变量与方法
public static void main(String[] args) {
Class<?> c = null;
try {
c = Class.forName("io.zhongan.xdy4.instal.pre.Person");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Field[] fs = c.getDeclaredFields();
for(Field f : fs) {
int modifier = f.getModifiers();
String mString = Modifier.toString(modifier);
//输出
//private int age
//private float height
//private double weight
System.out.println(mString +" "+f.getType().getName() +" "+f.getName());
}
Method[] methods = c.getMethods();
for(Method m : methods) {
StringBuilder sb = new StringBuilder();
int modifier = m.getModifiers();
String mString = Modifier.toString(modifier);
String returnType = m.getReturnType().getName();
String methodName = m.getName();
sb.append(mString).append(" ").append(returnType).append(" ").append(methodName).append("(");
Parameter[] parameters = m.getParameters();
//获取参数
for(Parameter p:parameters) {
sb.append(Modifier.toString(p.getModifiers())).append(" ");
sb.append(p.getType().getName()).append(" ");
sb.append(p.getName()).append(", ");
}
if(sb.lastIndexOf(",")!=-1) {
sb.deleteCharAt(sb.lastIndexOf(","));
}
sb.append(")\n{\n}");
//打印类的方法(包含本类，父类及接口所有方法)
System.out.println(sb.toString());
}
}
4:)运行时，调用任意对象的方法，与操作属性
public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
Class<?> c = null;
try {
c = Class.forName("io.zhongan.xdy4.instal.pre.Person");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Method method= c.getMethod("eat", String.class);
//输出：Person eat 蔬菜和水果
method.invoke(c.newInstance(), "蔬菜和水果");
Person p = (Person) c.newInstance();
Method setMethod = c.getMethod("setHeight", float.class);
setMethod.invoke(p, 180.1f);
//输出：Person [age=0, height=180.1, weight=0.0]
System.out.println(p);
Field field = c.getDeclaredField("height");
field.setAccessible(true);
field.set(p, 191.1f);
//输出：Person [age=0, height=191.1, weight=0.0]
System.out.println(p);
}
5:)运行时，生成动态代理
//接口类：见上面的Animal
//实现类：见上面的Person
//代理类：见下面的DynamicProxy
//客户端类：见下面的Client
class DynamicProxy implements InvocationHandler {
private Object animal;
public DynamicProxy(Object animal) {
this.animal = animal;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("before " + getClass().getName() + " invoke.");
//此处传入被代理的对象
method.invoke(animal, args);
System.out.println("after " + getClass().getName() + " invoke.");
return null;
}
}
public class Client {
public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException, NoSuchFieldException {
Animal animal = new Person();
InvocationHandler handler = new DynamicProxy(animal);
Animal animalProxy = (Animal) Proxy.newProxyInstance(animal.getClass().getClassLoader(), animal.getClass().getInterfaces(), handler);
//此处输出：
//io.zhongan.xdy4.instal.pre.$Proxy0
//before io.zhongan.xdy4.instal.pre.DynamicProxy invoke.
//Person run.
//after io.zhongan.xdy4.instal.pre.DynamicProxy invoke.
System.out.println(animalProxy.getClass().getName());
animalProxy.run();
}
}
4：反射机制的常见应用
4.1:) 在JDBC中的应用
在JDBC 的操作中，如果要想进行数据库的连接，则必须按照以上的几步完成
- 通过Class.forName()加载数据库的驱动程序 （通过反射加载，前提是引入相关了Jar包）
- 通过 DriverManager 类进行数据库的连接，连接的时候要输入数据库的连接地址、用户名、密码
- 通过Connection 接口接收连接
由于每个数据库厂商提供的驱动路径是不同的，与其写死在代码中，每增加一个数据库厂商都要修改代码，不如将驱动路径写到上层应用的配置文件里，然后通过反射加载驱动。这样，底层JDBC的代码就不用频繁改动了，具备了良好的扩展性。
public class ConnectionJDBC {
/**
* @param args
*/
//驱动程序就是之前在classpath中配置的JDBC的驱动程序的JAR 包中
public static final String DBDRIVER = "com.mysql.jdbc.Driver";
//连接地址是由各个数据库生产商单独提供的，所以需要单独记住
public static final String DBURL = "jdbc:mysql://localhost:3306/test";
//连接数据库的用户名
public static final String DBUSER = "root";
//连接数据库的密码
public static final String DBPASS = "";
public static void main(String[] args) throws Exception {
Connection con = null; //表示数据库的连接对象
Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序 ,反射机制的体现
con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库
System.out.println(con);
con.close(); // 3、关闭数据库
}
4.1:) Spring 框架的使用
在 Java的反射机制在做基础框架的时候非常有用，行内有一句这样的老话：反射机制是Java框架的基石。一般应用层面很少用，不过这种东西，现在很多开源框架基本都已经封装好了，自己基本用不着写。典型的除了hibernate之外，还有spring也用到很多反射机制。最经典的就是xml的配置模式。
Spring 通过 XML 配置模式装载 Bean 的过程：
- 将程序内所有 XML 或 Properties 配置文件加载入内存中
- Java类里面解析xml或properties里面的内容，得到对应实体类的字节码字符串以及相关的属性信息
- 使用反射机制，根据这个字符串获得某个类的Class实例
- 动态配置实例的属性
Spring这样做的好处：
- 不用每一次都要在代码里面去new或者做其他的事情
- 以后要改的话直接改配置文件，代码维护起来就很方便了
- 有时为了适应某些需求，Java类里面不一定能直接调用另外的方法，可以通过反射机制来实现
模拟 Spring 加载 XML 配置文件：
public class BeanFactory {
private Map<String, Object> beanMap = new HashMap<String, Object>();
/**
* bean工厂的初始化.
* @param xml xml配置文件
*/
public void init(String xml) {
try {
//读取指定的配置文件
SAXReader reader = new SAXReader();
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
//从class目录下获取指定的xml文件
InputStream ins = classLoader.getResourceAsStream(xml);
Document doc = reader.read(ins);
Element root = doc.getRootElement();
Element foo;
//遍历bean
for (Iterator i = root.elementIterator("bean"); i.hasNext();) {
foo = (Element) i.next();
//获取bean的属性id和class
Attribute id = foo.attribute("id");
Attribute cls = foo.attribute("class");
//利用Java反射机制，通过class的名称获取Class对象
Class bean = Class.forName(cls.getText());
//获取对应class的信息
java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean);
//获取其属性描述
java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();
//设置值的方法
Method mSet = null;
//创建一个对象
Object obj = bean.newInstance();
//遍历该bean的property属性
for (Iterator ite = foo.elementIterator("property"); ite.hasNext();) {
Element foo2 = (Element) ite.next();
//获取该property的name属性
Attribute name = foo2.attribute("name");
String value = null;
//获取该property的子元素value的值
for(Iterator ite1 = foo2.elementIterator("value"); ite1.hasNext();) {
Element node = (Element) ite1.next();
value = node.getText();
break;
}
for (int k = 0; k < pd.length; k++) {
if (pd[k].getName().equalsIgnoreCase(name.getText())) {
mSet = pd[k].getWriteMethod();
//利用Java的反射极致调用对象的某个set方法，并将值设置进去
mSet.invoke(obj, value);
}
}
}
//将对象放入beanMap中，其中key为id值，value为对象
beanMap.put(id.getText(), obj);
}
} catch (Exception e) {
System.out.println(e.toString());
}
}
//other codes
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
