java反射实现类

‘壹’ java中反射是什么

JAVA中反射是动态获取信息以及动态调用对象方法的一种反射机制。

Java反射就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；并且能改变它的属性。而这也是Java被视为动态语言的一个关键性质。

Java反射的功能是在运行时判断任意一个对象所属的类，在运行时构造任意一个类的对象，在运行时判断任意一个类所具有的成员变量和方法，在运行时调用任意一个对象的方法，生成动态代理。

(1)java反射实现类扩展阅读：

JAVA中反射实例：

1、Class superClass=clazz.getSuperclass();//获取父类。

System.out.println("getSuperclass："+superClass)。

2、Class[] interfaces=clazz.getInterfaces();//获取实现接口。

System.out.println("getInterfaces:"+interfaces.length)。

3、Constructor[] cons=clazz.getConstructors();//构造方法。

System.out.println("getConstructors:"+cons.length)。

参考资料来源：网络： JAVA反射机制

‘贰’ Java的反射机制是什么，如何实现

Java中的反射机制，通俗点解释就是能够在程序运行中动态获取到内存中任一对象的信息，这些信息包括对象所属类、类中的方法和属性、以及它们的访问控制域和返回值类型等等，还可以通过反射动态调用对象中的方法，而不管该方法的访问域是私有或是公开，包括构造方法，还能实现动态代理等。总之，反射能够破坏掉JAVA类本身的封装性，进而获取其私有的或公开的信息，也就能突破封装进而调用私有的或公开的方法。
实现的话就是通过反射接口，JAVA把反射相关的类接口都封装在了java.lang.reflect这个包中，你可以研究下这个包中的类，对于类的每一个属性，如变量、方法，构造方法，这个包中都就与之相对应的类，通过这个类就可以操作这个属性了。
java反射很强大，但也很危险，在实际开发中应少用或不用，在必要用之时，往往也能解决你遇到的问题。

‘叁’ java反射怎么实现的

Java中反射有如下几种实现方式：
1、通过Class.forName()方法加载字符串，就可以得到该字符串做代表的Class对象。
2、通过类名调用class属性得到该类的Class对象。
例如：Class<?> clazz = String.class也可以得到String类的Class对象。
3、调用实例的getClass()方法。
例如：Date date = new Date();
Class<?> clazz = date.getClass();
通过上边的两句代码就可以得到date实例的Class对象。

‘肆’ 如何利用java反射构造一个类，使之实现一个接口和一些功能

可以实现，很方便。我去找个例子贴给你

Class FactoryClass = Class.forName(Name);
//Name是DAOFactory实现类的名字

// types of the constructor arguments
Class[] constrArgs = {Properties.class};

Object[] args = {Props};
//Props是Properties类型,它的内容来自一个配置文件
// get Constructor of this class with matching parameter types
Constructor<IDAOFactory> constructor = FactoryClass.getConstructor(constrArgs);

this.factory = constructor.newInstance(args);

‘伍’ 实用的Java反射工具类

反射的Utils函数集合

提供访问私有变量 获取泛型类型Class 提取集合中元素的属性等Utils函数

package reflection

import java lang reflect Field import java lang reflect Modifier import java lang reflect ParameterizedType import java lang reflect Type import java util ArrayList import java util Collection import java util List

import mons beanutils PropertyUtils import mons lang StringUtils import slf j Logger import slf j LoggerFactory import springframework util Assert

/** * 反射的Utils函数集合 提供访问私有变量 获取泛型类型Class 提取集合中元素的属性等Utils函数

* * @author lei */ public class ReflectionUtils {

private static Logger logger = LoggerFactory getLogger（ReflectionUtils class）

private ReflectionUtils（） { }

/** * 直接读取对象属性值 无视private/protected修饰符 不经过getter函数

*/ public static Object getFieldValue（final Object object final String fieldName） { Field field = getDeclaredField（object fieldName）

if （field == null）

throw new IllegalArgumentException（ Could not find field [ + fieldName + ] on target [ + object + ] ）

makeAccessible（field）

Object result = null try { result = field get（object） } catch （IllegalAccessException e） { logger error（ 不可能抛出的异常{} e getMessage（）） } return result }

/** * 直接设置对象属性值 无视private/protected修饰符 不经过setter函数

*/ public static void setFieldValue（final Object object final String fieldName final Object value） { Field field = getDeclaredField（object fieldName）

if （field == null）

throw new IllegalArgumentException（ Could not find field [ + fieldName + ] on target [ + object + ] ）

makeAccessible（field）

try { field set（object value） } catch （IllegalAccessException e） { logger error（ 不可能抛出的异常 {} e getMessage（）） } }

/** * 循环向上转型 获取对象的DeclaredField */ protected static Field getDeclaredField（final Object object final String fieldName） { Assert notNull（object object不能为空 ） return getDeclaredField（object getClass（） fieldName） }

/** * 循环向上转型 获取类的DeclaredField */ @SuppressWarnings（ unchecked ）

protected static Field getDeclaredField（final Class clazz final String fieldName） { Assert notNull（clazz clazz不能为空 ） Assert hasText（fieldName fieldName ） for （Class superClass = clazz superClass ！= Object class superClass = superClass getSuperclass（）） { try { return superClass getDeclaredField（fieldName） } catch （NoSuchFieldException e） { // Field不在当前类定义 继续向上转型 } } return null }

/** * 强制转换fileld可访问

*/ protected static void makeAccessible（final Field field） { if （！Modifier isPublic（field getModifiers（）） || ！Modifier isPublic（field getDeclaringClass（） getModifiers（））） { field setAccessible（true） } }

/** * 通过反射 获得定义Class时声明的父类的泛型参数的类型 如public UserDao extends HibernateDao<User> * * @param clazz * The class to introspect * @return the first generic declaration or Object class if cannot be * determined */ @SuppressWarnings（ unchecked ）

public static Class getSuperClassGenricType（final Class clazz） { return getSuperClassGenricType（clazz ） }

/** * 通过反射 获得定义Class时声明的父类的泛型参数的类型 如public UserDao extends * HibernateDao<User Long> * * @param clazz * clazz The class to introspect * @param index * the Index of the generic ddeclaration start from * @return the index generic declaration or Object class if cannot be * determined */

@SuppressWarnings（ unchecked ）

public static Class getSuperClassGenricType（final Class clazz final int index） {

Type genType = clazz getGenericSuperclass（）

if （！（genType instanceof ParameterizedType）） { logger warn（clazz getSimpleName（） + s superclass not ParameterizedType ） return Object class }

Type[] params = （（ParameterizedType） genType） getActualTypeArguments（）

if （index >= params length || index < ） { logger warn（ Index + index + Size of + clazz getSimpleName（） + s Parameterized Type + params length） return Object class } if （！（params[index] instanceof Class）） { logger warn（clazz getSimpleName（） + not set the actual class on superclass generic parameter ） return Object class } return （Class） params[index] }

/** * 提取集合中的对象的属性 组合成List * * @param collection * 来源集合

* @param propertityName * 要提取的属性名

*/ @SuppressWarnings（ unchecked ）

public static List fetchElementPropertyToList（final Collection collection final String propertyName） throws Exception {

List list = new ArrayList（）

for （Object obj collection） { list add（PropertyUtils getProperty（obj propertyName）） }

return list }

/** * 提取集合中的对象的属性 组合成由分割符分隔的字符串

* * @param collection * 来源集合

* @param propertityName * 要提取的属性名

* @param separator * 分隔符

*/ @SuppressWarnings（ unchecked ）