jsTree pre1.0使用笔记（下）

上篇大致讲了原理，这篇主要罗列代码。代码写的不是很好，大致思路应该能够看的出来，仅供参考：

public String getSrcStructureStr(String appProfileId, String id, String onlyShowCheckedExcept, String showCalledFunction, String onlyShowInterfaceAndMethod) {

        StringBuilder sb = new StringBuilder();

        // 请求所有包名
        if (id.equals("0")) {
            List<String> packageNames = null;

            if (onlyShowCheckedExcept.equals("true")) {
                packageNames = getAllPackageNamesWithThrowExceptFunction(appProfileId, onlyShowInterfaceAndMethod);
            } else {
                packageNames = getAllPackageNames(appProfileId, onlyShowInterfaceAndMethod);
            }

            Collection<String> commonPackagePrefixes = getThreeLevelCommonPrefixes(packageNames);

            JSONArray jsonArr = new JSONArray();

            for(String packageName : commonPackagePrefixes) {
                TreeNode nodeP = new TreeNode();
                nodeP.setId("pkg:" + packageName);
                nodeP.setRel("pkg");
                nodeP.setPkg(packageName);
                nodeP.setTitle(packageName);
                //nodeP.setTitle("pkg:" + packageName);
                nodeP.setState(TreeNode.NODE_STATE_CLOSED);

                JSONObject jsonObj = nodeP.toJsonObject();
                if (jsonObj != null) {
                    jsonArr.put(jsonObj);
                }
            }

            return jsonArr.toString();
        } else

        // 请求所有类节点
        if (id.startsWith("pkg:") && (id.indexOf(",cls:") <= 0)) {
            // 包名长度为0，这种情形不会出现
            if (id.length() == 4) {
                return "[]";
            }

            // "pkg:"占4个位置
            String packageName = id.substring(4);

            JSONArray jsonArr = new JSONArray();

            List<String> packageNames = null;
            if (onlyShowCheckedExcept.equals("true")) {
                packageNames = getAllPackageNamesWithThrowExceptFunction(appProfileId, onlyShowInterfaceAndMethod);
            } else {
                packageNames = getAllPackageNames(appProfileId, onlyShowInterfaceAndMethod);
            }

            // 获取下两层真子包名
            Collection<String> subPackageNames = getNextTwoLevelCommonPrefixes(packageNames, packageName);

            for(String subPackageName : subPackageNames) {
                TreeNode nodeP = new TreeNode();
                nodeP.setId("pkg:" + subPackageName);
                nodeP.setRel("pkg");
                nodeP.setPkg(subPackageName);
                nodeP.setTitle(subPackageName.substring(packageName.length() + 1));
                //nodeP.setTitle("pkg:" + subPackageName);
                nodeP.setState(TreeNode.NODE_STATE_CLOSED);

                JSONObject jsonObj = nodeP.toJsonObject();
                if (jsonObj != null) {
                    jsonArr.put(jsonObj);
                }
            }

            List<String> clsNames = null;

            if (onlyShowCheckedExcept.equals("true")) {
                clsNames = getAllClassNamesWithThrowExceptFunction(appProfileId, packageName, onlyShowInterfaceAndMethod);
            } else {
                clsNames = getAllClassNames(appProfileId, packageName, onlyShowInterfaceAndMethod);
            }

            for(String clsName : clsNames) {

                TreeNode nodeC = new TreeNode();
                nodeC.setId("pkg:" + packageName + ",cls:" + clsName);
                nodeC.setRel("cls");
                nodeC.setPkg(packageName);
                nodeC.setCls(clsName);
                nodeC.setTitle(clsName);
                //nodeC.setTitle("pkg:" + packageName + ",cls:" + clsName);
                nodeC.setState(TreeNode.NODE_STATE_CLOSED);
                sb.append(nodeC.toJsonString());

                JSONObject jsonObj = nodeC.toJsonObject();
                if (jsonObj != null) {
                    jsonArr.put(jsonObj);
                }
            }

            return jsonArr.toString();
        } else

        // 请求所有方法节点
        if (id.startsWith("pkg:") && (id.indexOf(",cls:") > 0) && (id.indexOf(",method:") <= 0)) {
            // 包名长度为0，或者包名长度为1，但是类名长度为0，这种情形不会出现
            if(id.length() <= 10) {
                return "[]";
            }

            int pkgNameLastPos = id.indexOf(",cls:");
            // "pkg:"占4个位置
            String packageName = id.substring(4, pkgNameLastPos);
            // ",cls:"占5个位置
            String clsName = id.substring(pkgNameLastPos + 5);

            List<MethodSignatureBean> methodBeans = getAllMethodNames(appProfileId, packageName, clsName);

            JSONArray jsonArr = new JSONArray();

            for(MethodSignatureBean methodBean : methodBeans) {

                if ((onlyShowCheckedExcept.equals("true")) && (methodBean.exceptions.equals(""))) {
                    continue;
                }

                // 过滤出调用方法中含有指定接口和接口方法的类
                if ((onlyShowInterfaceAndMethod != null) && (!onlyShowInterfaceAndMethod.equals(""))) {
                    if (!methodBean.calledMethods.contains(onlyShowInterfaceAndMethod)) {
                        continue;
                    }
                }

                TreeNode nodeM = new TreeNode();
                nodeM.setId("pkg:" + packageName + ",cls:" + clsName + ",method:" + methodBean.methodName);
                nodeM.setRel("method");
                nodeM.setPkg(packageName);
                nodeM.setCls(clsName);
                nodeM.setMethod(methodBean.methodName + methodBean.methodDesc);

                String title = methodBean.methodName + TypeSignature.shortenSignature(methodBean.parameters) +
                    " " + TypeSignature.shortenSignature(methodBean.returnType);
                if (!methodBean.exceptions.equals("")) {
                    title += " : " + methodBean.exceptions;
                }

                nodeM.setTitle(title);

                String calledMethods = methodBean.calledMethods;

                if (showCalledFunction.equals("true")&&(calledMethods != null)&&(!calledMethods.equals(""))) {
                    nodeM.setState(TreeNode.NODE_STATE_CLOSED);
                } else {
                    nodeM.setState(TreeNode.NODE_STATE_LEAF);
                }

                JSONObject jsonObj = nodeM.toJsonObject();
                if (jsonObj != null) {
                    jsonArr.put(jsonObj);
                }
            }

            return jsonArr.toString();
        } else
        // 请求所有函数内的调用指令节点
        if (id.startsWith("pkg:") && (id.indexOf(",cls:") > 0) && (id.indexOf(",method:") > 0)) {
            int pkgNameLastPos = id.indexOf(",cls:");
            // "pkg:"占4个位置
            String packageName = id.substring(4, pkgNameLastPos);

            int clsNameLastPos = id.indexOf(",method:");
            // ",cls:"占5个位置
            String clsName = id.substring(pkgNameLastPos + 5, clsNameLastPos);

            // ",method:"占8个位置
            String methodName = id.substring(clsNameLastPos + 8);

            if (packageName.equals("") || clsName.equals("") || methodName.equals("")) {
                return "[]";
            }

            List<MethodSignatureBean> methodBeans = getExactMethod(appProfileId, packageName, clsName, methodName);
            int count = methodBeans.size();
            if (count == 0) {
                return "[]";
            }

            MethodSignatureBean methodBean = methodBeans.get(0);

            String calledMethods = methodBean.calledMethods;

            String[] calledMethodsArr = calledMethods.split("%");

            JSONArray jsonArr = new JSONArray();

            for(String calledMethod : calledMethodsArr) {
                // 跳过
                if (calledMethod.equals("")) {
                    continue;
                }

                // 过滤出调用方法中含有指定接口和接口方法的类
                if ((onlyShowInterfaceAndMethod != null) && (!onlyShowInterfaceAndMethod.equals(""))) {
                    if (!calledMethod.contains(onlyShowInterfaceAndMethod)) {
                        continue;
                    }
                }

                String[] calledClsMethodDescArr = calledMethod.split("@");
                String calledClsName = calledClsMethodDescArr[0];
                String calledMethodName = calledClsMethodDescArr[1];
                String calledMethodDescAndIp = calledClsMethodDescArr[2];
                String[] calledMethodDescAndIpArr = calledMethodDescAndIp.split("#");
                String calledMethodDesc = calledMethodDescAndIpArr[0];
                String calledIp = calledMethodDescAndIpArr[1];

                TreeNode nodeM = new TreeNode();
                nodeM.setId("pkg:" + packageName + ",cls:" + clsName + ",method:" + methodBean.methodName);
                nodeM.setRel("called_method");
                nodeM.setPkg(packageName);
                nodeM.setCls(clsName);
                nodeM.setMethod(methodBean.methodName + methodBean.methodDesc);
                nodeM.setCalled_cls(calledClsName);
                nodeM.setCalled_method(calledMethodName + "@" + calledMethodDesc + "#" + calledIp);

                TypeSignature ts = new TypeSignature(calledMethodDesc);
                String calledReturnType = ts.getReturnType();
                String calledParameters = ts.getParameters();
                String shortenMethodDesc = TypeSignature.shortenSignature(calledParameters) + " " +
                    TypeSignature.shortenSignature(calledReturnType);





                String title = TypeSignature.shortenSignature(calledClsName.replace("/", ".")) + " " + calledMethodName + shortenMethodDesc
                    + " #" + calledIp;

                nodeM.setTitle(title);
                nodeM.setState(TreeNode.NODE_STATE_LEAF);

                JSONObject jsonObj = nodeM.toJsonObject();
                if (jsonObj != null) {
                    jsonArr.put(jsonObj);
                }
            }

            return jsonArr.toString();

        }

        return "[]";
    }

TreeNode是从jquery插件中抽取出来，再经过些许改造，也完整地贴出来：

 

public class TreeNode {

    public static final String NODE_STATE_CLOSED = "closed";
    public static final String NODE_STATE_LEAF = "leaf";
    public static final String NODE_STATE_OPEN = "open";

    private Map<String, Object> attr;
    private Collection<TreeNode> children;
    private Map<String, Object> data;
    private String icon;
    private String id;
    private String state = TreeNode.NODE_STATE_CLOSED;
    private String title;
    private String type;

    // 五和增加：jstree为了规避IE的兼容性，图标类型用rel属性来标识（同时，它也可以代表节点类型）
    private String rel;

    // 五和：为了方便界面的javascript处理，直接将值返回给界面
    // 所在包名
    private String pkg;
    // 所在类名
    private String cls;
    // 所在函数名
    private String method;

    // 被调用函数所在类
    private String called_cls;

    // 被调用函数
    private String called_method;

    public TreeNode() {
        super();
    }

    public TreeNode(String title) {
        super();
        this.title = title;
    }

    public TreeNode(String title, Collection<TreeNode> children) {
        super();
        setTitle(title);
        setChildren(children);
    }

    public TreeNode(String id, String title) {
        super();
        setId(id);
        setTitle(title);
    }

    public TreeNode(String id, String title, Collection<TreeNode> children) {
        super();
        setId(id);
        setTitle(title);
        setChildren(children);
    }

    public Map<String, Object> getAttr() {
        return attr;
    }

    public Collection<TreeNode> getChildren() {
        return children;
    }

    public Map<String, Object> getData() {
        return data;
    }

    /**
     * Get the Tree Node Title
     */
    // public String getDatay() {
    // return title;
    // }
    public String getIcon() {
        return icon;
    }

    public String getId() {
        return id;
    }

    public String getState() {
        return state;
    }

    public String getTitle() {
        return title;
    }

    public String getType() {
        return type;
    }

    public void setAttr(Map<String, Object> attr) {
        this.attr = attr;
    }

    /**
     * Set the Tree Node Childrens
     *
     * @param children
     */
    public void setChildren(Collection<TreeNode> children) {
        this.children = children;
    }

    public void setData(Map<String, Object> data) {
        this.data = data;
    }

    /**
     * Set the Tree Node Icon
     *
     * @param icon
     */
    public void setIcon(String icon) {
        if (this.data == null) {
            data = new HashMap<String, Object>();
        }

        if (this.data.containsKey("icon")) {
            this.data.remove("icon");
        }
        this.data.put("icon", icon);
        this.icon = icon;
    }

    /**
     * Set the Tree Node Id
     *
     * @param icon
     */
    public void setId(String id) {

        this.id = id;
        if (this.attr == null) {
            attr = new HashMap<String, Object>();
        }

        if (this.attr.containsKey("id")) {
            this.attr.remove("id");
        }
        this.attr.put("id", id);
    }

    /**
     * Set the Tree Node State open, closed or leaf
     *
     * @param state
     */
    public void setState(String state) {
        this.state = state;
    }

    /**
     * Set the Tree Node Title
     *
     * @param title
     */
    public void setTitle(String title) {
        if (this.data == null) {
            data = new HashMap<String, Object>();
        }

        if (this.data.containsKey("title")) {
            this.data.remove("title");
        }
        this.data.put("title", title);
        this.title = title;
    }

    /**
     * Set the Tree Node Type
     *
     * @param type
     */
    public void setType(String type) {
        this.type = type;
    }

    public String getRel() {
        return rel;
    }

    public void setRel(String rel) {
        this.rel = rel;
    }

    public String getPkg() {
        return pkg;
    }

    public void setPkg(String pkg) {
        this.pkg = pkg;
    }

    public String getCls() {
        return cls;
    }

    public void setCls(String cls) {
        this.cls = cls;
    }

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    public String getCalled_cls() {
        return called_cls;
    }

    public void setCalled_cls(String called_cls) {
        this.called_cls = called_cls;
    }

    public String getCalled_method() {
        return called_method;
    }

    public void setCalled_method(String called_method) {
        this.called_method = called_method;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("TreeNode [id=").append(id).append(", title=").append(
                title).append(", icon=").append(icon).append(", state=")
                .append(state).append(", attr=").append(attr).append(
                        ", children=").append(children).append("]");
        return builder.toString();
    }

    /**
     * {"attr":{"id":"pkg:com.taobao.defensor.hello"},"children":null,"data":{"title":"com.taobao.defensor.hello"},"icon":null,"id":"pkg:com.taobao.defensor.hello","state":"closed","title":"com.taobao.defensor.hello","type":null}
     *
     * @return
     */
    public String toJsonString() {

        try {
            JSONObject jo = new JSONObject();
            JSONObject attr = new JSONObject();
            attr.put("id", id);
            attr.put("rel", rel);
            attr.put("pkg", pkg);
            attr.put("cls", cls);
            attr.put("method", method);
            attr.put("called_cls", called_cls);
            attr.put("called_method", called_method);
            jo.put("attr", attr);

            jo.put("children", (Object) null);

            JSONObject data = new JSONObject();
            data.put("title", title);

            jo.put("data", data);

            jo.put("icon", icon);

            jo.put("id", id);

            jo.put("state", state);

            jo.put("title", title);

            jo.put("type", (Object) null);

            return jo.toString();
        } catch (JSONException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return "";
    }

    public JSONObject toJsonObject() {

        try {
            JSONObject jo = new JSONObject();
            JSONObject attr = new JSONObject();
            attr.put("id", id);
            attr.put("rel", rel);
            attr.put("pkg", pkg);
            attr.put("cls", cls);
            attr.put("method", method);
            attr.put("called_cls", called_cls);
            attr.put("called_method", called_method);
            jo.put("attr", attr);

            jo.put("children", (Object) null);

            JSONObject data = new JSONObject();
            data.put("title", title);

            jo.put("data", data);

            jo.put("icon", icon);

            jo.put("id", id);

            jo.put("state", state);

            jo.put("title", title);

            jo.put("type", (Object) null);

            return jo;
        } catch (JSONException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return null;
    }
}

注意这些代码：

 

if (showCalledFunction.equals("true")&&(calledMethods != null)&&(!calledMethods.equals(""))) {
                    nodeM.setState(TreeNode.NODE_STATE_CLOSED);
                } else {
                    nodeM.setState(TreeNode.NODE_STATE_LEAF);
                }

是用来控制文件夹图标的开合，或者是否是叶子节点。

因为是第一次使用jsTree，写代码那会，对jsTree理解的也不透。所以，采用了分析id的值来获取子节点，其实，可以做的更简单，多设置几个请求参数，然后，这些请求参数的值一直跟随树上的节点，这样可以少掉解析id的步骤。

代码是个巨型函数，将就着看。如果你确实看懂了，相信，也就学会如何使用jsTree了。:)