java学习：用反射构造bean

先贴一些反射的基本知识：
--------------------------------------------------------------------

一、什么是反射：
反射的概念是由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.cnblogs.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;
}

}