Java Reflect(反射)机制详解
反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
反射机制主要提供了以下功能：
-在运行时判断任意一个对象所属的类；
-在运行时构造任意一个类的对象；
-在运行时判断任意一个类所具有的成员变量和方法；
-在运行时调用任意一个对象的方法；
-生成动态代理。
反射机制的相关API
通过一个对象获得完整的包名和类名
/**
* 获得完整的包名和类名
* @author mazaiting
*/
public class Reflect1 {
public static void main(String[] args) {
Reflect1 reflect1 = new Reflect1();
System.out.println("包名: " + reflect1.getClass().getPackage());
System.out.println("类名: " + reflect1.getClass().getName());
System.out.println("简单名: " + reflect1.getClass().getSimpleName());
System.out.println("规范名: " + reflect1.getClass().getCanonicalName());
System.out.println("类型名: " + reflect1.getClass().getTypeName());
/**
* 包名: package com.mazaiting
* 类名: com.mazaiting.Reflect1
* 简单名: Reflect1
* 规范名: com.mazaiting.Reflect1
* 类型名: com.mazaiting.Reflect1
*/
}
}
实例化Class类对象
/**
* 实例化Class类对象
* @author mazaiting
*/
public class Reflect2 {
public static void main(String[] args) throws ClassNotFoundException {
Class<?> class1 = null;
Class<?> class2 = null;
Class<?> class3 = null;
class1 = Class.forName("com.mazaiting.Reflect2");
class2 = new Reflect2().getClass();
class3 = Reflect2.class;
System.out.println("类名: " + class1.getName());
System.out.println("类名: " + class2.getName());
System.out.println("类名: " + class3.getName());
/**
* 类名: com.mazaiting.Reflect2
* 类名: com.mazaiting.Reflect2
* 类名: com.mazaiting.Reflect2
*/
}
}
获取一个对象的父类与实现的接口
/**
* 获取一个对象的父类与实现的接口
* @author mazaiting
*/
public class Reflect3 implements Serializable{
public static void main(String[] args) throws ClassNotFoundException {
Class<?> clazz = Class.forName("com.mazaiting.Reflect3");
Class<?> superclass = clazz.getSuperclass();
System.out.println("clazz的父类: " + superclass.getName());
Class<?>[] interfaces = clazz.getInterfaces();
for (int i = 0; i < interfaces.length; i++){
System.out.println("接口" + i + ": " + interfaces[i].getName());
}
/**
* clazz的父类: java.lang.Object
* 接口0: java.io.Serializable
*/
}
}
获取某个类中的全部构造函数
/**
* 获取某个类中的全部构造函数
* 通过反射机制实例化一个类的对象
* @author mazaiting
*/
public class Reflect4 {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
Class<?> clazz = Class.forName("com.mazaiting.User");
Constructor<?>[] constructors = clazz.getConstructors();
System.out.println("构造方法共 " + constructors.length + "个");
for (int i=0;i<constructors.length; i++){
Class<?>[] parameterTypes = constructors[i].getParameterTypes();
System.out.print("cons[" + i + "] (");
for (int j=0; j<parameterTypes.length; j++){
if (j == parameterTypes.length - 1)
System.out.print(parameterTypes[j].getName());
else
System.out.print(parameterTypes[j].getName() + ",");
}
System.out.println(")");
}
/**
* 构造方法共 3个
* cons[0] (java.lang.String,int)
* cons[1] (java.lang.String)
* cons[2] ()
*/
User user0 = (User) constructors[0].newInstance("mazaiting", 23);
System.out.println(user0.toString());
User user1 = (User) constructors[1].newInstance("mazaiting");
System.out.println(user1.toString());
User user2 = (User) constructors[2].newInstance();
System.out.println(user2.toString());
/**
* User [name=mazaiting, age=23]
* User [name=mazaiting, age=0]
* User [name=null, age=0]
*/
}
}
public class User {
private String name;
private int age;
public User() {
super();
}
public User(String name) {
super();
this.name = name;
}
public User(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + "]";
}
}
获取某个类的全部属性
/**
* 获取某个类的全部属性
* @author mazaiting
*/
public class Reflect5 implements Serializable{
private static final long serialVersionUID = -2862585049955236662L;
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
Class<?> clazz = Class.forName("com.mazaiting.Reflect5");
System.out.println("===============本类属性===============");
// 取得本类的全部属性
Field[] fields = clazz.getDeclaredFields();
for(int i=0;i<fields.length; i++){
// 权限修饰
int modifiers = fields[i].getModifiers();
String mo = Modifier.toString(modifiers);
// 属性类型
Class<?> type = fields[i].getType();
System.out.println(mo + " " + type.getName() + " " + fields[i].getName() + ";");
}
System.out.println("==========实现的接口或者父类的属性==========");
// 取得实现的接口或者父类的属性
Field[] fields2 = clazz.getFields();
for(int i=0;i<fields2.length;i++){
int modifiers = fields2[i].getModifiers();
String mo = Modifier.toString(modifiers);
Class<?> type = fields2[i].getType();
System.out.println(mo + " " + type.getName() + " " + fields2[i].getName() + ";");
}
/**
* ===============本类属性===============
* private static final long serialVersionUID;
* ==========实现的接口或者父类的属性==========
*
*/
}
}
获取某个类的全部方法
/**
* 获取某个类的全部方法
* @author mazaiting
*/
public class Reflect6 implements Serializable{
private static final long serialVersionUID = -2862585049955236662L;
public static void main(String[] args) throws ClassNotFoundException {
Class<?> clazz = Class.forName("com.mazaiting.User");
// 获取与父类的全部方法，如果要获取当前类的方法所有方法
// 则使用clazz.getDeclaredMethods()方法
Method[] methods = clazz.getMethods();
for(int i=0;i<methods.length;i++){
// 返回类型
Class<?> returnType = methods[i].getReturnType();
int modifiers = methods[i].getModifiers();
// 权限修饰符
String modifier = Modifier.toString(modifiers);
Class<?>[] parameterTypes = methods[i].getParameterTypes();
Class<?>[] exceptionTypes = methods[i].getExceptionTypes();
System.out.println("函数名: " + methods[i].getName());
System.out.println("权限修饰: " + modifier);
System.out.println("返回值: " + returnType.getName());
System.out.println("参数个数: " + parameterTypes.length);
System.out.println("异常个数: " + exceptionTypes.length);
System.out.println("---------------------------------------");
}
/**
* 函数名: toString
* 权限修饰: public
* 返回值: java.lang.String
* 参数个数: 0
* 异常个数: 0
* ---------------------------------------
* 函数名: getName
* 权限修饰: public
* 返回值: java.lang.String
* 参数个数: 0
* 异常个数: 0
* ---------------------------------------
* 函数名: setName
* 权限修饰: public
* 返回值: void
* 参数个数: 1
* 异常个数: 0
* ---------------------------------------
* 函数名: getAge
* 权限修饰: public
* 返回值: int
* 参数个数: 0
* 异常个数: 0
* ---------------------------------------
* 函数名: setAge
* 权限修饰: public
* 返回值: void
* 参数个数: 1
* 异常个数: 0
* ---------------------------------------
* 函数名: wait
* 权限修饰: public final
* 返回值: void
* 参数个数: 0
* 异常个数: 1
* ---------------------------------------
* 函数名: wait
* 权限修饰: public final
* 返回值: void
* 参数个数: 2
* 异常个数: 1
* ---------------------------------------
* 函数名: wait
* 权限修饰: public final native
* 返回值: void
* 参数个数: 1
* 异常个数: 1
* ---------------------------------------
* 函数名: equals
* 权限修饰: public
* 返回值: boolean
* 参数个数: 1
* 异常个数: 0
* ---------------------------------------
* 函数名: hashCode
* 权限修饰: public native
* 返回值: int
* 参数个数: 0
* 异常个数: 0
* ---------------------------------------
* 函数名: getClass
* 权限修饰: public final native
* 返回值: java.lang.Class
* 参数个数: 0
* 异常个数: 0
* ---------------------------------------
* 函数名: notify
* 权限修饰: public final native
* 返回值: void
* 参数个数: 0
* 异常个数: 0
* ---------------------------------------
* 函数名: notifyAll
* 权限修饰: public final native
* 返回值: void
* 参数个数: 0
* 异常个数: 0
* ---------------------------------------
*/
}
}
通过反射机制调用某个类的方法
/**
* 反射机制调用某个类的方法
* @author mazaiting
*/
public class Reflect7 implements Serializable{
private static final long serialVersionUID = -2862585049955236662L;
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
Class<?> clazz = Class.forName("com.mazaiting.Reflect7");
// 获取当前类的reflect1方法
Method reflect1 = clazz.getDeclaredMethod("reflect1");
// 执行方法
reflect1.invoke(clazz.newInstance());
Method reflect2 = clazz.getDeclaredMethod("reflect2", int.class, String.class);
reflect2.invoke(clazz.newInstance(), 20, "mazaiting");
/**
* Java 反射机制 - 调用某个类的方法1.
* Java 反射机制 - 调用某个类的方法2.
* age -> 20. name -> mazaiting
*/
}
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);
}
}
通过反射机制操作某个类的属性
/**
* 反射机制更改属性值
* @author mazaiting
*/
public class Reflect8 implements Serializable{
private static final long serialVersionUID = -2862585049955236662L;
private String proprety = null;
public static void main(String[] args) throws Exception{
// 获取类
Class<?> clazz = Class.forName("com.mazaiting.Reflect8");
// 得到当前类的实例
Reflect8 instance = (Reflect8) clazz.newInstance();
// 获取要更改的属性
Field proprety = clazz.getDeclaredField("proprety");
// 设置可访问
proprety.setAccessible(true);
// 设置属性
proprety.set(instance, "属性");
System.out.println(proprety.get(instance));
/**
* 属性
*/
}
}
反射机制的动态代理
/**
* 反射机制的动态代理
* 在java中有三种类类加载器。
* 1) Bootstrap ClassLoader 此加载器采用c++编写，一般开发中很少见。
* 2) Extension ClassLoader 用来进行扩展类的加载，一般对应的是jrelibext目录中的类
* 3) AppClassLoader 加载classpath指定的类，是最常用的加载器。同时也是java中默认的加载器。
* 如果想要完成动态代理，首先需要定义一个InvocationHandler接口的子类，已完成代理的具体操作。
* @author mazaiting
*/
public class Reflect9 {
public static void main(String[] args) throws Exception{
MyInvocationHandler invocationHandler = new MyInvocationHandler();
Subject sub = (Subject) invocationHandler.bind(new RealSubject());
String info = sub.say("mazaiting", 23);
System.out.println(info);
/**
* mazaiting, 23
*/
}
}
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);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object temp = method.invoke(obj, args);
return temp;
}
}
class RealSubject implements Subject{
@Override
public String say(String name, int age) {
return name + ", " + age;
}
}
interface Subject{
String say(String name, int age);
}
实例
在泛型为Integer的ArrayList中存放一个String类型的对象。
/**
* 在泛型为Integer的ArrayList中存放一个String类型的对象。
* @author mazaiting
*/
public class Reflect10 {
public static void main(String[] args) throws Exception{
ArrayList<Integer> list = new ArrayList<>();
Method method = list.getClass().getDeclaredMethod("add", Object.class);
method.invoke(list, "Java反射机制实例");
System.out.println(list.get(0));
/**
* Java反射机制实例
*/
}
}
通过反射取得并修改数组的信息
/**
* 反射取得并修改数组的信息
* @author mazaiting
*/
public class Reflect11 {
public static void main(String[] args) throws Exception{
int[] temp = {1, 2, 3, 4, 5};
Class<?> componentType = temp.getClass().getComponentType();
System.out.println("数组类型: " + componentType.getName());
System.out.println("数组长度: " + Array.getLength(temp));
System.out.println("数组的第一个元素: " + Array.get(temp, 0));
// 设置第一个元素数据为100
Array.set(temp, 0, 100);
System.out.println("修改之后数组第一个元素为： " + Array.get(temp, 0));
}
}
通过反射机制修改数组的大小
/**
* 反射机制修改数组的大小
* @author mazaiting
*/
public class Reflect12 {
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);
/**
* 数组长度为： 15
* 1 2 3 4 5 6 7 8 9 0 0 0 0 0 0
* 数组长度为： 8
* a b c null null null null null
*/
}
// 修改数组大小
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();
}
}
将反射机制应用于工厂模式
/**
* 反射机制应用于工厂模式
* @author mazaiting
*/
public class Reflect13 {
public static void main(String[] args) throws Exception {
// Fruit f = Factory.getInstance("com.mazaiting.Orange");
Fruit f = Factory.getInstance("com.mazaiting.Apple");
if (f != null) {
f.eat();
}
/**
* Apple
*/
}
}
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;
}
}