1.概述
我们要将外部系统给的xml文件进行解析，并存入到数据库。
但是我们并没有dtd或者schema，只有一个word格式的说明文档；更离谱的是，xml结点树的结构(即xml结点与xml结点之间的关系)与业务bean树的结构(即业务bean与业务bean的关系)并不完全一致，比如说，从业务角度讲，一只猪有只猪头，而在xml里，却写成了 pig --content --pighead 的三级关系，无端端多了一个content结点！ 没有dtd/schema，结构又不规范，我们就没法用自动化的第三方java转换api进行解析，而只能手动地、一个一个地解析。但在手动解析的过程中，我们仍然发现各个结点的解析和入库中有很多东西是共同的，或者有共同的规律，这些东西可以抽出来作为一个准框架，然后再将结点中不同的部分开放出来，允许具体的结点做具体的实现，并最终形成一个半自动的解析/入库框架。
为什么说它是半自动的？它有哪些限制？
自动：不必为每个结点编写xml 解析代码和入库代码
“半”：需手动地编写每个javabean，并手动地为每个bean建表
限制：
a.所有业务字段的类型只能设为string/varchar，并且非业务字段的类型在bean中不能为string
b.bean名与表名必须相同，或者可以进行一对一映射
c.bean的成员变量名必须与xml结点的属性名/元素名相同，或者可以进行一对一映射
这三种限制都是利用java反射机制进行自动操作的前提。
2.基本思想
所谓的xml解析，就是将xml结点转换成javabean实例，xml结点的attribute值和element值就是javabean实例的成员变量值; 所谓的持久化，就是将javabean实例变成数据库对应表中的一条记录，javabean实例的成员变量值就是记录中某个字段的值，或者其他表中某个参考了该记录的另一条记录。
而在xml中，javabean体系中，数据据表关系结构中，结点和结点之间的关系都是树形的关系。整体的解析和入库，就是在遍历树时执行转换动作。而我们知道，树的遍历是可以用递归算法实现的，而递归，就不用说了吧，它是实现程序“自动化”的主要途径之一。
以下是对各“树”的具体分析：
假设两个业务实体a和b之间存在聚合关系(父子关系)。那么具体可分三种情况：
a.b是一个原子字段（即不可再分），并且是a的一个属性。
xml中，b是a的xml attribute或者a的原子element
bean中，b是a的成员变量，并且b是一个java内置的数据类型
数据库中，b是a表的一个列
b.b是一个复合字段，并且是a的一个属性，而且和a是1:1关系
xml中，b是a的element，并且b有自己的element或者attribute
bean中，b是a的成员变量，并且程序中有个b类
数据库中，b表是a表的子表(即b外键参考了a表)
c.b是一个复合字段，并且是a的一个属性，而且和a是n:1关系
xml中，b是a的element，并且b有自己的element或者attribute
bean中，b组成一个类集（list,set）共同作为a的成员变量，并且程序中有个b类
数据库中，b表是a表的子表(即b外键参考了a表)
了解了这三种情况，接下来就好办了。程序每抓到一个结点，都要递归地进行以下处理：先处理它的原子属性（情形a），接着处理它的单个子结点（情形b），最后处理它的类集子结点( 情形c)。
3.代码实现的重点
两个重点：
a.如何让业务实体在三棵树内一一对应好？
b.如何发现树形关系，比如a的属性有哪些，a的子结点有哪些？
问题a很简单，就是让三棵树里相同的业务实体取相同的名字。
a.解析xml时发现 结点x 的 属性y 等于 值z，则执行propertyutils.setproperty(结点x , 属性y , 值z)即可。在这里x，y,z是变量，程序不用关心具体的结点和属性是哪些个。需要注意的是，如果属性y是原子字段，则要求属性y必须为string类型，否则程序不知道将值z转换成哪种类型（注：关于propertyutils， 请见apache commons beanutils ）
b.入库时发现x.gety()=z。如果属性y是原子字段，则执行sql insert into x(...,y,...) values (...,z,...)，这里要求y字段必须为varchar/char类型， 以免发生类型转换错误.
关于问题b
xml树：jdom, dom4j等都可以直接找到父子关系
bean体系：
i.原子属性。我们限定一个bean中所有有业务意义的原子字段的类型都string，所有string类型的字段都是业务字段
ii.单个子结点。我们让所有有业务意义的非原子字段都实现一个共同的接口businode，这样一个bean中所有businode成员都是这个bean的子结点
iii.类集子结点。我们也可以限定所有且只有类集子结点可以使用list或set类型，这样可以利用过滤出所有类集子结点。然而，在java1.4及以前的版本里，程序并不知道过滤出的类集子结点是哪个class的实例（因为没有泛型），也就没办法实例化一个类集子结点（见后文），因此只能手动注册类集子结点的属性名和class。java1.5以上的版本我没用过，不知道可不可以解决这个问题。
数据库表关系: 这就不用多说了，就是通过外键参考。因此每类结点对应的表中，都必须有个外键，以参考它的父结点；还必须有个主键，以供它的子结点参考。各表的外键名必须相同并为一常数，否则程序生成insert sql时才可以不用理会具体表的具体的外键名。
程序在解析时，遍历的是bean树；在持久化时也是。比起xml树，bean树代表真正的业务结构；比起数据库表关系树，bean树才能由父至子地进行先序遍历
4.其他问题
a.要让程序知道，原子属性中哪些是xml结点的属性，哪些是xml结点的原子element。代码中这是两个抽象方法，必须让具体的结点类实现
b.回顾本文概述部分提到的“pig --content --pighead 的三级关系，无端端多了一个content结点”，因此我们要让程序知道，pighead,pigfoot等结点的子结点，究竟是pig，还是pig下的content。处理不规范xml时要注意这个问题。这也是一个抽象方法，必须让具体的结点类实现
c.与上一条类似但更变态的，是类集结点的不规范问题。假设一个pig有多个pighead，那结构可能为 pig--pighead,pighead,...，也可能为pig--pigheads--content,content.... 必须让程序知道某个具体结点用的是哪种模式
5.代码
核心：多态 + 递归
a.接口businode
import java.util.*;
import org.dom4j.element;
/**
* 每个结点都要实现的接口
* 它提供了一些方法以方便实现递归的xml解析和持久化
*
*/
public interface businode {
/**
* 所有类型为不可分类型的属性
* @return 属性名的集合
*/
public list getatomicpropnames();
/**
* 一些成员变量。这些成员变量是xml结点的属性
* @return
*/
public list getxmlattributes();
/**
* 一些成员变量。这些成员变量是xml结点的子元素，并且类型为不可分的
* @return
*/
public list getxmlatomicelements();
/**
* 所有类型为类集的属性，并且这些类集中每个元素的类型都是businode
* @return key = 属性名, value = 属性类的class对象。
* 如果为空不返回null，而是空的map
*/
public map getcollectionpropsmap();
/**
* 所有类型为businode的属性
* @return 属性名的集合
*/
public list getbusinodepropnames();
/**
* 从xml中解析出来。
* @param element
* @return
*/
public void parsefromxml(element element);
}
|
b.默认的实现
import java.lang.reflect.field;
import java.util.*;
import org.apache.commons.beanutils.propertyutils;
import org.dom4j.attribute;
import org.dom4j.element;
/**
* 默认的busi node。 继承此类的busi node 需满足 所有不可分属性集=string类型的属性集
* myutils类的代码欠奉
*
*/
public abstract class defaultbusinode implements businode {
public list getatomicpropnames() {
return myutils.getfieldnamesofclass(this.getclass(), string.class);
}
public list getbusinodepropnames() {
return myutils.getfieldnamesofclass(this.getclass(), businode.class);
}
/*
* 所有子元素的父元素。有时是本结点，有时是本结点下的元素。变态
*/
public abstract element getxmlelementparent(element rootelement);
/*
* 类集子结点根元素的iterator 。 假设一个pig有多个pighead，
* 那结构可能为 pig--pighead,pighead,...，
* 也可能为pig--pigheads--content,content....
* 必须让程序知道某个具体结点用的是哪种模式
*
* 如果为空则返回一个空类集的iterator ，不要返回null
*/
public abstract iterator getcollectionelementiterator(
element xmlelementparent, string attname);
/**
* 解析xml属性
*
* @param rootelement
*/
protected void parseattributesfromxml(element rootelement) {
list xmlattributes = this.getxmlattributes();
for (int i = 0; i < this.getxmlattributes().size(); i++) {
string attname = (string) xmlattributes.get(i);
attribute att = rootelement.attribute(attname);
if (att != null) {
try {
propertyutils.setproperty(this, attname, att.getvalue());
} catch (exception e) {
throw new runtimeexception(e);
}
}
}
}
/**
* 解析不可分的element
*
* @param rootelement
*/
protected void parseatomicelementfromxml(element rootelement) {
element xmlelementparent = getxmlelementparent(rootelement);
if (xmlelementparent == null) {
return;
}
list xmlelements = this.getxmlatomicelements();
for (int i = 0; i < xmlelements.size(); i++) {
string attname = (string) xmlelements.get(i);
element elmt = xmlelementparent.element(attname);
if (elmt != null) {
try {
propertyutils.setproperty(this, attname, elmt.gettext());
} catch (exception e) {
throw new runtimeexception(e);
}
}
}
}
/**
* 解析businode属性
*
* @param rootelement
*/
protected void parsebusinodeelementfromxml(element rootelement) {
element xmlelementparent = getxmlelementparent(rootelement);
if (xmlelementparent == null) {
return;
}
// 再解析businode属性
list businodepropnames = this.getbusinodepropnames();
for (int i = 0; i < businodepropnames.size(); i++) {
try {
string attname = (string) businodepropnames.get(i);
element elmt = xmlelementparent.element(attname);
if (elmt != null) {
field field = this.getclass().getdeclaredfield(attname);
businode att = (businode) field.gettype().newinstance();
att.parsefromxml(elmt);
propertyutils.setproperty(this, attname, att);
}
} catch (exception e) {
throw new runtimeexception(e);
}
}
}
/**
* 解析类集属性
*
* @param rootelement
*/
protected void parsecollectionpropsfromxml(element rootelement) {
// 先解析xml属性
element xmlelementparent = getxmlelementparent(rootelement);
if (xmlelementparent == null) {
return;
}
// 最后解析类集属性
map collectionpropsmap = this.getcollectionpropsmap();
for (iterator it = collectionpropsmap.keyset().iterator(); it.hasnext();) {
try {
string attname = (string) it.next();
collection coll = (collection) propertyutils.getproperty(this,
attname);
class atttype = (class) collectionpropsmap.get(attname);
iterator collelementsit = this.getcollectionelementiterator(
xmlelementparent, attname);
// xmlelementparent.elementiterator(attname);
while (collelementsit.hasnext()) {
element collelmt = (element) collelementsit.next();
businode sinlgeatt = (businode) atttype.newinstance();
sinlgeatt.parsefromxml(collelmt);
coll.add(sinlgeatt);
}
} catch (exception e) {
throw new runtimeexception(e);
}
}
}
/**
* 从xml中解析出结点。此方法可能抛出rumtimeexception
*/
public void parsefromxml(element rootelement) {
this.parseattributesfromxml(rootelement);
this.parseatomicelementfromxml(rootelement);
this.parsebusinodeelementfromxml(rootelement);
this.parsecollectionpropsfromxml(rootelement);
}
}
/**
* 入库
* jdbcutil,myutils的代码欠奉
*
*/
public class businodedao {
private long savebusinode(businode node, long parentnodeid) {
// 先存储原子属性
long id = savebarebusinode(node, parentnodeid);
// 再存储类集属性
map collectionpropsmap = node.getcollectionpropsmap();
for (iterator it = collectionpropsmap.keyset().iterator(); it.hasnext();) {
string attname = (string) it.next();
collection coll = null;
try {
coll = (collection) propertyutils.getproperty(node, attname);
} catch (exception e) {
throw new runtimeexception("编码错误");
}
for (iterator iitt = coll.iterator(); iitt.hasnext();) {
businode subnode = (businode) iitt.next();
savebusinode(subnode, id);
}
}
// 最后存储所有businode属性
iterator iitt = node.getbusinodepropnames().iterator();
while (iitt.hasnext()) {
businode subnode = null;
try {
subnode = (businode) propertyutils.getproperty(node,
(string) iitt.next());
} catch (exception e) {
throw new runtimeexception("编码错误");
}
if (subnode != null) {
savebusinode(subnode, id);
}
}
return id;
}
/**
* 插入某个businode的根结点，此方法可能抛出runtimeexception
*
* @param node
* @return
*/
private long savebarebusinode(businode node, long parentnodeid) {
stringbuffer sbforsql = new stringbuffer();
list paramvalues = new arraylist();
geninsertsqlandparam(node, parentnodeid, node.getatomicpropnames(),
sbforsql, paramvalues);
return new long(jdbcutil.queryforlong(
sbforsql.tostring(), paramvalues.toarray()));
}
/**
* 生成某个结点的插入语句和paramvalues数组，此方法可能抛出runtimeexception
*
* @param node
* @param columnnames
* @param sbforsql
* @param paramvalues
*/
private void geninsertsqlandparam(businode node, long parentnodeid,
list columnnames, stringbuffer sbforsql, list paramvalues) {
sbforsql.append(" insert into ");
sbforsql.append(myutils.getclassbarename(node.getclass()));
list cns = new arraylist();
cns.addall(columnnames);
cns.add("parentnodeid");
sbforsql.append(myutils.enclosewithcurve(myutils
.joincollectionstrings(cns, ",")));
sbforsql.append(" values ");
list qms = new arraylist(); // 问号
for (iterator it = columnnames.iterator(); it.hasnext();) {
qms.add("?");
string cn = (string) it.next();
try {
paramvalues.add(propertyutils.getproperty(node, cn));
} catch (exception e) {
throw new runtimeexception(e);
}
}
qms.add("?"); // parentnodeid
paramvalues.add(parentnodeid);
sbforsql.append(myutils.enclosewithcurve(myutil
.joincollectionstrings(qms, ",")));
sbforsql.append(";select @@identity");
}
}
|
闽公网安备 35060202000074号