Java中的反射
2021/7/11 14:06:30
本文主要是介绍Java中的反射,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!
反射是什么
Java的反射(reflection)机制是指在程序的运行状态中,可以构造任意一个类的对象,可以了解任意一个对象所属的类,可以了解任意一个类的成员变量和方法,可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键。
学习反射之前,对于一个类的操作:
@Test public void test1(){ //1.创建Person类的对象 Person p1 = new Person("Tom", 12); //2.通过对象,调用其内部的属性、方法 p1.age = 10; System.out.println(p1.toString()); p1.show(); //在Person类外部,不可以通过Person类的对象调用其内部私有结构。 //比如:name、showNation()以及私有的构造器 }
学习反射之后,通过反射来调用该类的属性以及方法(包括该类的私有结构)
@Test public void test2() throws Exception{ Class<Person> clazz = Person.class; //1.通过反射,创建Person类的对象 Constructor<Person> cons = clazz.getConstructor(String.class, int.class); Person tom = cons.newInstance("Tom", 12); System.out.println(tom.toString()); //2.通过反射,调用对象指定的属性、方法 //调用属性 Field age = clazz.getDeclaredField("age"); age.set(tom,10); System.out.println(tom.toString()); //调用方法 Method show = clazz.getDeclaredMethod("show"); show.invoke(tom); System.out.println("================================="); //通过反射,可以调用Person类的私有结构的。比如:私有的构造器、方法、属性 //调用私有的构造器 Constructor<Person> cons1 = clazz.getDeclaredConstructor(String.class); cons1.setAccessible(true); Person jerry = cons1.newInstance("Jerry"); System.out.println(jerry.toString()); //调用私有的属性 Field name = clazz.getDeclaredField("name"); name.setAccessible(true); name.set(jerry,"Jack"); System.out.println(jerry); //调用私有的方法 Method showNation = clazz.getDeclaredMethod("showNation", String.class); showNation.setAccessible(true); String nation = (String) showNation.invoke(jerry, "中国");//相当于jerry.showNation("中国") System.out.println(nation); }
关于java.lang.Class类的理解
- 类的加载过程:
程序经过javac.exe命令以后,会生成一个或多个字节码文件(.class结尾)。
接着使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。
加载到内存中的类,称为运行时类,此运行时类,就作为Class的一个实例。 - 换句话说,Class的实例就对应着一个运行时类。
- 加载到内存中的运行时类,会缓存一定的时间。在此时间之内,我们可以通过不同的方式来获取此运行时类。
获取Class实例的方式(前三种方式需要掌握)
@Test public void test3() throws ClassNotFoundException { //方式一:调用运行时类的属性:.class Class<Person> clazz1 = Person.class; System.out.println(clazz1); //方式二:通过运行时类的对象,调用getClass() Person p1 = new Person(); Class<? extends Person> clazz2 = p1.getClass(); System.out.println(clazz2); //方式三:调用Class的静态方法:forName(String classPath) Class<?> clazz3 = Class.forName("reflection.Person"); System.out.println(clazz3); System.out.println(clazz1 == clazz2); System.out.println(clazz1 == clazz3); //方式四:使用类的加载器:ClassLoader (了解) ClassLoader classLoader = ReflectionTest.class.getClassLoader(); Class<?> clazz4 = classLoader.loadClass("reflection.Person"); System.out.println(clazz4); System.out.println(clazz1 == clazz4); }
不仅仅是类才有Class实例,也可以是其他结构:
@Test public void test4(){ Class c1 = Object.class; //类 Class c2 = Comparable.class; //接口 Class c3 = String[].class; //数组 Class c4 = int[][].class; //二维数组 Class c5 = ElementType.class; //枚举类 Class c6 = Override.class; //注解 Class c7 = int.class; //基本数据类型 Class c8 = void.class; //void Class c9 = Class.class; //Class类本身 int[] a = new int[10]; int[] b = new int[100]; Class c10 = a.getClass(); Class c11 = b.getClass(); //只要数组的元素类型与维度一样,就是同一个Class System.out.println(c10 == c11); }
通过反射创建对应的运行时类的对象
newInstance():调用此方法,创建对应的运行时类的对象。内部调用了运行时类的空参构造器。
要想此方法正常的创建运行时类的对象,有如下的要求:
- 运行时类必须提供空参的构造器
- 空参构造器的访问权限得够,通常设置为public。
开发时会在javabean中要求提供一个public的空参构造器。原因如下:
- 便于通过反射,创建运行时类的对象。
- 便于子类继承此运行时类时,默认调用super()时,保证父类有此构造器
@Test public void test1() throws IllegalAccessException, InstantiationException { Class<Person> clazz = Person.class; Person p = clazz.newInstance(); System.out.println(p); }
通过newInstance()方法和forName()方法来体会反射的动态性
@Test public void test2(){ for (int i = 0; i < 10; i++) { int num = new Random().nextInt(3); String classPath = ""; switch (num){ case 0: classPath = "java.lang.Object"; break; case 1: classPath = "java.util.Date"; break; case 2: classPath = "reflection.Person"; break; } try { Object obj = getInstance(classPath); //无法确定输出的obj实例到底是哪个类,可能是Object,也可能是Date或者Person System.out.println(obj); } catch (Exception e) { e.printStackTrace(); } } } public Object getInstance(String classPath) throws Exception{ Class clazz = Class.forName(classPath); return clazz.newInstance(); }
了解类的加载器
Java类加载器(Java Classloader)是Java运行时环境(JRE)的一部分,负责动态加载Java类到Java虚拟机的内存空间中。类通常是按需加载,即第一次使用该类时才加载。由于有了类加载器,Java运行时系统不需要知道文件与文件系统。每个Java类必须由某个类加载器装入到内存。
JVM中有3个默认的类加载器:
- Bootstrap ClassLoader(引导类加载器):由原生代码编写,不继承自java.lang.ClassLoader。负责加载核心Java库。
- Extension ClassLoader(拓展类加载器):Java 虚拟机的实现会提供一个扩展库目录,该类加载器在此目录里面查找并加载 Java 类。
- Application ClassLoader(系统类加载器):一般来说,Java 应用的类都是由它来完成加载的。可以通过ClassLoader.getSystemClassLoader()来获取它。
@Test public void test1(){ //对于自定义类,使用系统类加载器进行加载 ClassLoader classLoader = ClassLoaderTest.class.getClassLoader(); System.out.println(classLoader); //调用系统类加载器的getParent():获取扩展类加载器 ClassLoader classLoader1 = classLoader.getParent(); System.out.println(classLoader1); //调用扩展类加载器的getParent():无法获取到引导类加载器 //引导类加载器主要负责加载java的核心类库,无法加载自定义类的。 ClassLoader classLoader2 = classLoader1.getParent(); System.out.println(classLoader2);//输出为null,无法获取到引导类加载器 //String作为为java核心类之一,也是通过引导类加载器加载 ClassLoader classLoader3 = String.class.getClassLoader(); System.out.println(classLoader3);//同样为null,无法获取引导类加载器 }
使用类的加载器读取配置文件:
@Test public void test2() throws Exception{ Properties pros = new Properties(); //使用类的加载器读取配置文件 //配置文件默认识别为:当前module的src下 ClassLoader loader = ClassLoaderTest.class.getClassLoader(); InputStream is = loader.getResourceAsStream("jdbc1.properties"); pros.load(is); String user = pros.getProperty("user"); String pass = pros.getProperty("pass"); System.out.println("user = " + user + ", password = " +pass); }
动态代理——反射的应用之一
代理模式是常用的java设计模式,他的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类,以及事后处理消息等。一个代理类的对象与一个委托类的对象关联,代理类的对象本身并不真正实现服务,而是通过调用委托类的对象的相关方法,来提供特定的服务。简单的说就是,我们在访问实际对象时,是通过代理对象来访问的,代理模式就是在访问实际对象时引入一定程度的间接性。
动态代理是代理模式中的一种。动态代理中,代理类并不是在Java代码中定义的,而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理, 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理,而不用修改每个代理类中的方法。 动态生成代理类就需要通过反射来实现。
要想实现动态代理,需要解决以下两个问题
问题一:如何根据加载到内存中的被代理类,动态的创建一个代理类及其对象。
问题二:当通过代理类的对象调用方法a时,如何动态的去调用被代理类中的同名方法a。
测试代码:
//代理类与被代理类公共的接口 interface Human{ String getBelief(); void eat(String food); } //被代理类 class SuperMan implements Human{ @Override public String getBelief() { return "I believe I can fly!"; } @Override public void eat(String food) { System.out.println("我喜欢吃" + food); } } //定义一个动态生成代理类的工厂 class ProxyFactory{ //调用此方法,返回一个代理类的对象。解决问题一 public static Object getProxyInstance(Object obj){//obj:被代理类的对象 MyInvocationHandler handler = new MyInvocationHandler(); handler.bind(obj); return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),handler); } } //定义一个Handler class MyInvocationHandler implements InvocationHandler { private Object obj;//需要使用被代理类的对象进行赋值 public void bind(Object obj){ this.obj = obj; } //当我们通过代理类的对象,调用方法a时,就会自动的调用如下的方法:invoke() //将被代理类要执行的方法a的功能就声明在invoke()中 @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //method:即为代理类对象调用的方法,此方法也就作为了被代理类对象要调用的方法 //obj:被代理类的对象 Object returnValue = method.invoke(obj, args); //上述方法的返回值就作为当前类中的invoke()的返回值。 return returnValue; } } //测试 public class ProxyTest { public static void main(String[] args) { SuperMan superMan = new SuperMan(); //proxyInstance:代理类的对象 Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan); //当通过代理类对象调用方法时,会自动的调用被代理类中同名的方法 String belief = proxyInstance.getBelief(); System.out.println(belief); proxyInstance.eat("四川麻辣烫"); } }
这篇关于Java中的反射的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!
- 2024-09-07面向对象编程基础:初学者指南
- 2024-09-07数据结构入门:了解基础概念与简单应用
- 2024-09-07面向对象编程入门:掌握基本概念与实践
- 2024-09-07数据结构入门:从基础概念到基本操作
- 2024-09-07从零开始学数据库:入门级指南与实操技巧
- 2024-09-07综合设备故障分析与预防:实例代码与优化策略
- 2024-09-07数据库入门:轻松掌握数据管理基础
- 2024-09-07面向对象入门:快速掌握对象编程基础
- 2024-09-07数据库教程:入门与实践指南
- 2024-09-07面向对象开发教程 - 从零基础到实践应用的进阶之路