疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

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 作为超类。所有对象(包括数组)都实现这个类的方法。
--------------------------------------------------------------------
 
反射的优势在于它可以在程序运行期间动态地构造对象,比较常见的例子是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;
    }
 
}
复制代码