一文搞懂Java中的反射机制
前一段时间一直忙，所以没什么时间写博客，拖了这么久，也该更新更新了。最近看到各种知识付费的推出，感觉是好事，也是坏事，好事是对知识沉淀的认可与推动，坏事是感觉很多人忙于把自己的知识变现，相对的在沉淀上做的实际还不够，我对此暂时还没有什么想法，总觉得，慢慢来，会更快一点，自己掌握好节奏就好。
好了，言归正传。
反射机制是Java中的一个很强大的特性，可以在运行时获取类的信息，比如说类的父类，接口，全部方法名及参数，全部常量和变量，可以说类在反射面前已经衣不遮体了（咳咳，这是正规车）。先举一个小栗子，大家随意感受一下：
publicvoidtestA(){
Stringname="java.lang.String";
try{
Classcl=Class.forName(name);
Classsupercl=cl.getSuperclass();
Stringmodifiers=Modifier.toString(cl.getModifiers());
if(modifiers.length()>0){
System.out.print(modifiers+"");
}
System.out.print(name);
if(supercl!=null&&supercl!=Object.class){
System.out.print("extents"+supercl.getName());
}
System.out.print("{\n");
printFields(cl);
System.out.println();
printConstructors(cl);
System.out.println();
printMethods(cl);
System.out.println("}");
}catch(ClassNotFoundExceptione){
e.printStackTrace();
}
System.exit(0);
}
privatestaticvoidprintConstructors(Classcl){
Constructor[]constructors=cl.getDeclaredConstructors();
for(Constructorc:constructors){
Stringname=c.getName();
System.out.print("");
Stringmodifiers=Modifier.toString(c.getModifiers());
if(modifiers.length()>0){
System.out.print(modifiers+"");
}
System.out.print(name+"(");
Class[]paraTypes=c.getParameterTypes();
for(intj=0;j0){
System.out.print(",");
}
System.out.print(paraTypes[j].getSimpleName());
}
System.out.println(");");
}
}
privatestaticvoidprintMethods(Classcl){
Method[]methods=cl.getDeclaredMethods();
for(Methodm:methods){
ClassretType=m.getReturnType();
Stringname=m.getName();
System.out.print("");
Stringmodifiers=Modifier.toString(m.getModifiers());
if(modifiers.length()>0){
System.out.print(modifiers+"");
}
System.out.print(retType.getSimpleName()+""+name+"(");
Class[]paramTypes=m.getParameterTypes();
for(intj=0;j0){
System.out.print(",");
}
System.out.print(paramTypes[j].getName());
}
System.out.println(");");
}
}
privatestaticvoidprintFields(Classcl){
Field[]fields=cl.getFields();
for(Fieldf:fields){
Classtype=f.getType();
Stringname=f.getName();
System.out.print("");
Stringmodifiers=Modifier.toString(f.getModifiers());
if(modifiers.length()>0){
System.out.print(modifiers+"");
}
System.out.println(type.getSimpleName()+""+name+";");
}
}
调用testA方法输出如下：
publicfinaljava.lang.String{
publicstaticfinalComparatorCASE_INSENSITIVE_ORDER;
publicjava.lang.String(byte[],int,int);
publicjava.lang.String(byte[],Charset);
publicjava.lang.String(byte[],String);
publicjava.lang.String(byte[],int,int,Charset);
publicjava.lang.String(byte[],int,int,String);
java.lang.String(char[],boolean);
publicjava.lang.String(StringBuilder);
publicjava.lang.String(StringBuffer);
publicjava.lang.String(byte[]);
publicjava.lang.String(int[],int,int);
publicjava.lang.String();
publicjava.lang.String(char[]);
publicjava.lang.String(String);
publicjava.lang.String(char[],int,int);
publicjava.lang.String(byte[],int);
publicjava.lang.String(byte[],int,int,int);
publicbooleanequals(java.lang.Object);
publicStringtoString();
publicinthashCode();
publicintcompareTo(java.lang.String);
publicvolatileintcompareTo(java.lang.Object);
publicintindexOf(java.lang.String,int);
publicintindexOf(java.lang.String);
publicintindexOf(int,int);
publicintindexOf(int);
staticintindexOf([C,int,int,[C,int,int,int);
staticintindexOf([C,int,int,java.lang.String,int);
publicstaticStringvalueOf(int);
publicstaticStringvalueOf(long);
publicstaticStringvalueOf(float);
publicstaticStringvalueOf(boolean);
publicstaticStringvalueOf([C);
publicstaticStringvalueOf([C,int,int);
publicstaticStringvalueOf(java.lang.Object);
publicstaticStringvalueOf(char);
publicstaticStringvalueOf(double);
publiccharcharAt(int);
privatestaticvoidcheckBounds([B,int,int);
publicintcodePointAt(int);
publicintcodePointBefore(int);
publicintcodePointCount(int,int);
publicintcompareToIgnoreCase(java.lang.String);
publicStringconcat(java.lang.String);
publicbooleancontains(java.lang.CharSequence);
publicbooleancontentEquals(java.lang.CharSequence);
publicbooleancontentEquals(java.lang.StringBuffer);
publicstaticStringcopyValueOf([C);
publicstaticStringcopyValueOf([C,int,int);
publicbooleanendsWith(java.lang.String);
publicbooleanequalsIgnoreCase(java.lang.String);
publicstatictransientStringformat(java.util.Locale,java.lang.String,[Ljava.lang.Object;);
publicstatictransientStringformat(java.lang.String,[Ljava.lang.Object;);
publicvoidgetBytes(int,int,[B,int);
publicbyte[]getBytes(java.nio.charset.Charset);
publicbyte[]getBytes(java.lang.String);
publicbyte[]getBytes();
publicvoidgetChars(int,int,[C,int);
voidgetChars([C,int);
privateintindexOfSupplementary(int,int);
publicnativeStringintern();
publicbooleanisEmpty();
publicstatictransientStringjoin(java.lang.CharSequence,[Ljava.lang.CharSequence;);
publicstaticStringjoin(java.lang.CharSequence,java.lang.Iterable);
publicintlastIndexOf(int);
publicintlastIndexOf(java.lang.String);
staticintlastIndexOf([C,int,int,java.lang.String,int);
publicintlastIndexOf(java.lang.String,int);
publicintlastIndexOf(int,int);
staticintlastIndexOf([C,int,int,[C,int,int,int);
privateintlastIndexOfSupplementary(int,int);
publicintlength();
publicbooleanmatches(java.lang.String);
privatebooleannonSyncContentEquals(java.lang.AbstractStringBuilder);
publicintoffsetByCodePoints(int,int);
publicbooleanregionMatches(int,java.lang.String,int,int);
publicbooleanregionMatches(boolean,int,java.lang.String,int,int);
publicStringreplace(char,char);
publicStringreplace(java.lang.CharSequence,java.lang.CharSequence);
publicStringreplaceAll(java.lang.String,java.lang.String);
publicStringreplaceFirst(java.lang.String,java.lang.String);
publicString[]split(java.lang.String);
publicString[]split(java.lang.String,int);
publicbooleanstartsWith(java.lang.String,int);
publicbooleanstartsWith(java.lang.String);
publicCharSequencesubSequence(int,int);
publicStringsubstring(int);
publicStringsubstring(int,int);
publicchar[]toCharArray();
publicStringtoLowerCase(java.util.Locale);
publicStringtoLowerCase();
publicStringtoUpperCase();
publicStringtoUpperCase(java.util.Locale);
publicStringtrim();
}
这里把String类型的所有方法和变量都获取到了，使用的仅仅是String类型的全名。当然，反射的功能不仅仅是获取类的信息，还可以在运行时动态创建对象，回想一下，我们正常的对象使用，都是需要在代码中先声明，然后才能使用它，但是使用反射后，就能在运行期间动态创建对象并调用其中的方法，甚至还能直接查看类的私有成员变量，还能获取类的注解信息，在泛型中类型判断时也经常会用到。反射可以说完全打破了类的封装性，把类的信息全部暴露了出来。
上面的代码看不太明白也没关系，只要稍微感受一下反射的能力就好了。介绍完了反射能做的事情，本篇教程就不再写一些玩具代码了，这次以一个实用型的代码为媒介来介绍反射。
在开发中，经常会遇到两个不同类对象之间的复制，把一个类中的字段信息get取出来，然后set到另一个类中，大部分情况下，两个类对应的字段是一样，每次这样使用是很麻烦的，那么利用反射就可以实现一个封装，只需要调用一个方法即可实现简单的类字段复制。
那么，先来想想，要复制一个类对象的所有字段信息到另一个类对象中，首先，怎么获取一个类的某个字段的值呢？我们先来编写一个方法：
/**
*获取对象的指定字段的值
*@paramobj目标对象
*@paramfieldName目标字段
*@return返回字段值
*@throwsException可能抛出异常
*/
privatestaticObjectgetFieldValue(Objectobj,StringfieldName)throwsException{
//获取类型信息
Classclazz=obj.getClass();
//取对应的字段信息
Fieldfield=clazz.getDeclaredField(fieldName);
//设置可访问权限
field.setAccessible(true);
//取字段值
Objectvalue=field.get(obj);
returnvalue;
}
这里使用了两个之前没有说过的类，一个是Class，是不是很眼熟，想一想，我们每次定义一个类的时候是不是都要用到它，哈哈，那你就想错了，那是class关键词，java是大小写的敏感的，这里的Class是一个类名，那这个类是干嘛用的呢？
虚拟机在加载每一个类的时候，会自动生成一个对应的Class类来保存该类的信息，可以理解为Class类是那个类的代理类，是连接实际类与类加载器的桥梁，可以通过它来获取虚拟机的类加载器引用，从而实现更多的骚操作。Class类是一个泛型类，每个类都有对应的一个Class类，比如String对应的Class类就是Class
Class有很多方法来获取更多关于类的信息，这里使用getDeclaredField方法来获取指定字段信息，返回的是Field类型对象，这个对象里存储着关于字段的一些信息，如字段名称，字段类型，字段修饰符，字段可访问性等，setAccessible方法可以设置字段的可访问性质，这样就能直接访问private修饰的字段了，然后使用get方法来获取指定对象的对应字段的值。
我们来测试一下：
publicvoidtestB(){
try{
Employeeemployee=newEmployee();
employee.setName("Frank");
employee.setSalary(6666.66);
System.out.println((String)getFieldValue(employee,"name"));
System.out.println((double)getFieldValue(employee,"salary"));
}catch(Exceptione){
e.printStackTrace();
}
}
输出如下：
Frank
6666.66
接下来，我们需要获取类中所有字段，然后在另一个类中查找是否有对应字段，如果有的话就设置字段的值到相应的字段中。
/**
*复制一个类对象属性到另一个类对象中
*@paramobjA需要复制的对象
*@paramobjB复制到的目标对象类型
*@return返回复制后的目标对象
*/
privatestaticvoidparseObj(ObjectobjA,ObjectobjB)throwsException{
if(objA==null){
return;
}
//获取objA的类信息
ClassclassA=objA.getClass();
ClassclassB=objB.getClass();
try{
//获取objA的所有字段
Field[]fieldsA=classA.getDeclaredFields();
//获取objB的所有字段
Field[]fieldsB=classB.getDeclaredFields();
if(fieldsA==null||fieldsA.length<=0||fieldsB==null||fieldsB.length<=0){
return;
}
//生成查询map
MapfieldMap=newHashMap<>();
for(Fieldfield:fieldsA){
fieldMap.put(field.getName(),field);
}
//开始复制字段信息
for(FieldfieldB:fieldsB){
//查找是否在objB的字段中存在该字段
FieldfielaA=fieldMap.get(fieldB.getName());
if(fielaA!=null){
fieldB.setAccessible(true);
fieldB.set(objB,getFieldValue(objA,fielaA.getName()));
}
}
}catch(IllegalStateExceptione){
thrownewIllegalStateException("instacefail:",e);
}
}
这里获取到classA和classB的所有字段之后，先生成了一个map用于查找，可以减少遍历次数，然后之后只需要遍历一次就可以判断相应字段是否存在，如果存在则取出对应值设置到相应的字段里去。
接下来测试一下：
publicvoidtestB(){
try{
//生成Employee对象
Employeeemployee=newEmployee("Frank",6666.66);
//生成一个Manager对象
Managermanager=newManager();
//复制对象
parseObj(employee,manager);
System.out.println(manager.getName());
System.out.println(manager.getSalary());
}catch(Exceptione){
e.printStackTrace();
}
}
publicclassEmployee{
privateStringname;
privateDoublesalary;
publicEmployee(Stringname,Doublesalary){
this.name=name;
this.salary=salary;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicDoublegetSalary(){
returnsalary;
}
publicvoidsetSalary(Doublesalary){
this.salary=salary;
}
}
publicclassManager{
privateStringname;
privateDoublesalary;
privateDoublebonus;
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicDoublegetSalary(){
returnsalary;
}
publicvoidsetSalary(Doublesalary){
this.salary=salary;
}
publicDoublegetBonus(){
returnbonus;
}
publicvoidsetBonus(Doublebonus){
this.bonus=bonus;
}
}
输出如下：
Frank
6666.66
完美，这样我们就利用了反射机制完美的把相同的字段在不同类的对象之间进行了复制，这里仅仅是两个字段，所以可能好处不明显，但事实上，实际开发中，经常会有将BO转换为VO的操作，这时候，这个操作就很有必要了，简单的一行命令就可以代替一大堆的get和set操作。
当然，使用反射机制固然高端大气上档次，但是也是一把双刃剑，使用不当很可能会带来严重后果，而且使用反射的话，会占用更多资源，运行效率也会降低，上述工具类是用运行效率换开发效率。开发中不建议大量使用，还是那句话，技术只是手段，需要使用的时候再使用，不要为了使用而使用。
至于反射中的其他方法和姿势，大家尽可以慢慢去摸索，这里仅仅是抛砖引玉。
至此，本篇讲解完毕，欢迎大家继续关注。
以上就是一文搞懂Java中的反射机制的详细内容，更多关于Java反射机制的资料请关注毛票票其它相关文章！
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。