​Java反射详解

反射

反射的概念是软件可以在运行时,检查,分析,修改代码。例如:在Junit中,使用@Test注解等。 在Java中,通过反射可以在运行时检查字段,方法,类,接口,注解等。无需知道类或者方法是如何调用的,也无需知道参数是如何传递的,这些都可以在运行时通过反射获取。同样也可以通过反射创建实例,调用实例方法。 当然反射也不是万能的,使用反射有如下的缺点:

  • 性能问题。因为反射是在运行时而不是在编译时,所有不会利用到编译优化,同时因为是动态生成,所以会比编译后的代码更慢
  • 安全问题。使用反射可以动态调用方法,动态生成实例等,可能会导致一些意想不到的事情,例如调用未对反序列化进行校验直接运行方法等。
  • 代码问题。反射动态生成代码,所有的逻辑并没有直接暴露给用户,会导致为何代码更加的码放。
使用案例

尽管反射有诸多的限制,但是它在某些场景中仍然是一项强大的工具。例如:

  • IDE重度使用反射,例如代码不全,动态类型,继承结构等。
  • Debugger 使用发射检查动态代码是如何执行的
  • Junit,Mockito等使用反射调用特定方法执行各种测试
  • 代码分析工具使用,Findbug等使用反射分析代码 总之,在实际应用中应该避免使用反射,而在编写框架的时候,反射会是一项强大的工具。反射的组件和机制 Java中所有的都是类,反射也是这样。java.lang.Class包含了各种方法可以在运行时获取一个类的各种信息 获取一个类:Class<? extends String> stringGetClass = stringer.getClass(); Class<String> stringClass = String.class; Class.forName("java.lang.String"); 检测其是否是某个实例或者是原生类型stringGetClass.isInstance("dani"); stringGetClass.isPrimitive(); 同样也可以通过Class创建新的实例:String newInstanceStringClass = stringClass.newInstance(); String otherInstance = (String)Class.forName("java.lang.String").newInstance(); java.lang.Class.newInstance() 只能在有默认无参构造函数的时候使用,如果有参数,可以使用稍后介绍的Constructor来创建。接口 接口不能实例化,只能暴露方法,对于接口来获取的只能是其基本信息String interfaceName = InterfaceExample.class.getName(); 枚举 枚举本质上是一个不可变的Java类enum ExampleEnum{ ONE,TWO,THREE,FOUR } 同样也有一些枚举专用的反射方法:
  • java.lang.Class.isEnum(): 如果元素是枚举返回true否则返回false。
  • java.lang.Class.getEnumConstants(): 获取给定枚举所有的常量值。
  • java.lang.reflect.Field.isEnumConstant(): 如果字段是一个枚举返回true,否则返回false

对于枚举的用法:

ExampleEnum value = ExampleEnum.FOUR;
System.out.println("isEnum " + value.getClass().isEnum());
ExampleEnum[] enumConstants = value.getClass().getEnumConstants();
for(ExampleEnum exampleEnum: enumConstants){
    System.out.println("enum constant " + exampleEnum)
}

Field[] flds = value.getCalss().getDelcaredFields();
for(Field f: flds){
    System.out.println(f.getName() + " " + f.isEnumConsntats());
}

执行结果:

isEnum true
enum constant ONE
enum constant TWO
enum constant THREE
enum constant FOUR
ONE true
TWO true
THREE true
FOUR true
ENUM$VALUES false
原生类型

在Java中共有8个原生类型,byte,char,short,int,long,float,double,boolean。对于原生类型,可以获取其反射类,也可以检测一个反射类是否是原生类型,但是无法使用newInstance()创建原生类型实例,如果需要创建,可以使用它的包装类代替原生类使用。

Class<?> intClass = int.class;
System.out.println("is primiteve: " + intClass.isPrimitive());
字段

处理字段的主要类和方法:

  • java.lang.Class.getDeclaredFileds() 获取所有字段包括private字段
  • java.lang.Class.getFileds() 获取所有可以访问的字段,包括父类的
  • java.lang.Class.getFiled(String) 根据名字获取字段,包括其父类,如果不存在抛出异常
  • java.lang.getDeclaredFiled(String) 根据名字其声明获取字段,如果名字不存在抛出异常
  • java.lang.reflect.Field 该类是处理字段的主要类

示例:

String stringer = "this is a String called stringer";
Class<? extends String> stringGetClass = stringer.getClass();
Class<String> stringclass = String.class;
Field[] fields = stringclass.getDeclaredFields();
for( Field field : fields )
{
System.out.println( "*************************" );
System.out.println( "Name: " + field.getName() );
System.out.println( "Type: " + field.getType() );
// values
if( field.isAccessible() )
{
    System.out.println( "Get: " + field.get( stringer ) );
    // depending on the type we can access the fields using these methods
    // System.out.println( "Get boolean: " + field.getBoolean( stringer ) )
    // System.out.println( "Get short: " + field.getShort( stringer ) );
    // ...
}
System.out.println( "Modifiers:" + field.getModifiers() );
System.out.println( "isAccesible: " + field.isAccessible() );
}
// stringclass.getField( "hashCode" );//exception
Field fieldHashCode = stringclass.getDeclaredField( "hash" );// all fields can be
// fieldHashCode.get( stringer ); // this produces an java.lang.IllegalAccessException
// we change the visibility
fieldHashCode.setAccessible( true );
// and we can access it
Object value = fieldHashCode.get( stringer );
int valueInt = fieldHashCode.getInt( stringer );
System.out.println( value );
System.out.println( valueInt );

运行结果如下:

*************************
Name: value
Type: class [C
Modifiers:18
isAccesible: false
*************************
Name: hash
Type: int
Modifiers:2
isAccesible: false
*************************
Name: serialVersionUID
Type: long
Modifiers:26
isAccesible: false
*************************
Name: serialPersistentFields
Type: class [Ljava.io.ObjectStreamField;
Modifiers:26
isAccesible: false
*************************
Name: CASE_INSENSITIVE_ORDER
Type: interface java.util.Comparator
Modifiers:25
isAccesible: false
0
0
方法

处理方法的主要使用:

  • java.lang.Class.getMethods() 获取所有的方法,包括继承的方法
  • java.lang.Class.getDeclaredMethods() 获取所有其声明的方法
  • java.lang.Class.getMethod(String) 根据名字获取方法,包括继承方法
  • java.lang.Class.getDeclaredMethod(String) 根据名字获取其声明的方法
  • java.lang.reflect.Method 处理方法的主要类
Class<String> stringclass = String.class;
Method[] methods = stringclass.getMethods();
Method methodIndexOf = stringclass.getMethod( "indexOf", String.class );
// All methods for the String class
for( Method method : methods )
{
System.out.println( "****************************************************" );
System.out.println( "name: " + method.getName() );
System.out.println( "defaultValue: " + method.getDefaultValue() );
System.out.println( "generic return type: " + method.getGenericReturnType() );
System.out.println( "return type: " + method.getReturnType() );
System.out.println( "modifiers: " + method.getModifiers() );
// Parameters
Parameter[] parameters = method.getParameters();
System.out.println( parameters.length + " parameters:" );
// also method.getParameterCount() is possible
for( Parameter parameter : parameters )
{
    System.out.println( "parameter name: " + parameter.getName() );
    System.out.println( "parameter type: " + parameter.getType() );
}
Class<?>[] parameterTypes = method.getParameterTypes();
System.out.println( parameterTypes.length + " parameters:" );
for( Class<?> parameterType : parameterTypes )
{
    System.out.println( "parameter type name: " + parameterType.getName() );
}

// Exceptions
Class<?>[] exceptionTypes = method.getExceptionTypes();
System.out.println( exceptionTypes.length + " exception types: " );
for( Class<?> exceptionType : exceptionTypes )
{
    System.out.println( "exception name " + exceptionType.getName() );
}
System.out.println( "is accesible: " + method.isAccessible() );
System.out.println( "is varArgs: " + method.isVarArgs() );
}
构造函数

构造函数相关的类和方法:

  • java.lang.Class.getDeclaredConstructors() getConstructors()获取所有的构造函数
  • java.lang.Class.getDeclaredConstructor(String) getConstructr(String) 根据名字获取构造函数
  • java.lang.reflect.Constroctor 处理构造函数主要的类

示例:

// get all visible constructors
Constructor<?>[] constructors = stringGetClass.getConstructors();
//all constructors
Constructor<?>[] declaredConstructors =     stringclass.getDeclaredConstructors();
for( Constructor<?> constructor : constructors )
{
    int numberParams = constructor.getParameterCount() ;
    System.out.println( "constructor " + constructor.getName() );
    System.out.println( "number of arguments " + numberParams);
    // public, private, etc.
    int modifiersConstructor = constructor.getModifiers();
    System.out.println( "modifiers " + modifiersConstructor );
    // array of parameters, more info in the methods section
    Parameter[] parameters = constructor.getParameters();
    // annotations array, more info in the annotations section
    Annotation[] annotations = constructor.getAnnotations();

}
// can be used to create new instances (no params in this case)
String danibuizaString = (String)constructor.newInstance(  );
Getters 和 Setters

getters和setters和其他的方法没有区别,只是他们是访问私有函数的主要方法。

例如:

public class Car
{

    private String name;
    private Object price;
    private Object year;

    public Car( String name, String year, String price )
    {
    this.name = name;
    this.price = price;
    this.year = year;
    }

    public String getName()
    {
    return name;
    }

    public void setName( String name )
    {
    this.name = name;
    }

    public Object getPrice()
    {
    return price;
    }

    public void setPrice( Object price )
    {
    this.price = price;
    }

    public Object getYear()
    {
    return year;
    }

    public void setYear( Object year )
    {
    this.year = year;
    }

}
Car car = new Car( "vw touran", "2010", "12000" );

Method[] methods = car.getClass().getDeclaredMethods();

// all getters, original values
for( Method method : methods )
{
    if( method.getName().startsWith( "get" ) )
    {
        System.out.println( method.invoke( car ) );
    }
}

// setting values
for( Method method : methods )
{

    if( method.getName().startsWith( "set" ) )
    {
        method.invoke( car, "destroyed" );
    }
}

// get new values
for( Method method : methods )
{
    if( method.getName().startsWith( "get" ) )
    {
        System.out.println( method.invoke( car ) );
    }
}

运行结果:

vw touran
2010
12000
destroyed
destroyed
destroyed
静态元素

静态的类,方法,字段和实例类,方法,字段完全不一样,因为它无需初始化类就可以直接使用。 例如:

public class StaticReflection
{

       static class StaticExample
       {
       int counter;
       }
}
// 1 access static class
System.out.println( "directly " + StaticExample.class.getName() );
//2 using for name directly throws an exception
Class<?> forname = Class.forName("com.danibuiza.javacodegeeks.reflection.StaticReflection.StaticExample" );
//3 using $ would work but is not that nice    
Class<?> forname = Class.forName("com.danibuiza.javacodegeeks.reflection.StaticReflection$StaticExample" );
// 4 another way iterating through all classes declared inside this class
Class<?>[] classes = StaticReflection.class.getDeclaredClasses();
for( Class<?> class1 : classes )
{
    System.out.println( "iterating through declared classes " + class1.getName() );
}
数组

类java.lang.reflect.Array提供了各种方法处理数组的反射:

  • java.lang.reflect.Array.newInstance(Class,int) 创建一个数组
  • java.lang.reflect.Array.set(Object,int,Object) 设置数组元素值
  • java.lang.reflect.Array.getLength(Object) 返回数组大小
  • java.lang.reflect.Array.get(Object,int) 获取数组元素
  • java.lang.reflect.Array.getXxx(Object,int) 获取数组元素,Xxx代表原生类型,int,long等。

示例:

// using the Array class it is possible to create new arrays passing the type and the length via reflection
String[] strArrayOne = (String[])Array.newInstance( String.class, 10 );

// it contains utility methods for setting values
Array.set( strArrayOne, 0, "member0" );
Array.set( strArrayOne, 1, "member1" );
Array.set( strArrayOne, 9, "member9" );

// and for getting values as well
System.out.println( "strArrayOne[0] : " + Array.get( strArrayOne, 0 ) );
System.out.println( "strArrayOne[1] : " + Array.get( strArrayOne, 1 ) );
System.out.println( "strArrayOne[3] (not initialized) : " + Array.get( strArrayOne, 3 ) );
System.out.println( "strArrayOne[9] : " + Array.get( strArrayOne, 9 ) );

// also methods to retrieve the lenght of the array
System.out.println( "lenght strArrayOne: " + Array.getLength( strArrayOne ) );

// primitive types work as well
int[] intArrayOne = (int[])Array.newInstance( int.class, 10 );

Array.set( intArrayOne, 0, 1 );
Array.set( intArrayOne, 1, 2 );
Array.set( intArrayOne, 9, 10 );

// and specific getters and setters for primitive types
for( int i = 0; i < Array.getLength( intArrayOne ); ++i )
{
    System.out.println( "intArrayOne[" + i + "] : " + Array.getInt( intArrayOne, i ) );
}
// retrieve the class from an instance
Class<String[]> stringArrayClassUsingInstance = String[].class;
System.out.println( "stringArrayClassUsingInstance is array: " + stringArrayClassUsingInstance.isArray() );

// using class for name and passing [I
Class<?> intArrayUsingClassForName = Class.forName( "[I" );
System.out.println( "intArrayUsingClassForName is array: " + intArrayUsingClassForName.isArray() );

// or [Ljava.lang.String
Class<?> stringArrayClassUsingClassForName = Class.forName( "[Ljava.lang.String;" );
System.out.println( "stringArrayClassUsingClassForName is array: "
    + stringArrayClassUsingClassForName.isArray() );

// this has no much sense in my opinion since we are creating an array at runtime and
// getting the class to create a new one...
Class<? extends Object> stringArrayClassUsingDoubleLoop = Array.newInstance( String.class, 0 ).getClass();
System.out.println( "stringArrayClassUsingClassForName is array: " + stringArrayClassUsingDoubleLoop.isArray() );
Collection

对于反射来说,集合并没有特别之处,例如:

private static void reflectionCollections( Object ref )
{
//check is collection    
    if( ref instanceof Collection )
    {
        System.out.println( "A collection:  " + ref.getClass().getName() );
        @SuppressWarnings( "rawtypes" )
        // not nice
        Iterator items = ( (Collection)ref ).iterator();
        while( items != null && items.hasNext() )
        {
            Object item = items.next();
            System.out.println( "Element of the collection:  " + item.getClass().getName() );
        }
    }
    else
    {
        System.out.println( "Not a collection:  " + ref.getClass().getName() );
    }
}
Map<String, String> map = new HashMap<String, String>();
map.put( "1", "a" );
map.put( "2", "b" );
map.put( "3", "c" );
map.put( "4", "d" );

reflectionCollections( map );
reflectionCollections( map.keySet() );
reflectionCollections( map.values() );

List<String> list = new ArrayList<String>();
list.add( "10" );
list.add( "20" );
list.add( "30" );
list.add( "40" );

reflectionCollections( list );
reflectionCollections( "this is an string" );

输出:

Not a collection:  java.util.HashMap
A collection:  java.util.HashMap$KeySet
Element of the collection:  java.lang.String
Element of the collection:  java.lang.String
Element of the collection:  java.lang.String
Element of the collection:  java.lang.String
A collection:  java.util.HashMap$Values
Element of the collection:  java.lang.String
Element of the collection:  java.lang.String
Element of the collection:  java.lang.String
Element of the collection:  java.lang.String
A collection:  java.util.ArrayList
Element of the collection:  java.lang.String
Element of the collection:  java.lang.String
Element of the collection:  java.lang.String
Element of the collection:  java.lang.String
Not a collection:  java.lang.String
注解

关于注解,会有另一片文章详细说明,现在只是简单介绍下它的用法:

Class<ReflectableClass> object = ReflectableClass.class;
// Retrieve all annotations from the class
Annotation[] annotations = object.getAnnotations();
for( Annotation annotation : annotations )
{
System.out.println( annotation );
}
// Checks if an annotation is present
if( object.isAnnotationPresent( Reflectable.class ) )
{
    // Gets the desired annotation
    Annotation annotation = object.getAnnotation( Reflectable.class );

    System.out.println( annotation + " present in class " +             object.getClass() );// java.lang.class
    System.out.println( annotation + " present in class " +     object.getTypeName() );//     com.danibuiza.javacodegeeks.reflection.ReflectableClass

}
泛型

泛型是在java1.5之后引入的。通过注解,可以得到参数,返回值是否是一个泛型值,对于泛型将会有另一篇文章详细解释。这里只给出简单示例:

Method getInternalListMethod = GenericsClass.class.getMethod( "getInternalList", null );

// we get the return type
Type getInternalListMethodGenericReturnType = getInternalListMethod.getGenericReturnType();

// we can check if the return type is parameterized (using ParameterizedType)
if( getInternalListMethodGenericReturnType instanceof ParameterizedType )
{
    ParameterizedType parameterizedType = (ParameterizedType)getInternalListMethodGenericReturnType;
    // we get the type of the arguments for the parameterized type
    Type[] typeArguments = parameterizedType.getActualTypeArguments();
    for( Type typeArgument : typeArguments )
    {
        // warning not nice
        // we can work with that now
        Class typeClass = (Class)typeArgument;
        System.out.println( "typeArgument = " + typeArgument );
        System.out.println( "typeClass = " + typeClass );
    }
}
类加载器

Java中类的加载是通过ClassLoader加载到内存的。 获取一个ClassLoader

ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
ClassLoader classClassLoader = ReflectableClass.class.getClassLoader();

加载一个类:

Class<?> reflectableClassInstanceLoaded = systemClassLoader
                .loadClass( "com.danibuiza.javacodegeeks.reflection.ReflectableClass" );
Class<?> reflectableClassInstanceForName = Class
                .forName( "com.danibuiza.javacodegeeks.reflection.ReflectableClass", true, systemClassLoader );
动态代理

动态代理可以动态的改变一个函数的行为,增强一个函数的功能,例如Spring中的AOP功能等。 示例:

public class HandlerImpl implements InvocationHandler
{

    @Override
    public Object invoke( Object obj, Method method, Object[] arguments ) throws Throwable
    {
        System.out.println( "using proxy " + obj.getClass().getName() );
        System.out.println( "method " + method.getName() + " from interface " + method.getDeclaringClass().getName() );

        // we can check dynamically the interface and load the implementation that we want
        if( method.getDeclaringClass().getName().equals( "com.danibuiza.javacodegeeks.reflection.InformationInterface" ) )
        {
            InformationClass informationImpl = InformationClass.class.newInstance();
            return method.invoke( informationImpl, arguments );
        }

        return null;
    }
}
// an invocation handler for our needs
InvocationHandler myHandler = new HandlerImpl();

// we can create dynamic proxy clases using the Proxy class
InformationInterface proxy = InformationInterface)Proxy.newProxyInstance(InformationInterface.class.getClassLoader(),  new Class[] {InformationInterface.class },  myHandler);

// all calls to the proxy will be passed to the handler -> the handler     implementation can be
// decided on runtime as well
System.out.println( proxy.getInfo() );
Java 8 反射功能

Java 8在编译时增加了 -parameters 的参数,可以保留函数的参数名,如果不加这个参数,那么Java会将函数的参数名全部替换为arg0,arg1…这种形式。 使用

javac -parameters <class>

对于Maven

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.1</version>
 <configuration>
        <source>1.8</source>
        <target>1.8</target>
     <compilerArgument>-parameters</compilerArgument>
 </configuration>
</plugin>

原文发布于微信公众号 - 代码拾遗(gh_8f61e8bcb1b1)

原文发表时间:2018-05-07

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏阮一峰的网络日志

Ramda 函数库参考教程

学习函数式编程的过程中,我接触到了 Ramda.js。 我发现,这是一个很重要的库,提供了许多有用的方法,每个 JavaScript 程序员都应该掌握这个工具。...

91080
来自专栏拭心的安卓进阶之路

深入理解 Java 反射:Field (成员变量)

深入理解 Java 反射系列: 深入理解 Java 反射:Class (反射的入口) 深入理解 Java 反射:Field (成员变量) 深入理解 Java ...

84080
来自专栏微信公众号:Java团长

Java反射机制详解

反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象...

9720
来自专栏小白的技术客栈

Python内置数据结构之迭代器知多少?

迭代器 迭代器 今天给大家说说迭代器是什么东东。 ? 什么是迭代器 先说一些概念性的东西: 可迭代对象:列表、元组、集合、字符串、bytes、bytearra...

38860
来自专栏静默虚空的博客

[Java 基础]运算符和表达式

Java运算符 (1)赋值操作符 赋值操作符(=)表示:取右边的值(即右值),把它复制给左边(即左值)。 右值可以是任意的常量、变量或表达式(只要可以生成一个值...

19590
来自专栏C/C++基础

C++11 变参模板

版权声明:感谢您对博文的关注!校招与社招,有需要内推腾讯的可以QQ(1589276509)or 微信(louislvlv)联系我哈,期待您的加入。 ...

42320
来自专栏一个会写诗的程序员的博客

第2章 Kotlin 语法基础第2章 Kotlin 语法基础

人与人之间通过语言来交流沟通,互相协作。人与计算机之间怎样“交流沟通”呢?答案是编程语言。一门语言有词、短语、句子、文章等,对应到编程语言中就是关键字、标识符、...

16320
来自专栏代码拾遗

反射基础之Class

Java中每个类型要么是引用类型,要么是原生类型。类,枚举,数组(他们都继承于java.lang.Object)和接口都是引用类型。例如:java.lang.S...

11540
来自专栏微信公众号:Java团长

Java反射初探 ——“当类也学会照镜子”

镜子(反射机制)照出(反射)了人的全貌(类的全方位的信息,例如方法,成员变量和构造器等的相关信息)

8130
来自专栏彭湖湾的编程世界

【java】java反射初探 ——“当类也学会照镜子”

反射的作用 开门见山地说说反射的作用 1.为我们提供了全面的分析类信息的能力 2.动态加载类 我理解的“反射”的意义 (仅个人理解哈) 我理解的java反射机制...

273100

扫码关注云+社区

领取腾讯云代金券