Java: removing all of the attributes from XML Document

[mike pea]

Hi there,

I'm currently on the SCJP course (I'm on book 3 of 4 and should take the exam within then next year)

This is question is for a personal project I'm working on, and I've only covered xml breifly in Book 3 (the course recomends this forum )
I have lots of xml files that I want to strip down to a very simplified format (and manuipulate some elements).
As part of this stripping down, I need to remove all of the XML attibutes at some point.

I'm trying to write a method that will strip out all of the attributes from my XML Document (going through each child, child-child ... etc in turn)
The way I'm doing it is clearly wrong, but I havent figured out a better way to do it yet. If anyone could point me in the right direction.
As you can see, I will keep cycling through for ever and this is huge and currently only goes 4 nodes deep, is there a better way?

The method I've create so far is as follows:

public Document removeAllAttributes(Document thisDoc){
  NodeList nodeList = thisDoc.getChildNodes();
  for(int i=0; i<nodeList.getLength(); i++){
    Node childNode = nodeList.item(i);
    NamedNodeMap namedNodeMap = childNode.getAttributes(); // this is a list of Attributes (if there are any)			
    // remove attributes for child
    for(int j=0; j<namedNodeMap.getLength(); j++){
      Node childAttribute = namedNodeMap.item(j);
      thisDoc.getChildNodes().item(i).getAttributes().removeNamedItem(childAttribute.getNodeName());
    }
    
    NodeList childNodeList = childNode.getChildNodes();
    for(int k=0; k<childNodeList.getLength(); k++){
      if(childNodeList.item(k).getNodeName()!="#text"){
        Node granChildNode = childNodeList.item(k);
        NamedNodeMap chileNamedNodeMap = granChildNode.getAttributes(); // this is a list of Attributes (if there are any)			
        for(int l=0; l<chileNamedNodeMap.getLength(); l++){
          Node granChildAttribute = chileNamedNodeMap.item(l);
          thisDoc.getChildNodes().item(i).getChildNodes().item(k).getAttributes().removeNamedItem(granChildAttribute.getNodeName());
        }

        NodeList gChildNodeList = granChildNode.getChildNodes();
        for(int m=0; m<gChildNodeList.getLength(); m++){
          if(gChildNodeList.item(m).getNodeName()!="#text"){
            Node ggranChildNode = gChildNodeList.item(m);
            NamedNodeMap gchildNamedNodeMap = ggranChildNode.getAttributes(); 			
            for(int n=0; n<gchildNamedNodeMap.getLength(); n++){
              Node ggChildAttribute = gchildNamedNodeMap.item(n);
              thisDoc.getChildNodes().item(i).getChildNodes().item(k).getChildNodes().item(m).getAttributes().removeNamedItem(ggChildAttribute.getNodeName());
           }

            NodeList ggChildNodeList = ggranChildNode.getChildNodes();
            for(int o=0; o<ggChildNodeList.getLength(); o++){
              if(ggChildNodeList.item(o).getNodeName()!="#text"){
                Node gggranChildNode = gChildNodeList.item(o);
                NamedNodeMap ggchildNamedNodeMap = gggranChildNode.getAttributes(); 			
                for(int p=0; p<ggchildNamedNodeMap.getLength(); p++){
                  Node gggChildAttribute = ggchildNamedNodeMap.item(p);
                  thisDoc.getChildNodes().item(i).getChildNodes().item(k).getChildNodes().item(m).getChildNodes().item(o).getAttributes().removeNamedItem(gggChildAttribute.getNodeName());
		
                // AT THIS POINT I'M ONLY 4 LEVELS DEEP, and you can see already the above is looking silly.
                }
              }	
            }	
          }	
        }
      }	
    }
  }
  return thisDoc;
}

[Matthew Brown]

Hi Mike. Welcome to The Ranch!

If you're going to do this using DOM methods, I'd say it's crying out for a recursive approach, which will be able to cope with arbitrary depth in your XML document. Write a method that processes the top level elements, then calls itself with the next level as the input arguments.

But personally, I'd use an XSLT transformation. If you search for "xslt identity transform" you should find plenty of references to an "identity transformation" - a transformation that produces output identical to the input. That's a good starting point - it's relatively simple to modify that to leave everything untouched except attributes.

[mike pea]

Matthew Brown wrote:Hi Mike. Welcome to The Ranch!

If you're going to do this using DOM methods, I'd say it's crying out for a recursive approach, which will be able to cope with arbitrary depth in your XML document. Write a method that processes the top level elements, then calls itself with the next level as the input arguments.

But personally, I'd use an XSLT transformation. If you search for "xslt identity transform" you should find plenty of references to an "identity transformation" - a transformation that produces output identical to the input. That's a good starting point - it's relatively simple to modify that to leave everything untouched except attributes.

Thanks Matthew, XSLT Transforms looking like they might be the way to go. I wanted to do this a quick and dirty way, but nothing is ever quick (although often dirty )

I tried making the method recursive, but I have to explicitly define which element I'm currently updating in order to strip out the attributes:
(* this line: thisDoc.getChildNodes().item(i).getAttributes().removeNamedItem(childAttribute.getNodeName()))

The rest of it is just repetition. I wrote it like that, in the hope I would be able to later re-write it with one block re-cursively feeding in the NodeList (for a given depth)
The problem is, if you want to removeNameItem from the Document, you have to explicitly define which node you are currently updating(theres no way of searching though the entire depths of the Document).
So as you can see, that line (*) above keeps getting longer, making it not possible to re-cursively do this
(or at least not do it the way I've written it)

I've been banging my head against the wall for a couple of weeks now, it might be time to give up the ghost and stop trying to do this the quick way

[William Brogden]

Wouldn't it be a LOT easier to use SAX processing to create a new attribute stripped file?

Your startElement() event call is the ONLY place that attributes appear, just don't write them to the output file.

Bill

[g tsuji]

The recursion is not difficult to construct. It is not only shorter, it is conceptually much more satisfactory. This is how it would look like.

/* 
//supposed imported the constants at the top
import static org.w3c.dom.Node.ATTRIBUTE_NODE;
import static org.w3c.dom.Node.ELEMENT;
*/
void removeAllAttributes (Node node) {
    short type=node.getNodeType();
    switch (type) {
        case ATTRIBUTE_NODE:    //otherwise 2:
            ((Attr)node).getOwnerElement().getAttributes().removeNamedItem(node.getNodeName());
            break;
        case ELEMENT_NODE:    //otherwise 1:
            NamedNodeMap nnmap=node.getAttributes();
            for (int i=nnmap.getLength()-1; i>=0; i--) {
                removeAllAttributes(nnmap.item(i));
            }
            NodeList nlist=node.getChildNodes();
            for (int i=0; i<nlist.getLength(); i++) {
                removeAllAttributes(nlist.item(i));
            }
            break;
        default: break;
    }
}

You can simply use it and pass to it any Node (an element node - not necessarily the root or even an attribute node or else) and it would eliminate all attributes from the node down (deep-removal).>