cfg.java

培训考试系统代码

        }
        else //节点非空
        {
            Node f = node.getFirstChild();
            if (f.getNodeType()==Node.TEXT_NODE)
            {
                f.setNodeValue(value);
            }
            else
            {
                node.insertBefore(doc.createTextNode(value),f);
            }
        }
        isDirty = true; //修改后,脏标记设为真
    }

    /**
     * 取名字为key的节点的布尔值。
     * @param key 取值节点对象的名字。
     * @param def 若没有取到，则返回该值。
     */
    public boolean getBoolean(String key, boolean def)
    {
        String str = String.valueOf(def); //把布尔型def变成字符串类str
        boolean result;
        String resstr = get(key,str);
        Boolean resboolean = Boolean.valueOf(resstr);
        result = resboolean.booleanValue();
        return result;
    }

    /**
     * 取名字为key的节点的整型值。
     * @param key 取值节点对象的名字。
     * @param def 若没有取到，则返回该值。
     */
    public int getInt(String key,int def)
    {
        int result;
        String str = String.valueOf(def);//把整型def变成字符串类str
        String resstr = get(key,str);
        try
        {
            result = Integer.parseInt(resstr);//把字符串类resstr变成整型result
        }
        catch(NumberFormatException e)
        {
            return def;
        }
        return result;
    }

    /**
     * 取名字为key的节点的浮点值。
     * @param key 取值节点对象的名字。
     * @param def 若没有取到，则返回该值。
     */
    public float getFloat(String key,float def)
    {
        float result;
        String str = String.valueOf(def);//把浮点型def变成字符串类str
        String resstr = get(key,str);
        try
        {
            result = Float.parseFloat(resstr);//把字符串类resstr变成浮点型result
        }
        catch(NumberFormatException e)
        {
            return def;
        }
        return result;
    }

    /**
     * 取名字为key的节点的双精度值。
     * @param key 取值节点对象的名字。
     * @param def 若没有取到，则返回该值。
     */
    public double getDouble(String key,double def)
    {
        double result;
        String str = String.valueOf(def);//把double型def变成字符串类str
        String resstr = get(key,str);
        try
        {
            result = Double.parseDouble(resstr);//把字符串类resstr变成double型result
        }
        catch(NumberFormatException e)
        {
            return def;
        }
        return result;
    }

    /**
     * 取名字为key的节点的长整型值。
     * @param key 取值节点对象的名字。
     * @param def 若没有取到，则返回该值。
     */
    public long getLong(String key,long def)
    {
        long result;
        String str = String.valueOf(def);//把long型def变成字符串类str
        String resstr = get(key,str);
        try
        {
            result = Long.parseLong(resstr);//把字符串类resstr变成long型result
        }
        catch(NumberFormatException e)
        {
            return def;
        }
        return result;
    }

    /**
     * 取名字为key的节点的字节数组值。
     * @param key 取值节点对象的名字。
     * @param def 若没有取到，则返回该值。
     */
    public byte[] getByteArray(String key,byte[] def)
    {
        byte[] result;
        String str = new String(def);//把byte[]型def变成字符串类str
        String resstr = get(key,str);
        result = resstr.getBytes();//把字符串类resstr变成byte[]型result
        return result;
    }

    /**
     * 设名字为key的节点的布尔型值。
     * @param key 设值节点对象的名字。
     * @param value 所设的值。
     */
    public void putBoolean(String key, boolean value)
    {
        String str = String.valueOf(value); //将boolean型转换成String类型
        try
        {
            put(key,str);
        }
        catch(RuntimeException e)
        {
            throw e;
        }
    }

    /**
     * 设名字为key的节点的整型值。
     * @param key 设值节点对象的名字。
     * @param value 所设的值。
     */
    public void putInt(String key,int value)
    {
        String str = String.valueOf(value); //将int型转换成String类型
        try
        {
            put(key,str);
        }
        catch(RuntimeException e)
        {
            throw e;
        }
    }

    /**
     * 设名字为key的节点的浮点型值。
     * @param key 设值节点对象的名字。
     * @param value 所设的值。
     */
    public void putFloat(String key,float value)
    {
        String str = String.valueOf(value); //将float型转换成String类型
        try
        {
            put(key,str);
        }
        catch(RuntimeException e)
        {
            throw e;
        }
    }

    /**
     * 设名字为key的节点的双精度型值。
     * @param key 设值节点对象的名字。
     * @param value 所设的值。
     */
    public void putDouble(String key,double value)
    {
        String str = String.valueOf(value); //将double型转换成String类型
        try
        {
            put(key,str);
        }
        catch(RuntimeException e)
        {
            throw e;
        }
    }

    /**
     * 设名字为key的节点的长整型值。
     * @param key 设值节点对象的名字。
     * @param value 所设的值。
     */
    public void putLong(String key,long value)
    {
        String str = String.valueOf(value); //将long型转换成String类型
        try
        {
            put(key,str);
        }
        catch(RuntimeException e)
        {
            throw e;
        }
    }

    /**
     * 设名字为key的节点的字节数组值。
     * @param key 设值节点对象的名字。
     * @param value 所设的值。
     */
    public void putByteArray(String key,byte[] value)
    {
        put(key,Base64.encode(value));
    }

    /**
     * 删除某个节点。
     * @param key 该节点的名称。
     */
    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;  //脏标志设为真
        }
    }

    /**
     * 清理某节点的所有子节点。
     * @param key 该节点的名称。
     */
    public void clear(String key)
    {
        Node node = findNode(key);//查找该节点
        if (node == null) //未找到就抛出异常
        {
            throw new RuntimeException("InvalidName");
        }
        Node lastnode = null;

        //依次把最后一个子节点清除
        while (node.hasChildNodes())
        {
            lastnode = node.getLastChild();
            node.removeChild(lastnode);
        }

        //若有子节点被清除,脏标志设为真
        if (lastnode != null)
        {
            isDirty = true;
        }
    }

    /**
     * 查找某节点下的所有子节点的名字。
     * @param key 被查节点的名字。
     * @return String[] 子节点名字的字符串数组，如果不存在key对应的子节点，
     * 则返回长度为0的空数组。
     */
    public String[] childrenNames(String key)
    {
        Node node = findNode(key); //查找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()==Node.ELEMENT_NODE
                && 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;
    }

    /**
     * 判断某个节点是否存在。
     * @param key 被查节点的全名。
     * @return true 节点存在返回true，节点不存在返回false。
     */
    public boolean nodeExist(String key)
    {
        Node theNode = this.findNode(key);
        if (theNode == null)
        {
            return false;
        }
        else if ( theNode.hasChildNodes())
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * 加载XML解析器驱动程序。
     */
    private void loadXMLParser() throws IOException
    {
        //如果尚未加载过，则加载XML解析器驱动程序
        if (builder == null)
        {
            try
            {
                factory = DocumentBuilderFactory.newInstance();
                factory.setIgnoringComments(true);
                builder = factory.newDocumentBuilder();
            }
            catch (ParserConfigurationException ex)
            {
                throw new IOException("XML Parser load error:" +
                                      ex.getLocalizedMessage());
            }
        }
    }

    /**
     * 重新读取XML文件。
     */
    public void load() throws IOException
    {
        loadXMLParser();

        //解析配置文件
        try
        {
            this.doc = builder.parse(file);
        }
        catch (SAXException ex)
        {
            ex.printStackTrace();
            String message = ex.getMessage();
            Exception e = ex.getException();
            if (e!=null)
            {
                message += "embedded exception:" + e;
            }
            throw new IOException("XML file parse error:" + message);
        }
        root = doc.getDocumentElement();
        if (!"config".equals(root.getNodeName()))
        {
            throw new IOException("Config file format error, " +
                            "root node must be <config>");
        }
    }

    /**
     * 把配置写进配置文件。
     */
    public void flush() throws IOException
    {
        if(isDirty) //如果配置发生过修改
        {
            String proc = new URL(this.file).getProtocol().toLowerCase();
            if (!proc.equalsIgnoreCase("file"))
            {
                throw new UnsupportedOperationException(
                        "Unsupport write config URL on protocal " + proc);
            }
            String fileName = new URL(this.file).getPath();
            BufferedOutputStream bos = new BufferedOutputStream
                                      (new FileOutputStream(fileName),2048);
            PrintWriter pw = new PrintWriter(bos);
            writeNode(doc,pw,0);//输出整个文档
            pw.flush();
            pw.close();
            isDirty = false; //脏标志设为假
        }
    }

    /**
     * 将字符串中的大于号、小于号等特殊字符做转义处理。
     * @param str 转义前字符串。
     * @return 转义后的字符串。
     */
    private String change(String str) throws IOException
    {
        if (str.indexOf('&')!=-1 || str.indexOf('<')!=-1
            || str.indexOf('>')!=-1)
        {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ByteArrayInputStream bis = new ByteArrayInputStream(str.getBytes());
            byte temp;
            byte[] ba1 = {'&','a','m','p',';'};
            byte[] ba2 = {'&','l','t',';'};
            byte[] ba3 = {'&','g','t',';'};
            while( (temp = (byte)bis.read()) != -1 )
            {
                switch (temp)
                {
                    case '&':
                        bos.write(ba1);
                        break;
                    case '<':
                        bos.write(ba2);
                        break;
                    case '>':
                        bos.write(ba3);
                        break;
                    default:
                        bos.write(temp);
                }
            }
            return bos.toString();
        }
        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);
        }
    }
}