正确理解Java反射的姿势

反射简介

反射是Java的高级特性之一,但是在实际的开发中,使用Java反射的案例却非常的少,但是反射确实在底层框架中被频繁的使用。

比如:JDBC中的加载数据库驱动程序,Spring框架中加载bean对象,动以及态代理,这些都使用到反射,因为我们要想理解一些框架的底层原理,反射是我们必须要掌握的。

理解反射我们先从他的概念入手,那么什么是反射呢?

反射就是在运行状态能够动态的获取该类的属性和方法,并且能够任意的使用该类的属性和方法,这种动态获取类信息以及动态的调用对象的方法的功能就是反射。

实现上面操作的前提是能够获取到该类的字节码对象,也就是.class文件,在反射中获取class文件的方式有三种:

类名.class如:Person.class

对象.getClass如:person.getClass

Class.forName(全类名)获取如:Class.forName("ldc.org.demo.person")

Class对象

对于反射的执行过程的原理,我这里画了一张图,以供大家参考理解。

我们看过JVM的相关书籍都会详细的了解到,Java文件首先要通过编译器编译,编译成Class文件,然后通过类加载器(ClassLoader)将class文件加载到JVM中。

在JVM中Class文件都与一个Class对象对应,在因为Class对象中包含着该类的类信息,只要获取到Class对象便可以操作该类对象的属性与方法。

在这里深入理解反射之前先来深入的理解Class对象,它包含了类的相关信息。

Java中我们在运行时识别对象和类的信息,也叫做RTTI,方式主要有来两种:

传统的RTTI(Run-Time Type Information)

反射机制

那么什么是RTTI呢?RTTI称为运行时类型识别,传统的RTTI是在编译时就已经知道所有类型;而反射机制则是在程序运行时才确定的类型信息。

想要运行时使用类型信息,就必须要获取Class对象的引用,获取Class对象的方式上面已经提及。

这里有点区别的就是使用(.class)方式获取Class对象,并不会初始化Class对象,而使用(forName("全类名"))的方式会自动初始化Class对象

当一个.class文件要被加载到JVM中的时候,会进行如下的准备工作,首先会检查这个类是否被加载,若是没有被加载就会根据全类名找到class文件,接着加载Class文件,并创建类的静态成员引用。

但是在程序中并非是一开始就完全加载该类的class文件,而是在程序用的地方再加载,即为懒加载模式

当加载完Class文件后,接着就会验证Class文件中的字节码,并静态域分配存储空间。这个过程也叫做链接

最后一步就是进行初始化,即为了使用类而提前做的准备工作如下图所示:

反射

反射对应到Java中的类库就是在java.lang.reflect下,    在该包下包含着Field、Method和Constructor类。

Field是表示一个类的属性信息,Method表示类的方法信息,Constructor表示的是类的构造方法的信息。

在反射中常用的方法,我这里做了一个列举,当然更加详细的可以查官方的API文档进行学习。

方法名作用

getConstructors()获取公共构造器

getDeclaredConstructors()获取所有构造器

newInstance()获取该类对象

getName()获取类名包含包路径

getSimpleName()获取类名不包含包路径

getFields()获取类公共类型的所有属性

getDeclaredFields()获取类的所有属性

getField(String name)获取类公共类型的指定属性

getDeclaredField(String name)获取类全部类型的指定属性

getMethods()获取类公共类型的方法

getDeclaredMethods()获取类的所有方法

getMethod(String name, Class[] parameterTypes)获得类的特定公共类型方法

getDeclaredClasses()获取内部类

getDeclaringClass()获取外部类

getPackage()获取所在包

另外对于反射的使用这里附上一段小demo,具体的实际应用,会在后面继续说到,并且也会附上代码的实现:

publicclassUser{

privateString name;

privateInteger age;

publicUser(){

}

publicUser(String name, Integer age){

this.name = name;

this.age = age;

}

privatevoidprivateMethod(){

System.err.println("privateMethod");

}

publicvoidpublicMethod(String param){

System.err.println("publicMethod"+param);

}

@Override

publicStringtoString(){

return"User{"+

"name='"+ name +'\''+

", age="+ age +

'}';

}

}

在User的实体类中,有两个属性age和name,并且除了有两个测试方法privateMethod和publicMethod用于测试私有方法和公共方法的获取。接着执行如下代码:

Class clazz=User.class;

//获取有参构造

Constructor constructor = clazz.getConstructor(String.class, Integer.class);

//获取该类对象并设置属性的值

Objectobj = constructor.newInstance("黎杜",18);

//获得类全类名,既包含包路径

StringfullClassName = clazz.getName();

//获得类名

StringclassName = clazz.getSimpleName();

//获得类中公共类型(public)属性

Field[] fields = clazz.getFields();

StringfieldName="";

for(Field field : fields){

// 获取属性名

fieldName=field.getName();

System.out.println(fieldName)

}

//获得类中全部类型属性(包括private)

Field[] fieldsAll = clazz.getDeclaredFields();

fieldName="";

for(Field field : fieldsAll){

// 获取属性名

fieldName=field.getName();

System.out.println(fieldName)

}

//获得指定公共属性值

Field age = clazz.getField("age");

Objectvalue = age.get(obj);

System.err.println("公共指定属性: "+value);

//获得指定的私有属性值

Field name = clazz.getDeclaredField("name");

//设置为true才能获取私有属性

name.setAccessible(true);

Objectvalue2= name.get(obj);

System.err.println("私有指定属性值: "+value2);

//获取所有公共类型方法   这里包括 Object 类的一些方法

Method[] methods = clazz.getMethods();

StringmethodsName="";

for(Method method : methods){

methodsName=method.getName();

}

//获取该类中的所有方法(包括private)

Method[] methodsAll = clazz.getDeclaredMethods();

methodsName="";

for(Method method : methodsAll){

methodsName=method.getName();

}

//获取并使用指定方法

Method privateMethod= clazz.getDeclaredMethod("privateMethod");//获取无参私有方法

privateMethod.setAccessible(true);

privateMethod.invoke(obj);//调用方法

Method publicMethod= clazz.getMethod("publicMethod",String.class);//获取有参数方法

publicMethod.invoke(obj,"黎杜");//调用有参方法

看完上面的demo以后,有些人会说,老哥这只是一个很简单的demo,确实是,这里为了照顾一下一些新手,先熟悉一下反射的一些方法的用法,好戏还在后头。

反射在jdk 1.5的时候允许对Class对象能够支持泛型,也称为泛化Class,具体的使用如下:

Class user= User.class;

//泛化class可以直接得到具体的对象,而不再是Object

Useruser= user.newInstance();

泛化实现了在获取实例的时候直接就可以获取到具体的对象,因为在编译器的时候就会做类型检查。当然也可以使用通配符的方式,例如:Class

反射实际应用

经过上面的反射的原理介绍,下面就要开始反射的实际场景的应用,所有的技术,你知道的该技术的应用场景永远是最值钱。这个是越多越好,知道的场景越多思路就越多。

反射的实际场景的应用,这里主要列举这几个方面:

动态代理

JDBC 的数据库的连接

Spring 框架的使用

动态代理实际就是使用反射的技术来实现,在程序运行时创建一个代理类,用来代理给定的接口,实现动态处理对其所代理的方法的调用。

实现动态代理主要有以下几个步骤:

实现InvocationHandler接口,重写invoke方法,实现被代理对象的方法调用的逻辑。

Proxy.getProxyClass获取代理类

执行方法,代理成功

动态代理的实现代码如下所示,首先创建自己类DynamicProxyHandler实现InvocationHandler:

publicclassDynamicProxyHandlerimplementsInvocationHandler{

privateObject targetObj;

publicDynamicProxyHandler(){

super();

}

publicDynamicProxyHandler(Object targetObj){

super();

this.targetObj= targetObj;

}

@Override

publicObjectinvoke(Object proxy, Method method, Object[] args)throwsThrowable{

System.err.println("开始执行targetObj的方法");

//执行被代理的targetObj的方法

method.invoke(targetObj, args);

System.out.println("执行方法结束");

returnnull;

}

}

然后执行Proxy.newProxyInstance方法创建代理对象,最后执行代理对象的方法,代码实现如下:

User user =newUserImpl();

DynamicProxyHandler dynamicProxy =newDynamicProxyHandler(user);

//第一个参数:类加载器;第二个参数:user.getClass().getInterfaces():被代理对象的接口;第三个参数:代理对象

User userProxy = (User )Proxy.newProxyInstance(user.getClass().getClassLoader(), user.getClass().getInterfaces(), dynamicProxy);

userProxy.login();

userProxy.logout();

以上的实现是jdk的动态代理方式,还有一种动态代理是Cglib的动态代理方式,Cglib动态代理也是被广泛的使用,比如Spring AOP框架中,实现了方法的拦截功能

在ORM框架Hibernate框架也是使用Cglib框架来代理单端single-ended的关联关系。

jdk的动态代理与Cglib的动态代理的区别在于jdk动态代理必须实现接口,而Cglib的动态代理是对那些没有实现接口的类,实习那的原理通通过继承称为子类,并覆盖父类中的一些方法。

对于Cglib的动态代理这里由于篇幅的原因不再做详细讲解,下一篇将会详细的讲解jdk的动态代理和Cglib的动态代理的实现。

下面我们来看看JDBC中反射的应用案例,在JDBC中使用Class.forName()方法来加载数据库驱动,就是使用反射的案例。

让我们来一波入门的时候写的代码,一波回忆杀历历在目,具体的实现代码我相信也是很多人在初学者的时候也写过,如下所示:

Class.forName("com.mysql.jdbc.Driver");//1、使用CLASS 类加载驱动程序 ,反射机制的体现 

con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test","root","root");//2、连接数据库  

最后一个案例实现是使用反射模拟Spring通过xml文件初始化Bean的过程,学过ssm的项目都会依稀的记得Spring的配置文件,比如:

上面的配置文件非常的熟悉,在标签里面有属性,属性有属性值,以及标签还有子标签,子标签也有属性和属性值,那么怎么用他们初始化成Bean呢?

思路可以是这样的,首先得得到配置文件的位置,然后加载配置文件,加载配置文件后就可以解析具体的标签,获取到属性和属性值,通过属性值初始化Bean。

实现的代码如下,首先加载配置文件的内容,并获取到配置文件的根节点:

SAXReaderreader = new SAXReader();

ClassLoaderclassLoader = Thread.currentThread().getContextClassLoader();

InputStreamis= classLoader.getResourceAsStream(beanXml);

Documentdoc = reader.read(is);

Elementroot = doc.getRootElement();

拿到根节点后,然后可以获取bean标签中的属性和属性值,当拿到属性class属性值后就可以通过反射初始化Bean对象。

for(Iteratori = root.elementIterator("bean"); i.hasNext();) {

Elementfoo = (Element) i.next();

//获取Bean中的属性值

Attribute idValue = foo.attribute("id");

Attribute clazzValue = foo.attribute("class");

//通过反射获取Class对象

Class bean = Class.forName(clazzValue.getText());

//并实例化Bean对象

Objectobj = bean.newInstance();

}

除了初始化对象你还可以为Bean对象赋予初始值,例如上面的bean标签下还有property标签,以及它的属性值value:

我们就可以通过一下代码来初始化这些值:

BeanInfo beanInfo = Introspector.getBeanInfo(bean);

// bean对象的属性信息

PropertyDescriptor propertyDescriptor[] = beanInfo .getPropertyDescriptors();

for(Iteratorite = foo.elementIterator("property"); ite.hasNext();) {

Elementproperty= (Element) ite.next();

Attribute name = property.attribute("name");

Attribute value = property.attribute("value");

for(inti=0; k < propertyDescriptor.length; i++) {

if(propertyDescriptor[i].getName().equalsIgnoreCase(name.getText())) {

Method method= propertyDescriptor[i].getWriteMethod();

//使用反射将值设置进去

method.invoke(obj, value.getText());

}

}

以上就是简单的三个反射的应用案例,也是比较简单,大佬不喜勿喷哈,初学者就当是自己学多一点知识,总之一点一点进步。

反射优点和缺点

优点:反射可以动态的获取对象,调用对象的方法和属性,并不是写死的,比较灵活,比如你要实例化一个bean对象,你可能会使用new User()写死在代码中。

但是使用反射就可以使用class.forName(user).newInstance(),而变量名user可以写在xml配置文件中,这样就不用修改源代码,灵活、可配置

缺点:反射的性能问题一直是被吐槽的地方,反射是一种解释操作,用于属性字段和方法的接入时要远远慢于直接使用代码,因此普通程序也很少使用反射。

你可能感兴趣的:(正确理解Java反射的姿势)