你的位置:首页 > ASP.net教程

[ASP.net教程]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格式的字符串转化成对象,可以找一些源码参看。

最近写了个方法,用反射的方式根据

public static <T> T createObjectFrom

document:

config:配置信息,标明构造的对象所需的数据在

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指向的

   xpath[@att]:xpath指向的

   xpath[$]:取出一系列数据,构造List(仅list可用)

   *;*;...:用";"分割的一系列数据构造目标字段(需要有相应的set方法)

以上的写法可以互相搭配使用。

 

优点:以后遇到解析

不足:只支持构造可以分解为基本类型和List的对象,还有一些类型待添加,如Map等等;

   当取数逻辑复杂时,无能为力,比如要取出比a节点的value大的所有节点,好好敲代码吧——或者取出来再做处理。

 

代码如下:

public class 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();  /**   * 根据@param document @param config  properties   * @param clazz  目标对象   * @return 对象实体   * @throws Exception   */  public static <T> T createObjectFrom clazz)      throws Exception {    initTypeMap();    return (T) createObjectFrom);  }  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 createObjectFrom 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 = createObjectFrom);        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 = createListObjectFrom);          method.invoke(object, results);        }      }    }    return object;  }  private static Object createListObjectFrom 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 = createObjectFrom);          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 = createListObjectFrom);            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;  }}