Java的反射机制

什么是Java的反射机制？

反射（relfection）：Java的反射机制是Java被称为动态语言（准动态语言）的本质原因之一。

Java的反射机制具体指的是：Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。

这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等）、superclass（例如Object）、实现类interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运行时改变fields内容或唤起methods。

Java反射机制容许程序在运行时加载、探知、使用编译期间完全未知的classes。

换言之，Java可以加载一个运行时才得知名称的class，获得其完整结构。

类信息------->对象

对象 -------->类信息

基本的来历：

由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力，并能根据自身的行为的状态和结果，调整和修改应用所描述的状态和相关语义。

反射机制的作用：

Java反射机制提供如下功能：

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判段任意一个类所具有的成员变量和方法
在运行时调用任一个对象的方法
在运行时创建新类对象
在使用Java的反射功能时，基本首先都要获取类的Class对象，再通过Class对象获取其他的对象。

①：反编译：.class---->.java ②：通过反射机制动态访问Java对象的属性、方法、构造器等。

常用类：

Java程序在运行时，虚拟机一直对所有的对象进行所谓的运行时类型标识。虚拟机通常使用运行时类型信息选准正确方法去执行，用来保存这些类型信息的类是java.lang.Class类。

在运行状态把 Java 类中的各种成分映射成相应相应的 Java 类，可以动态得获取所有的属性以及动态调用任意一个方法。

成分	Java类
类	Class
包	Package
权限修饰符	Modifier
构造方法	Constructor
成员方法	Method
成员属性	Field

Class类：

1、Class是一个类，一个描述类的类（也就是描述类本身），封装了描述方法的Method，描述字段的Filed，描述构造器的Constructor等属性
    2、对象照镜子后（反射）可以得到的信息：某个类的数据成员名、方法和构造器、某个类到底实现了哪些接口。
    3、对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。
        一个 Class 对象包含了特定某个类的有关信息。
    4、Class 对象只能由系统建立对象。

5、一个类在 JVM 中只会有一个Class实例。

package reflect;

/**
 * 人类封装类
 * 
 * @author 
 *
 */
public class Person {
	private String name;
	private int code;

	public String getName() {
		return name;
	}

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

	public int getCode() {
		return code;
	}

	public void setCode(int code) {
		this.code = code;
	}

	public Person(String name, int code) {//我是有参构造器
		super();
		this.name = name;
		this.code = code;
	}

	public Person() {//我是无参构造器
		super();
		// TODO Auto-generated constructor stub
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", code=" + code + "]";
	}
}

Class类常用方法：

Package getPackage()	获取此类的包。
String getName()	此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称
int getModifiers()	修饰符由 Java 虚拟机的 public、protected、private、final、static、abstract 和 interface 对应的常量组成；它们应当使用 Modifier 类的方法来解码。
Class<? super T> getSuperclass()	此 Class 所表示的实体（类、接口、基本类型或 void）的超类的 Class
Class<?>[] getInterfaces()	确定此对象所表示的类或接口实现的接口
Constructor<?>[] getDeclaredConstructors()	此 Class 对象表示的类声明的所有构造方法。
Field[] getDeclaredFields()	此 Class 对象所表示的类或接口所声明的所有字段。
Method[] getDeclaredMethods()	此 Class 对象表示的类或接口声明的所有方法

获取Class类的三种方式：

这里以Java引用类型的String对象来对示范↓↓↓

（1）根据任意一个对象来获取Class对象
例如:Class c1 = new String("").getClass();

（2）根据已定义类型，获取Class对象
例如：Class c2 = String.class;

（3）通过Class类的静态方法Class.forName()来实现
例如：Class c3 = Class.forName("java.lang.String");

Class创建一个对象的栗子：

try {
//Class<?> cl = new Person().getClass();
//Class<?> cl = Class.forName("reflect.Person");//这里有个小技巧：先在括号中写出包下的类，这样在有提示的情况下不容易打错；
Class<?> cl = Person.class;//三种方法选择一个自己喜欢的就好。
		
	Person person = (Person) cl.newInstance();//通过newInstance创建一个新的对象；这里注意Person类中要有无参构造。
	//因为cl.newInstance()返回的是一个Object对象，因此需要一个强制转换(Person) 。
	System.out.println(person);//结果：Person [name=null, code=0]
			
	//实际调用的类的那个 无参数的构造器（这就是为什么写的类的时候，要写一个无参数的构造器，就是给反射用的);一般的，一个类若声明了带参数的构造器，也要声明一个无参数的构造器  		
} catch (Exception e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

ClassLoader类加载器：

    /** 
     * ClassLoader类装载器 
     */  
    @Test  
    public void testClassLoader1() throws ClassNotFoundException, IOException {  
        //1、获取一个系统的类加载器  
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();  
        System.out.println("系统的类加载器-->" + classLoader);  
      
        //2、获取系统类加载器的父类加载器(扩展类加载器（extensions classLoader）)  
        classLoader = classLoader.getParent();  
        System.out.println("扩展类加载器-->" + classLoader);  
      
        //3、获取扩展类加载器的父类加载器  
        //输出为Null,无法被Java程序直接引用  
        classLoader = classLoader.getParent();  
        System.out.println("启动类加载器-->" + classLoader);  
      
        //  
      
        //4、测试当前类由哪个类加载器进行加载 ,结果就是系统的类加载器  
        classLoader = Class.forName("com.java.reflection.Person").getClassLoader();  
        System.out.println("当前类由哪个类加载器进行加载-->"+classLoader);  
      
        //5、测试JDK提供的Object类由哪个类加载器负责加载的  
        classLoader = Class.forName("java.lang.Object").getClassLoader();  
        System.out.println("JDK提供的Object类由哪个类加载器加载-->" + classLoader);  
    }

结果：系统的类加载器-->sun.misc.Launcher$AppClassLoader@43be2d65
扩展类加载器-->sun.misc.Launcher$ExtClassLoader@7a9664a1
启动类加载器-->null
当前类由哪个类加载器进行加载-->sun.misc.Launcher$AppClassLoader@43be2d65
JDK提供的Object类由哪个类加载器加载-->null

getResourceAsStream方法：

      @Test  
        public void testGetResourceAsStream() throws ClassNotFoundException, IOException {  
    //          这么写的话，文件需要放到src目录下  
            //       InputStream in = new FileInputStream("test.properties");  
      
            //5、关于类加载器的一个主要方法  
            //调用getResourceAsStream 获取类路径下的文件对应的输入流  
            InputStream in = this.getClass().getClassLoader()  
                    .getResourceAsStream("com/java/reflection/test.properties");  
            System.out.println("in: " +in);  
      
            Properties properties = new Properties();  
            properties.load(in);  
      
            String driverClass = properties.getProperty("dirver");  
            String jdbcUrl = properties.getProperty("jdbcUrl");  
            //中文可能会出现乱码，需要转换一下  
            String user = new String(properties.getProperty("user").getBytes("ISO-8859-1"), "UTF-8");  
            String password = properties.getProperty("password");  
      
            System.out.println("diverClass: "+driverClass);  
            System.out.println("user: " + user);  
        }  

test.properties内容如下：
dirver=com.mysql.jdbc.Driver;
jdbcUrl=jdbc:mysql://192.168.42.108:3306/test
user=测试
password=993803

结果：
in: java.io.BufferedInputStream@2aca0115
diverClass: com.mysql.jdbc.Driver;
user: 测试

Method类（方法）: 先看栗子

@Test  
    public void testMethod() throws Exception{  
        Class cl = Class.forName("reflect.Person");  
      
        /*1、得到class 对应的类中有哪些方法,不能获取private方法  */
        Method[] methods =cl.getMethods();  
        System.out.print("        getMethods: ");  
        for (Method method : methods){  //打印所有的公有方法，包括继承自Object的方法
            System.out.print(method.getName() + ", ");  
        }  
      
        /*2、获取所有的方法(且只获取当着类声明的方法，包括private方法）  */
        Method[] methods2 = cl.getDeclaredMethods();  
        System.out.print("\ngetDeclaredMethods: ");  
        for (Method method : methods2){  //打印所有的本类方法，不包括继承自Object的方法
            System.out.print(method.getName() + ", ");  
        }  
      
        /*3、获取指定的方法  */
	      /*第一个参数是方法名，后面的是方法里的参数  
	       *这里的String.class是一种可变类型，因为方法是可以进行重写的。
	       *什么是可变型参数？
	       * 因为方法中的参数 是不确定的，也就是说参数类型或参数个数都改变
	       * 获取那个方法，那么方法中的参数类型或参数个数是不一样的
	       */
        Method method = cl.getDeclaredMethod("setName",String.class);
        System.out.println("\nmethod : " + method);  
      
        Method method2 = cl.getDeclaredMethod("setName",String.class ,int.class);//第一个参数是方法名，后面的是方法里的参数  
        System.out.println("method2: " + method2);  
      
        //4、执行方法！  
        Object obj = cl.newInstance();  
        method2.invoke(obj, "setName", "张三");  
    }  //结果就不展示了

invoke方法：

    public class PersonInvoke {  
        public PersonInvoke() {  
        }  
      
        private String method2() {  
            return "Person private String method2";  
        }  
    }  

    public class StudentInvoke extends PersonInvoke{  
        private void method1(Integer age) {  
            System.out.println("Student private void method1, age=:" +age);  
        }  
    }

Method类常用的方法：

String getName()	此 Method 对象表示的方法名称
int getModifiers()	修饰符由 Java 虚拟机的 public、protected、private、final、static、abstract 和 interface 对应的常量组成；它们应当使用 Modifier 类的方法来解码。
Class<?>[] getParameterTypes()	此 Method 对象所表示的方法的形参类型
Class<?> getReturnType()	此 Method 对象所表示的方法的正式返回类型。
public Object invoke(Object obj, Object... args)	对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。如果底层方法是静态的，那么可以忽略指定的 obj 参数。该参数可以为 null。如果底层方法所需的形参数为 0，则所提供的 args 数组长度可以为 0 或 null。

Field类（属性）：

常用方法：

String getName()	此 Field 对象表示的字段的名称
int getModifiers()	修饰符由 Java 虚拟机的 public、protected、private、final、static、abstract 和 interface 对应的常量组成；它们应当使用 Modifier 类的方法来解码。
Class<?> getType()	此 Field 对象所表示字段的声明类型
void set(Object obj, Object value)	此 Field 对象表示的字段设置为指定的新值。
Object get(Object obj)	返回指定对象上此 Field 表示的字段的值。

第一个栗子：

   /** 
     * Field: 封装了字段的信息 
     */  
    @Test  
    public void testField() throws  
            ClassNotFoundException, NoSuchFieldException, IllegalAccessException {  
      
        Class clazz = Class.forName("reflect.Person");  
      
        //1、获取字段  
        //1.1 获取Field的数组,私有字段也能获取  
        Field[] fields = clazz.getDeclaredFields();  
        for (Field field: fields) {  
            System.out.print(field.getName() + ", ");  
        }  
      
        //1.2 获取指定名字的Field（如果是私有的，见下面的4)  
        Field field = clazz.getDeclaredField("name");  
        System.out.println("\n获取指定Field名=: " + field.getName());  
      
        Person person = new Person("ABC", 12);  
        //2、获取指定对象的Field的值  
        Object val = field.get(person);  
        System.out.println("获取指定对象字段'name'的Field的值=： " + val);  
      
        //3、设置指定对象的Field的值  
        field.set(person, "changwen2");  
        System.out.println("设置指定对象字段'name'的Field的值=: " + person.getName());  
      
        //4、若该字段是私有的，需要调用setAccessible(true)方法  ；（打破封装的方法）
        Field field2 = clazz.getDeclaredField("age");  
        field2.setAccessible(true);  
        System.out.println("获取指定私有字段名=: " + field2.getName());  
    }//依旧不展示结果了

第二个栗子：

  /** 
     * 一个实例： 
     * 反射获取一个继承Person2的Student类 
     * 设置字段"code"=20(该字段可能为私有，可能在其父类中） 
     */  
    @Test  
    public void testClassField() throws ClassNotFoundException, IllegalAccessException, InstantiationException {  
        String className = "reflect.Student";  
        String fieldName = "code";  //可能为私有，可能在其父类中  
        Object val = 20;  
      
        //创建className 对应类的对象，并为其fieldName赋值为val  
        Class clazz = Class.forName(className);  
        Field field = null;  
        for (Class clazz2 = clazz; clazz2 != Object.class; clazz2 = clazz2.getSuperclass()){  
            try {  
                field = clazz2.getDeclaredField(fieldName);  
            } catch (Exception e) {  
      
            }  
        }  
      
        Object obj = clazz.newInstance();  
        assert field != null;  
        field.setAccessible(true);  //打破封装状态
        field.set(obj, val);  
      
        Student stu = (Student) obj;  
        System.out.println("age = " + stu.getAge());  
    }

Constructor类（构造器）：

    /** 
     * 构造器：开发用的比较少 
     */  
    @Test  
    public void testConstructor() throws ClassNotFoundException, NoSuchMethodException,  
            IllegalAccessException, InvocationTargetException, InstantiationException {  
        String className = "reflect.Person";  
        Class<Person> clazz = (Class<Person>) Class.forName(className);  
      
        //1.获取Constructor对象  
        Constructor<Person>[] constructors =  
                (Constructor<Person>[]) Class.forName(className).getConstructors();  
      
        for (Constructor<Person> constructor: constructors) {  
            System.out.println(constructor);  
        }  
      
        Constructor<Person> constructor = clazz.getConstructor(String.class, Integer.class);  
        System.out.println("指定的-->" + constructor);  
      
        //2.调用构造器的newInstance()方法创建对象  
        Object obj= constructor.newInstance("changwen", 11);  
    }

效果： public com.java.reflection.Person()
public com.java.reflection.Person(java.lang.String,java.lang.Integer)
指定的-->public com.java.reflection.Person(java.lang.String,java.lang.Integer)

常用方法：

String getName()	此构造方法的名称
int getModifiers()	修饰符由 Java 虚拟机的 public、protected、private、final、static、abstract 和 interface 对应的常量组成；它们应当使用 Modifier 类的方法来解码。
Class<?>[] getParameterTypes()	表示构造方法的形参类型

注解（Annotation）

从 JDK5.0 开始,Java 增加了对元数据(MetaData)的支持,也就是Annotation(注释)
Annotation其实就是代码里的特殊标记,这些标记可以在编译,类加载, 运行时被读取,并执行相应的处理.通过使用Annotation,程序员可以在不改变原有逻辑的情况下,在源文件中嵌入一些补充信息.
Annotation 可以像修饰符一样被使用,可用于修饰包,类,构造器, 方法,成员变量, 参数,局部变量的声明,这些信息被保存在Annotation的 “name=value”对中.
Annotation能被用来为程序元素(类,方法,成员变量等)设置元数据

基本的 Annotation

使用 Annotation时要在其前面增加@符号,并把该Annotation 当成一个修饰符使用.用于修饰它支持的程序元素
三个基本的Annotation:

–@Override:限定重写父类方法,该注释只能用于方法

–@Deprecated:用于表示某个程序元素(类,方法等)已过时

–@SuppressWarnings:抑制编译器警告

自定义 Annotation

定义新的 Annotation类型使用@interface关键字。
Annotation 的成员变量在Annotation 定义中以无参数方法的形式来声明.其方法名和返回值定义了该成员的名字和类型。
可以在定义Annotation的成员变量时为其指定初始值,指定成员变量的初始值可使用default关键字。
没有成员定义的Annotation称为标记;包含成员变量的Annotation称为元数据Annotation。

    @Retention(RetentionPolicy.RUNTIME) //运行时检验  
    @Target(value = {ElementType.METHOD})  //作用在方法上  
    public @interface AgeValidator {  
      
        int min();  
        int max();  
    }  

    /** 
     * 通过反射才能获取注解 
     */  
    @Test  
    public void testAnnotation() throws Exception {  
        //这样的方式不能使用注解  
        Person3 person3 = new Person3();  
        person3.setAge(10);*/  
      
        String className = "com.java.reflection.Person3";  
        Class clazz = Class.forName(className);  
        Object obj = clazz.newInstance();  
      
        Method method = clazz.getDeclaredMethod("setAge",Integer.class);  
        int val =40;  
      
        //获取注解  
        Annotation annotation = method.getAnnotation(AgeValidator.class);  
        if (annotation != null){  
            if (annotation instanceof AgeValidator){  
                AgeValidator ageValidator = (AgeValidator) annotation;  
      
                if (val< ageValidator.min() || val>ageValidator.max()){  
                    throw new RuntimeException("数值超出范围");  
                }  
            }  
        }  
      
        method.invoke(obj, val);  
        System.out.println(obj);  
    }

提取 Annotation信息

JDK5.0 在 java.lang.reflect包下新增了 AnnotatedElement接口,该接口代表程序中可以接受注释的程序元素。
当一个 Annotation类型被定义为运行时Annotation后,该注释才是运行时可见,当 class文件被载入时保存在 class文件中的 Annotation才会被虚拟机读取。

程序可以调用AnnotationElement对象的如下方法来访问 Annotation信息。

–获取 Annotation实例：

getAnnotation( Class<T> annotationClass)

getDeclaredAnnotations()

getParameterAnnotations()

JDK 的元Annotation

JDK 的元Annotation 用于修饰其他Annotation 定义。
@Retention:只能用于修饰一个 Annotation定义,用于指定该 Annotation可以保留多长时间,@Rentention包含一个RetentionPolicy类型的成员变量,使用 @Rentention时必须为该 value成员变量指定值:

–RetentionPolicy.CLASS:编译器将把注释记录在 class文件中.当运行 Java程序时,JVM 不会保留注释.这是默认值。

–RetentionPolicy.RUNTIME:编译器将把注释记录在class文件中. 当运行 Java 程序时, JVM 会保留注释. 程序可以通过反射获取该注释。

–RetentionPolicy.SOURCE:编译器直接丢弃这种策略的注释。

@Target: 用于修饰Annotation 定义,用于指定被修饰的 Annotation能用于修饰哪些程序元素.@Target 也包含一个名为 value的成员变量。
@Documented:用于指定被该元 Annotation修饰的 Annotation类将被 javadoc工具提取成文档。
@Inherited:被它修饰的 Annotation将具有继承性.如果某个类使用了被@Inherited 修饰的Annotation, 则其子类将自动具有该注释。

注：注解的学习很重要。

Java---反射机制

Java的反射机制

什么是Java的反射机制？

基本的来历：

Java反射机制提供如下功能：

常用类：

Class类：

Class类常用方法：

获取Class类的三种方式：

ClassLoader类加载器：

getResourceAsStream方法：

Method类（方法）: 先看栗子

invoke方法：

Method类常用的方法：

Field类（属性）：

常用方法：

第一个栗子：

第二个栗子：

Constructor类（构造器）：

常用方法：

注解（Annotation）

基本的 Annotation

自定义 Annotation

提取 Annotation信息

JDK 的元Annotation

猜你喜欢