Java反射机制
反射
反射机制
反射机制就是通过一个抽象的类名能够在加载类的内存中找到相匹配的类的具体信息
java能够反射的前提：已经加载过这个类就可以通过类名来寻找到这个类的所有相关信息
Java Reflection(反射)是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任何对象的内部属性及方法
Java反射机制提供的功能
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行时调用任何一个对象的成员变量和方法生成动态代理
一个类极限情况都有什么？
- 一个父类
- 多个接口
- 多个属性
- 多个构造方法，包括构造的参数及其类型
- 多个普通方法，包括参数及其类型，返回值类型
一、Class类
在Object类中定义了以下的方法，此方法将被所有子类继承：
public final Class getClass()
以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称
反射可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个类的有关信息。
Class本身也是一个类
Class对象只能由系统建立对象
一个类在JVM中只会有一个Class实例
一个Class对象对应的是一个加载到JVM中的一个.class文件
每个类的实例都会记得自己是由哪个Class实例所生成
通过Class可以完整地得到一个类中的完整结构
实例化Class类对象(四种方法)
前提：若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高
实例：Class clazz = String.class;
前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象
实例：Class clazz = "www.xyd.com".getClass();
前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException
实例：Class clazz = Class.forName("java.lang.String");
其他方式(不做要求)
ClassLoader cl = this.getClass().getClassLoader();
Class clazz4 = cl.loadClass("类的全类名")
二、通过反射调用类的完整结构
Field
Method
Constructor
Superclass
Interface
Annotation
实现的全部接口
所继承的父类
全部的构造器
全部的方法
全部的Field
通过反射调用类的完整结构
使用反射可以取得
- 实现类的全部接口
- 所继承的父类
- 全部的构造器
- 全部的方法
- 全部的Field(属性)
- 类的所在的包
package com.aggregate.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Test2 {
public static void main(String[] args) {
try {
//通过包名.类名的字符串，调用Class.forName方法获取指定类的Class实例
Class clazz = Class.forName("com.aggregate.reflection.Student");
Class superclass = clazz.getSuperclass();//获取父类
System.out.println("父类：" + superclass.getName());
Class[] interfaces = clazz.getInterfaces();//获取当前类的所有接口
for (Class anInterface : interfaces) {
System.out.println("接口：" + anInterface.getName());
}
Constructor[] constructors = clazz.getConstructors();//获取类的公有的构造方法
for (Constructor constructor : constructors) {
System.out.println("构造方法名称：" + constructor.getName() + "的修饰符是：" + constructor.getModifiers());
Class[] parameterTypes = constructor.getParameterTypes();
for (Class parameterType : parameterTypes) {
System.out.println("构造方法：" + constructor.getName() + "的参数类型是：" + parameterType.getName());
}
}
System.out.println("===========================================");
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();//获取类的所有构造方法，包括公有和私有
for (Constructor declaredConstructor : declaredConstructors) {
System.out.println("构造方法名称：" + declaredConstructor.getName() + "的修饰符是：" + declaredConstructor.getModifiers());
Class[] parameterTypes = declaredConstructor.getParameterTypes();
for (Class parameterType : parameterTypes) {
System.out.println("构造方法：" + declaredConstructor.getName() + "的参数类型是：" + parameterType.getName());
}
}
//如何用反射的构造方法来创建对象
try {
Object o = clazz.newInstance();//调用的是Student类的无参构造方法
Student student = (Student) o;
//指定获取有一个参数并且为String类型的公有的构造方法
Constructor constructor = clazz.getConstructor(String.class);
//实例化对象；调用的是Student类的public Student(String school)构造方法
Student student1 = (Student) constructor.newInstance("第一中学");
System.out.println(student1.school);
//通过反射机制，可以强制的调用私有的构造方法
Constructor declaredConstructor = clazz.getDeclaredConstructor(String.class, int.class);
//解除私有的封装，就可以对私有方法强制调用
declaredConstructor.setAccessible(true);
Student student2 = (Student) declaredConstructor.newInstance("张三", 12);
Method[] methods = clazz.getMethods();//获取到类的所有公有的方法
// Method[] methods = clazz.getDeclaredMethods();//获取类所有方法，包括私有
for (Method method : methods) {
System.out.println("方法名：" + method.getName());
System.out.println("返回值类型：" + method.getReturnType());
System.out.println("修饰符：" + method.getModifiers());
Class[] parameterTypes = method.getParameterTypes();//获取方法的参数类型
if (parameterTypes != null && parameterTypes.length > 0) {
for (Class parameterType : parameterTypes) {
System.out.println("参数类型：" + parameterType.getName());
}
}
System.out.println("=============================");
}
// Field[] fields = clazz.getFields();//获取本类和父类的公有属性
Field[] fields = clazz.getDeclaredFields();//获取本类所有的属性，包括私有
for (Field field : fields) {
System.out.println("修饰符：" + field.getModifiers());
System.out.println("属性的类型：" + field.getType());
System.out.println("属性的名称：" + field.getName());
}
System.out.println("*****************************");
//获取类所在的包
Package aPackage = clazz.getPackage();
System.out.println(aPackage.getName());
} catch (Exception e) {
e.printStackTrace();
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
通过反射调用类中的指定方法、指定属性
package com.aggregate.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Test2 {
public static void main(String[] args) {
try {
//通过包名.类名的字符串，调用Class.forName方法获取指定类的Class实例
Class clazz = Class.forName("com.aggregate.reflection.Student");
Class superclass = clazz.getSuperclass();//获取父类
System.out.println("父类：" + superclass.getName());
Class[] interfaces = clazz.getInterfaces();//获取当前类的所有接口
for (Class anInterface : interfaces) {
System.out.println("接口：" + anInterface.getName());
}
Constructor[] constructors = clazz.getConstructors();//获取类的公有的构造方法
for (Constructor constructor : constructors) {
System.out.println("构造方法名称：" + constructor.getName() + "的修饰符是：" + constructor.getModifiers());
Class[] parameterTypes = constructor.getParameterTypes();
for (Class parameterType : parameterTypes) {
System.out.println("构造方法：" + constructor.getName() + "的参数类型是：" + parameterType.getName());
}
}
System.out.println("===========================================");
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();//获取类的所有构造方法，包括公有和私有
for (Constructor declaredConstructor : declaredConstructors) {
System.out.println("构造方法名称：" + declaredConstructor.getName() + "的修饰符是：" + declaredConstructor.getModifiers());
Class[] parameterTypes = declaredConstructor.getParameterTypes();
for (Class parameterType : parameterTypes) {
System.out.println("构造方法：" + declaredConstructor.getName() + "的参数类型是：" + parameterType.getName());
}
}
//如何用反射的构造方法来创建对象
try {
Object o = clazz.newInstance();//调用的是Student类的无参构造方法
Student student = (Student) o;
//指定获取有一个参数并且为String类型的公有的构造方法
Constructor constructor = clazz.getConstructor(String.class);
//实例化对象；调用的是Student类的public Student(String school)构造方法
Student student1 = (Student) constructor.newInstance("第一中学");
System.out.println(student1.school);
//通过反射机制，可以强制的调用私有的构造方法
Constructor declaredConstructor = clazz.getDeclaredConstructor(String.class, int.class);
//解除私有的封装，就可以对私有方法强制调用
declaredConstructor.setAccessible(true);
Student student2 = (Student) declaredConstructor.newInstance("张三", 12);
Method[] methods = clazz.getMethods();//获取到类的所有公有的方法
// Method[] methods = clazz.getDeclaredMethods();//获取类所有方法，包括私有
for (Method method : methods) {
System.out.println("方法名：" + method.getName());
System.out.println("返回值类型：" + method.getReturnType());
System.out.println("修饰符：" + method.getModifiers());
Class[] parameterTypes = method.getParameterTypes();//获取方法的参数类型
if (parameterTypes != null && parameterTypes.length > 0) {
for (Class parameterType : parameterTypes) {
System.out.println("参数类型：" + parameterType.getName());
}
}
System.out.println("=============================");
}
// Field[] fields = clazz.getFields();//获取本类和父类的公有属性
Field[] fields = clazz.getDeclaredFields();//获取本类所有的属性，包括私有
for (Field field : fields) {
System.out.println("修饰符：" + field.getModifiers());
System.out.println("属性的类型：" + field.getType());
System.out.println("属性的名称：" + field.getName());
}
System.out.println("*****************************");
//获取类所在的包
Package aPackage = clazz.getPackage();
System.out.println(aPackage.getName());
} catch (Exception e) {
e.printStackTrace();
}
/**
* 注意：下面不论是反射调用setInfo还是test方法
* 都调用的o对象的方法，o对象实际上就是Student对象
*/
//调用指定的公有方法
Constructor constructor = clazz.getConstructor();
Object o = constructor.newInstance();
Method method = clazz.getMethod("setInfo", String.class, String.class);
method.invoke(o, "张三", "第一中学");
//调用指定的私有方法
Method declaredMethod = clazz.getDeclaredMethod("test", String.class);
declaredMethod.setAccessible(true);//解除私有封装，可以强制调用私有的方法
declaredMethod.invoke(o, "李四");
//调用一个重载的方法
Method method1 = clazz.getMethod("setInfo", int.class);
method1.invoke(o, 1);
//调用有返回值的方法
Method method2 = clazz.getMethod("getSchool");//这是获取方法名为getSchool并且没有参数的方法
String school = (String) method2.invoke(o);//调用有返回值的但是没有参数的方法
System.out.println(school);
//反射创建一个对象
Constructor con = clazz.getConstructor();
Student stu = (Student) con.newInstance();
//公有属性
Field f = clazz.getField("school");//获取名称为school的属性
f.set(stu, "第三中学");
String s = (String) f.get(stu);
System.out.println(s);
//私有属性
Field privateField = clazz.getDeclaredField("privateField");
//解除私有的封装
privateField.setAccessible(true);
privateField.set(stu, "测试私有属性");
System.out.println(privateField.get(stu));
} catch (Exception e) {
e.printStackTrace();
}
}
}
JAVA动态代理
Proxy:专门完成代理的操作类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类。
创建一个动态代理类所对应的Class对象
package com.aggregate.reflection;
public interface ITestDemo {
void test1();
void test2();
}
package com.aggregate.reflection;
public class TestDemoImpl implements ITestDemo {
@Override
public void test1() {
System.out.println("执行test1()方法");
}
@Override
public void test2() {
System.out.println("执行test2()方法");
}
}
package com.aggregate.reflection;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class Test1 {
public static void main(String[] args) {
//对象多态
ITestDemo testDemo = new TestDemoImpl();
/**
* 注意：如果一个对象想要通过Proxy.newProxyInstance方法被代理，
* 那么这个对象的类一定要有相应的接口
* 就像本例子中的ITestDemo接口和实现类TestDemoImpl
*/
testDemo.test1();
testDemo.test2();
System.out.println("==================================");
/**
* 需求：
* 在执行test1和test2方法时需要加入一些东西
* 执行前打印开始执行
* 执行后打印执行完毕
* 打印的方法名要和调用的保持一致
*/
InvocationHandler handler = new ProxyDemo(testDemo);
/**
* Proxy.newProxyInstance(Classloader,interfaces,h)
* 参数1是代理对象类加载器，参数2是被代理的对象的接口，参数3是代理对象
* 返回的值就是成功被代理后的对象,返回的是Object类型，需要根据当时的情况去转换类型
*/
ITestDemo t = (ITestDemo) Proxy.newProxyInstance(handler.getClass().getClassLoader(), testDemo.getClass().getInterfaces(), handler);
t.test1();
System.out.println("******************************");
t.test2();
}
}
package com.aggregate.reflection;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* 动态代理类
*/
public class ProxyDemo implements InvocationHandler {
Object obj;//被代理的对象
public ProxyDemo(Object obj) {
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(method.getName() + "方法开始执行");
Object result = method.invoke(this.obj, args);//执行的是指定代理对象的指定方法
System.out.println(method.getName() + "方法执行完毕");
return result;
}
}
浙公网安备 33010602011771号