cfg.java

华为java接口反编译结果！其中包含其所有接口实现过程

                return;
            } else
            {
                child.setNodeValue(value);
                isDirty = true;
                return;
            }
        }

        if(nl.getLength() == 0)
        {
            node.appendChild(doc.createTextNode(value));
        } else
        {
            Node f = node.getFirstChild();
            if(f.getNodeType() == 3)
                f.setNodeValue(value);
            else
                node.insertBefore(doc.createTextNode(value), f);
        }
        isDirty = true;
    }

    public boolean getBoolean(String key, boolean def)
    {
        String str = String.valueOf(def);
        String resstr = get(key, str);
        Boolean resboolean = Boolean.valueOf(resstr);
        boolean result = resboolean.booleanValue();
        return result;
    }

    public int getInt(String key, int def)
    {
        String str = String.valueOf(def);
        String resstr = get(key, str);
        int result;
        try
        {
            result = Integer.parseInt(resstr);
        }
        catch(NumberFormatException e)
        {
            int i = def;
            return i;
        }
        return result;
    }

    public float getFloat(String key, float def)
    {
        String str = String.valueOf(def);
        String resstr = get(key, str);
        float result;
        try
        {
            result = Float.parseFloat(resstr);
        }
        catch(NumberFormatException e)
        {
            float f = def;
            return f;
        }
        return result;
    }

    public double getDouble(String key, double def)
    {
        String str = String.valueOf(def);
        String resstr = get(key, str);
        double result;
        try
        {
            result = Double.parseDouble(resstr);
        }
        catch(NumberFormatException e)
        {
            double d = def;
            return d;
        }
        return result;
    }

    public long getLong(String key, long def)
    {
        String str = String.valueOf(def);
        String resstr = get(key, str);
        long result;
        try
        {
            result = Long.parseLong(resstr);
        }
        catch(NumberFormatException e)
        {
            long l = def;
            return l;
        }
        return result;
    }

    public byte[] getByteArray(String key, byte def[])
    {
        String str = new String(def);
        String resstr = get(key, str);
        byte result[] = resstr.getBytes();
        return result;
    }

    public void putBoolean(String key, boolean value)
    {
        String str = String.valueOf(value);
        try
        {
            put(key, str);
        }
        catch(RuntimeException e)
        {
            throw e;
        }
    }

    public void putInt(String key, int value)
    {
        String str = String.valueOf(value);
        try
        {
            put(key, str);
        }
        catch(RuntimeException e)
        {
            throw e;
        }
    }

    public void putFloat(String key, float value)
    {
        String str = String.valueOf(value);
        try
        {
            put(key, str);
        }
        catch(RuntimeException e)
        {
            throw e;
        }
    }

    public void putDouble(String key, double value)
    {
        String str = String.valueOf(value);
        try
        {
            put(key, str);
        }
        catch(RuntimeException e)
        {
            throw e;
        }
    }

    public void putLong(String key, long value)
    {
        String str = String.valueOf(value);
        try
        {
            put(key, str);
        }
        catch(RuntimeException e)
        {
            throw e;
        }
    }

    public void putByteArray(String key, byte value[])
    {
        put(key, Base64.encode(value));
    }

    public void removeNode(String key)
    {
        Node node = findNode(key);
        if(node == null)
            return;
        Node parentnode = node.getParentNode();
        if(parentnode != null)
        {
            parentnode.removeChild(node);
            isDirty = true;
        }
    }

    public void clear(String key)
    {
        Node node = findNode(key);
        if(node == null)
            throw new RuntimeException("InvalidName");
        Node lastnode = null;
        for(; node.hasChildNodes(); node.removeChild(lastnode))
            lastnode = node.getLastChild();

        if(lastnode != null)
            isDirty = true;
    }

    public String[] childrenNames(String key)
    {
        Node node = findNode(key);
        if(node == null)
            return new String[0];
        NodeList nl = node.getChildNodes();
        LinkedList list = new LinkedList();
        for(int i = 0; i < nl.getLength(); i++)
        {
            Node child = nl.item(i);
            if(child.getNodeType() == 1 && child.hasChildNodes())
                list.add(child.getNodeName());
        }

        String ret[] = new String[list.size()];
        for(int i = 0; i < ret.length; i++)
            ret[i] = (String)list.get(i);

        return ret;
    }

    public boolean nodeExist(String key)
    {
        Node theNode = findNode(key);
        if(theNode == null)
            return false;
        return theNode.hasChildNodes();
    }

    private void loadXMLParser()
        throws IOException
    {
        if(builder == null)
            try
            {
                factory = DocumentBuilderFactory.newInstance();
                factory.setIgnoringComments(true);
                builder = factory.newDocumentBuilder();
            }
            catch(ParserConfigurationException ex)
            {
                throw new IOException("XML Parser load error:".concat(String.valueOf(String.valueOf(ex.getLocalizedMessage()))));
            }
    }

    public void load()
        throws IOException
    {
        loadXMLParser();
        try
        {
            InputSource is = new InputSource(new InputStreamReader((new URL(file)).openStream()));
            is.setEncoding(System.getProperty("file.encoding"));
            doc = builder.parse(is);
        }
        catch(SAXException ex)
        {
            ex.printStackTrace();
            String message = ex.getMessage();
            Exception e = ex.getException();
            if(e != null)
                message = String.valueOf(message) + String.valueOf("embedded exception:".concat(String.valueOf(String.valueOf(e))));
            throw new IOException("XML file parse error:".concat(String.valueOf(String.valueOf(message))));
        }
        root = doc.getDocumentElement();
        if(!"config".equals(root.getNodeName()))
            throw new IOException("Config file format error, root node must be <config>");
        else
            return;
    }

    public void flush()
        throws IOException
    {
        if(isDirty)
        {
            String proc = (new URL(file)).getProtocol().toLowerCase();
            if(!proc.equalsIgnoreCase("file"))
                throw new UnsupportedOperationException("Unsupport write config URL on protocal ".concat(String.valueOf(String.valueOf(proc))));
            String fileName = (new URL(file)).getPath();
            Debug.dump((new URL(file)).getPath());
            Debug.dump((new URL(file)).getFile());
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(fileName), 2048);
            PrintWriter pw = new PrintWriter(bos);
            writeNode(doc, pw, 0);
            pw.flush();
            pw.close();
            isDirty = false;
        }
    }

    private String change(String str)
        throws IOException
    {
        if(str.indexOf(38) != -1 || str.indexOf(60) != -1 || str.indexOf(62) != -1)
        {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ByteArrayInputStream bis = new ByteArrayInputStream(str.getBytes());
            byte ba1[] = {
                38, 97, 109, 112, 59
            };
            byte ba2[] = {
                38, 108, 116, 59
            };
            byte ba3[] = {
                38, 103, 116, 59
            };
            do
            {
                byte temp;
                if((temp = (byte)bis.read()) == -1)
                    break;
                switch(temp)
                {
                case 38: // '&'
                    bos.write(ba1);
                    break;

                case 60: // '<'
                    bos.write(ba2);
                    break;

                case 62: // '>'
                    bos.write(ba3);
                    break;

                default:
                    bos.write(temp);
                    break;
                }
            } while(true);
            return bos.toString();
        } else
        {
            return str;
        }
    }

    public static void main(String args[])
        throws Exception
    {
        Cfg c = new Cfg("testcfg.xml", true);
        c.put("a/b", "汉字");
        c.put("c", "");
        c.put("a", "avalusaaaaaaaaae");
        c.flush();
        c = new Cfg("testcfg.xml", true);
        System.out.println("Config file content:");
        BufferedReader in = new BufferedReader(new FileReader("testcfg.xml"));
        String line;
        while((line = in.readLine()) != null) 
            System.out.println(line);
    }

}