java基础浅谈反射

小猪弟

已于 2022-03-03 11:34:19 修改

阅读量179

点赞数

分类专栏： Java基础文章标签： java 反射

于 2021-07-01 18:37:18 首次发布

本文链接：https://blog.csdn.net/u011863822/article/details/118393407

版权

Java基础专栏收录该内容

63 篇文章 0 订阅

订阅专栏

反射

在说发射之前，先说两个概念动态语言和静态语言

动态语言：动态语言又被称为扩建的语言，或者脚本语言，是一种编程语言，用来控制软件应用程序，脚本通常以文本（如ASCII)保存，只在被调用时进行解释或编译。

简单的说就是一种在运行时，可以改变其结构的语言：例如新的函数，对象，甚至代码也可以引进，已有的函数可以被删除或者其结构上的修改。通俗点说就是在运行时代码可以根据某些条件修改自身结构的语言。比如创建变量的时候没有定义变量的类型，只有运行到此的时候才知道是什么类型。常见的语言：js，python，php等语言。
静态语言：与动态语言刚好相反，就是在运行之前定好结构，在运行的时候不可以修改代码结构的语言。常见的语言：java，c，c++等语言。

补充：Java是静态语言，但是有时候称之为准动态语言，为什会这样说呢？就是因为其可以通过反射机制来获得动态语言的特点。java的这种特性，让java编程更加灵活

反射的定义

反射是java被视为动态语言的关键，反射机制允许程序在执行的时候，借助于反射机制获取任何类的内部信息并且可以直接操作任意对象的内部属性以及方法。

具体实现的原理：加载完类之后，在堆内存的方法去中产生了一个Class类型的对象（一个类只有一个Class对象）。这个对象就包含了完整的类的结构信息。所以可以通过这个对象的看到类的结构。这个对象就像是一个镜子，通过这个对象可以看见类的结构，所以形象的将其称为：反射。

Class 对象

既然前面说了Class对象，那么Class对象到底是什么？

用一句绕口的话来说：Class对象是描述对象类的类。

对象照镜子后可以得到信息：某个类的属性，方法和构造器，某个类实现了那些接口。对于某个类而言，JRE都为其保留的一个不变的Class类型的对象。一个Class对象包含了特定的结构（class/interface/enum/annotation/primitive type/void[]）的有关信息。

Class 本身就是一个类
Class对象只能由系统建立对象。
一个加载的类在jvm中只有一个Class实例（下面代码演示的数组可以看出）。
一个Class对象对应的是加载到JVM中的.class文件。
每个类的实例都会记得自己是由那个Class文件生成的。
通过Class可以完整地得到一个类的所有被加载的结构
Class类是Reflection的根源，针对任何你想动态加载，运行的类，唯有先得到相应的Class对象。

先看一下Class对象

public  static void show() {        
        System.out.println(Object.class);
		System.out.println(int.class);
		System.out.println(Integer.TYPE);//  表示基本类型 int 的 Class 实例。
		System.out.println(Integer.class);
		System.out.println(int[].class);	
		System.out.println(int[][].class);	
		System.out.println(String.class);
		System.out.println(String[].class);
		System.out.println(String[][].class);
		System.out.println(float.class);
		System.out.println(List.class);
		System.out.println(Override.class);
		
		
		//这些是直接用对象类或者基础数据通过.class得到Class对象
		//int 数组就是对象了
		int[] a= {12};
		int[] b= {123};
		int[][] c= {{123},{233}};
		Class aClass=(a.getClass());
		Class bClass=(b.getClass());
		Class cClass=(c.getClass());
		System.out.println(aClass);
		System.out.println(bClass);
		System.out.println(cClass);
		System.out.println(aClass==bClass);//true
		System.out.println(aClass==cClass);//false
}

//输出
class java.lang.Object
int
int
class java.lang.Integer
class [I
class [[I
class java.lang.String
class [Ljava.lang.String;
class [[Ljava.lang.String;
float
interface java.util.List
interface java.lang.Override
class [I
class [I
class [[I
true
false

注意： 上面可以看出aClass和bClass两者完全相等，为什么呢？因为其都是一维数组，所以其描述一维数组这个对象的类是同一个类。因此aClass和cClass不相等也是可以解释了，因为是二维对象。

类加载器

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OqFOnB03-1625135585301)(C:\Users\jhfan\AppData\Roaming\Typora\typora-user-images\image-20210617160333952.png)]$

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Classs 对象，作为方法区中数据的访问入口（即引用机制）。所有需要访问和使用类数据只能通过这个Class对象。这个加载过程需要加载器的参与。
链接：将Java类的二机制代码合并到JVM的运行状态之中的过程。
- 验证：确保加载的类信息符合JVM规范。
- 准备：正式为类变量（static）分配内存并设置变量默认初始值的阶段，这些内存将在方法去中进行分配。
- 解析：虚拟机常量池内的符合引用（常量名）替换为直接引用（地址）的过程。
初始化：
- 执行类构造器()方法的过程，类加载器() 方法是由编译器自动收集所有类变量赋予的动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是该类对象的构造器。）
- 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发器父类的初始化。
- 虚拟机保证一个类的（）方法在多线程环境中被正确的加锁和同步。

类的加载与ClassLoader的理解

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XbOMBhg9-1625135585304)(C:\Users\jhfan\AppData\Roaming\Typora\typora-user-images\image-20210617185839932.png)]$

类加载器的作用：

作用：将Class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后再堆中生成一个代表这个类的java.lang.Classs.
类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间，不过JVM垃圾回收机制（GC）可以回收这些Class对象。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7qrhfaMR-1625135585305)(C:\Users\jhfan\AppData\Roaming\Typora\typora-user-images\image-20210618095147721.png)]$

上面可以看出加载器可以分两大类

默认加载器
- 引导类加载器：用C++编写，是JVM自带的类加载器，负责java平台核心库，用来装载核心库。该加载器无法直接获取。
- 扩展类加载器：负责jre/lib/ext目录下的jar包或-D java.ext.dirs 指定目录下的jar包装入工作库
- 系统类加载器：负责java -classpath或-D java.class.path所指的目录下的类与jar包装入工作，是最常用的加载器。
自定义加载器：

自定义加载器就是自己定义了一个加载器不过自定义的类加载器的必须继承ClassLoader，以及父类的loadClass方法直接继承。（暂时知道即可，如果需要后期再聊）

补充类加载器的委托机制：

Java的类加载器一般是采用委托机制。即classloader都有一个parent classloader，当它收到一个加载类的请求时，会首先请求parent classloader加载，如果parent classloader加载不到，才会自己去尝试加载（如果自己也加载不到，则抛出ClassNotFoundException）。采用这种机制的目的，主要是从安全角度考虑。比如用户自己定义了一个java.lang.Object，把jdk中的覆盖了，那显然是有问题的。

现在看一下类加载在代码中的呈现：

public class Test  {

	public static void main(String[] args) {
		
		Test t=new Test();
		ClassLoader classloader1=t.getClass().getClassLoader();
		System.out.println(classloader1);//sun.misc.Launcher$AppClassLoader@2a139a55  系统加载器
		ClassLoader classloader2=classloader1.getParent();
		System.out.println(classloader2); //sun.misc.Launcher$ExtClassLoader@7852e922  扩展加载器
		
		ClassLoader classloader3=classloader2.getParent();
		System.out.println(classloader3);//null    引导加载类是无法得到的，所以返回为空
		
		
		//前面我说的自定义一个java.lang.Object，覆盖jdk会报错，为什么呢？
		System.out.println(new Object().getClass().getClassLoader());//null   可以看出核心的一些类，直接通过引导类加载器进行加载的。
    }
}

得到Class 的四种方式

          // 常用的三种得到Class的方法

			// 第一种，使用的频率很低，几乎很少用，   注意任何个类都会又class这个属性
			Class c=Test.class;

			//第二种：使用情况不少，因为有时候会知道对象，然后反向知道是那个用按个class创建的。
			Class c1=new Test().getClass();

			//第三种：最常用的一种方法，因为器完全可以体现 反射的动态，因为这个加载 的时候会判断是否参数为字符串，而这个类是否存在是在运行的时候才知道。还有一点就耦合性更高，写一个工具类直接传参为字符串即可。
			Class c2=  Class.forName("test.Test");
			// 第四种是也是一种，其中是通过加载器进行生成的Class对象，其可以生成自身以及在相同的加载器里面的其他对象类。
			ClassLoader classload=Test.class.getClassLoader();
			Class tclass=classload.loadClass("package.test.类名"); //一般都是生成其他类的Class对象毕竟Test.class已经得到Class对象了。就不需要在通过加载器再来一遍了

反射的具体使用

//父类
public class testA<T> extends testB {


	String name;
	public int age;
	protected int testAge;

	//无参的构造方法
	public testA() {   
	}
	// 这个地方要注意，虽然是自定义的泛型类，其构建方法不用添加一对<>括号
	public testA(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;
	}

}


//子类

public class Test extends testA implements Runnable {

	int id;
	String name;

	public Test() {
	}

	private Test(int id) {
		super();
		this.id = id;

	}
	protected Test(String name) {
		super();
		this.name = name;

	}
	public Test(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}

	public void showPublic() {
		System.out.println("showPublic");
	}

	private void showPrivate(int i) {
		System.out.println("showPrivate");
	}



	
	@Override
	public String toString() {
		return "Test [id=" + id + ", name=" + name + "]";
	}
}

上面是举例的java类，而下面是用反射进行实现

反射创建对象，得到方法以及调用方法，得到属性以及给属性赋值


  		Class c=  Class.forName("test.Test");
  		// 同反射创建一个实例  当然必须又空参的构造方法
  		Test t=(Test) c.newInstance();
  		System.out.println(t);
  		
  		// 如果是有参发我们如何通过反射创建一个对象呢 getConstructor 必须调用的是public修饰的 
  		Constructor tc=c.getConstructor(int.class,String.class);
  		System.out.println(tc.newInstance(1,"dfdfdf"));
  		
  		// 可以得到任何的方构造函数，那怕是private 方法
  		Constructor tc1=c.getDeclaredConstructor(int.class);
  		tc1.setAccessible(true);
  		System.out.println(tc1.newInstance(2));
  		
  		
  		// 得到构造方法不过只能得到public 修饰的
  		Constructor<Test>[] constr=c.getConstructors();
  		for (Constructor con:constr) {
  			System.out.println(con);
  		}
  		
  		// 可以得到class中的所有构造方法，那怕是私有的
  		Constructor<Test>[] constr1=c.getDeclaredConstructors();
  		for (Constructor con:constr1) {
  			System.out.println(con);
  		}
         Method[] m=c.getMethods();
         for (Method cc:m) {
      	   System.out.println(cc);
      	   }
               
     方法的执行
         Method mshow=c.getDeclaredMethod("showPrivate", int.class);
         mshow.setAccessible(true);
         mshow.invoke(t, 10);// 这个地方如果是静态方法，那么就不是对象，而是对象类mshow.invoke(t.class, 10)

         
     这个其实由上面的方法，就推断一下，其可以得到类的所有public修饰的属性，同样也可以拿到父类的public修饰的属性
         Field[] fields= c.getFields();
         
         System.out.println(Arrays.toString(fields));
        得到自己本身的所有属性，哪怕是private修饰的，但是无法得到父类的。
         fields=c.getDeclaredFields();
         
         System.out.println(Arrays.toString(fields));
        当然也可以单独拿一个属性，进行简单的设置，可以将其赋值
           
         Field field=c.getDeclaredField("name");
        打开权限。
         field.setAccessible(true);
         field.set(t, "反射属性赋值");// set(所属的类实例，属性赋值)
         System.out.println(t);
         
       可以得到其继承的父类的Class,而得不到其父类的父类
         System.out.println( c.getSuperclass());
         可以得到其实现的接口的Class,
         System.out.println( c.getInterfaces());

反射在泛型上体现

泛型的机制：java采用的是泛型擦除的机制来引入泛型的，也就是java中的泛型是在编译器javac中使用的，确保数据的安全性和免去强制类型的转换问题，但是编译完后，所有的泛型有关的类型将全部擦除。
为了通过反射操作这些类型，java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归到Class类中的数据但是又和原来的类型齐名的类型。
ParameterizedType：表示一种参数类型，比如Collection
GennericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型
TypeVariable：是各种类型变量的公共父接口。
WildcardType：代表一种通配符类型表达式

这个时候又有了一个很矛盾的问题：既然参数机制，那么在反射中如何得到泛型呢？

简单的说擦除机制是泛型第一次出现在1.5版本，而为了兼容以前的运行环境，而这样做的。但是其虽然擦除了但是为额外有一个Signature存储泛型的信息。如果要了解详细可以参考

现在看代码

public class test_1 {
	
	public void show(List<String> l,Map<String, Integer> m) {
		

	}
	
	public static void main(String[] args) {
		try {
			Class c=Class.forName("test.test_1");
			Method m= c.getMethod("show", List.class,Map.class);
			
			
			
			
			Class[] parameters= m.getParameterTypes();
			for (Class parameter:parameters) {
				//：interface java.util.List
				//interface java.util.Map
				System.out.println("方法中的参数类型："+parameter);
			}
			
			
			Type[] typeParameters= m.getGenericParameterTypes();
			for (Type typeParameter:typeParameters) {
				//java.util.List<java.lang.String>
//				java.util.Map<java.lang.String, java.lang.Integer>
				System.out.println("方法中的参数类型："+typeParameter);
				if(typeParameter instanceof ParameterizedType) {
					
					Type[] t=((ParameterizedType) typeParameter).getActualTypeArguments();
					for (Type t1:t) {
						System.out.println("方法中的参数类型上的泛型："+t1);
					}
				}
				
//				Type t  =parameter.getGenericSuperclass();
				
			}
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
   //输出
    
方法中的参数类型：interface java.util.List
方法中的参数类型：interface java.util.Map
方法中的参数类型：java.util.List<java.lang.String>
方法中的参数类型上的泛型：class java.lang.String
方法中的参数类型：java.util.Map<java.lang.String, java.lang.Integer>
方法中的参数类型上的泛型：class java.lang.String
方法中的参数类型上的泛型：class java.lang.Integer

反射得到注解信息

package test;

import java.lang.annotation.Annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;

public class MyAnnotation {
	
	@myan(name="test",interest= {"testInsterest"})//只有age不写才不会报错，而且顺序无关因为参数赋值需要 参数名=参数值
	@myAn1("df")
   public void test() {


}
	
	public static void main(String[] args) {
	try {
		Class c=Class.forName("test.MyAnnotation");
		Method m=c.getMethod("test");
		Annotation[] anno= m.getAnnotations();
		for(Annotation a:anno) {
			System.out.println(a);
		}
//		得到注解的上的属性值
		myan my= m.getAnnotation(myan.class);
		System.out.println(my.age());
		System.out.println(my.interest());

		
		
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	}	
}

// 注解可以使用，目前我定义的是方法，和属性，可以看 ElementType这个枚举下面，其实有很多，可以选择
@Target({ElementType.METHOD,ElementType.FIELD})
// SOURCE< CLASS<RUNTIME 这个是作用的范围，其中下面的包含关系，其中范围最大的是RUNTIME，三个地方都会其中，一般自己写的话都会写RUNTIME
@Retention(value=RetentionPolicy.RUNTIME)
@Inherited// 可以被继承
@interface myan{
//	这个不是方法，而是注解的参数。具体写法就是  类型+参数名+（） 
	String name();
	String[] interest();
	// 如果不写默认值，就需要在使用是时候需要填写值
	int age() default 0;
	
	
}
@Target({ElementType.METHOD,ElementType.FIELD})
@Retention(value=RetentionPolicy.RUNTIME)
@interface myAn1{
	// value 是最神奇的一个参数值，其如果写value 不需要使用 value=value的值
		String value();
}

上面可以看出如果使用反射，可以得到注解以及注释上属性的值，这样的话就可以理解为什么在框架中注解就可以影响方法或者给属性赋值等操作了。

反射的效率

public class Test  {

	public void show() {

	}

	public static void main(String[] args) throws Exception {
//		直接正常调用show 方法
		Date d=new Date();
		Long beging=d.getTime();
		Test t =new Test();
		for (int i = 0; i < 20000000 ; i++) {
			t.show();
		}
		d=new Date();
		Long end=d.getTime();

		System.out.println("直接正常调用show 方法"+(end -beging));

		
//		反射后直接调用
		Class c=t.getClass();
		d=new Date();
		beging=d.getTime();
		Method m=c.getMethod("show");
		for (int i = 0; i < 20000000 ; i++) {
			m.invoke(t);
		}
		d=new Date();
		end=d.getTime();

		System.out.println("反射"+(end -beging));


//反射后修改权限
		d=new Date();
		beging=d.getTime();

		m.setAccessible(true);
		for (int i = 0; i < 20000000 ; i++) {
			m.invoke(t);
		}
		d=new Date();
		end=d.getTime();

		System.out.println("反射后修改权限"+(end -beging));



	}
}
//输出

直接正常调用show 方法4
反射28
反射后修改权限16

上面可以看出反射的效率本身还是低于正常逻辑调用的。

补充

java 的三个特性大家都知道：封装，多态，继承。

封装的主要就是包装数据安全，而反射是否破坏了java 的封装这个特征呢？

完全没有封装其中对private的修饰，本身就是对数据的权限进行的一个限制。就像是一个房子告诉别人哪里是窗户，哪里是门。告诉人们你要从门口进来，不要从窗户进来。而反射却是直接将其墙壁打穿然后所以进出。

个人理解的话封装就是数据安全的规范，而反射却是无视规范的破环者，所以要分开看，对于数据java流程来说就算是反射修改了数据，那么在流程向下走的时候修改的数据也是有自己的封装性。

小猪弟

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础浅谈反射

反射在说发射之前，先说两个概念动态语言和静态语言动态语言：动态语言又被称为扩建的语言，或者脚本语言，是一种编程语言，用来控制软件应用程序，脚本通常以文本（如ASCII)保存，只在被调用时进行解释或编译。简单的说就是一种在运行时，可以改变其结构的语言：例如新的函数，对象，甚至代码也可以引进，已有的函数可以被删除或者其结构上的修改。通俗点说就是在运行时代码可以根据某些条件修改自身结构的语言。常见的语言：js，python，php等语言。静态语言：与动态语言刚好相反，就是在运行之前定好结构，在运行
复制链接

扫一扫