xml分割

Question

/**
 * 保存xml
 * @param doc xml document对象
 * @param idx 保存的文件索引号
 * @throws Exception
 */
public static void saveXML(Document doc, int idx) throws Exception{
OutputFormat format = new OutputFormat();
format = OutputFormat.createPrettyPrint();
XMLWriter output = null;
output = new XMLWriter(new FileOutputStream(new File(
                          "c:\\" + idx + ".xml")), format);
output.write(doc);
output.flush();
output.close();
}

public static void main(String[] args) throws Exception{
SAXReader reader = new SAXReader();
Document doc = reader.read(new File("c:/tmp.xml"));

List<Element> infos = doc.selectNodes("catalog/info");

int nodeNum = infos.size(); //总共的info元素个数
int max = 1000; //每份info元素个数
int fileNum = nodeNum/max; //分割的文件个数
if(nodeNum%max!=0){
fileNum++;
}

int nodeIdx=0; //遍历中的节点索引
int fileIdx=0; //分割的文件索引
Document sliptDoc = null;
Element rootEle = null;
for(int i=0;i<nodeNum;i++){
if(nodeIdx==max || nodeIdx==0){
if(nodeIdx==max){
saveXML(sliptDoc, fileIdx);
nodeIdx = 0;
fileIdx ++;
}
sliptDoc = DocumentHelper.createDocument();
rootEle = sliptDoc.addElement("catalog");
}

Element item = (Element)infos.get(i);
rootEle.add((Element)item.clone());
nodeIdx ++;
}

saveXML(sliptDoc, fileIdx); //保存最后一个文件
          }
已测试...

Answer 1

必然很容易会有不完整节点，比如分成了：“....<ro” 和 “ot>....”，可是这对你会有什么不良影响么？因为你如果真的要使用它，其实还是会先以某种手段（物理上合并成一个文件 或者 内存中合并）将其合并成一份完整文档，然后才能正常的进行处理。按照节点切分，主要是浪费计算开销，而且确实没有很强必要性。老实说，我第一眼看到你的需求还以为你是要拆成N份完整的独立文档，这个的话某些场合还相对有价值。
也即：
<catalog>
  <info>..........</info>
  <info>..........</info>
  <info>..........</info>
  ....
</catalog>
变成了N份完整的子文档（每份子文档自身是WellForm的）：
<catalog>
  <info>..........</info>
  <info>..........</info>
</catalog><catalog>
  <info>..........</info>
  <info>..........</info>
</catalog><catalog>
  <info>..........</info>
  <info>..........</info>
</catalog>

Answer 2

还是节点复制吧 目前完成了   数据库递归滤重，代码贡献上 给需要的人看吧。  思路是如果有重复跳过这个节点，结合1楼的分割  这个是将分割后的xml数据入库static List<File> fileList = new ArrayList<File>();
 
  public static void main(String[] args) {
  File file = new File("E:\\tmp\\test\\");
  File[] files = file.listFiles();
  int temp = 0;
  int name_i = 0;
  int name_j = 0;
  System.out.println(files.length);
  //冒泡排序 
  for (int i = 0; i < files.length; i++) {
  for (int j = 1; j < files.length; j++) {
  name_i = getIndex(files[i].getName());
  name_j = getIndex(files[j].getName());
  if (name_i < name_j) {
  temp = name_i;
  name_i = name_j;
  name_j = temp;
 
  }
  fileList.add(i,
  new File(file.getPath() + "/" + name_j + ".xml"));
  }
  }
 
  importData(fileList);
 
  }
 
  public static void importData(List<File> fileList) {
  SAXReader reader = new SAXReader();
  for (File s : fileList) {
  try {
  Document document = reader.read(s);
  List<Element> infos = document.selectNodes("catalog/info");
  for (int i = 0; i < infos.size(); i++) {
  addData(infos.get(i).element("name").getStringValue()
  .toString(), s.getPath(), i);
  }
  } catch (Exception e) {
  e.printStackTrace();
  }
 
  }
 
  }
 
  public static String importData(String fileName, int index) {
  File file = new File(fileName);
  int i = fileList.indexOf(file);  //获取索引
  SAXReader reader = new SAXReader();
 
  for (; i < fileList.size(); i++) {
 
  try {
  Document document = reader.read(fileList.get(i));
  List<Element> infos = document.selectNodes("catalog/info");
  for (; index < infos.size(); index++) {
  addData(infos.get(i).element("name").getStringValue()
  .toString(), fileList.get(i).getPath(), index);
  }
 
  } catch (Exception e) {
  e.printStackTrace();
  }
  }
  return fileName;
  }
 
  private static void addData(String name, String fileName, int index) {
  if (name.equals("华为")) {
  importData(fileName, index + 1); //递归
  }else{
  System.out.println("添加成功"+fileName+"     :"+name);
  }
 
 
  }
 
  public static int getIndex(String name) {
  return Integer.parseInt(name.substring(0, name.lastIndexOf(".")));
  }

Answer 3

我是为了较少时间 应为数据库操作那有重复数据直接就报错了，这时候用递归，如果说分割后在内存里拼成整个文件重新载入的话还是很慢，这样切割后只切割一次， 首次执行时候我会把切割成的 1 2 3 4.xml放到list里进行排序 然后再数据库层出错后递归 递归方法的参数有文件名 和索引  索引+1递归 在递归的方法里 找到当前文件在list里的索引 在去便利 这样不用重复便利了，节点的位置就是返回的索引+1 跳过重复数据。