java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > java反射Reflection

java中反射(Reflection)机制举例详解

作者：的的小白

Java中的反射机制是指Java程序在运行期间可以获取到一个对象的全部信息,这篇文章主要介绍了java中反射(Reflection)机制的相关资料,文中通过代码介绍的非常详细,需要的朋友可以参考下

一、什么是反射？

反射(Reflection)是一种 Java 程序运行期间的动态技术，可以在运行时(runtime)检査、修改其自身结构或行为。通过反射，程序可以访问、检测和修改它自己的类、对象、方法、属性等成员

二、反射的用途

  • 动态加载类:程序可以在运行时动态地加载类库中的类；
  • 动态创建对象:反射可以基于类的信息，程序可以在运行时，动态创建对象实例;
  • 调用方法:反射可以根据方法名称，程序可以在运行时，动态地调用对象的方法(即使方法在编写程序时还没有定义)
  • 访问成员变量:反射可以根据成员变量名称，程序可以在运行时，访问和修改成员变量(反射可以访问私有成员变量)
  • 运行时类型信息:反射允许程序在运行时，查询对象的类型信息，这对于编写通用的代码和库非常有用;

                Spring 框架使用反射来自动装配组件，实现依赖注入;

                MyBatis 框架使用反射来创建resultType 对象，封装数据查询结果;

三、获取Class对象

反射的第一步是获取 Class 对象。Class 对象表示某个类的元数据，可以通过以下几种方式获取：

//获取Class类型信息
public class Text02 {
	public static void main(String[] args) throws ClassNotFoundException {
		//方式1:通过类名
		Class stringClass1 = String.class;
		
		//方式2：通过Class类的forName()方法
		Class stringClass2 = Class.forName("java.lang.String");
		
		//方式3：通过对象调用getClass()方法
		Class stringClass3 = "".getClass();
		
		System.out.println(stringClass1.hashCode());//1604839423
		System.out.println(stringClass2.hashCode());//1604839423
		System.out.println(stringClass3.hashCode());//1604839423
	}

}

四、Class类型的对象使用场景1

将一个 JSON 字符串解析为 Java 对象，并输出该对象的字段值。

//Class类型的对象使用场景1
public class Text03 {
	public static void main(String[] args) {
		String json= "{\"name\":\"长安荔枝\",\"favCount\":234}";
		
		//方法定义
		Document doc=JSON.parseObject(json,Document.class);
		System.out.println(doc.getName());
		System.out.println(doc.getFavCount());
	}

}

使用 JSON.parseObject 方法将 JSON 字符串解析为 Document 类的对象。在解析过程中，JSON 字符串中的数据会自动映射到 Document 类的对应字段中。

五、Class类型的对象使用场景2

通过 Class 对象在运行时获取一个类的相关信息，包括类名、包名、成员变量（字段）、成员方法等。

//Class类型的对象使用场景2
//获取丰富的类型内容
public class Text04 {
	public static void main(String[] args) throws ClassNotFoundException {
		Class clz = Class.forName("java.util.HashMap");
		
		//获取类名
		System.out.println("完全限定名："+clz.getName());
		System.out.println("简单的类名："+clz.getSimpleName());
		
		//获取包名
		System.out.println("package"+clz.getPackage().getName());
		System.out.println();
		
		//获取成员变量
		Field[] fieldArray =clz.getDeclaredFields();
		System.out.println("成员变量(字段)");
		for(Field field:fieldArray) {
			System.out.println(field);
		}
		System.out.println();
		
		//获取成员方法
		Method[] methodArray = clz.getDeclaredMethods();
		System.out.println("成员方法");
		for(Method method:methodArray) {
			System.out.println(method);
		}	
	}
}

六、通过反射创建对象

方式一：通过 Class 对象直接调用 newInstance() 方法

方式二：通过获取构造方法（Constructor）来创建对象。

//通过反射的方式，创建对象
public class Text05 {
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
		Class clz = Class.forName("com.apesource.demo01.Document");
		
		//方式1：直接通过Class对象，调用newInstance()方法
		Object objx = clz.newInstance();//相当于在执行无参构造方法
		
		//方式2：通过构造器(构造方法)
		//无参构造方法
		Constructor constructor1 = clz.getDeclaredConstructor();//获取无参构造方法
		System.out.println(constructor1);
		Object obj1 = constructor1.newInstance();//执行构造器(构造方法),创建对象
		
		//有参构造方法
		Constructor constructor2 = clz.getDeclaredConstructor(String.class);//获取有参构造方法
		System.out.println(constructor2);
		Object obj2 = constructor2.newInstance("两京十五日");
		
		Constructor constructor3 = clz.getDeclaredConstructor(int.class);//获取有参构造方法
		System.out.println(constructor3);
		Object obj3 = constructor3.newInstance(34);
		
		Constructor constructor4 = clz.getDeclaredConstructor(String.class,int.class);//获取有参构造方法
		System.out.println(constructor4);
		Object obj4 = constructor4.newInstance("风起陇西",64);
		
		System.out.println(objx);
		System.out.println(obj1);
		System.out.println(obj2);
		System.out.println(obj3);
		System.out.println(obj4);
	}

七、使用 Java 反射机制获取和调用类的构造方法，访问私有构造方法并创建对象

public class Text06 {
	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		Class clz = Class.forName("com.apesource.demo01.Document");
		
		//获取一组构造器
		Constructor[] constructorArray1 = clz.getConstructors();//public
		Constructor[] constructorArray2 = clz.getDeclaredConstructors();//public、private
		
		//获取指定构造器
		Constructor constructor1 = clz.getConstructor();
		Constructor constructor2 = clz.getDeclaredConstructor(String.class);
		System.out.println(constructor1);
		System.out.println(constructor2);
		
		//调用私有构造器，必须设置它的访问全限
		constructor2.setAccessible(true);
		
		//调用构造器，创建对象
		Object obj = constructor2.newInstance("长安三万里");
		System.out.println(obj);
	}

}

八、通过反射，访问并使用成员方法

public class Text08 {
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
		//硬编码的方式
//		Document doc1 = new Document();
//		doc1.setName("海底两万里");
//		doc1.setFavCount(10025);
		
		//反射的方式
		Class clz = Class.forName("com.apesource.demo01.Document");//获取类型信息
		Object doc1 = clz.newInstance();//创建对象
		
		//获取指定名称和参数类型的方法
		Method setNameMethod = clz.getMethod("setName", String.class);
		Method setFavCountMethod = clz.getMethod("setFavCount", int.class);
		
		//执行方法
		//doc1.setName("海底两万里");
		setNameMethod.invoke(doc1, "海底两万里");
		//doc1.setFavCount(10025);
		setFavCountMethod.invoke(doc1, 10025);
		
		System.out.println(doc1);
		
	}

}

九、通过反射，调用静态方法以及处理可变参数

public class Text09_01 {
	public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, ClassNotFoundException {
		//硬编码的方式
		//调用静态方法
//		Document.dosth();
		
		String ret1 = String.format("HashMap的默认初始容量是%d,加载因子是%.2f", 16,0.75f);
		System.out.println(ret1);
		
		
		//反射的方式
//		Class clz = Class.forName("com.apesource.demo01.Document");
//		Method dosthMethod = clz.getMethod("dosth");
//		dosthMethod.invoke(null);
		
		Class clz = String.class;
		Method formatMethod = clz.getMethod("format", String.class,Object[].class);
		String ret2 = formatMethod.invoke(null, "HashMap的默认初始容量是%d,加载因子是%.2f",new Object[] {16,0.75f}).toString();
		
		System.out.println(ret2);
	}

}

十、反射的性能问题

反射虽然功能强大，但由于是在运行时动态操作类，因此性能相对较低。此外，反射也会破

坏封装性，使用时要谨慎。

十一、反射的安全性

使用反射时需要注意安全问题，因为它可以绕过 Java 的访问控制机制。例如，可以访问私有

字段或方法，因此在开发中使用反射要特别小心。

十二、反射的常见场景

  • 框架开发：如 Spring 中的依赖注入、Hibernate 中的 ORM 等。
  • 调试工具：如 Java 的调试器、分析工具等。
  • 动态代理：在 Java 中，动态代理依赖于反射。

总结 

到此这篇关于java中反射(Reflection)机制的文章就介绍到这了,更多相关java反射Reflection内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文