先贴一些反射的基本知识：
--------------------------------------------------------------------
一、什么是反射：
反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提 出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。其中 LEAD/LEAD++ 、OpenC++ 、MetaXa和Openjava等就是基于反射机制的语言。最近，反射机制也被应用到了视窗系统、操作系统和文件系统中。
反射本身并不 是一个新概念，尽管计算机科学赋予了反射概念新的含义。在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机 制来实现对自己行为的描述（self-rePResentation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用 所描述行为的状态和相关的语义。
二、什么是Java中的类反射：
Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性和方法。Java 的这一能力在实际应用中用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。
Reflection 是 Java 被视为动态（或准动态）语言的关键，允许程序于执行期 Reflection APIs 取得任何已知名称之 class 的內部信息，包括 package、type parameters、superclass、implemented interfaces、inner classes, outer class, fields、constructors、methods、modifiers，並可于执行期生成instances、变更 fields 內容或唤起 methods。
三、Java类反射中所必须的类：
Java的类反射所需要的类并不多，它们分别是：Field、Constructor、Method、Class、Object，下面我将对这些类做一个简单的说明。
Field类：提供有关类或接口的属性的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）属性或实例属性，简单的理解可以把它看成一个封装反射类的属性的类。
Constructor类：提供关于类的单个构造方法的信息以及对它的访问权限。这个类和Field类不同，Field类封装了反射类的属性，而Constructor类则封装了反射类的构造方法。
Method类：提供关于类或接口上单独某个方法的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。 这个类不难理解，它是用来封装反射类方法的一个类。
Class类：类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。
Object类：每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。
以上来自 http://www.VEVb.com/forlina/archive/2011/06/21/2085849.html
--------------------------------------------------------------------
反射的优势在于它可以在程序运行期间动态地构造对象，比较常见的例子是json格式的字符串转化成对象，可以找一些源码参看。
最近写了个方法，用反射的方式根据xml文件和配置文件构造所需的对象，分享在这里。
public static <T> T createObjectFromXMLAndProperty(Document document, Map<String, String> config, Class<T> clazz)
document：xml文件生成的Document对象，数据源
config：配置信息，标明构造的对象所需的数据在xml中的位置
clazz：目标对象
其中的config配置信息是要自己写的，也有一定的写法，例如：
a=xx
b=
c=/root/ele
d=/root/ele[@att]
e=/root/ele;/root/ele[@att]
f=/root/nodes/node[$]
g.aa=/root/nodes/node[$][@key]
g.bb=/root/nodes/node[$][@value]
"="左侧是目标对象中的字段名，右侧是数据/数据的xpath/多个数据
左侧：a：目标对象中的a字段
g.aa：目标对象中的g，中的aa字段
同理，对于对象中不是基本类型的对象，用a.b.c....的形式构造
右侧：具体的值
空：默认值
xpath：xpath指向的xml中的节点的value
xpath[@att]：xpath指向的xml中的节点名为“att”的属性
xpath[$]：取出一系列数据，构造List（仅list可用）
*;*;...：用";"分割的一系列数据构造目标字段（需要有相应的set方法）
以上的写法可以互相搭配使用。
优点：以后遇到解析xml文件的情况时，只需要编写一个配置文件即可，迭代速度快，之后若有改动也是改配置文件，代码不用变动。
不足：只支持构造可以分解为基本类型和List的对象，还有一些类型待添加，如Map等等；
当取数逻辑复杂时，无能为力，比如要取出比a节点的value大的所有节点，好好敲代码吧——或者取出来再做处理。
代码如下：
public class XMLAnalysisUtils { private static final String REGEX_RULE = "//[@(//w+)//]"; private static final Pattern pat = Pattern.compile(REGEX_RULE); private static final Splitter splitter = Splitter.on(";"); private static Map<Type, AbstractStringConverter> typeMap = Maps.newHashMap(); /** * 根据xml和properties构造对象，properties用于描述对象中的字段的值在xml中到位置 * * @param document xml数据 * @param config properties * @param clazz 目标对象 * @return 对象实体 * @throws Exception */ public static <T> T createObjectFromXMLAndProperty(Document document, Map<String, String> config, Class<T> clazz) throws Exception { initTypeMap(); return (T) createObjectFromXMLAndProperty(document, config, clazz, ""); } private static void initTypeMap() { typeMap.put(boolean.class, new BooleanConverter()); typeMap.put(int.class, new IntegerConverter()); typeMap.put(double.class, new DoubleConverter()); typeMap.put(Boolean.class, new BooleanConverter()); typeMap.put(Integer.class, new IntegerConverter()); typeMap.put(Double.class, new DoubleConverter()); typeMap.put(String.class, new StringConverter()); } private static Object createObjectFromXMLAndProperty(Document document, Map<String, String> properties, Class clazz, String owner) throws Exception { Method[] methods = clazz.getDeclaredMethods(); Object object = clazz.newInstance(); for (Method method : methods) { String methodName = method.getName(); Type[] type = method.getGenericParameterTypes(); if (!methodName.startsWith("set")) { continue; } String parameter = owner + methodName.substring(3, 4).toLowerCase() + methodName.substring(4); String xPath = properties.get(parameter); if (xPath != null) { if (xPath.isEmpty()) { if (type.length == 1 && String.class == type[0]) { method.invoke(object, ""); } continue; } if (!isBaseType(type)) { if (type[0] instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) type[0]; Type tp = pt.getActualTypeArguments()[0]; if (!isBaseType(tp)) { continue; } Object results = createList(document, properties, tp, parameter); method.invoke(object, results); } continue; } List<String> values = getValue(document, xPath); if (isAllNull(values)) { continue; } List<Object> result = transType(values, type); if (result == null) { continue; } method.invoke(object, result.toArray()); continue; } if (isBaseType(type)) { if (type.length == 1 && String.class == type[0]) { method.invoke(object, ""); } continue; } if (type[0] instanceof Class) { Object res = createObjectFromXMLAndProperty(document, properties, (Class) type[0], parameter + "."); method.invoke(object, res); continue; } if (type[0] instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) type[0]; if (pt.getRawType().equals(List.class)) { Type tp = pt.getActualTypeArguments()[0]; Object results = createListObjectFromXMLAndProperty(document, properties, (Class) tp, parameter + "."); method.invoke(object, results); } } } return object; } private static Object createListObjectFromXMLAndProperty(Document document, Map<String, String> properties, Class clazz, String owner) throws Exception { Method[] methods = clazz.getDeclaredMethods(); List<Object> objects = Lists.newArrayList(); Integer row = 1; boolean mark = true; boolean isList = true; while (mark & isList) { mark = false; isList = false; Object object = clazz.newInstance(); for (Method method : methods) { String methodName = method.getName(); Type[] type = method.getGenericParameterTypes(); if (!methodName.startsWith("set")) { continue; } String parameter = owner + methodName.substring(3, 4).toLowerCase() + methodName.substring(4); String xPath = properties.get(parameter); if (xPath != null) { if (xPath.isEmpty()) { if (type.length == 1 && String.class == type[0]) { method.invoke(object, ""); } continue; } if (xPath.contains("$")) { isList = true; } if (!isBaseType(type)) { if (type[0] instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) type[0]; Type tp = pt.getActualTypeArguments()[0]; if (!isBaseType(tp)) { continue; } Object results = createList(document, properties, tp, parameter); method.invoke(object, results); } continue; } List<String> values = getValue(document, xPath.replaceAll("//$", row.toString())); if (isAllNull(values)) { continue; } List<Object> result = transType(values, type); if (result == null) { continue; } mark = mark || xPath.contains("$");//非固定值被invoke时判定为可继续 method.invoke(object, result.toArray()); continue; } if (isBaseType(type)) { if (type.length == 1 && String.class == type[0]) { method.invoke(object, ""); } continue; } if (type[0] instanceof Class) { logger.debug("type0:{}, method.name{}", type[0].toString(), method.getName()); Object res = createObjectFromXMLAndProperty(document, properties, (Class) type[0], parameter + "."); method.invoke(object, res); continue; } if (type[0] instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) type[0]; if (pt.getRawType().equals(List.class)) { Type tp = pt.getActualTypeArguments()[0]; Object results = createListObjectFromXMLAndProperty(document, properties, (Class) tp, parameter + "."); method.invoke(object, results); } } } objects.add(object); row++; } objects.remove(objects.size() - 1); return objects; } private static Object createList(Document document, Map<String, String> properties, Type type, String parameter) { List<Object> objects = Lists.newArrayList(); Integer row = 1; boolean mark = true; boolean isList = true; while (mark & isList) { mark = false; String xPath = properties.get(parameter); if (xPath == null) { return null; } if (xPath.isEmpty()) { return objects; } if (!xPath.contains("$")) { isList = false; } xPath = xPath.replaceAll("//$", row.toString()); List<String> values = getValue(document, xPath); if (isAllNull(values)) { continue; } List<Object> result = transType(values, type); if (result == null) { continue; } mark = true; objects.add(result.get(0)); row++; } return objects; } private static List<Object> transType(List<String> values, Type... types) { if (values.size() != types.length) { return null; } List<Object> result = Lists.newArrayList(); int len = values.size(); for (int i = 0; i < len; i++) { result.add(typeMap.get(types[i]).doForward(values.get(i))); } return result; } private static List<String> getValue(Document document, String xPath) { List<String> paths = splitter.splitToList(xPath); List<String> values = Lists.newArrayList(); for (String path : paths) { if (!path.startsWith("/")) { values.add(path); continue; } Element element; element = (Element) document.selectSingleNode(path); if (element == null) { values.add(null); continue; } if (path.contains("@")) { Matcher match = pat.matcher(path); if (match.find()) { String attr = match.group(1); values.add(element.attributeValue(attr)); } continue; } values.add(element.getStringValue()); } return values; } private static boolean isBaseType(Type... types) { return typeMap.keySet().containsAll(Lists.newArrayList(types)); } private static boolean isAllNull(List<String> values) { boolean result = true; if (values == null) { return true; } for (String value : values) { result = result && value == null; } return result; }}新闻热点
疑难解答
