[ java swing derby开发pc应用 ] 从零到上线(二)

使用xml  缓存数据

         XML  可以作为轻量级缓存 存储一些简单数据
         明文的 XML还可以作为脚本文件 外面修改数据 可以改变一些程序运行参数
         关于 XML加密 使用DES 加密方式   中间明文的 XML程序运行的时候已手动删除  

public class Main {
	public static void main(String[] args) {
		
		CacheXML xml = new CacheXML(true);
		
		xml.setXMLValue("a", "1");
		System.out.println("获取插入a数据："+xml.getXMLValue("a"));
		xml.setXMLValue("b", "1");
		System.out.println("获取插入b数据："+xml.getXMLValue("b"));
		xml.setXMLValue("a", "2");
		System.out.println("获取更新a数据："+xml.getXMLValue("a"));
		
		xml.close();
		xml = null;
		
	}
	
	
	
}

打印输出并生成加密bufferdata.xml

获取插入a数据：1
获取插入b数据：1
获取更新a数据：2

调用代码

  try {
			//解密出中间缓存的明文xml  和  打印数据进行比较 判断是否正确
			xml.decrypt();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

可解密xml  生成新的data.xml

<?xml version="1.0" encoding="UTF-8"?>
<XML>
<a_Title>
<a>2</a>
</a_Title>
<b_Title>
<b>1</b>
</b_Title></XML>

package com.text;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.security.Key;

import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
import javax.crypto.CipherOutputStream;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;


public class CacheXML {

	private final String patch = System.getProperty("user.dir")+"\\dataxml\\data.xml".replace("\\\\", "/");
	private final String buffer_patch = System.getProperty("user.dir")+"\\dataxml\\bufferdata.xml".replace("\\\\", "/");
	private Cipher cipher;   
	private Key key;
	private boolean Encrypt = false;
	
	private File getPatch(){
		if(Encrypt){
			return new File(patch);
		}
		return new File(buffer_patch);
	}
	private File getBufferPatch(){
	    
		return new File(buffer_patch);
	}
	
	public void close(){
		cipher = null;
		key = null;
	}
	
	//_Encrypt 是否对xml 进行加密
	public CacheXML(boolean _Encrypt){
		
		Encrypt= _Encrypt;
		
		if(Encrypt){
			try {
				key = getKey("DESDES".getBytes());  
			    cipher = Cipher.getInstance("DES");  
			    
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		File filexml = new File(System.getProperty("user.dir")+"\\dataxml\\");
		// 如果文件夹不存在则创建
		if (!filexml.exists() && !filexml.isDirectory()) {
			filexml.mkdir();
		}
		
		delete();
	}
	
	//根据Key值获取对应数据
	public String getXMLValue(String key)
	{
		try {  
			Document doc = loadInit(); 
			if(null==doc)return "";
			String v = doc.getElementsByTagName(key).item(0).getFirstChild().getNodeValue();
			delete();
			return v;  
		} catch (Exception e) {   
	       e.printStackTrace(); 
	       return "";
		}   
	}
	
	//根据Key值存入数据
	public void setXMLValue(String key,Object value)
	{
		if(null==value || "".equals(value))return;
		
		if(!getBufferPatch().exists()){
    	    createXML(key,value);
    	    return;
    	}
		
		try{ 
			Document document = loadInit();  
			NodeList n = document.getElementsByTagName(key);
			
			if(n.getLength()>0){
				document.getElementsByTagName(key).item(0).getFirstChild().setNodeValue(""+value);
			}else{
				Element root = document.getDocumentElement();  
		        Element stuEle = document.createElement(key+"_Title");  
		        Element nameEle = document.createElement(key);  
		        Text nameText = document.createTextNode(""+value);  
		        //Attr stuAttr = document.createAttribute("attr");  
		        //stuAttr.setValue("x");  
		        //stuEle.setAttributeNode(stuAttr);  
		        stuEle.appendChild(nameEle);  
		        nameEle.appendChild(nameText);
		        root.appendChild(stuEle);  
			}
			
            saveXML(document);  
         }catch(Exception e){  
             e.printStackTrace();  
         }  
		
	}
	
	
	//读取xml 并缓存到Document
    private Document loadInit(){  
    	
    	if(!getBufferPatch().exists())
    		return null;
    	
        Document document = null;  
        try{  
        	decrypt();
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  
            DocumentBuilder builder = factory.newDocumentBuilder();  
            document = builder.parse(getPatch());  
            document.normalize(); 
            return document;  
        }catch(Exception e){  
            e.printStackTrace();  
            System.out.println(e.getMessage());  
            return null;  
        }  
    }  
    
    //保存xml
    private boolean saveXML(Document document){  
        try{  
        	
            TransformerFactory tFactory = TransformerFactory.newInstance();  
            Transformer transformer = tFactory.newTransformer();  
            DOMSource source = new DOMSource(document);  
            StreamResult result = new StreamResult(getPatch());  
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            transformer.transform(source, result);  
            
    		encrypt();
    		delete();
            return true;  
        }catch(Exception e){  
            e.printStackTrace();  
            System.out.println(e.getMessage());  
            return false;  
        }  
    }  
    
    private void createXML(String key,Object value) {
    	
        // 创建DocumentBuilderFactory
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        try {
            // 创建DocumentBuilder
            DocumentBuilder builder = factory.newDocumentBuilder();
            // 创建Document
            Document document = builder.newDocument();
            // 创建根节点
            Element bookstore = document.createElement("XML");
            // 创建子节点，并设置属性
            Element book = document.createElement(key+"_Title");
            //book.setAttribute("attr", "x");
            // 为book添加子节点
            Element name = document.createElement(key);
            name.setTextContent((String) value);
            book.appendChild(name);
            // 为根节点添加子节点
            bookstore.appendChild(book);
            // 将根节点添加到Document下
            document.appendChild(bookstore);
            
            saveXML(document);

        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } 

    }


    //秘钥
    private Key getKey(byte[] arrBTmp) throws Exception {  
        // 创建一个空的8位字节数组（默认值为0）  
        byte[] arrB = new byte[8];  
  
        // 将原始字节数组转换为8位  
        for (int i = 0; i < arrBTmp.length && i < arrB.length; i++) {  
            arrB[i] = arrBTmp[i];  
        }  
        // 生成密钥  
        Key key = new javax.crypto.spec.SecretKeySpec(arrB, "DES");  
        return key;  
    }  
     
    //加密
    private void encrypt() throws Exception {  
    	if(Encrypt){
    		cipher.init(Cipher.ENCRYPT_MODE, key);
        	BufferedInputStream in = new BufferedInputStream(new FileInputStream(patch));
            //输出流
            CipherOutputStream out = new CipherOutputStream(new BufferedOutputStream(new FileOutputStream(buffer_patch)), cipher);
            int i;
            do {
              i = in.read();
              if (i != -1)
                out.write(i);
            }
            while (i != -1);
     
            in.close();
            out.close();
    	}
    	
    }  
    
    //解密
    public void decrypt() throws Exception {  
    	if(Encrypt){
    		cipher.init(Cipher.DECRYPT_MODE, key);
            //输出流
            BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(patch));
            //输入流
            CipherInputStream in = new CipherInputStream(new BufferedInputStream(
                new FileInputStream(buffer_patch)), cipher);
     
            int i;
            do {
              i = in.read();
              if (i != -1)
                out.write(i);
            }
            while (i != -1);
     
            in.close();
            out.close();
    	}
    	 
    }  
    
    //删除中间转换的xml
    public void delete(){
    	
    	if(Encrypt){
    		File f = new File(patch);
        	if(f.exists()){
        		f.delete();
        	}
    	}
    	
    }
     
   
}