`

Java 反射与内省

    博客分类：
  • java
JavaBeanJ# 
阅读更多

一、java反射机制
JAVA反射机制是在运行状态中,
对于任意一个类,都能够得到这个类的所有属性和方法;
对于任意一个对象,都能够调用它的任意一个方法;
这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制.

概括一下:
反射就是让你可以通过名称来得到对象(类,属性,方法)的技术。
例如我们可以通过类名来生成一个类的实例;
知道了方法名,就可以调用这个方法;
知道了属性名就可以访问这个属性的值。

1、获取类对应的Class对象
   运用(已知对象)getClass():Object类中的方法,每个类都拥有此方法。
   如: String str = new String();
Class strClass = str.getClass();
   运用(已知子类的class) Class.getSuperclass():Class类中的方法,返回该Class的父类的Class;
   运用(已知类全名):Class.forName() 静态方法
   运用(已知类): 类名.class

2、通过类名来构造一个类的实例
   a、调用无参的构造函数:
   Class newoneClass = Class.forName(类全名);
   newoneClass.newInstance();

   b、调用有参的构造函数：我们可以自定义一个函数。
   public Object newInstance(String className, Object[] args) throws Exception {
   //args为参数数组
   Class newoneClass = Class.forName(className);
   //得到参数的Class数组(每个参数的class组成的数组),由此来决定调用那个构造函数
   Class[] argsClass = new Class[args.length];
   for (int i = 0, j = args.length; i < j; i++) {
argsClass[i] = args[i].getClass();
   }
   Constructor cons = newoneClass.getConstructor(argsClass); //根据argsClass选择函数
   return cons.newInstance(args); //根据具体参数实例化对象。
   }

3、得到某个对象的属性

   a、非静态属性:首先得到class,然后得到这个class具有的field,然后以具体实例为参数调用这个field

   public Object getProperty(Object owner, String fieldName) throws Exception {
       Class ownerClass = owner.getClass();//首先得到class
       Field field = ownerClass.getField(fieldName);
       //然后得到这个class具有的field,也可以通过getFields()得到所有的field
       Object property = field.get(owner);
       //owner指出了取得那个实例的这个属性值,如果这个属性是非公有的,这里会报IllegalAccessException。
       return property;

   }

   b、静态属性：
      只有最后一步不同,由于静态属性属于这个类,所以只要在这个类上调用这个field即可
      Object property = field.get(ownerClass);

4、执行某对象的方法

  public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
     Class ownerClass = owner.getClass(); //也是从class开始的
     //得到参数的class数组,相当于得到参数列表的类型数组,来取决我们选择哪个函数。
     Class[] argsClass = new Class[args.length];
     for (int i = 0, j = args.length; i < j; i++) {
         argsClass[i] = args[i].getClass();
     }
     //根据函数名和函数类型来选择函数
     Method method = ownerClass.getMethod(methodName, argsClass);
     return method.invoke(owner, args);//具体实例下,具体参数值下调用此函数
  }

5、执行类的静态方法
   和上面的相似只是最后一行不需要指定具体实例
   return method.invoke(null, args);

6、判断是否为某个类的实例

   public boolean isInstance(Object obj, Class cls) {
        return cls.isInstance(obj);
   }

测试bean类:SimpleBean.java

Java代码 复制代码 收藏代码
  1. package com.royzhou.bean;   
  2.   
  3. public class SimpleBean {   
  4.     private String name;   
  5.     private String[] hobby;   
  6.        
  7.     public SimpleBean() {   
  8.     }   
  9.   
  10.     public SimpleBean(String name, String[] hobby) {   
  11.         this.name = name;   
  12.         this.hobby = hobby;   
  13.     }   
  14.   
  15.     public void setName(String name) {   
  16.         this.name = name;   
  17.     }   
  18.   
  19.     public String getName() {   
  20.         return this.name;   
  21.     }   
  22.   
  23.     public void setHobby(String[] hobby) {   
  24.         this.hobby = hobby;   
  25.     }   
  26.   
  27.     public String[] getHobby() {   
  28.         return this.hobby;   
  29.     }   
  30.        
  31.     public String toString() {   
  32.         String returnValue = super.toString() + "\n";   
  33.         returnValue += "name:=" + this.name + "\n";   
  34.         if(this.hobby != null) {   
  35.             returnValue += "hobby:";   
  36.             for(String s : this.hobby) {   
  37.                 returnValue += s + ",";   
  38.             }   
  39.             returnValue += "\n";   
  40.         }   
  41.         return  returnValue;   
  42.     }   
  43. }  
package com.royzhou.bean;

public class SimpleBean {
	private String name;
	private String[] hobby;
	
	public SimpleBean() {
	}

	public SimpleBean(String name, String[] hobby) {
		this.name = name;
		this.hobby = hobby;
	}

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

	public String getName() {
		return this.name;
	}

	public void setHobby(String[] hobby) {
		this.hobby = hobby;
	}

	public String[] getHobby() {
		return this.hobby;
	}
	
	public String toString() {
		String returnValue = super.toString() + "\n";
		returnValue += "name:=" + this.name + "\n";
		if(this.hobby != null) {
			returnValue += "hobby:";
			for(String s : this.hobby) {
				returnValue += s + ",";
			}
			returnValue += "\n";
		}
		return  returnValue;
	}
}



反射测试类:ReflectTest.java

Java代码 复制代码 收藏代码
  1. package com.royzhou.bean;   
  2.   
  3. import java.lang.reflect.Constructor;   
  4. import java.lang.reflect.Field;   
  5. import java.lang.reflect.Method;   
  6.   
  7. public class ReflectTest {   
  8.     public static void main(String[] args) throws Exception {   
  9.         Class clazz = SimpleBean.class;   
  10.         //使用无参构造函数实例化bean   
  11.         SimpleBean sb = (SimpleBean)clazz.newInstance();   
  12.         System.out.println(sb);   
  13.            
  14.         //使用有参构造函数实例化bean   
  15.         Constructor constructor = clazz.getConstructor(new Class[]{String.class, String[].class});   
  16.         sb = (SimpleBean)constructor.newInstance(new Object[]{"royzhou",new String[]{"football","basketball"}});   
  17.         System.out.println(sb);   
  18.            
  19.         //为name字段设置值   
  20.         Field field = clazz.getDeclaredField("name");   
  21.         field.setAccessible(true); //避免private不可访问抛出异常   
  22.         field.set(sb, "royzhou1985");   
  23.         System.out.println("modify name using Field:=" + sb.getName() + "\n");   
  24.            
  25.         //列出类SimpleBean的所有方法   
  26.         Method[] methods = clazz.getDeclaredMethods();   
  27.         System.out.println("get methods of class SimpleBean:");   
  28.         for(Method method : methods) {   
  29.             if("setHobby".equals(method.getName())) {   
  30.                 //动态调用类的方法来为hobby设置值   
  31.                 method.invoke(sb, new Object[]{new String[]{"tennis","fishing"}});   
  32.             }   
  33.             System.out.println(method.getName());   
  34.         }   
  35.            
  36.         System.out.println("\nset by invoke Method");   
  37.         System.out.println(sb);   
  38.     }   
  39. }  
package com.royzhou.bean;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectTest {
	public static void main(String[] args) throws Exception {
		Class clazz = SimpleBean.class;
		//使用无参构造函数实例化bean
		SimpleBean sb = (SimpleBean)clazz.newInstance();
		System.out.println(sb);
		
		//使用有参构造函数实例化bean
		Constructor constructor = clazz.getConstructor(new Class[]{String.class, String[].class});
		sb = (SimpleBean)constructor.newInstance(new Object[]{"royzhou",new String[]{"football","basketball"}});
		System.out.println(sb);
		
		//为name字段设置值
		Field field = clazz.getDeclaredField("name");
		field.setAccessible(true); //避免private不可访问抛出异常
		field.set(sb, "royzhou1985");
		System.out.println("modify name using Field:=" + sb.getName() + "\n");
		
		//列出类SimpleBean的所有方法
		Method[] methods = clazz.getDeclaredMethods();
		System.out.println("get methods of class SimpleBean:");
		for(Method method : methods) {
			if("setHobby".equals(method.getName())) {
				//动态调用类的方法来为hobby设置值
				method.invoke(sb, new Object[]{new String[]{"tennis","fishing"}});
			}
			System.out.println(method.getName());
		}
		
		System.out.println("\nset by invoke Method");
		System.out.println(sb);
	}
}



输出结果:
com.royzhou.bean.SimpleBean@757aef
name:=null

com.royzhou.bean.SimpleBean@d9f9c3
name:=royzhou
hobby:football,basketball,

modify name using Field:=royzhou1985

get methods of class SimpleBean:
setHobby
getHobby
getName
toString
setName

set by invoke Method
com.royzhou.bean.SimpleBean@d9f9c3
name:=royzhou1985
hobby:tennis,fishing,


二、java内省机制

    内省是 Java 语言对 Bean 类属性、事件的一种处理方法(也就是说给定一个javabean对象,我们就可以得到/调用它的所有的get/set方法)。
    例如类 A 中有属性 name, 那我们可以通过 getName,setName 来得到其值或者设置新的值。通过 getName/setName 来访问 name 属性,这就是默认的规则。
    Java 中提供了一套 API 用来访问某个属性的 getter/setter 方法,通过这些 API 可以使你不需要了解这个规则,这些 API 存放于包 java.beans 中。
    一般的做法是通过类 Introspector 的 getBeanInfo方法 来获取某个对象的 BeanInfo 信息,然后通过 BeanInfo 来获取属性的描述器(PropertyDescriptor),
    通过这个属性描述器就可以获取某个属性对应的 getter/setter 方法,然后我们就可以通过反射机制来调用这些方法。
  
内省测试类:Introspector.java

Java代码 复制代码 收藏代码
  1. package com.royzhou.bean;   
  2.   
  3. import java.beans.BeanInfo;   
  4. import java.beans.Introspector;   
  5. import java.beans.MethodDescriptor;   
  6. import java.beans.PropertyDescriptor;   
  7.   
  8. public class IntrospectorTest {   
  9.     public static void main(String[] args) throws Exception {   
  10.         SimpleBean sb = new SimpleBean("royzhou",new String[]{"football","backetball"});   
  11.            
  12.         System.out.println(sb);   
  13.            
  14.         /**  
  15.          * 使用Introspector.getBeanInfo(SimpleBean.class)将Bean的属性放入到BeanInfo中。  
  16.          * 第二个参数为截止参数,表示截止到此类之前,不包括此类。  
  17.          * 如果不设置的话,那么将会得到本类以及其所有父类的info。  
  18.          * BeanInfo中包含了SimpleBean的信息  
  19.          */  
  20.         BeanInfo beanInfo = Introspector.getBeanInfo(sb.getClass());   
  21.            
  22.         //将每个属性的信息封装到一个PropertyDescriptor形成一个数组其中包括属性名字,读写方法,属性的类型等等   
  23.         PropertyDescriptor[] propertys = beanInfo.getPropertyDescriptors();   
  24.         for(PropertyDescriptor property : propertys) {   
  25.             System.out.println("属性名:" + property.getName());   
  26.             System.out.println("类型:" + property.getPropertyType());   
  27.         }   
  28.         System.out.println();   
  29.            
  30.         System.out.println("列出SimpleBean的所有方法");   
  31.         MethodDescriptor[] methods = beanInfo.getMethodDescriptors();   
  32.         for(MethodDescriptor method : methods) {   
  33.             System.out.println(method.getName());   
  34.         }   
  35.         System.out.println();   
  36.            
  37.         /**  
  38.          * 重新设置属性值  
  39.          */  
  40.         for(PropertyDescriptor property : propertys) {   
  41.             if(property.getPropertyType().isArray()){  //getPropertyType得到属性类型。   
  42.                 if(property.getPropertyType().isArray()) {   
  43.                     if("hobby".equals(property.getName())) {   
  44.                         //getComponentType()可以得到数组类型的元素类型   
  45.                         if(property.getPropertyType().getComponentType().equals(String.class)) {   
  46.                             //getWriteMethod()得到此属性的set方法----Method对象,然后用invoke调用这个方法   
  47.                             property.getWriteMethod().invoke(sb, new Object[]{new String[]{"tennis","fishing"}});   
  48.                         }   
  49.                     }   
  50.                 }   
  51.              } else if("name".equals(property.getName())) {   
  52.                 property.getWriteMethod().invoke(sb, new Object[] { "royzhou1985" });   
  53.              }   
  54.         }   
  55.            
  56.         /**  
  57.          * 获取对象的属性值  
  58.          */  
  59.         System.out.println("获取对象的属性值");   
  60.         for(PropertyDescriptor property : propertys) {   
  61.             if(property.getPropertyType().isArray()){  //getPropertyType得到属性类型。   
  62.                 //getReadMethod()得到此属性的get方法----Method对象,然后用invoke调用这个方法   
  63.                 String[] result=(String[]) property.getReadMethod().invoke(sb, new Object[]{});   
  64.                 System.out.print(property.getName()+":");//getName得到属性名字   
  65.                 for (int j = 0; j < result.length; j++) {   
  66.                    System.out.print(result[j] + ",");   
  67.                 }   
  68.                 System.out.println();   
  69.              }   
  70.              else{   
  71.                 System.out.println(property.getName()+":"+property.getReadMethod().invoke(sb, new Object[]{}));   
  72.              }   
  73.         }   
  74.            
  75.     }   
  76. }  
package com.royzhou.bean;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.MethodDescriptor;
import java.beans.PropertyDescriptor;

public class IntrospectorTest {
	public static void main(String[] args) throws Exception {
		SimpleBean sb = new SimpleBean("royzhou",new String[]{"football","backetball"});
		
		System.out.println(sb);
		
		/**
		 * 使用Introspector.getBeanInfo(SimpleBean.class)将Bean的属性放入到BeanInfo中。
		 * 第二个参数为截止参数,表示截止到此类之前,不包括此类。
		 * 如果不设置的话,那么将会得到本类以及其所有父类的info。
		 * BeanInfo中包含了SimpleBean的信息
		 */
		BeanInfo beanInfo = Introspector.getBeanInfo(sb.getClass());
		
		//将每个属性的信息封装到一个PropertyDescriptor形成一个数组其中包括属性名字,读写方法,属性的类型等等
		PropertyDescriptor[] propertys = beanInfo.getPropertyDescriptors();
		for(PropertyDescriptor property : propertys) {
			System.out.println("属性名:" + property.getName());
			System.out.println("类型:" + property.getPropertyType());
		}
		System.out.println();
		
		System.out.println("列出SimpleBean的所有方法");
		MethodDescriptor[] methods = beanInfo.getMethodDescriptors();
		for(MethodDescriptor method : methods) {
			System.out.println(method.getName());
		}
		System.out.println();
		
		/**
		 * 重新设置属性值
		 */
		for(PropertyDescriptor property : propertys) {
			if(property.getPropertyType().isArray()){  //getPropertyType得到属性类型。
				if(property.getPropertyType().isArray()) {
					if("hobby".equals(property.getName())) {
						//getComponentType()可以得到数组类型的元素类型
						if(property.getPropertyType().getComponentType().equals(String.class)) {
							//getWriteMethod()得到此属性的set方法----Method对象,然后用invoke调用这个方法
							property.getWriteMethod().invoke(sb, new Object[]{new String[]{"tennis","fishing"}});
						}
					}
				}
	         } else if("name".equals(property.getName())) {
				property.getWriteMethod().invoke(sb, new Object[] { "royzhou1985" });
	         }
		}
		
		/**
		 * 获取对象的属性值
		 */
		System.out.println("获取对象的属性值");
		for(PropertyDescriptor property : propertys) {
			if(property.getPropertyType().isArray()){  //getPropertyType得到属性类型。
	            //getReadMethod()得到此属性的get方法----Method对象,然后用invoke调用这个方法
	            String[] result=(String[]) property.getReadMethod().invoke(sb, new Object[]{});
	            System.out.print(property.getName()+":");//getName得到属性名字
	            for (int j = 0; j < result.length; j++) {
	               System.out.print(result[j] + ",");
	            }
	            System.out.println();
	         }
	         else{
	            System.out.println(property.getName()+":"+property.getReadMethod().invoke(sb, new Object[]{}));
	         }
		}
		
	}
}



输出结果:
com.royzhou.bean.SimpleBean@757aef
name:=royzhou
hobby:football,backetball,

属性名:class
类型:class java.lang.Class
属性名:hobby
类型:class [Ljava.lang.String;
属性名:name
类型:class java.lang.String

列出SimpleBean的所有方法
hashCode
setHobby
equals
wait
wait
notify
getClass
toString
notifyAll
getHobby
setName
wait
getName

获取对象的属性值
class:class com.royzhou.bean.SimpleBean
hobby:tennis,fishing,
name:royzhou1985

三、总结
    将 Java 的反射以及内省应用到程序设计中去可以大大的提供程序的智能化和可扩展性,有很多项目都是采取这两种技术来实现其核心功能,
    其实应该说几乎所有的项目都或多或少的采用这两种技术,在实际应用过程中二者要相互结合方能发挥真正的智能化以及高度可扩展性。

分享到：
| 详解 Spring 3.0 基于 Annotation 的依赖注 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java反射与内省-PPT

    Java反射与内省是Java编程语言中的核心特性，它们为开发者提供了强大的能力，可以在运行时检查和操作类、接口、对象及其属性。本PPT深入探讨了这些概念，旨在帮助开发者充分利用Java平台的灵活性。 首先，Java反射...

    java反射全解（反射原理+反射API详解+反射与数组+反射与泛型+反射源码与性能开销+反射优缺点+反射与内省）

    反射机制的分类包括反射 API、反射与数组、反射与泛型、反射源码与性能开销、反射优缺点、反射与内省等。 反射 API 是 Java 语言提供的一组 Application Programming Interface（API），用于在运行时获取类的信息和...

    Java中的内省与反射.doc

    ### Java中的内省与反射详解 #### 一、引言 在深入了解Java语言的过程中，我们会遇到两个重要的概念：反射和内省。这两种技术在实际开发中有着广泛的应用，尤其是在需要进行动态操作或元数据处理的场景下尤为重要...

    java面试题--反射机制

    ### Java反射机制详解 #### 一、引言 在Java面试中，经常会出现与反射机制相关的题目。这是因为Java反射机制不仅是Java语言的一项重要特性，也是理解Java动态特性的关键所在。通过本文，我们将深入探讨Java反射...

    用反射和内省技术实现简单SpringIOC

    本篇文章将深入探讨如何利用反射和内省技术来实现一个简单的Spring IOC。首先，我们来理解什么是反射和内省。 反射是Java提供的一种强大的动态类型机制，它允许程序在运行时检查类的信息，如类名、属性、方法等，并...

    候捷谈Java反射机制

    Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时获取和操作任何已知名称的类的内部信息。这一机制使得Java具备了一定的动态性，虽然在传统的分类中Java被视为静态类型语言。通过反射，开发者可以在...

    JAVA的内省机制(introspector)与反射机制(reflection).docx

    "JAVA的内省机制(introspector)与反射机制(reflection)" JAVA 的内省机制（introspector）和反射机制（reflection）是两个重要的概念，在 JAVA 编程中扮演着至关重要的角色。那么，什么是内省机制和反射机制？它们...

    java反射机制.pdf

    ### Java反射机制详解 #### 一、引言 Java反射机制是Java语言中一项重要的功能，使得Java在一定程度上具备了动态语言的特性。通过Java反射机制，可以在运行时获取类的信息并操作类的对象，这为Java应用开发带来了...

    JAVA反射侯捷观点

    Java反射机制是Java被视为动态语言的关键特性之一，它允许程序在运行时通过Reflection APIs获取任何已知名称的类的内部信息。这一机制使得开发者能够在运行时检查类的修饰符（如public、static等）、超类（如Object...

    酷炫javaweb后台系统适合初学者【里面有封装 反射内省等】

    在这个"酷炫javaweb后台系统"中，包含了一些核心的JavaWeb技术和编程理念，如封装、反射和内省等。这些概念是Java编程的重要组成部分，对于理解和构建高效的应用程序至关重要。 首先，让我们来探讨一下"封装"。封装...

    java ioc,aop实现(内省),仿spring功能实现.

    Java IOC（Inversion of Control，控制反转）和AOP（Aspect-Oriented ...在源码和工具方面，我们可以学习到如何利用Java的内省API进行类信息的获取，以及如何利用反射和动态代理来实现依赖注入和面向切面编程。

    Java 内省(Introspector)深入理解

    内省在实际开发中有着广泛的应用，例如在框架中进行数据绑定、属性的动态修改、序列化和反序列化，以及XML与Java对象之间的映射等。了解并熟练掌握Java内省机制，可以提高代码的灵活性和可维护性，尤其是在处理基于...

    Java Reflection in Action

    Java反射机制是一种在运行时查询、监视和操作类、方法、字段和对象的机制，其提供了一种强大的编程能力，允许程序在运行时进行自我检查和调整行为。Java Reflection in Action这本书作为Java反射机制的经典之作，...

    minimalcode-reflect:JavaBean 的简约反射和内省功能

    在Java编程语言中，反射和内省是两个强大的特性，它们允许程序在运行时检查类、接口、字段和方法的信息，甚至动态地调用方法和访问属性。"minimalcode-reflect"项目提供了一个简约的框架，专注于JavaBean的反射和...

    内省所需jar包

    内省（Introspection）是Java编程语言中的一个重要特性，它允许程序在运行时检查对象的属性和方法，以及类的信息。在Java中，内省主要用于动态操作对象，特别是那些在设计时没有完全预知其行为的对象。内省机制使得...

    类的反射机制您的网络连接，请

    Java反射API主要包括以下几个核心类： 1. **Class类**：每个类在JVM中都有一个对应的Class对象，它包含了类的所有信息。我们可以通过`Class.forName()`或者对象的`getClass()`方法来获取对应的Class对象。 2. **...

Magicbox
Global site tag (gtag.js) - Google Analytics