谁还没有辜负几段昂贵的时光-毛不易
在工作中会时不时的用到反射,今天我们系统的梳理一下反射的知识点,以下分几个模块来梳理反射的内容。
Class的获取方式
-
通过类名.class获取
Class clazz = Animal.class;
-
通过对象.getClass方法获取
Cat cat = new Cat(); Class aClass = cat.getClass();
-
通过类名获取
try { Class<?> aClass1 = Class.forName("com.example.testreflect.Animal"); } catch (ClassNotFoundException e) { e.printStackTrace(); }
注意:尽管获取的方式有多种,但是类对象在内存中是唯一的,所以静态方法加锁的对象是类对象。
类对象的一些方法,以String为例:
方法 | 作用 |
---|---|
getName() | 获取类的全名称,带包名(java.lang.String) |
getSimpleName() | 获取类的名称,不带包名 (String) |
getPackage().getName() | 获取包名 (java.lang) |
isInterface() | 是否是接口(不是接口) |
isEnum() | 是否是枚举(不是枚举) |
isArray() | 是否是数组(不是数组) |
isPrimitive() | 是否是基本类型(不是基本类型) |
newInstance() | 创建类实例,只能调用public的无参数构造方法。 |
一些使用技巧,用来判断类是否存在
boolean isClassPresent(String name) {
try {
Class.forName(name);
return true;
} catch (Exception e) {
return false;
}
}
字段访问
- 获取字段的方法:
方法 | 作用 |
---|---|
Field getField(name) | 根据字段名获取某个public的field(包括父类) |
Field getDeclaredField(name) | 根据字段名获取当前类的某个field,私有的也可以(不包括父类) |
Field[] getFields() | 获取所有public的field(包括父类) |
Field[] getDeclaredFields() | 获取当前类的所有field,私有的也可以(不包括父类) |
测试以及运行结果
public void filedId() throws NoSuchFieldException {
Class<Cat> catClass = Cat.class;
Field age = catClass.getField("age");
Field name = catClass.getField("name");
Field climb = catClass.getDeclaredField("climb");
Field[] fields = catClass.getDeclaredFields();
Field[] fields1 = catClass.getFields();
System.out.println(age + "\n" + name + "\n" + climb + "\n" + Arrays.toString(fields) + "\n" + Arrays.toString(fields1));
}
运行结果
I System.out: public int com.example.testreflect.Animal.age
I System.out: public java.lang.String com.example.testreflect.Animal.name
I System.out: private int com.example.testreflect.Cat.climb
I System.out: [private int com.example.testreflect.Cat.climb]
I System.out: [public int com.example.testreflect.Animal.age, public java.lang.String com.example.testreflect.Animal.name]
- Field的一些方法
方法 | 作用 |
---|---|
getName() | 返回字段名称 |
getType() | 返回字段类型,也是一个Class实例 |
getModifiers() | 返回字段的修饰符,它是一个int,不同的bit表示不同的含义。 |
Field测试:
Field f = String.class.getDeclaredField("value");
f.getName(); // "value"
f.getType(); // class [B 表示byte[]类型
int m = f.getModifiers();
Modifier.isFinal(m); // true
Modifier.isPublic(m); // false
Modifier.isProtected(m); // false
Modifier.isPrivate(m); // true
Modifier.isStatic(m); // false
- 获取对象字段值
class Test{
public void getValue() throws NoSuchFieldException, IllegalAccessException {
Animal animal = new Animal(1, "小强");
Class<? extends Animal> aClass = animal.getClass();
Field name = aClass.getDeclaredField("name");
//setAccessible作用是启动和禁用访问安全检查的开关
name.setAccessible(true);
Object o = name.get(animal);
System.out.println(o);//小强
}
}
class Animal{
private int age;
private String name;
public Animal(int age, String name) {
this.age = age;
this.name = name;
}
}
注意以上访问的是Animal的私有属性,必须禁用访问安全检查才可以访问setAccessible。
-
设置对象字段值
class Test{ @Test public void setValue() throws NoSuchFieldException, IllegalAccessException { Animal animal = new Animal(1, "小强"); Class<? extends Animal> aClass = animal.getClass(); Field name = aClass.getDeclaredField("name"); //setAccessible作用是启动和禁用访问安全检查的开关 name.setAccessible(true); name.set(animal,"小明"); Object o = name.get(animal); System.out.println(o);//小明 } } class Animal{ private int age; private String name; public Animal(int age, String name) { this.age = age; this.name = name; } }
方法调用
-
方法调用
方法 作用 Method getMethod(name, Class…) 获取某个 public
的Method
(包括父类)Method getDeclaredMethod(name, Class…) 获取当前类的某个 Method
(不包括父类)Method[] getMethods() 获取所有 public
的Method
(包括父类)Method[] getDeclaredMethods() 获取当前类的所有 Method
(不包括父类)测试代码
class Test{ public void call() throws NoSuchMethodException { Class<Cat> catClass = Cat.class; //获取public的getAge,参数为String类型 Method getAge = catClass.getMethod("getAge", String.class); //获取public的getNameByTag,参数为int类型 Method getNameByTag = catClass.getMethod("getNameByTag", int.class); // 获取private方法getClimb, Method getClimb = catClass.getDeclaredMethod("getClimb"); } } class Animal{ private int age; private String name; public String getNameByTag(int tag) { return name + tag; } public int getAge(String type) { return age; } } class Cat extends Animal{ private int climb; private int getClimb() { return climb; } }
-
Method方法
方法 作用 getName() 返回方法名称 getReturnType() 返回方法返回值类型,也是一个Class实例 getParameterTypes() 返回方法的参数类型,是一个Class数组 getModifiers() 返回方法的修饰符,它是一个 int
,不同的bit表示不同的含义 -
反射调用方法
invoke
的第一个参数是对象实例,即在哪个实例上调用该方法,后面的可变参数要与方法参数一致,否则将报错。public void invoke() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { Cat cat = new Cat(); cat.setName("小强"); Class<? extends Cat> aClass = cat.getClass(); Method getNameByTag = aClass.getMethod("getNameByTag", int.class); Object invoke = getNameByTag.invoke(cat, 1); System.out.println(invoke);//小强1 }
-
静态方法调用
获取到的Method表示一个静态方法,调用静态方法时,由于无需指定实例对象,所以
invoke
方法传入的第一个参数永远为null
。public void callStaticMethod() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { Method test = Animal.class.getMethod("test"); //调用者直接传null。 Object invoke = test.invoke(null); }
-
私有方法调用
为了调用非public方法,我们通过
Method.setAccessible(true)
允许其调用。public void invokePrivateMethod() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { Animal animal = new Animal(); animal.setName("小强"); Class<Animal> animalClass = Animal.class; Method getName = animalClass.getDeclaredMethod("getName"); getName.setAccessible(true);//getName是私有方法 Object invoke = getName.invoke(animal); System.out.println(invoke);//小强 }
注意:setAccessible(true)可能会失败。如果JVM运行期存在SecurityManager,那么它会根据规则进行检查,有可能阻止setAccessible(true)。例如,某个SecurityManager可能不允许对java和javax开头的package的类调用setAccessible(true),这样可以保证JVM核心库的安全。
-
多态思考
父类获取方法,子类执行,其使用反射调用方法时,仍然遵循多态原则。
以下测试程序打印cat。
class Test{ public void duotai() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException { Cat cat = new Cat(); Method eat = cat.getClass().getDeclaredMethod("eat"); eat.invoke(cat); } } class Animal{ public void eat(){ System.out.println("animal"); } } class Cat extends Animal{ @Override public void eat() { System.out.println("cat"); } }
构造方法调用
-
调用public无参的构造方法
Animal animal = Animal.class.newInstance();
-
为了调用任意的构造方法,Java的反射API提供了Constructor对象,它包含一个构造方法的所有信息,可以创建一个实例。
class{ public void invokeC() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { Class<Animal> aClass = Animal.class; Constructor<Animal> constructor = aClass.getConstructor(String.class, int.class); Animal animal = constructor.newInstance("小强", 2); System.out.println(animal.getAge() + "--" + animal.getName());//2--小强 } } class Animal{ private String name; private int age; public Animal(String name, int age) { this.name = name; this.age = age; } public void eat(){ System.out.println("animal"); } public String getName() { return name; } public int getAge() { return age; } }
-
构造方法方法汇总
方法 作用 getConstructor(Class…) 获取某个 public
的Constructor
getDeclaredConstructor(Class…) 获取某个 Constructor
getConstructors() 获取所有 public
的Constructor
getDeclaredConstructors() 获取所有 Constructor
注意:调用非
public
的Constructor
时,必须首先通过setAccessible(true)
设置允许访问。setAccessible(true)
可能会失败。
继承关系
class实例通过调用getSuperclass()可以获取其父类的class,调用getInterfaces可以获取其实现的接口类型。
注意:etInterfaces()只返回当前类直接实现的接口类型,并不包括其父类实现的接口类型
动态代理
我们都知道,class(非abstract)是可以创建对象的,而interface是不能够进行实例化的。java开发规范中有一条是面向接口编程,其实通过某个实例向上转型并赋值给接口类型变量的。
而动态代理则是不需要编写实现类,则直接在运行期间创建某个interface的实例。
动态代理是直接通过JDK提供的一个Proxy.newProxyInstance()创建了一个接口对象,这个对象是在运行期间创建的,也是在内存中产生的对象。
其使用方式如下:
在运行期动态创建一个interface实例的方法如下:
-
定义一个InvocationHandler实例,它负责实现接口的方法调用;
-
通过Proxy.newProxyInstance()创建interface实例,它需要3个参数:
-
使用的ClassLoader,通常就是接口类的ClassLoader;
-
需要实现的接口数组,至少需要传入一个接口进去;
-
用来处理接口方法调用的InvocationHandler实例。
-
-
将返回的Object强制转型为接口。
class Test{
public void testProxy(){
InvocationHandler invocationHandler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(method + "--" + Arrays.toString(args));// public abstract void com.example.testreflect.Action.eat(java.lang.String)--[fruit]
return null;
}
};
Action action = (Action) Proxy.newProxyInstance(Action.class.getClassLoader(), new Class[]{Action.class}, invocationHandler);
action.eat("fruit");
}
}
interface Action {
void eat(String food);
}