browsertreepane.java

Java Bytecode Editor 是一个 JAVA 的字节码反汇编和修改器。它可以很方便的修改已经编译成 Class 文件的 JAVA 文件。

                                                  ClassMember[] classMembers) {

        BrowserTreeNode classMemberNode = new BrowserTreeNode(text);
        if (text.equals("Methods")) {
            classMemberNode.setType(BrowserTreeNode.NODE_METHOD_GENERAL);
        } else {
            classMemberNode.setType(BrowserTreeNode.NODE_FIELDS_GENERAL);
        }
        int classMembersCount = classMembers.length;

        for (int i = 0; i < classMembersCount; i++) {
            addClassMembersNode(classMembers[i],
                    i,
                    classMembersCount,
                    type,
                    classMemberNode);
        }

        return classMemberNode;
    }

    private void addClassMembersNode(ClassMember classMember,
                                     int index,
                                     int classMembersCount,
                                     String type,
                                     BrowserTreeNode classMemberNode) {

        if (classMember == null) {
            classMemberNode.add(buildNullNode());
        } else {
            try {
                BrowserTreeNode entryNode =
                        new BrowserTreeNode(
                        classMember.getName(),
                                type,
                                index);

                classMemberNode.add(entryNode);
                addAttributeNodes(entryNode, classMember);

            } catch (InvalidByteCodeException ex) {
                classMemberNode.add(buildNullNode());
            }
        }
    }

    private BrowserTreeNode buildAttributesNode() {
        BrowserTreeNode mainNode = new BrowserTreeNode("Attributes");
        mainNode.setType(BrowserTreeNode.NODE_ATTRIBUTES_GENERAL);
        
        //BrowserTreeNode attributesNode = new BrowserTreeNode("Attributes");
        addAttributeNodes(mainNode, services.getClassFile());
       
        
      //  mainNode.add(attributesNode);
        
        return mainNode;
    }

    private BrowserTreeNode buildNullNode() {

        return new BrowserTreeNode("[error] null");
    }

    private void addAttributeNodes(BrowserTreeNode parentNode,
                                   AbstractStructureWithAttributes structure) {

        AttributeInfo[] attributes = structure.getAttributes();
        if (attributes == null) {
            return;
        }
        int attributesCount = attributes.length;
        for (int i = 0; i < attributesCount; i++) {
            addSingleAttributeNode(attributes[i],
                    i,
                    attributesCount,
                    parentNode);
        }
    }

    private void addSingleAttributeNode(AttributeInfo attribute,
                                        int index,
                                        int attributesCount,
                                        BrowserTreeNode parentNode) {


        if (attribute == null) {
            parentNode.add(buildNullNode());
        } else {
            try {
                BrowserTreeNode entryNode =
                        new BrowserTreeNode(getFormattedIndex(index, attributesCount) +
                        attribute.getName(),
                                BrowserTreeNode.NODE_ATTRIBUTE,
                                index);

                parentNode.add(entryNode);
                if (attribute instanceof RuntimeAnnotationsAttribute) {
                    addRuntimeAnnotation(entryNode, (RuntimeAnnotationsAttribute)attribute);
                } else if (attribute instanceof AnnotationDefaultAttribute) {
                    addSingleElementValueEntryNode(((AnnotationDefaultAttribute)attribute).getDefaultValue(), 0, 1, entryNode);
                } else {
                    addAttributeNodes(entryNode, attribute);
                }

            } catch (InvalidByteCodeException ex) {
                parentNode.add(buildNullNode());
            }
        }
    }


    private String getFormattedIndex(int index, int maxIndex) {

        StringBuffer buffer = new StringBuffer("[");
        String indexString = String.valueOf(index);
        String maxIndexString = String.valueOf(maxIndex - 1);
        for (int i = 0; i < maxIndexString.length() - indexString.length(); i++) {
            buffer.append("0");
        }
        buffer.append(indexString);
        buffer.append("]");
        buffer.append(" ");

        return buffer.toString();
    }

    private BrowserTreeNode findCodeNode(BrowserTreeNode treeNode, MethodInfo methodInfo) {
        AttributeInfo[] attributes = methodInfo.getAttributes();
        for (int i = 0; i < attributes.length; i++) {
            if (attributes[i] instanceof CodeAttribute) {
                return (BrowserTreeNode)treeNode.getChildAt(i);
            }
        }
        return null;
    }


    private void addRuntimeAnnotation(BrowserTreeNode parentNode,
                                      RuntimeAnnotationsAttribute structure) {

        AnnotationElementValue[] annotations = structure.getRuntimeAnnotations();
        if (annotations == null) {
            return;
        }
        int annotationsCount = annotations.length;
        for (int i = 0; i < annotationsCount; i++) {
            addSingleAnnotationNode(annotations[i],
                    i,
                    annotationsCount,
                    parentNode);
        }
    }

    private void addSingleAnnotationNode(AnnotationElementValue annotation,
                                         int index,
                                         int attributesCount,
                                         BrowserTreeNode parentNode) {


        if (annotation == null) {
            parentNode.add(buildNullNode());
        } else {
            BrowserTreeNode entryNode =
                    new BrowserTreeNode(getFormattedIndex(index, attributesCount) +
                    annotation.getEntryName(),
                            BrowserTreeNode.NODE_ANNOTATION,
                            index,
                            annotation);
            parentNode.add(entryNode);
            addElementValuePairEntry(entryNode, annotation);
        }
    }

    private void addElementValuePairEntry(BrowserTreeNode parentNode,
                                          AnnotationElementValue annotation) {

        ElementValuePair[] entries = annotation.getElementValuePairEntries();
        if (entries == null) {
            return;
        }
        int entriesCount = entries.length;
        for (int i = 0; i < entriesCount; i++) {
            addSingleElementValuePairEntryNode(entries[i],
                    i,
                    entriesCount,
                    parentNode);
        }
    }

    private void addArrayElementValueEntry(BrowserTreeNode parentNode,
                                           ArrayElementValue aeve) {

        ElementValue[] entries = aeve.getElementValueEntries();
        if (entries == null) {
            return;
        }
        int entriesCount = entries.length;
        for (int i = 0; i < entriesCount; i++) {
            addSingleElementValueEntryNode(entries[i],
                    i,
                    entriesCount,
                    parentNode);
        }
    }


    private void addSingleElementValuePairEntryNode(ElementValuePair evep,
                                                    int index,
                                                    int attributesCount,
                                                    BrowserTreeNode parentNode) {


        if (evep == null) {
            parentNode.add(buildNullNode());
        } else {
            BrowserTreeNode entryNode =
                    new BrowserTreeNode(getFormattedIndex(index, attributesCount) +
                    evep.getEntryName(),
                            BrowserTreeNode.NODE_ELEMENTVALUEPAIR,
                            index,
                            evep);
            parentNode.add(entryNode);
            addSingleElementValueEntryNode(evep.getElementValue(), 0, 1, entryNode);
        }
    }

    private void addSingleElementValueEntryNode(ElementValue eve,
                                                int index,
                                                int attributesCount,
                                                BrowserTreeNode parentNode) {

        if (eve == null) {
            parentNode.add(buildNullNode());
        } else {
            String prefix = attributesCount > 1 ?
                    getFormattedIndex(index, attributesCount) : "";
            String nodeType = BrowserTreeNode.NODE_ELEMENTVALUE;
            if (eve instanceof AnnotationElementValue) {
                nodeType = BrowserTreeNode.NODE_ANNOTATION;
            } else if (eve instanceof ArrayElementValue) {
                nodeType = BrowserTreeNode.NODE_ARRAYELEMENTVALUE;
            }

            BrowserTreeNode entryNode =
                    new BrowserTreeNode(prefix + eve.getEntryName(),
                            nodeType, index, eve);

            parentNode.add(entryNode);
            if (nodeType == BrowserTreeNode.NODE_ANNOTATION) {
                addElementValuePairEntry(entryNode, (AnnotationElementValue)eve);
            } else if (nodeType == BrowserTreeNode.NODE_ARRAYELEMENTVALUE) {
                addArrayElementValueEntry(entryNode, (ArrayElementValue)eve);
            }
        }
    }
}