java的反射机制

1.反射机制的定义

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

2.反射能做什么

在运行时判断任意一个对象所属的类；
在运行时构造任意一个类的对象；
在运行时判断任意一个类所具有的成员变量和方法；
在运行时调用任意一个对象的方法；
生成动态代理。

3.反射的常用API

//通过一个对象获得完整的包名和类名
public static void main(String[] args)
{
ReflectDemo reflectDemo = new ReflectDemo();
System.out.println(reflectDemo.getClass().getName());
/** * 运行结果:
* org.xiaowu.reflect.test.ReflectDemo
* */ }

//实例化Class类对象
public static void main(String[] args)
throws ClassNotFoundException {

Class<?> class1 = null;
Class<?> class2 = null;
Class<?> class3 = null; // 一般采用这种形式
class1 = Class.forName(“org.xiaowu.reflect.test.ReflectDemo”);
class2 = new ReflectDemo().getClass();
class3 = ReflectDemo.class;
System.out.println("类名称 " + class1.getName());
System.out.println("类名称 " + class2.getName());
System.out.println("类名称 " + class3.getName());
}

获取一个对象的父类和其实现的方法
package org.xiaowu.reflect.test;
import java.io.Serializable;
public class ReflectDemo6 implements Serializable
{
/** * */
private static final long serialVersionUID = 1L;
public static void main(String[] args)
throws ClassNotFoundException
{
Class<?> clazz = Class.forName(“org.xiaowu.reflect.test.ReflectDemo6”);
// 取得父类
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
}
}

想学习交流HashMap,nginx、dubbo、Spring MVC,分布式、高性能高可用、MySQL，redis、jvm、多线程、netty、kafka、的加尉xin（同英）：cgmx9880 扩列获取java进阶资料学习，无工作经验不要加哦！

//获取某个类的全部方法
package org.xiaowu.reflect.test;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class TestReflect1 implements Serializable{
/** * */
private static final long serialVersionUID = 1L;
public static void main(String[] args)
throws Exception
{
Class<?> clazz = Class.forName(“org.xiaowu.reflect.test.TestReflect1”);
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();
}
}
}

//通过反射机制调用某个类的方法
package org.xiaowu.reflect.test;
import java.lang.reflect.Method;
public class TestReflect2
{
public static void main(String[] args)
throws Exception {
Class<?> clazz = Class.forName(“org.xiaowu.reflect.test.TestReflect2”);
// 调用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);
}
}

//通过反射机制操作某个类的属性
package org.xiaowu.reflect.test;
import java.lang.reflect.Field;
public class TestReflect3
{
private String proprety = null;
public static void main(String[] args) throws Exception
{
Class<?> clazz = Class.forName(“org.xiaowu.reflect.test.TestReflect3”);
Object obj = clazz.newInstance();
// 可以直接对 private 的属性赋值
Field field = clazz.getDeclaredField(“proprety”);
field.setAccessible(true);
field.set(obj, “Java反射机制”);
System.out.println(field.get(obj));
}
}

反射机制实现动态代理
package org.xiaowu.reflect.demo;
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);
  }
  }

/反射机制的应用实例
package org.xiaowu.reflect.demo;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class TestReflect1
{
public static void main(String[] args)
throws IllegalAccessException,
IllegalArgumentException, InvocationTargetException,
NoSuchMethodException, SecurityException
{
ArrayList list = new ArrayList();
Method method = list.getClass().getMethod(“add”, Object.class);
method.invoke(list, “Java反射机制实例。”);
System.out.println(list.get(0));
System.out.println(list);
}
}

//通过反射取得并修改数组的信息
package org.xiaowu.reflect.demo;
import java.lang.reflect.Array;
public class TestReflect2
{
public static void main(String[] args)
{
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));
}
}

//通过反射机制修改数组的大小
package org.xiaowu.reflect.demo;
import java.lang.reflect.Array;
public class TestReflect3
{
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 org.xiaowu.reflect.demo;
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;
}
} /** * 对于普通的工厂模式当我们在添加一个子类的时候，就需要对应的修改工厂类。 当我们添加很多的子类的时候，会很麻烦。想学习交流HashMap,nginx、dubbo、Spring MVC,分布式、高性能高可用、MySQL，redis、jvm、多线程、netty、kafka、的加尉xin（同英）：cgmx9880 扩列获取java进阶资料学习，无工作经验不要加哦！

 * 现在我们利用反射机制实现工厂模式，可以在不修改工厂类的情况下添加任意多个子类。
 * 
 * 但是有一点仍然很麻烦，就是需要知道完整的包名和类名，这里可以使用properties配置文件来完成。
 * 
 * java 读取 properties 配置文件 的方法可以参考
 * http://baike.xsoftlab.net/view/java-read-the-properties-configuration-file * 
 * @author xsoftlab.net */

    public class TestReflect4 { 

public static void main(String[] args) throws Exception {
fruit f = Factory.getInstance(“org.xiaowu.reflect.demo.Apple”);
if (f != null)
{
f.eat();
System.out.println("-------------");
}
}
}

4.为什么要使用反射？使用反射的好处？

    这样我们就可以获得类的各种内容，进行了反编译。对于JAVA这种先编译再运行的语言来说，反射机制可以使代码更加灵活，更加容易实现面向对象。

5.怎样使用反射？

6.反射在我们项目中的应用？

  配置文件---.properties,称作属性文件。通过反射读取里边的内容。这样代码是固定的，但是配置文件的内容我们可以改，这样使我们的代码灵活了很多！

思维导图：