[项目]WebService涉及到的部分核心代码

 前言：

　　博客园似乎不太喜欢设计模式的东西，一连写了几篇设计模式的东西，都没什么人气，也许是写的水平有些不够，另外设计模式属于内功，怎们都得修炼一下，否则，设计混乱，不成体系，对于大型项目来说，就会显的特别的小儿科，因此，无论如何，都得继续学习与修炼。今天就写点之前项目涉及到的Webservice处的一些关键设计与部分源码，这里只是描述关键部分，因为涉及到之前公司的一些东西，特别是对于数据库操作部分没有展示，另外对于部分内容，也进行了重构与简化，希望各位了解。

业务场景：

　　先描述一下业务场景，我们系统运行稳健，由于某些原因，有部分业务功能需要切换到另外的系统去处理，但是，需要保证双方系统数据在业务层面的实时更新[因此仅数据库层面的同步更新是不可取，以后，会开源自己开发的数据库层面的同步工具，有需要可以留言，以便尽快整理]，所以主要是利用webservice技术，由于双方系统的固有差距，相关webservice的互联调试费了些功夫，这里不做太多介绍，双方通信的基础是互相传递Xml数据，这就涉及到了xml的解析，xml的构造等。另外，由于业务的多样化，这里用到了类似简单工厂的设计方法，现在看来，当时只是为了尽快的解决的问题，对于设计的深层考虑还是缺乏的，有很多地方都是不尽合理的，还需要继续深究设计模式。还有一部分就是数据持久化的过程，这一块对于不同的业务需求做了封装，具体这里就不做介绍。其他如日志记录等也就不赘述了。用到的开源类库有Jdom，axis，cxf等

核心实现代码：

webservice互联部分：

  服务器端ServiceRun.java：

package me.service;
public class ServiceRun {
    public static void main(String[] args) {

        System.out.println("Starting Server"); 
        ZC zc = new ZCImpl(); 
        String address = "http://localhost:8090/ZC"; 
        javax.xml.ws.Endpoint.publish(address, zc); 
        System.out.println("服务启动完成。。。。");
    }
}

客户端访问：

package me.service;

import java.net.URL;

import javax.xml.namespace.QName;
import javax.xml.rpc.ParameterMode;

import org.apache.axis.client.Call;
import org.apache.axis.client.Service;

public class ClientRun {
    
    public static void main(String[] args) throws Exception {
        
        String url = "http://localhost:8090/ZC";
        Service service = new Service();
        Call call = (Call) service.createCall();
        call.setTargetEndpointAddress(new URL(url));
        String targetNamespace = "http://service.me/";
        QName qName = new QName(targetNamespace,"getZcmethod");
        call.setOperationName(qName);
        call.addParameter("text", null,ParameterMode.IN);
        String message = (String) call.invoke( new Object[]{"test"});
        System.out.println(message);
    }
}

辅助实现类：

package me.service;

import javax.jws.WebService;


@WebService(endpointInterface="me.service.ZC",name="ZC")
public class ZCImpl implements ZC{

    @Override
    public String getZcmethod(String text) throws Exception {
        System.out.println("parameter is =======>>>> " + text);
        return "parameter is =======>>>> " + text;
    }
    
}

这一部分代码，较为简单而且属于固定模式的。不多介绍。

==================================华丽分割线=======================================

xml服务类，包括解析与构造，这里使用了单例模式（发现之前使用的很不规范，现在仍然使用了饿汉模式，又重新写了双重锁机制）。另外使用了反射机制机制，主要目的是将解析得到的结果转化为类的结果。还是看代码吧。

/**
 * <p>File Name:xmlService.java</p>
 * <p>Create Time:2014-9-22</p>
 * <p>Create Author:ljl</p>
 * <p>Description:</p>
 * <p>Version:1.0</p>
 * <p>Modify:</p>
 */
package com.service.xmlService;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;

import com.service.business.bean.ZC_GDZC;
import com.service.serviceHelper.StrUtil;
import com.service.xmlService.node.CWROW;
import com.service.xmlService.node.CWROWDATA;
import com.service.xmlService.node.DATAPACKAGE;

/**
 * <p>Class Name:xmlService.java</p>
 * <p>Create Time:2014-9-22</p>
 * <p>Create Author:ljl</p>
 * <p>Description:</p>
 * <p>Version:1.0</p>
 * <p>Modify:</p>
 */
public class XmlService {
    /** 不重复随机号*/
    private static String PACKAGEID = "";
    /** 调用监控服务*/
    private static String PACKAGETYPE = "";
    private static List sendRdList = new ArrayList();
    private static String sendStrXml = "";
    private static Object Bean;
    private static XmlService instance=null;
    /**
     * <p>Method Name:</p>
     * <p>Create Time:2014-9-22</p>
     * <p>Create Author:ljl</p>
     * <p>Description:</p>
     * <p>Version:1.0</p>
     * <p>Modify:</p>
     */
    private XmlService(){
        
    }
    public static XmlService getInstance(){
        if(null==instance){
            synchronized (XmlService.class) {
                if(null==instance){
                    instance=new XmlService();
                }
            }
        }
        return instance;
    }
    public void setBean(Object bean) {
        Bean = bean;
    }
    public Object getBean() {
        return Bean;
    }

    /**
     * 
     * <p>Method Name:</p>
     * <p>Create Time:2014-9-24</p>
     * <p>Create Author:ljl</p>
     * <p>Description:make the bean to xml</p>
     * <p>Version:1.0</p>
     * <p>Modify:</p>
     */
    public String beansToStrXml(Object []beans) throws Exception{
        sendRdList = new ArrayList();
        sendStrXml = "";
        for(int i=0;i<beans.length;i++){
            sendRdList.add(beans[i]);
        }
        DATAPACKAGE dpSend = new DATAPACKAGE();
        CWROWDATA cwSend = new CWROWDATA();
        CWROW row = new CWROW();
        cwSend.setPACKAGEID(PACKAGEID);
        cwSend.setPACKAGETYPE(PACKAGETYPE);
        row.setROW(sendRdList);
        cwSend.setROWDATA(row);
        dpSend.setCW(cwSend);
        Document document = XMLDocumentUtil.createXMLDocument(dpSend);
        sendStrXml = XMLDocumentUtil.getStrFromDoc(document);
        return sendStrXml;
    }
    /**
     * 
     * <p>Method Name:</p>
     * <p>Create Time:2014-9-24</p>
     * <p>Create Author:ljl</p>
     * <p>Description:get the data node list</p>
     * <p>Version:1.0</p>
     * <p>Modify:</p>
     */
    public ArrayList parseXML(String recStrXml){
//        System.out.println(recStrXml);
        LinkedHashMap map=new LinkedHashMap();
        ArrayList retArr=new ArrayList();
        if(StrUtil.isEmpty(recStrXml)){
            return null;
        }else{
            SAXBuilder builder = new SAXBuilder();     
            Document doc=null;
            try {
                doc = builder.build(new ByteArrayInputStream(recStrXml.getBytes("GB2312")));
                Element cw = null;
                if (doc.getRootElement()!=null&&doc.getRootElement().getChild(IXmlMemberUtil.CWNAME) != null){
                    cw = doc.getRootElement().getChild(IXmlMemberUtil.CWNAME);
                    PACKAGEID = cw.getChildText(IXmlMemberUtil.PACKANGEIDNAME); // 
                    PACKAGETYPE = cw.getChildText(IXmlMemberUtil.PACKAGETYPENAME); // 
                }
                
                if (cw.getChild(IXmlMemberUtil.ROWDATA)!=null&&cw.getChild(IXmlMemberUtil.ROWDATA).getChildren(IXmlMemberUtil.ROW)!= null){
                    List rds = cw.getChild(IXmlMemberUtil.ROWDATA).getChildren(IXmlMemberUtil.ROW);
                    for(int i=0;i<rds.size();i++){
                        Element row=((Element)rds.get(i));
                        List rows=row.getChildren();
                        for(int j=0;j<rows.size();j++){
                            Element rs=((Element)rows.get(j));
                            map.put(rs.getName(), rs.getValue());
                        }
                        retArr.add(map);
                    }
                }                                                
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            } catch (JDOMException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return retArr;
    }
    /**
     * 
     * <p>Method Name:</p>
     * <p>Create Time:2014-9-26</p>
     * <p>Create Author:ljl</p>
     * <p>Description:change the bean to linkedhashmap.</p>
     * <p>Version:1.0</p>
     * <p>Modify:</p>
     */
    public LinkedHashMap beanToLinkedHashMap(Object bean){
        java.lang.reflect.Field []f= bean.getClass().getFields();
        LinkedHashMap lmap=new LinkedHashMap();
        for(int i=0;i<f.length;i++){
            try {
                lmap.put(f[i].getName(), f[i].get(bean));
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return lmap;
    }
    /**
     * 
     * <p>Method Name:</p>
     * <p>Create Time:2014-9-26</p>
     * <p>Create Author:ljl</p>
     * <p>Description:chage the linkedhashmap to the bean.</p>
     * <p>Version:1.0</p>
     * <p>Modify:</p>
     */
    public void LinkedHashMapToBean(LinkedHashMap lmap){
        if(lmap==null){
            return;
        }
        Class bClass=Bean.getClass();
        Iterator it=lmap.entrySet().iterator();
        Method []method=bClass.getMethods();
        while(it.hasNext()){
            Map.Entry entry=(Map.Entry)it.next();
            String kName=entry.getKey().toString().toUpperCase();
            for(int i=0;i<method.length;i++){
                Method m=method[i];
                String mName=m.getName().toUpperCase();
                if((mName.indexOf(kName)!=-1)&&(mName.indexOf(IXmlMemberUtil.SET)!=-1)){
                    try {
                        Class [] o= new Class[1];
                        o[0]=String.class;
                        Method mSet=bClass.getDeclaredMethod(m.getName(), o);
                        try {
                            String [] s=new String[1];
                            s[0]=entry.getValue().toString();
                            mSet.invoke(Bean,s);
                        } catch (IllegalArgumentException e) {
                            e.printStackTrace();
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        } catch (InvocationTargetException e) {
                            e.printStackTrace();
                        }
                    } catch (SecurityException e) {
                        e.printStackTrace();
                    } catch (NoSuchMethodException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    /**
     * 
     * <p>Create Auther:ljl</p>
     * <p>Create Time:2014-10-29</p>
     * <p>Description:</p>
     * <p>Version:1.0</p>
     * <p>Modify Time:</p>
     * <p>Modify Author:</p>
     * <p>Modify Content:</p>
     */
    public Object invokeMehtod(Object bean,String methodName,Object[]args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
        Class bClass=bean.getClass();
        Class []argClass=new Class[args.length];
        for(int i=0;i<args.length;i++){
            argClass[i] = args.getClass();
        }
        Method method=bClass.getDeclaredMethod(methodName, argClass);
        return method.invoke(bean, args); 
    }
    public static void main(String[] args) {
        XmlService c =XmlService.getInstance();
        StringBuffer sb=new StringBuffer();
          sb.append("<?xml version='1.0' encoding='GB2312'?>"
          +"<DATAPACKAGE>"
          +"<CW>"
            +"<PACKAGEID>001</PACKAGEID>"
            +"<PACKAGETYPE>GDZC</PACKAGETYPE>"
            +"<ROWDATA>"
              +"<ROW>"
                +"<JLHH>123122312</JLHH>"
                +"<ZCMC>你好</ZCMC>"
              +"</ROW>"
              +"<ROW>"
              +"<JLHH>1213545</JLHH>"
              +"<ZCMC>你好adds</ZCMC>"
              +"</ROW>"
            +"</ROWDATA>"
          +"</CW>"
        +"</DATAPACKAGE>");
      ArrayList arr=new ArrayList();
      arr=c.parseXML(sb.toString());
      c.setBean(new ZC_GDZC());
      ZC_GDZC z[] =new ZC_GDZC[arr.size()];
      for(int i=0;i<arr.size();i++){
         LinkedHashMap lmap= (LinkedHashMap)arr.get(i);
         Iterator it=lmap.entrySet().iterator();
         while(it.hasNext()){
             Map.Entry entry=(Map.Entry)it.next();
             String kName=entry.getKey().toString().toUpperCase();
             String kValue=entry.getValue().toString().toUpperCase();
             System.out.println(kName+":"+kValue);
         }
         c.LinkedHashMapToBean(lmap);
         System.out.println("+++"+((ZC_GDZC)c.getBean()).getJLHH());
         System.out.println("+++"+((ZC_GDZC)c.getBean()).getZCMC());
         z[i]=(ZC_GDZC)c.getBean();
         System.out.println("==="+z[i].getJLHH());
         System.out.println("==="+z[i].getZCMC());
      }
      try {
        System.out.println(c.beansToStrXml(z));
    } catch (Exception e) {
        e.printStackTrace();
    }
//        
//          
//        try {
//            PACKAGEID="001";
//            PACKAGETYPE="MESSAGE";
//            try {
//                MESSAGE m=new MESSAGE();
////                Class bClass=Class.forName(getBean().getClass().getName());
//                try {
////                    m = (MESSAGE)bClass.newInstance();
//                    m.setMsgResult("1");
//                    m.setMsgType("GDZC");
//                    Bean=m;
//                    System.out.println("msg:"+m.getMsgType());
//                    System.out.println(c.beanToLinkedHashMap(m));
//                    System.out.println(c.beanToStrXml(m));
//                    
//                    ArrayList arr=c.parseXML(c.beanToStrXml(m));
//                    for(int i=0;i<arr.size();i++){
//                        LinkedHashMap lmap= (LinkedHashMap)arr.get(i);
//                        c.LinkedHashMapToBean(lmap);
//                    }
//                } catch (InstantiationException e) {
//                    e.printStackTrace();
//                } catch (IllegalAccessException e) {
//                    e.printStackTrace();
//                }
//            } catch (ClassNotFoundException e) {
//                e.printStackTrace();
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
    }
}

另外将xml的基础类，写在下边：

package com.service.xmlService;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.lang.reflect.Field; 
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Iterator;
import java.util.List; 
import java.util.Map; 
import java.util.Set; 

import org.jdom2.Document; 
import org.jdom2.Element; 
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;


public class XMLDocumentUtil { 

    /** 
    * 利用对象生产相应的xml数据信息 
    * @param obj 数据源 
    * @return document xml文档对象 
    * @throws Exception 
    */ 
    public static Document createXMLDocument(Object obj) throws Exception { 
        Element headerNode = getElementFromName(obj.getClass().getName()); 
        Document document = new Document(headerNode); 
        int flag = estimateNestingNode(obj); 
        if (0 == flag) { 
            headerNode.addContent("" + obj); 
        } else { 
            distributeCreateNodeTask(null, obj, headerNode, flag); 
        } 
        return document; 
} 

    /** 
    * 根据属性类型选择相应的处理方法 
    * @param name 父节点的名称 
    * @param obj 数据源 
    * @param element 父节点 
    * @flag 相应方法的选择依据 
    * throws Exception 
    * 
    */ 
    private static void distributeCreateNodeTask(String name, Object obj, 
        Element element, int flag) throws Exception { 
        if (flag == 1) { 
            createNodeProperties(name, obj, element); 
        } else if (flag == 2) { 
            createSingleNode(name, obj, element); 
        } else if (flag == 3) { 
            createListNode(name, obj, element); 
        } else if (flag == 4) { 
            createMapNode(name, obj, element); 
        } else if (flag == 5) { 
            createSetNode(name, obj, element); 
        } 
    } 

    /** 
    * 生成对象数组结点 
    * @param name 父节点的名称 
    * @param obj 数据源 
    * @param element 父节点 
    * @flag 相应方法的选择依据 
    * throws Exception 
    */ 
    public static void createNodeProperties(String name, Object obj, 
        Element element) throws Exception { 
        Element nodes; 
        if (null == name || name.equals("") || name.trim().equals("")) { 
            nodes = element; 
        } else { 
            nodes = new Element(name); 
            element.addContent(nodes); 
        } 
        Object[] objects = (Object[]) obj; 
        for (int i = 0; i < objects.length; i++) { 
            Element node = getElementFromName(objects[i].getClass().getName()); 
            nodes.addContent(node); 
            createSingleElement(objects[i], node); 
        } 
    } 
    /**
    * @Title createSingleNode
    * @Description TODO
    * @param name
    * @param obj
    * @param element
    * @throws Exception 
    * @Return void
    * @Throws 
    * @user Administrator
    * @Date 2016年1月20日
     */
    public static void createSingleNode(String name, Object obj, Element element) 
    throws Exception { 
        Element node; 
        if (null == name || name.equals("") || name.trim().equals("")) { 
            node = element; 
        } else { 
            node = new Element(name); 
            element.addContent(node); 
        } 
            createSingleElement(obj, node); 
    } 

    /** 
    * 将类属性所有数据依次写入相应xml的类结点中 
    * 
    * @param obj 数据源 
    * @param element 类结点 
    * throws Exception 
    */ 
    public static void createSingleElement(Object obj, Element element) 
    throws Exception { 
        Field[] fields = obj.getClass().getDeclaredFields(); 
        for (int i = 0; i < fields.length; i++) { 
            int flag = estimateNestingNode(fields[i], obj); 
            String name = fields[i].getName(); 
            if (0 == flag) { 
                setNodeProperties(fields[i], obj, element); 
            } else { 
                distributeCreateNodeTask(name, fields[i].get(obj), element,flag); 
            } 
        } 
    } 

    /** 
    * 生成List类型的结点 
    * 
    * @param name 结点名称 
    * @param obj 数据源 
    * @param element 父结点 
    * throws Exception 
    */ 
    public static void createListNode(String name, Object obj, Element element) 
    throws Exception { 
        Element node; 
//        if (null != name && !name.trim().equals("")) { 
//            node = new Element(name); 
//            //node.setAttribute("name", name); 
//            element.addContent(node); 
//        } else { 
            node = element; 
//        } 
        List list = (List) obj; 
        for(int i=0;i<list.size();i++){
            Object object = (Object)list.get(i);
            createListElement(object, node,name); 
        }

    } 

    /**
    * 将List类型数据写入相应xml的List结点 
    * 
    * @param name 结点名称 
    * @param obj 数据源 
    * @param element 类结点 
    * throws Exception 
    */ 
    public static void createListElement(Object obj, Element element,String name) 
    throws Exception { 
        int flag = estimateNestingNode(obj); 
        //String name = "value"; 
        if (0 == flag) { 
            Element node = new Element(name); 
            node.addContent("" + obj); 
            element.addContent(node); 
        } else { 
            distributeCreateNodeTask(name, obj, element, flag); 
        } 
    } 

    /**
    * 将Map类型数据写入相应xml的Map结点 
    * 
    * @param name 结点名称 
    * @param obj 数据源 
    * @param element 类结点 
    * throws Exception 
    */ 
    public static void createMapNode(String name, Object obj, Element element) 
    throws Exception { 
        Element node; 
        if (null != name && !name.trim().equals("")) { 
            node = new Element("Map"); 
            node.setAttribute("name", name); 
            element.addContent(node); 
        } else { 
            node = element; 
        } 
        Map map = (Map) obj; 
        for (Iterator key= map.keySet().iterator();key.hasNext();) { 
            if (null == key) { 
                continue; 
            }
            Object object = (Object)key.next();
            Element ele = new Element("entry"); 
            ele.setAttribute("key", "" + object); 
            node.addContent(ele); 
            createMapElement(map.get(object), ele); 
        } 
    } 

    /** 
    * 将Map类型数据写入相应xml的Map结点 
    * @param name 结点名称 
    * @param obj 数据源 
    * @param element 类结点 
    * throws Exception 
    */ 
    public static void createMapElement(Object obj, Element node) 
    throws Exception { 
        int flag = estimateNestingNode(obj); 
        String name = "value"; 
        if (0 == flag) { 
            node.setAttribute(name, "" + obj); 
        } else { 
            distributeCreateNodeTask(name, obj, node, flag); 
        } 
    } 

    /** 
    * 将Set类型数据写入相应xml的Set结点 
    * @param name 结点名称 
    * @param obj 数据源 
    * @param element 类结点 
    * throws Exception 
    */ 
    public static void createSetNode(String name, Object obj, Element element) 
    throws Exception { 
        Element node; 
        if (null != name && !name.trim().equals("")) { 
            node = new Element("Set"); 
            node.setAttribute("name", name); 
            element.addContent(node); 
        } else { 
            node = element; 
        } 
        Set set = (Set) obj; 
        for (Iterator key= set.iterator(); key.hasNext();) {
              Object object = (Object)key.next();
              createListElement(object, node,name);// set、list结构一样 
        } 
    } 

    /** 
    * 将单个基础java类型（flag==0）的属性数据写入相应xml的类节点的子结点中 
    * @param field 属性信息 
    * @param obj 数据源 
    * @param element 类结点 
    * throws Exception 
    */ 
    
    private static void setNodeProperties(Field field, Object obj, 
    Element element) throws Exception { 
        String name = field.getName(); 
        boolean accFlag = field.isAccessible(); 
        field.setAccessible(true); 
        Object value = field.get(obj); 
        field.setAccessible(accFlag);
        Element node; 
        if (null == name || name.equals("") || name.trim().equals("")) { 
            node = element; 
        } else { 
            node = new Element(name); 
            element.addContent(node); 
        }
        node.setText(String.valueOf(value)); 
    } 

    /**
    * @Title estimateNestingNode
    * @Description 
    * 0--基本数据类型、String 
    * 1--数组 
    * 2--自定义类 
    * 3--List 
    * 4--Map 
    * 5--Set 
    * @param obj
    * @return 
    * @Return int
    * @Throws 
    * @user Administrator
    * @Date 2016年1月20日
     */
    private static int estimateNestingNode(Object obj) { 
        String str = ""; 
        if (obj instanceof List) { 
            return 3;// 表示该属性是list 
        } 
        if (obj instanceof Map) { 
            return 4;// 表示该属性是Map 
        } 
        if (obj instanceof Set) { 
            return 5;// 表示该属性是Set 
        } 
        if (null != obj) { 
            str = obj.getClass().getName(); 
        } 
        if (str.indexOf("[") != -1) { 
            return 1; 
        } 
        if (str.indexOf("java") != -1) { 
            return 0; 
        } 
        return 2; 
    } 

    private static int estimateNestingNode(Field field, Object obj) 
    throws Exception { 
        String str = ""; 
        Object value = null; 
        value = field.get(obj); 
        if (value instanceof List) { 
            return 3;// 表示该属性是list 
        } 
        if (value instanceof Map) { 
            return 4;// 表示该属性是list 
        } 
        if (value instanceof Set) { 
            return 5;// 表示该属性是list 
        } 
        if (null != value) { 
            str = value.getClass().getName(); 
            if (str.indexOf("[") != -1) { 
                return 1; 
            } 
            if (str.indexOf("java") != -1) { 
                return 0; 
            } 
        } 
        return 2; 
    } 

    /**
    * @Title getElementFromName
    * @Description TODO
    * @param name
    * @return 
    * @Return Element
    * @Throws 
    * @user Administrator
    * @Date 2016年1月20日
     */
    private static Element getElementFromName(String name) { 
        String[] namesplit = name.split("\."); 
        if (namesplit[namesplit.length - 1].endsWith(";")) { 
            namesplit[namesplit.length - 1] = namesplit[namesplit.length - 1].replace(';', 'S'); 
        } 
        return new Element(namesplit[namesplit.length - 1]); 
    } 
    
    public static String getCurrentTime(){
        Calendar cal = Calendar.getInstance();
         java.util.Date date = cal.getTime(); 
         SimpleDateFormat sdFormat = new SimpleDateFormat("HHmmssSSS"); 
         String myTime = sdFormat.format(date);
         return myTime;
    }
    public static String getCurrentDate(){
        Calendar cal = Calendar.getInstance();
         java.util.Date date = cal.getTime(); 
         SimpleDateFormat sdFormat = new SimpleDateFormat("yyyyMMdd"); 
         String myTime = sdFormat.format(date);
         return myTime;
    }
    public static String getCurrentDateMiles(){
        Calendar cal = Calendar.getInstance();
         java.util.Date date = cal.getTime(); 
         SimpleDateFormat sdFormat = new SimpleDateFormat("yyyyMMddHHmmssSSS"); 
         String myTime = sdFormat.format(date);
         return myTime;
    }
    /**
    * @Title getStrFromDoc
    * @Description 从document生成xml
    * @param document
    * @return
    * @throws IOException 
    * @Return String
    * @Throws 
    * @user Administrator
    * @Date 2016年1月20日
     */
    public static String getStrFromDoc(Document document) throws IOException{
        Format format = Format.getPrettyFormat();
        format.setEncoding("GB2312");
        XMLOutputter xmlout = new XMLOutputter(format);
        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        xmlout.output(document,bo);
        String xmlStr = bo.toString();
        return xmlStr;
    }
} 

后续有用到的基础类，再在新的文章中介绍。