目录
一、反射机制概述
二、理解并获取Class实例
三、反射的用法
1. 通过反射创建运行时类的对象
2. 通过反射获取运行时类的属性结构
3. 通过反射获取运行时类的方法结构
4. 通过反射获取运行时类的构造器结构
5. 通过反射获取运行时类的父类
6. 通过反射获取运行时类的接口、所在包、注解
7. 通过反射调用指定属性
8. 通过反射调用指定方法
9. 通过反射调用指定构造器
四、应用场景
五、总结
一、反射机制概述
Reflection(反射)是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象 (一个类只有一个Class对象)，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射
二、理解并获取Class实例
关于java.lang.Class类的理解
1.类的加载过程:程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)。接着我们使用java.exe命今对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例。
2.换句话说，Class的实例就对应着一个运行时类。
3.加载到内存中的运行时类，会缓存一定的时间。在此时间内，我们可以通过不同的方式来获取此运行时类
获取Class实例的四种方式:
//方式一: 调用运行时类的属性: .class
Class clazz1 = Person.class;
System.out.println(clazz1);
//方式二: 通过运行时类的对象，调用getclass()
Person p1 = new Person();
Class clazz2 = p1.getClass();
System.out.println(clazz2);
//方式三: 调用CLass的静态方法: forName(String classPath)
Class clazz3 = Class .forName("com.fd.java.Person");
//clazz3 = Class.forName("java.lang.String");
System.out.println(clazz3);
//方式四: 使用类的加载器: CLassLoader
ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class clazz4 = classLoader.loadClass("com.fd.java.Person");
System.out.println(clazz4);
System.out.println(clazz1 == clazz2); //true
System.out.println(clazz1 == clazz3); //true
System.out.println(clazz1 == clazz4); //true三、反射的用法
1. 通过反射创建运行时类的对象
public void test() throws IllegalAccessException,InstantiationException {
Class<Person> clazz = Person.class;
/*
newInstance():调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参的构造器
要想此方法正常的创建运行时类的对象，要求:
1.运行时类必须提供空参的构造器
2.空参的构造器的访问权限得够。通常，设置为public。
在javabean 中要求提供一个public的空参构道器。原因:
1.便于通过反射，创建运行时类的对象
2.便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器
*/
Person obj = clazz.newInstance();
System.out.println(obj);
}2. 通过反射获取运行时类的属性结构
@Test
public void test1(){
Class clazz = Person.class;
//获取属性结构
//getFields(): 获取当前运行时类及其父类中声明为public 访问权限的属性
Field[] fields = clazz.getFields();
for(Field f : fields){
System.out.printIn(f);
}
//getDecLaredFieLds(): 获取当前运行时类中声明的所有属性(不包含父类中声明的属性)
Field[] declaredFields = clazz.getDeclaredFields();
for(Field f : declaredFields){
System.out.println(f);
}
}
@Test
public void test2() {
//权限修饰符 数据类型 变量名
Class clazz = Person.class;
Field[] declaredFields = clazz.getDeclaredFields();
for(Field f : declaredFields){
//1.权限修饰符
int modifier = f.getModifiers();
System.out.print(Modifier.tostring(modifier) + "\t");
//2.数据类型
Class type = f.getType();
System.out.print(type.getName() + "\t"];
//3.变量名
String fName = f.getName();
System.out.print(fName);
System.out.println();
/*
* 得到字段值 通过get属性获得
* */
PropertyDescriptor pd = new PropertyDescriptor(f.getName(), clazz);
Method getMethod = pd.getReadMethod();
Object invoke = getMethod.invoke(person);
System.out.println(invoke);
// 设置值
Method writeMethod = pd.getWriteMethod();
try {
if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
readMethod.setAccessible(true);
}
Object value = readMethod.invoke(source);
if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
readMethod.setAccessible(true);
}
writeMethod.invoke(target, value);
} catch (IllegalAccessException | InvocationTargetException e) {
throw new RuntimeException(e);
}
}
}3. 通过反射获取运行时类的方法结构
@Test
public void test1() {
Class clazz = Person.class;
//getMethods(): 获当前运行时类及其所有父类中明为public权限的方法
Method[] methods = clazz.getMethods();
for(Method m : methods) {
System.out.println(m);
}
System.out.println();
//getDeclaredMethods(): 获取当前运行时类中声明的所有方法。(不包含父类中声明的方法）
Method[] declaredMethods = clazz.getDeclaredMethods();
for(Method m : declaredMethods) {
System.out.println(m);
}
}
/*方法具体结构
@Xxxx
权限修饰符，返回值类型 方法名(参数类型1 形参名1，..）thows XxxException{}
*/
@Test
public void test2() {
Class clazz = Person.class;
Method[] declaredMethods = clazz.getDeclaredMethods();
for(Method m : declaredMethods) {
//1.获取方法声明的注解
Annotation[] annos = m.getAnnotations();
for(Annotation a : annos) {
System.out.println(a);
}
//2.权限修饰符
System.out.print(Modifier.toString(m.getModifiers()) + "t");
//3.返回值类型
System.out.print(m.getReturnType().getName() + " t");
//4.方法名
System.out.print(m.getName());
System.out.print("(");
//5.形参列表
Class[] parameterTypes = m.getParameterTypes();
if(!(parameterTypes == null && parameterTypes.length == 0)) {
for(int i = 0;i < parameterTypes.length;i++) {
if(i == parameterTypes.length - 1) {
System.out.print(parameterTypes[i].getName() + " args_" + i);
break;
}
System.out.print(parameterTypes[i].getName() + " args_" + i + ",");
}
}
System.out.print(")");
//6.抛出的异常
Class[] exceptionTypes = m.getExceptionTypes();
if(exceptionTypes.length > 0) {
System.outprint("throws ");
for(int i = 0;i < exceptionTypes.length;i++) {
if(i == exceptionTypes.length - 1) {
System.out.print(exceptionTypes[i].getName());
break;
}
System.out.print(exceptionTypes[i].getName() + ",");
}
}
}
}4. 通过反射获取运行时类的构造器结构
//获取运行时类的构造器
@Test
public void test1() {
Class clazz = Person.class;
//getConstructors(): 获取当前运行时类中声明为public的构造器
Constructor[] constructors = clazz.getConstructors();
for(Constructor c : constructors){
System.out.println(c);
}
System.out.println();
//getDeclaredConstructors(): 获当前运行时类中声明的所有的构造器
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
for(Constructor c : declaredConstructors){
System.out.println(c);
}
}5. 通过反射获取运行时类的父类
@Test
public void test2() {
Class clazz = Person.class;
Class superclass = clazz.getSuperclass();
System.out.println(superclass);
}
//获取运行时类的带泛型的父类
@Test
public void test3() {
Class clazz = Person.class;
Type genericSuperclass = clazz.getGenericSuperclass();
System.out.println(genericSuperclass);
}
//获取运行时类的带泛型的父类的泛型
@Test
public void test4() {
Class clazz = Person.class;
Type genericSuperclass = clazz.getGenericSuperclass();
ParameterizedType paramType = (ParameterizedType) genericSuperclass;
//获取泛型类型
Type[] actualTypeArguments = paramType.getActualTypeArguments();
System.out.println(actualTypeArguments[0].getTypeName());
}6. 通过反射获取运行时类的接口、所在包、注解
@Test
public void test5() {
Class clazz = Person.class;
Class[] interfaces = clazz.getInterfaces();
for(Class c : interfaces) {
System.out.println(c);
}
System.out.println();
//获取运行时类的父类实现的接口
Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
for(Class c : interfaces1) {
System.out.println(c);
}
// 获取运行时类的包
Package pack = clazz.getPackage();
System.out.println(pack);
//获取运行时类声明的注解
Annotation[] annotations = clazz.getAnnotations();
for(Annotation annos : annotations) {
System.out.println(annos);
}
}7. 通过反射调用指定属性
Class clazz = Person.class;
//创建运行时类的对象
Person p = (Person) clazz.newInstance();
//获取指定的属性：要求属性声明为public，通常不采用此方法
Field id = clazz.getField("id");
/*
设置当前属性的值
set(): 参数1: 指明设置哪个对象的属性参数 2: 将此属性值设置为多少
*/
id.set(p, 1001);
/*获取当前属性的值
get(): 参数1: 获取哪个对象的当前属性值
*/
int pId = (int) id.get(p);
System.out.println(pId);
/*****************方式二（常用）************************/
Class cLazz = Person.class;
//创建运行时类的对象
Person p = (Person) clazz.newInstance();
//1.getDeclaredField(String fieldName):获运行时类中指定变量名的属性
Field name = clazz.getDeclaredField("name");
//2.保证当前属性是可访问的
name.setAccessible(true);
//3.获取、设置指定对象的此属性值
name.set(p, "Tom");
System.out.println(name.get(p));8. 通过反射调用指定方法
//如何操作运行时类中的指定的方法 -- 需要掌握
@Test
public void testMethod() throws Exception {
Class clazz = Person.class;
//创建运行时类的对象
Person p = (Person)clazz.newInstance();
/*
1.获取指定的某个方法
getDeclaredMethod(): 参数1 : 指明获取的方法的名称 参数2: 指明获取的方法的形参列表
*/
Method show = clazz.getDeclaredMethod("show", String.class);
//2.保证当前方法是可访问的
show.setAccessible(true);
/*
2. 调用方法的invoke():参数1: 方法的调用者 参数2: 给方法形参赋值的实参
invoke()的返回值即为对应类中调用的方法的返回值。
*/
Object returnValue = show.invoke(p, "CHN"); //String nation = p.show("CHN")
System.out.println(returnValue);
// 如何调用静态方法
// private static void showDesc()
Method showDesc = clazz.getDeclaredMethod("showDesc");
showDesc.setAccessible(true);
//如果调用的运行时类中的方法没有返回值，则此invoke()返回null
//Object returnVal = showDesc.invoke(null);
Object returnVal = showDesc.invoke(Person.class);
System.out.println(returnVal);//null
}9. 通过反射调用指定构造器
@Test
public void testConstructor() throws Exception {
Class clazz = Person.class;
//private Person(String name)
/*
1.获取指定的构造器
getDecLaredConstructor(): 参数:指明构造器的参数列表
*/
Constructor constructor = clazz.getDeclaredConstructor(String.class);
//2.保证此构造器是可访问的
constructor.setAccessible(true);
//3.调用此构造器创建运行时类的对象
Person per = (Person) constructor.newinstance("Tom");
}四、应用场景
反射机制可以用于很多实际应用场景中，例如：
1.框架开发
Java反射机制在框架开发中扮演了重要角色。许多框架都使用反射机制来实现插件化和动态配置等功能。例如，Spring框架就广泛使用反射机制来动态装配Bean和调用方法。
2.单元测试
Java反射机制在单元测试中也是非常有用的。测试框架可以使用反射机制来检查和调用测试类的方法，以及访问私有变量和方法等。
3.序列化和反序列化
Java反射机制还可以用于对象的序列化和反序列化。序列化就是将一个对象转换成字节序列的过程，而反序列化就是将字节序列转换回对象的过程。Java反射机制可以通过对类的属性进行访问，将对象的状态保存到一个字节序列中，并在需要的时候将其还原为对象。
4.动态代理
Java反射机制可以实现动态代理。动态代理是一种设计模式，它允许在运行时创建一个代理对象，来替代真实对象执行某些操作。在Java中，可以使用反射机制来创建代理对象，从而实现动态代理的功能。
5.IOC容器
IOC（Inversion of Control）是一种设计模式，它的核心思想是将对象之间的依赖关系反转。在Java中，可以使用反射机制来实现IOC容器。通过反射机制，IOC容器可以在运行时动态地实例化和装配Bean，并自动处理Bean之间的依赖关系，从而实现对象之间的松耦合。
6.AOP编程
AOP（Aspect-Oriented Programming）是一种编程思想，它的核心思想是将业务逻辑和系统功能分离。在Java中，可以使用反射机制来实现AOP编程。通过反射机制，AOP框架可以在运行时动态地为对象添加额外的功能，从而实现业务逻辑和系统功能的分离。
五、总结
Java反射机制是一种非常强大和灵活的技术，它可以在运行时动态地检查和操作Java程序的内部结构，可以用于很多实际应用场景。但是，反射机制也有一些缺点，例如运行时性能较差、容易出错等。因此，在使用反射机制时需要注意它的性能和安全性，避免出现不必要的问题。
