Java Swing窗体小工具实例 - 原创

时间：2021-05-22 06:42:35

Java Swing窗体小工具实例

　　1、本地webserice发布，代码如下：

1.1 JdkWebService.java

package server;

import java.net.InetAddress;

import java.net.UnknownHostException;

import javax.jws.WebParam;

import javax.jws.WebService;

import javax.xml.ws.Endpoint;

import org.apache.log4j.Logger;

@WebService

public class JdkWebService {

    private static Logger logger = Logger.getLogger(JdkWebService.class.getName());

    public String communicationTest(@WebParam(name="XML", /*targetNamespace = "http://para/",*/ mode = WebParam.Mode.IN)String xml) {

        return "成功接收：" + xml;

    }

    public static void main(String[] args) {

        try {

            String hostAddress = InetAddress.getLocalHost().getHostAddress();

            Endpoint.publish("http://" + hostAddress + ":18080/webservice/demo", new JdkWebService());

            System.out.println("Webservice 发布成功！");

        } catch (UnknownHostException e) {

            logger.error(e);

        }

    }

}

代码块

　　2、Client客户端窗体

　　　　通过地址，发送（XML格式字符串）数据，然后接收返回的数据并显示在Swing窗体文本框内，对字符串数据加解密。

　　　　加解密所需jar包：org.apache.commons.codec_1.3.0.v201101211617.jar

　　　　HTTP发送wsdl所需jar包：axis.jar、jaxrpc.jar、wsdl4j-1.6.2.jar、commons-logging-1.1.jar、commons-discovery-0.2.jar

2.1 ClienrFrame.java

package client;

import java.awt.Dimension;

import java.awt.Font;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.WindowEvent;

import java.io.File;

import java.net.InetAddress;

import java.net.UnknownHostException;

import java.util.Locale;

import javax.swing.JButton;

import javax.swing.JFileChooser;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTextArea;

import javax.swing.JTextField;

import javax.xml.ws.Endpoint;

import org.apache.log4j.Logger;

import cn.sanxing.cim.util.CimEncodeUtil;

import server.JdkWebService;

public class ClientFrame extends JFrame implements ActionListener {

    private static final long serialVersionUID = 1L;

    private static Logger logger = Logger.getLogger(ClientFrame.class.getName());

    JFrame mainFrame = new JFrame("Client-Interface Tool");

    JPanel panel;

    // 相关的Label标签

    JLabel url_lable = new JLabel("URL :");

    JLabel requestXML_lable = new JLabel("RequestXML :");

    JLabel responseXML_lable = new JLabel("ResponseXML :");

    // 相关的文本域

    JTextField url_textfield = new JTextField(20);

    // 滚动条以及请求的XML

    JScrollPane jscrollPane;

    JTextArea requestXML_textarea = new JTextArea();

    // 滚动条以及返回的XML

    JScrollPane jscrollPane1;

    JTextArea responseXML_textarea = new JTextArea();

    // 按钮

    JButton xmlIport_button = new JButton("Import");

    JButton encode_button = new JButton("Encrypt");

    JButton send_button = new JButton("Send");

    JButton decode_button = new JButton("Decrypt");

    // String[] types = {"AXIS", "CXF"};

    // JComboBox<String> webservice_type = new JComboBox<String>(types);

    // 标志

    String encrypted_requestXML = null;

    String decrypted_responseXML = null;

    public void showFrame() {

        initPanel();// 初始化面板

        initFrame();// 初始化窗体

    }

    // 初始化窗体

    public void initFrame() {

        // Setting the width and height of frame

        mainFrame.setSize(675, 590);

        mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        mainFrame.setResizable(false);// 固定窗体大小

        Toolkit kit = Toolkit.getDefaultToolkit(); // 工具包

        Dimension screenSize = kit.getScreenSize(); // 屏幕的尺寸

        int screenWidth = screenSize.width / 2; // 屏幕的宽

        int screenHeight = screenSize.height / 2; // 屏幕的高

        int height = mainFrame.getHeight(); // 窗口高度

        int width = mainFrame.getWidth(); // 窗口宽度

        mainFrame.setLocation(screenWidth - width / 2, screenHeight - height / 2);// 将窗口设置到屏幕的中部

        // Image myimage = kit.getImage("resourse/hxlogo.gif"); // 由tool获取图像

        // mainframe.setIconImage(myimage);

        mainFrame.add(panel);

        mainFrame.setVisible(true);

    }

    // 初始化面板

    public void initPanel() {

        this.panel = new JPanel();

        panel.setLayout(null);

        // this.panel = new JPanel(new GridLayout(3,2)); //3行3列的容器

        url_lable.setBounds(25, 20, 100, 25);

        this.panel.add(url_lable);

        // 地址输入框

        url_textfield.setBounds(63, 20, 310, 25);

        this.panel.add(url_textfield);

        // webservice 类型

        // webservice_type.setBounds(385, 20, 78, 25);

        // this.panel.add(webservice_type);

        // 导入按钮

        xmlIport_button.setBounds(385, 20, 78, 25);

        this.panel.add(xmlIport_button);

        // 加密按钮

        encode_button.setBounds(475, 20, 78, 25);

        this.panel.add(encode_button);

        // 发送按钮

        send_button.setBounds(565, 20, 78, 25);

        this.panel.add(send_button);

        // 请求XML Label

        requestXML_lable.setBounds(10, 65, 80, 25);

        this.panel.add(requestXML_lable);

        // 请求XML文本框

        // requestXML_textarea.setEditable(false);

        requestXML_textarea.setFont(new Font("标楷体", 12, 13));

        jscrollPane = new JScrollPane(requestXML_textarea);

        jscrollPane.setBounds(10, 85, 650, 200);

        this.panel.add(jscrollPane);

        // 返回XML Label

        responseXML_lable.setBounds(10, 310, 90, 25);

        this.panel.add(responseXML_lable);

        // 返回XML文本框

        responseXML_textarea.setFont(new Font("标楷体", 12, 13));

        jscrollPane1 = new JScrollPane(responseXML_textarea);

        jscrollPane1.setBounds(10, 330, 650, 200);

        this.panel.add(jscrollPane1);

        // 解密按钮

        decode_button.setBounds(565, 296, 78, 28);

        this.panel.add(decode_button);

        // 避免重复加解密

        encrypted_requestXML = requestXML_textarea.getText();

        decrypted_responseXML = responseXML_textarea.getText();

        // 动作监听

        xmlIport_button.addActionListener(this);

        encode_button.addActionListener(this);

        send_button.addActionListener(this);

        decode_button.addActionListener(this);

    }

    /**

     * 单击动作触发方法

     *

     * @param event

     */

    @Override

    public void actionPerformed(ActionEvent event) {

        // System.out.println(event.getActionCommand());

        // 导入

        if (event.getSource() == xmlIport_button) {

            xmlImport();

        }

        // 加密

        if (event.getSource() == encode_button) {

            encode();

        }

        // 发送

        if (event.getSource() == send_button) {

            send();

        }

        // 解密

        if (event.getSource() == decode_button) {

            decode();

        }

    }

    // 导入

    public void xmlImport() {

        File file = ClientUtil.openChoseWindow(JFileChooser.FILES_ONLY);

        if (file == null) {

            // JOptionPane.showMessageDialog(this.panel, "The file is not

            // exist.",

            // "Tips", 2);// 弹出提示对话框，warning

            return;

        }

        String xml_content = ClientUtil.readFile(file.getAbsolutePath());

        requestXML_textarea.setText(xml_content);

        // System.out.println("The xml was imported seccessfully!");

    }

    // 加密

    public void encode() {

        String requestXML = ClientUtil.getString(requestXML_textarea.getText());

        if (ClientUtil.isEmptyString(requestXML)) {

            JOptionPane.showMessageDialog(null, "The request is empty.", "Tips", 2);// 请求XML为空，warning

            return;

        }

        if (encrypted_requestXML.equals(requestXML)) {// 不重复加密

            return;

        }

        // System.out.println("Before encode:" + requestXML);

        String afterEncodeXML = ClientUtil.compressAndEncode(requestXML);

        // System.out.println("After dncode:" + encodeXML);

        if (ClientUtil.isEmptyString(afterEncodeXML)) {

            JOptionPane.showMessageDialog(null, "Encode failed!", "Tips", 2);// 加密失败，warning

            return;

        }

        encrypted_requestXML = ClientUtil.getString(afterEncodeXML);

        requestXML_textarea.setText(afterEncodeXML);

    }

    // 发送

    public void send() {

        // System.out.println(url_textfield.getText());

        boolean enCodeFlag = CimEncodeUtil.enCodeFlag;

        String url = ClientUtil.getString(url_textfield.getText());

        String requestXML = ClientUtil.getString(requestXML_textarea.getText());

        if (ClientUtil.isEmptyString(url)) {

            JOptionPane.showMessageDialog(null, "The URL is empty.", "Tips", 2);// 地址为空，warning

            return;

        }

        if (ClientUtil.isEmptyString(requestXML)) {

            JOptionPane.showMessageDialog(null, "The request is empty.", "Tips", 2);// 请求XML为空，warning

            return;

        }

        int index = url.lastIndexOf("?");

        String type;

        if (url.lastIndexOf("?") > 0) {

            type = url.substring(index + 1, url.length());

        } else {

            type = "http";

        }

        String responseXML = ClientUtil.sendXml(url, requestXML, type);

        if (ClientUtil.isEmptyString(responseXML)) {

            responseXML_textarea.setText(responseXML);

            JOptionPane.showMessageDialog(null, "The response is empty, Please check the URL.", "Tips", 2);// 返回结果为空，warning

            return;

        }

        if (!enCodeFlag) {

            responseXML = ClientUtil.formatXML(responseXML);

        }

        responseXML_textarea.setText(responseXML);

    }

    // 解密

    public void decode() {

        String responseXML = ClientUtil.getString(responseXML_textarea.getText());

        if (ClientUtil.isEmptyString(responseXML)) {

            JOptionPane.showMessageDialog(null, "The result is empty.", "Tips", 2);

            return;

        }

        if (decrypted_responseXML.equals(responseXML)) {// 不重复解密

            return;

        }

        // System.out.println("Before decode:"+ responseXML_textarea.getText());

        String afterDecodeXML = ClientUtil.decodeAndUncompress(responseXML);

        // System.out.println("After decode:"+ afterDecodeXML);

        // 解密失败

        if (ClientUtil.isEmptyString(afterDecodeXML)) {

            JOptionPane.showMessageDialog(null, "Decryption failed!", "Tips", 2);

            return;

        }

        String afterFormatXML = ClientUtil.formatXML(afterDecodeXML);

        decrypted_responseXML = ClientUtil.getString(afterFormatXML);

        responseXML_textarea.setText(afterFormatXML);

    }

    public void windowClosed(WindowEvent arg0) {

        System.exit(0);

    }

    public void windowClosing(WindowEvent arg0) {

        System.exit(0);

    }

    public static void main(String[] args) {

        // 客户端

        Locale.setDefault(Locale.ENGLISH);

        ClientFrame clientFrame = new ClientFrame();

        clientFrame.showFrame();

        // webservice发布

        try {

            String hostAddress = InetAddress.getLocalHost().getHostAddress();

            String url = "http://" + hostAddress + ":18080/webservice/demo";

            Endpoint.publish(url, new JdkWebService());

            JOptionPane.showConfirmDialog(null, "WebService address:\n" + url, "Local webService release success", 2);

            // System.out.println("WebService 发布成功！");

        } catch (UnknownHostException e) {

            logger.error(e);

        }

    }

}

客户端窗体代码

2.2 ClientUtil.java

package client;

import java.io.BufferedInputStream;

import java.io.BufferedReader;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.StringReader;

import java.io.StringWriter;

import java.net.HttpURLConnection;

import java.net.URL;

import java.rmi.RemoteException;

import java.util.zip.GZIPInputStream;

import java.util.zip.GZIPOutputStream;

import javax.swing.JFileChooser;

import javax.swing.JLabel;

import javax.xml.namespace.QName;

import javax.xml.rpc.ParameterMode;

import javax.xml.rpc.ServiceException;

import org.apache.axis.client.Call;

import org.apache.axis.client.Service;

import org.apache.axis.encoding.XMLType;

import org.apache.commons.codec.binary.Base64;

import org.apache.log4j.Logger;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.io.OutputFormat;

import org.dom4j.io.SAXReader;

import org.dom4j.io.XMLWriter;

public class ClientUtil {

    private static Logger logger = Logger.getLogger(ClientUtil.class.getName());

    public static String doPost(String path, String data, int timeout) throws Exception {

        URL url = null;

        HttpURLConnection conn = null;

        InputStream is = null;

        OutputStream os = null;

        ByteArrayOutputStream bos = null;

        String result = "";

        try {

            url = new URL(path);

            conn = (HttpURLConnection) url.openConnection();

            conn.setRequestMethod("POST");

            conn.setReadTimeout(timeout);

            conn.setConnectTimeout(timeout);

            conn.setRequestProperty("Connection", "keep-alive");

            conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

            conn.setRequestProperty("Content-Length", String.valueOf(data.getBytes().length));

            conn.setDoOutput(true); // 必须设置允许输出

            conn.setDoInput(true); // 必须设置允许输入

            os = conn.getOutputStream();

            os.write(data.getBytes());

            os.flush();

            if (conn.getResponseCode() == 200) {

                is = conn.getInputStream();

                bos = new ByteArrayOutputStream();

                int len = 0;

                byte buffer[] = new byte[1024];

                while ((len = is.read(buffer)) != -1) {

                    bos.write(buffer, 0, len);

                }

                result = new String(bos.toByteArray());

                bos.close();

                is.close();

                return result;

            } else {

                return null;

            }

        } catch (Exception e) {

            throw e;

        } finally {

            try {

                if (conn != null)

                    conn.disconnect();

                if (null != bos)

                    bos.close();

                if (null != is)

                    is.close();

            } catch (IOException e) {

                logger.error("msg:", e);

            }

        }

    }

    //发送RequestXML

    public static String sendXml(String url, String xml, String type) {

        String mdcAddress = url;

//        String mdcPath = sysMap.get("mdcPath");

        String mdcXml="null";

        try {

            if("http".equals(type)){

                mdcXml = doPost(mdcAddress,"xml="+xml,20000);

            } else if("wsdl".equals(type)){

                mdcXml = invokeRemoteFuc(mdcAddress,xml);

            }

        } catch (Exception e) {

            logger.error("msg:", e);

        }

        return mdcXml;

    }

    public static String invokeRemoteFuc(String endpoint, String xml) {

//        String endpoint = "http://localhost:8080/webservice/services/helloworld";

        String result = null;

        Service service = new Service();

        Call call;

        Object[] object = new Object[1];

        object[0] = xml;//Object是用来存储方法的参数

        try {

            call = (Call) service.createCall();

            call.setTargetEndpointAddress(endpoint);// 远程调用路径

//            call.setOperationName("communicationTest");// 调用的方法名  

//            if(type.equals("CXF")){

//                call.setOperationName(new QName("", "communicationTest"));

//            }

//            if(type.equals("AXIS")){

                call.setOperationName(new QName("http://server/", "communicationTest"));// 调用的方法名

//            }

            // 设置参数名:

            call.addParameter("XML", // 参数名

                    XMLType.XSD_STRING,// 参数类型:String

                    ParameterMode.IN);// 参数模式：'IN' or 'OUT'

            // 设置返回值类型：

            call.setReturnType(XMLType.XSD_STRING);// 返回值类型：String            

            result = (String) call.invoke(object);// 远程调用

        } catch (ServiceException e) {

            logger.error("msg:", e);

        } catch (RemoteException e) {

            logger.error("msg:", e);

        }

        return result;

    }

    // Base64加密

    public static String compressAndEncode(String xml) {

        byte[] xmlByte;

        try {

            xmlByte = xml.getBytes("UTF-8");

            ByteArrayOutputStream outstream = new ByteArrayOutputStream();

            GZIPOutputStream gzipOutstream;

            gzipOutstream = new GZIPOutputStream(outstream);

            gzipOutstream.write(xmlByte);

            gzipOutstream.close();

            byte[] b = Base64.encodeBase64(outstream.toByteArray());

            xml = new String(b);

        } catch (IOException e) {

//            logger.error("encode failed:", e);

            return null;

        }

        return xml;

    }

    //Base64解密

    public static String decodeAndUncompress(String xml){

        String s = "";

        byte[] unencoded = Base64.decodeBase64(xml.getBytes());

        ByteArrayInputStream bil = new ByteArrayInputStream(unencoded);

        GZIPInputStream gl;

        try {

            gl = new GZIPInputStream(bil);

            for (int c = gl.read(); c != -1; c = gl.read()) {

                s = s + (char) c;

            }

        } catch (IOException e) {

//            logger.error("解密失败:", e);

            return null;

        }

        return s;

    }

    //判空

    public static final boolean isEmptyString(String s) {

        return s == null || s.trim().equals("") || s.equals("null")

                || s.equals("NULL") || s.trim().equals("undefined");

    }

    public static String getString(Object s){

        return s == null?"":String.valueOf(s).trim();

    }

    //字符串格式化XML形式的字符串

    public static String formatXML(String inputXML) {

        SAXReader reader = new SAXReader();

        String requestXML = null;

        Document document;

        try {

            document = reader.read(new StringReader(inputXML));

            XMLWriter writer = null;

            if (document != null) {

                try {

                    StringWriter stringWriter = new StringWriter();

                    OutputFormat format = new OutputFormat(" ", true);

                    writer = new XMLWriter(stringWriter, format);

                    try {

                        writer.write(document);

                        writer.flush();

                    } catch (Exception e) {

                        logger.error(e);

                    }

                    requestXML = stringWriter.getBuffer().toString();

                } finally {

                    if (writer != null) {

                        try {

                            writer.close();

                        } catch (IOException e) {

                            logger.error(e);

                        }

                    }

                }

            }

        } catch (DocumentException e1) {

//            logger.error(e1);

            return inputXML;//非XML格式字符串 无法转换,返回原字符串

        }

        return requestXML;

    }

    // 文件读取

    public static String readFile(String filePath) {

        StringBuffer content = new StringBuffer();

        String fileline;

        BufferedReader filedata = null;

        try {

            filedata = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), getCharset(filePath)));

            while ((fileline = filedata.readLine()) != null) {

                content.append(fileline + "\r\n");

            }

        } catch (FileNotFoundException ex1) {

            logger.error(ex1);

        } catch (IOException ex2) {

            logger.error(ex2);

        } finally {

            if (filedata != null) {

                try {

                    filedata.close();

                } catch (IOException ex3) {

                    logger.error(ex3);

                }

            }

        }

        return content.toString();

    }

    // 文件编码格式

    private static String getCharset(String fileName) throws IOException {

        @SuppressWarnings("resource")

        BufferedInputStream bin = new BufferedInputStream(new FileInputStream(fileName));

        int p = (bin.read() << 8) + bin.read();

        String code = null;

        switch (p) {

        case 0xefbb:

            code = "UTF-8";

            break;

        case 0xfffe:

            code = "Unicode";

            break;

        case 0xfeff:

            code = "UTF-16BE";

            break;

        default:

            code = "GBK";

        }

        return code;

    }

    /**

     * 打开"导入"文件窗口选择并返回文件

     *

     * @param type

     * @return

     */

    public static File openChoseWindow(int type) {

        JFileChooser jfc = new JFileChooser();

        jfc.setFileSelectionMode(type);// 选择的文件类型(文件夹or文件)

        jfc.showDialog(new JLabel(), "Choose");

        File file = jfc.getSelectedFile();

        return file;

    }

}

工具类代码

　　3、Server服务端窗体

　　　　接收客户端发送的xml字符串数据，显示在窗体文本框并以xml文件形式保存。

　　　　所需jar包：dom4j-1.6.1.jar、log4j-1.2.13.jar

3.1 ServerFrame.java

package server;

import java.awt.Dimension;

import java.awt.GridLayout;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.io.BufferedOutputStream;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import javax.swing.BorderFactory;

import javax.swing.DefaultListModel;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTextArea;

import org.apache.log4j.Logger;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.DocumentHelper;

import org.dom4j.Element;

import cn.sanxing.cim.util.CimResult;

public class ServerFrame extends JFrame implements ActionListener{

    private static final long serialVersionUID = 1L;

    private static Logger logger = Logger.getLogger(ServerFrame.class.getName());

    SimpleDateFormat DATEFORMAT = new SimpleDateFormat("yyyyMMddHHmmss");//设置日期格式

    JFrame mainFrame = new JFrame("Server-Interface Tool");

    JPanel panel = new JPanel();

    JLabel receiveLable = new JLabel("Receive the requested XML");

    JButton refreshButton = new JButton("Refresh");

    JLabel recordLabel = new JLabel();

    //文件列表显示框

    DefaultListModel<String> dlm = new DefaultListModel<String>();

    private JList<String> jList = new JList<String>(dlm);

    JScrollPane file_jScrollPane = new JScrollPane(jList);    //文件列表滚动条

    // 接收并显示请求的XML

    JTextArea requestXML_textarea = new JTextArea();

    JScrollPane jScrollPane = new JScrollPane(requestXML_textarea);    //文本框添加滚动条

    String rootPath = System.getProperty("user.dir")+"/saveFile/";

    public void showFrame(String param, int time) {

        initPanel();// 初始化面板

        initFrame();// 初始化窗体

        //选中监听

        mouseListener();

        //校验是否为XML

        CimResult cr = ServerUtil.verifyXml2Object(param);

        if(!cr.isSuccess()){

            requestXML_textarea.setText(cr.getMsg());

            return;

        }else{

            param = ServerUtil.formatXML(param);

        }

        //将接收参数显示到文本框

        requestXML_textarea.setText(param);

        if(!ServerUtil.isEmptyString(param)){

            writeFile(param, time);    //保存

        }

    }

    // 初始化面板

    public void initPanel() {

        panel.setLayout(null);

        //接收XML标题

        receiveLable.setBounds(170, 15, 200, 25);

        this.panel.add(receiveLable);

        //记录数

        recordLabel.setBounds(840, 15, 80, 25);

        this.panel.add(recordLabel);

        //刷新按钮

        refreshButton.setBounds(10, 18, 80, 20);

        this.panel.add(refreshButton);

        //参数文本显示框

        jScrollPane.setBounds(170, 40, 710, 520);

        this.panel.add(jScrollPane);

        //保存文件

        file_jScrollPane.setBounds(10, 40, 155, 520);

        this.panel.add(file_jScrollPane); // 对list添加滚动条

//        vector = new Vector<String>();// 可实现自动增长对象数组

        this.jList.setBorder(BorderFactory.createTitledBorder("File List")); //文件列表框标题

        // 动作监听

        refreshButton.addActionListener(this);

    }

    public void initFrame(){

        mainFrame.setLayout(new GridLayout(1, 1));

        // Setting the width and height of frame

        mainFrame.setSize(895, 600);

        mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置关闭，则终止程序

        mainFrame.setResizable(false);// 固定窗体大小

        Toolkit kit = Toolkit.getDefaultToolkit(); // 工具包

        Dimension screenSize = kit.getScreenSize(); // 屏幕的尺寸

        int screenWidth = screenSize.width / 2; // 屏幕的宽

        int screenHeight = screenSize.height / 2; // 屏幕的高

        int height = mainFrame.getHeight(); // 窗口高度

        int width = mainFrame.getWidth(); // 窗口宽度

        mainFrame.setLocation(screenWidth - width / 2, screenHeight - height / 2);// 将窗口设置到屏幕的中部

//        Image myimage = kit.getImage("resourse/hxlogo.gif"); // 由tool获取图像

//        mainframe.setIconImage(myimage);

        mainFrame.add(panel);

        mainFrame.setVisible(true);

    }

    //保存并写入xml文件

    public void writeFile(String content,int number) {

        String name = "Interface";

        Document doc = null;

        try {

            doc = DocumentHelper.parseText(content);

        } catch (DocumentException e1) {

            logger.error(e1);

            return;

        }

        Element Noun = doc.getRootElement().element("Header").element("Noun");

        String nounText = Noun.getTextTrim();

        if(!ServerUtil.isEmptyString(nounText) && ("MeterReadings".equals(nounText) || "EndDeviceEvents".equals(nounText))){

            name = nounText;

        }

        byte[] contents = content.getBytes();

        String fileName =  name + "_" + number /*+DATEFORMAT.format(new Date())*/ +".xml";

        String filePath = rootPath + fileName;

        File file = new File(filePath);

        File folder = new File(rootPath);

        if(!folder.exists()){

            folder.mkdir();

        }

        BufferedOutputStream outfile = null;

        try {

            while(true){

                if (!file.exists()) {

                    file.createNewFile();

                    break;

                }

                fileName =  name + "_" + (++number)  /*+DATEFORMAT.format(new Date())*/+".xml";

                filePath = rootPath + fileName;

                file = new File(filePath);

            }

            outfile = new BufferedOutputStream(new FileOutputStream(filePath));

            outfile.write(contents);

            outfile.flush();

//            System.out.println("保存成功！");

        } catch (IOException ex1) {

            logger.error(ex1);

        } finally {

            if (outfile != null) {

                    try {

                        outfile.close();

                    } catch (IOException e) {

                        logger.error(e);

                    }

            }

        }

    }

    /**

     * 读取文件

     * @param fileName

     * @param encode

     * @return

     */

    public StringBuffer readFile(String fileName,String encode) {

        StringBuffer content = new StringBuffer();

        String fileline;

        BufferedReader filedata = null;

        try {

            filedata=new BufferedReader(new InputStreamReader(new FileInputStream(fileName),encode));

            while ((fileline = filedata.readLine()) != null) {

                content.append(fileline + "\r\n");

            }

        } catch (FileNotFoundException ex1) {

            logger.error(ex1);

        } catch (IOException ex2) {

            logger.error(ex2);

        } finally {

            if (filedata != null) {

                try {

                    filedata.close();

                } catch (IOException ex3) {

                    logger.error(ex3);

                }

            }

        }

        return content;

    }

    /**

     * 判断文件是否存在

     * @param path

     * @return

     */

    public boolean isFile(String path) {

        boolean flag = true;

        File dir = new File(path);

        if (!dir.exists()) {

            requestXML_textarea.setText("File does not exist");

            flag = false;

        }

        return flag;

    }

    //事件监听

    @Override

    public void actionPerformed(ActionEvent e) {

        if(e.getSource() == refreshButton){    //刷新文件列表

            refreshFileList();

        }

    }

    //获取文件列表

    public void refreshFileList() {

        File file = new File(rootPath);

        List<File> fileList = new ArrayList<File>();

        if(!file.exists()){

            jList = null;

            requestXML_textarea.setText("Folders do not exist!");

        }else{

            this.dlm.clear();

            File[] files = file.listFiles();

            if(files.length == 0){

                jList = null;

                requestXML_textarea.setText("The folder is empty!");

            }else{

                for(File file_xml : files){

                    String fileName = file_xml.getName();

                    String str_xml = fileName.substring(fileName.lastIndexOf(".") + 1);

                    if(str_xml.equals("xml")){

                        fileList.add(file_xml);

                    }

                }

                //文件名排序

                Collections.sort(fileList, new Comparator<File>() {

                    @Override

                    public int compare(File o1, File o2) {

                        int num1 = Integer.parseInt(o1.getName().substring(o1.getName().indexOf("_")+1, o1.getName().indexOf(".")));

                        int num2 = Integer.parseInt(o2.getName().substring(o2.getName().indexOf("_")+1, o2.getName().indexOf(".")));

                        if(num1 > num2){

                            return 1;

                        }

                        return -1;

                    }

                });

//                 Collections.sort(fileList, new Comparator<File>() {

//                       @Override

//                       public int compare(File o1, File o2) {

//                        if (o1.isDirectory() && o2.isFile())

//                              return -1;

//                        if (o1.isFile() && o2.isDirectory())

//                              return 1;

//                        return o1.getName().compareTo(o2.getName());

//                       }

//                      });

                //加入到model

                for(File fileName : fileList){

                    dlm.addElement(fileName.getName());

                }

            }

        }

    }

    //文件列表选中事件监听

    public void mouseListener() {

        jList.addMouseListener(new MouseAdapter() {

            @SuppressWarnings("unchecked")

            public void mouseClicked(MouseEvent e) {

                if (jList.getSelectedIndex() != -1) {    // 选中

                    if (e.getClickCount() == 1) {    // 单击（若判断双击改为等于2）

//                        System.out.println(jList.getSelectedValue().toString());

                        String selectedFileName = jList.getSelectedValue().toString().trim();//获取选中的文件名

                        String path = rootPath+selectedFileName;

                        if(isFile(path)){

                            String Content = readFile(path,"UTF-8").toString();//根据文件名读取文件内容

                            requestXML_textarea.setText(Content);//将所读取的文件内容显示在文本框

                            //获取XML中表号个数赋值到recordLabel

                            Document doc = null;

                            try {

                                doc = DocumentHelper.parseText(Content);

                            } catch (DocumentException e1) {

                                logger.error(e1);

                            }

                            if(doc != null){

                                Element Payload = doc.getRootElement().element("Payload");

                                String name = selectedFileName.substring(0, selectedFileName.lastIndexOf("_"));

                                Element element = null;

                                if(name.equals("MeterReadings") && Payload != null){

                                    element = Payload.element("MeterReadings");

                                }

                                if(name.equals("EndDeviceEvents") && Payload != null){

                                    element = Payload.element("EndDeviceEvents");

                                }

                                if(element != null){

                                    List<Element> list = element.elements();

                                    recordLabel.setText(String.valueOf(list.size()));

//                                    System.out.println(list.size());

                                }else{

                                    recordLabel.setText("");

                                }

                            }

                        }

                    }

                }

            }

        });

    }

    public static void main(String[] args) {

        ServerFrame serverFrame = new ServerFrame();

        serverFrame.showFrame("Test Message!",1);

    }

}

服务端窗体代码

3.2 ServerUtil.java

package server;

import java.io.IOException;

import java.io.StringReader;

import java.io.StringWriter;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.DocumentHelper;

import org.dom4j.io.OutputFormat;

import org.dom4j.io.SAXReader;

import org.dom4j.io.XMLWriter;

import cn.sanxing.cim.cis.CimCustomerModule;

import cn.sanxing.cim.cis.CimDataLinkageModule;

import cn.sanxing.cim.cis.CimEndDeviceModule;

import cn.sanxing.cim.cis.CimGridModule;

import cn.sanxing.cim.cis.CimHeader;

import cn.sanxing.cim.cis.CimMeterModule;

import cn.sanxing.cim.cis.CimModule;

import cn.sanxing.cim.cis.CimReplyModule;

import cn.sanxing.cim.cis.CimServiceRequest;

import cn.sanxing.cim.type.VerbType;

import cn.sanxing.cim.util.CimBaseCodeUtil;

import cn.sanxing.cim.util.CimResult;

import cn.sanxing.cim.util.CimUtil;

import cn.sanxing.cim.util.CimXmlUtil;

public class ServerUtil {

    public static CimResult xml2Object(String xml) {

        CimResult re = new CimResult(false);

        re = verifyXml2Object(xml);

        if (!re.isSuccess()) {

            return re;

        }

        Document doc = CimXmlUtil.strToDom(xml);

        re.setDataObject(CimXmlUtil.parseXml2Obj(doc));

        re.setSuccess(true);

        return re;

    }

    public static CimResult verifyXml2Object(String xml) {

        CimResult re = new CimResult(true);

        if (xml == null) {

            re.setMsg(CimBaseCodeUtil.getReplyDetail("00004"));

            re.setSuccess(false);

            return re;

        }

        try {

            DocumentHelper.parseText(xml);    //验证是否为标准xml格式的字符串xml

        } catch (DocumentException e) {

            re.setMsg(CimBaseCodeUtil.getReplyDetail("00005"));

            re.setSuccess(false);

            return re;

        }

        return re;

    }

    public static String doPost(CimResult cr) {

        String ss = "";

//        CimResult cr = CimUtil.xml2Object(xml);

        if (cr.isSuccess()) {

            CimHeader header = new CimHeader();

            Object o = cr.getDataObject();

            CimModule cm = new CimModule();

            if (o instanceof CimGridModule) {

                CimGridModule cgm = (CimGridModule) o;

                cm = cgm;

                header.setNoun(cgm.getNounType());

            } else if (o instanceof CimMeterModule) {

                CimMeterModule cmm = (CimMeterModule) o;

                cm = cmm;

                header.setNoun(cmm.getNounType());

            } else if (o instanceof CimEndDeviceModule) {

                CimEndDeviceModule cem = (CimEndDeviceModule) o;

                cm = cem;

                header.setNoun(cem.getNounType());

            } else if (o instanceof CimCustomerModule) {

                CimCustomerModule ccm = (CimCustomerModule) o;

                cm = ccm;

                header.setNoun(ccm.getNounType());

            } else if (o instanceof CimDataLinkageModule) {

                CimDataLinkageModule cdm = (CimDataLinkageModule) o;

                cm = cdm;

                header.setNoun(cdm.getNounType());

            } else if (o instanceof CimServiceRequest) {

                CimServiceRequest csr = (CimServiceRequest) o;

                cm = csr;

                header.setNoun(csr.getNounType());

            }

            CimReplyModule crm = new CimReplyModule();

            crm.setAck(false);

            crm.setCode("00000");

            crm.setDetail("No Error");

            header.setVerb(VerbType.reply);

            header.setSource("MDC");

            header.setRevision("2.0");

            header.setCorrelationID(cm.getCorrelationID());

            CimResult t = CimUtil.Object2xml(crm, header);

            if (t.isSuccess()) {

                ss = t.getXml();

//                ss = CimXmlUtil.formatXML(ss);

                return ss;

            }

        }

        return ss;

    }

    public static String getString(Object s){

        return s == null?"":String.valueOf(s).trim();

    }

    //判空

    public static final boolean isEmptyString(String s) {

        return s == null || s.trim().equals("") || s.equals("null") || s.equals("NULL") || s.trim().equals("undefined");

    }

    public static String formatXML(String inputXML) {

        SAXReader reader = new SAXReader();

        String requestXML = null;

        Document document;

        try {

            document = reader.read(new StringReader(inputXML));

            XMLWriter writer = null;

            if (document != null) {

                try {

                    StringWriter stringWriter = new StringWriter();

                    OutputFormat format = new OutputFormat("      ", true);

                    writer = new XMLWriter(stringWriter, format);

                    try {

                        writer.write(document);

                        writer.flush();

                    } catch (Exception e) {

                        e.printStackTrace();

                    }

                    requestXML = stringWriter.getBuffer().toString();

                } finally {

                    if (writer != null) {

                        try {

                            writer.close();

                        } catch (IOException e) {

                        }

                    }

                }

            }

        } catch (DocumentException e1) {

            e1.printStackTrace();

        }

        return requestXML;

    }

}

工具类代码

　　4、生成xml窗体

　　　　此工具参考价值不大，可学习swing日期控件如何使用，如何获取jar包资源（比如图片路径问题）。

　　　　swing日期控件所需jar包：datepicker.jar

4.1 BuildXMLFrame.java

package generateXML;

import java.awt.Dimension;

import java.awt.Font;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.text.ParseException;

import java.util.Arrays;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTextArea;

import javax.swing.JTextField;

import org.apache.log4j.Logger;

import com.eltima.components.ui.DatePicker;

import cn.sanxing.cim.payload.MeterConfig;

public class BuildXMLFrame extends JFrame implements ActionListener{

    private static final long serialVersionUID = 1L;

    private static Logger logger = Logger.getLogger(BuildXMLFrame.class.getName());

    JFrame mainFrame = new JFrame("Build XML Tool");

    JPanel panel;

    //类型

    JLabel typeLabel;

    JComboBox<String> typeComBox;

    String[] typeString = { "MeterReadings", "EndDeviceEvents", "EndDeviceControls" };

    //场景

    JLabel scenariosLabel;

    JComboBox<String> scenariosComBox;

    String[] scenariosString = { "Billing Data", "Meter Reading", "Instantaneous Data", "LoadProfile1", "LoadProfile2" };

    String[] meterNos = {"Billing Data", "LoadProfile1", "LoadProfile2", "Events"};//只需校验多表的scenarios

    String[] meterNo  = {"Meter Reading", "Instantaneous Data", "Connect/Disconnect"};//只需校验单表+抄读项的scenarios

    List<String> scenariosList = Arrays.asList(meterNos);

    List<String> scenariosList1 = Arrays.asList(meterNo);

    //表号

    JLabel meterNoLable;

    JTextField meterNoTextField;

    JButton addMeterNoButton;

    ImageIcon addMeterNoIcon = new ImageIcon(BuildXMLFrame.class.getClassLoader().getResource("image/add.jpg"));

    //抄读项

    JLabel readingTypeLabel;

    JTextField readingTypeTextField;

    JButton addReadTypeButton;

    ImageIcon addReadTypeIcon = new ImageIcon(BuildXMLFrame.class.getClassLoader().getResource("image/add.jpg"));

    //时间

    JLabel startTimeLabel;

    JLabel endTimeLabel;

    DatePicker startTimeDatePick;//时间控件

    DatePicker endTimeDatePick;

    //生成XML按钮

    JButton generateButton;

    //显示XML

    JTextArea xmlTextArea;

    JScrollPane xmlScroll;

    MyUtil util = new MyUtil();

    MeterConfig meterConfig = new MeterConfig();

    public void showFrame(){

        initPanel(); //初始化Panel

        initFrame(); //初始化Frame

    }

    //初始化窗体

    public void initFrame(){

        mainFrame.setSize(770, 700); //窗体大小

        mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //设置窗体点击关闭按钮，即终止程序

        mainFrame.setResizable(false); //取消窗体的固定大小设置

        Toolkit kit = Toolkit.getDefaultToolkit(); // 工具包

        Dimension screenSize = kit.getScreenSize(); // 屏幕的尺寸

        int screenWidth = screenSize.width / 2; // 屏幕的宽

        int screenHeight = screenSize.height / 2; // 屏幕的高

        int height = mainFrame.getHeight(); // 窗口高度

        int width = mainFrame.getWidth(); // 窗口宽度

        mainFrame.setLocation(screenWidth - width / 2, screenHeight - height / 2); // 将窗口设置到屏幕的中部

        mainFrame.add(panel); //panel加入到窗体中

        mainFrame.setVisible(true); //窗体设置可见

    }

    //初始化面板

    public void initPanel(){

        panel = new JPanel();

        panel.setLayout(null);

        //类型Label

        typeLabel = new JLabel("Type :");

        typeLabel.setBounds(50, 20, 100, 25);

        this.panel.add(typeLabel);

        //类型下拉框

        typeComBox = new JComboBox<String>(typeString);

        typeComBox.setBounds(90, 20, 150, 25);

        this.panel.add(typeComBox);

        //场景Label

        scenariosLabel = new JLabel("Scenarios :");

        scenariosLabel.setBounds(270, 20, 100, 25);

        this.panel.add(scenariosLabel);

        //场景下拉框

        scenariosComBox = new JComboBox<String>(scenariosString);

        scenariosComBox.setBounds(340, 20, 150, 25);

        this.panel.add(scenariosComBox);

        //表号Label

        meterNoLable = new JLabel("Meter No :");

        meterNoLable.setBounds(530, 20, 100, 25);

        this.panel.add(meterNoLable);

        //表号文本框

        meterNoTextField = new JTextField();

        meterNoTextField.setBounds(595, 20, 150, 25);

        this.panel.add(meterNoTextField);

        //添加表号按钮

        addMeterNoButton = new JButton(addMeterNoIcon);

        addMeterNoButton.setBounds(125, 0, 24, 24);

        meterNoTextField.add(addMeterNoButton);

        //开始时间Label

        startTimeLabel = new JLabel("Start Time : ");

        startTimeLabel.setBounds(20, 55, 100, 25);

        this.panel.add(startTimeLabel);

        //开始时间控件

        startTimeDatePick = getDatePicker("startTime");

        this.panel.add(startTimeDatePick);

        //结束时间Label

        endTimeLabel = new JLabel("End Time : ");

        endTimeLabel.setBounds(275, 55, 100, 25);

        this.panel.add(endTimeLabel);

        //结束时间控件

        endTimeDatePick = getDatePicker("endTime");

        this.panel.add(endTimeDatePick);

        //抄读项Label

        readingTypeLabel = new JLabel("ReadingType :");

        readingTypeLabel.setBounds(510, 55, 100, 25);

        this.panel.add(readingTypeLabel);

        //抄读项文本框

        readingTypeTextField = new JTextField();

        readingTypeTextField.setBounds(595, 55, 150, 25);

        this.panel.add(readingTypeTextField);

        //添加抄读项按钮

        addReadTypeButton = new JButton(addReadTypeIcon);

        addReadTypeButton.setBounds(125, 0, 24, 24);

        readingTypeTextField.add(addReadTypeButton);

        //生成XML按钮

        generateButton = new JButton("Generate");

        generateButton.setBounds(645, 95, 100, 25);

        this.panel.add(generateButton);

        //xml文本框

        xmlTextArea = new JTextArea();

        xmlScroll   = new JScrollPane(xmlTextArea); //xmlTextArea添加滚动条

        xmlScroll.setBounds(15, 130, 735, 530);

        this.panel.add(xmlScroll);

        //按钮加入监听

        generateButton.addActionListener(this);

        typeComBox.addActionListener(this);

        addMeterNoButton.addActionListener(this);

        addMeterNoButton.addMouseListener(new MouseAdapter() {

            @Override

            public void mouseEntered(MouseEvent e) {

                addMeterNoButton.setToolTipText("Add meterNo."); // 添加表号按钮的提示

            }

        });

        addReadTypeButton.addActionListener(this);

        addReadTypeButton.addMouseListener(new MouseAdapter() {

            @Override

            public void mouseEntered(MouseEvent e) {

                addReadTypeButton.setToolTipText("Add readingType"); // 添加抄读项按钮的提示

            }

        });

    }

    //时间控件

    public DatePicker getDatePicker(String flag) {

        DatePicker datepick;

        String DefaultFormat = "yyyy-MM-dd HH:mm:ss"; // 格式

        Date date = new Date(); // 当前时间

        Font font = new Font("Times New Roman", Font.BOLD, 14); // 字体

        Dimension dimension = new Dimension(150, 24); //控件宽、高

//        int[] hilightDays = { 1, 3, 5, 7 };

//        int[] disabledDays = { 4, 6, 5, 9 };

        // 构造方法（初始时间，时间显示格式，字体，控件大小）

        datepick = new DatePicker(date, DefaultFormat, font, dimension);

        if("startTime".equals(flag)){

            datepick.setLocation(90, 55);

        }

        if("endTime".equals(flag)){

            datepick.setLocation(340, 55);

        }

//        datepick.setBounds(137, 15, 177, 24); // setBounds()直接设置大小与位置

//        datepick.setHightlightdays(hilightDays, Color.red); // 设置一个月份中需要高亮显示的日子

//        datepick.setDisableddays(disabledDays); // 设置一个月份中不需要的日子，呈灰色显示

        datepick.setLocale(Locale.US); // 设置国家

        datepick.setTimePanleVisible(true); // 设置时、分、秒面板可见

        return datepick;

    }

    //click触发按钮事件

    @Override

    public void actionPerformed(ActionEvent e) {

        // type级联scenarios

        if (e.getSource() == typeComBox) {

            cascade();

        }

        // 添加表号

        if (e.getSource() == addMeterNoButton) {

            addMeterNo();

        }

        // 添加抄读项

        if (e.getSource() == addReadTypeButton) {

            addReadType();

        }

        // 生成XML

        if (e.getSource() == generateButton) {

            if (verifyData()) { // 数据校验

                showXML(); // 生成XML

            }

        }

    }

    //级联

    public void cascade() {

        String typeSelected = util.getString(typeComBox.getSelectedItem());

        if ("MeterReadings".equals(typeSelected)) {

            scenariosComBox.removeAllItems();

            for (String scenarios : scenariosString) {

                scenariosComBox.addItem(scenarios);

            }

        }

        if ("EndDeviceEvents".equals(typeSelected)) {

            scenariosComBox.removeAllItems();

            scenariosComBox.addItem("Events");

        }

        if ("EndDeviceControls".equals(typeSelected)) {

            scenariosComBox.removeAllItems();

            scenariosComBox.addItem("Connect/Disconnect");

        }

    }

    //添加表号

    public void addMeterNo() {

        String showInput = JOptionPane.showInputDialog(this.panel, "Add meter No.", "Tips", 3);

        if (!util.isEmptyString(showInput)) {

            if (!showInput.matches("[0-9]+")) {

                JOptionPane.showMessageDialog(this.panel, "The input must be a number.", "Tips", 2);// 表号错误

                return;

            }

            if (util.isEmptyString(meterNoTextField.getText())) {

                meterNoTextField.setText(showInput);

            } else {

                meterNoTextField.setText(meterNoTextField.getText() + "," + showInput);

            }

        }

    }

    //添加抄读项

    public void addReadType() {

        String showInput = JOptionPane.showInputDialog(this.panel, "Add readingType", "Tips", 3);

        if (!util.isEmptyString(showInput)) {

            //抄读项校验

            if (!showInput.matches("[0-9A-Z]+")) {

                JOptionPane.showMessageDialog(this.panel, "The input must be a number or letter.", "Tips", 2);// 抄读项错误

                return;

            }

            //赋值

            if (util.isEmptyString(readingTypeTextField.getText())) {

                readingTypeTextField.setText(showInput);

            } else {

                readingTypeTextField.setText(readingTypeTextField.getText() + "," + showInput);

            }

        }

    }

    //数据校验

    public boolean verifyData(){

        String typeSelected = util.getString(typeComBox.getSelectedItem());

        String scenariosSelected = util.getString(scenariosComBox.getSelectedItem());

        String meterNoText = util.getString(meterNoTextField.getText());

        String readTypeText = util.getString(readingTypeTextField.getText());

        Map<String, String> map = new HashMap<String, String>();

        map.put("type", typeSelected);

        map.put("scenarios", scenariosSelected);

        map.put("meterNo", meterNoText);

        map.put("readType", readTypeText);

        //MeterNo校验

        if(meterNoisEmpty(meterNoText)){

            return false;

        }

        //type

        switch (typeSelected) {

        case "MeterReadings":

            return MeterReadings(map);

        case "EndDeviceEvents":

            return EndDeviceEvents(map);

        case "EndDeviceControls":

            return EndDeviceControls(map);

        default:

            return true;

        }

    }

    public boolean MeterReadings(Map<String, String> map){

        String scenarios = map.get("scenarios");

        if (scenariosList.contains(scenarios)) {

            // 多表表号，需以逗号隔开

            return meterNosFormat(map.get("meterNo"));

        }

        if (scenariosList1.contains(scenarios)) {

            // 单表表号校验

            if(!meterNoFormat(map.get("meterNo"))){

                return false;

            }

            // readType校验

            return readTypeisEmpty(map.get("readType"));

        }

        return true;

    }

    public boolean EndDeviceEvents(Map<String, String> map) {

        String scenarios = map.get("scenarios");

        if (scenariosList.contains(scenarios)) {

            // 多表表号，需以逗号隔开

            return meterNosFormat(map.get("meterNo"));

        }

        return true;

    }

    public boolean EndDeviceControls(Map<String, String> map) {

        String scenarios = map.get("scenarios");

        if (scenariosList1.contains(scenarios)) {

            // 单表表号校验

            if (!meterNoFormat(map.get("meterNo"))) {

                return false;

            }

            // readType校验

            return readTypeisEmpty(map.get("readType"));

        }

        return true;

    }

    //表号为空

    public boolean meterNoisEmpty(String meterNo){

        if(util.isEmptyString(meterNo)){

            JOptionPane.showMessageDialog(this.panel, "MeterNo is empty!", "Tips", 2);// MeterNo为空，warning

            return true;

        }

        return false;

    }

    //单表表号格式校验

    public boolean meterNoFormat(String meterNo){

        if (!meterNo.matches("^\\d+$")) {

            JOptionPane.showMessageDialog(this.panel, "The format of the meterNo number must be a number!", "Tips", 2);// 表号必须数字格式，warning

            return false;

        }

        return true;

    }

    //多表表号格式校验

    public boolean meterNosFormat(String meterNo){

        if (!meterNo.matches("^\\d+($|,\\d+$)")) {

            JOptionPane.showMessageDialog(this.panel, "Multiple meterNos must be comma separated!", "Tips", 2);// 多表表号必须是数字格式且逗号分隔，warning

            return false;

        }

        return true;

    }

    //readType为空

    public boolean readTypeisEmpty(String readType){

        if (util.isEmptyString(readType)) {

            JOptionPane.showMessageDialog(this.panel, "ReadingType is empty!", "Tips", 2);// ReadingType为空，warning

            return false;

        }

        return true;

    }

    //生成XML

    public void showXML(){

        Map<String, String> map = new HashMap<String, String>();

        String type = util.getString(typeComBox.getSelectedItem());

        String scenarios = util.getString(scenariosComBox.getSelectedItem());

        String startTime = null;

        String endTime = null;

        String meterNo = util.getString(meterNoTextField.getText());

        String readingType = util.getString(readingTypeTextField.getText());

        try {

            startTime = util.sdfCim.format(util.sdfJava.parse(startTimeDatePick.getText().trim()));

            endTime = util.sdfCim.format(util.sdfJava.parse(endTimeDatePick.getText().trim()));

        } catch (ParseException e) {

            logger.error(e);

        }

        map.put("type", type);

        map.put("scenarios", scenarios);

        map.put("meterNo", meterNo);

        map.put("startTime", startTime);

        map.put("endTime", endTime);

        map.put("readType", readingType);

        String xml = util.createRequest(map);

        xmlTextArea.setText(xml);

    }

    public static void main(String[] args) {

        Locale.setDefault(Locale.ENGLISH);//设置控件为英文

        BuildXMLFrame xmlFrame = new BuildXMLFrame();

        xmlFrame.showFrame();

    }

}

生成xml的窗体代码

4.2 MyUtil.java

package generateXML;

import java.io.IOException;

import java.io.StringReader;

import java.io.StringWriter;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Map;

import java.util.UUID;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.DocumentHelper;

import org.dom4j.Element;

import org.dom4j.io.OutputFormat;

import org.dom4j.io.SAXReader;

import org.dom4j.io.XMLWriter;

import cn.sanxing.cim.cis.CimHeader;

import cn.sanxing.cim.util.CimResult;

public class MyUtil {

    public  String CIMDATE_FORMAT = "yyyy-MM-dd'T'HH:mm:ss'.0Z'";

    public  String JAVADATE_FORMAT = "yyyy-MM-dd HH:mm:ss";

    public  SimpleDateFormat sdfCim = new SimpleDateFormat(CIMDATE_FORMAT);

    public  SimpleDateFormat sdfJava = new SimpleDateFormat(JAVADATE_FORMAT);

    public static String XML_PRIFIX = "m:";

    public String createRequest(Map<String, String> map) {

        Document doc = DocumentHelper.createDocument();

        Element request = addRequestRoot(doc);

        Element headerElement = request.addElement("Header");

        Element payLoadElement = request.addElement("Payload");

        createHeader(headerElement, map);

        createPayLoad(payLoadElement, map);

        String xml = formatXML(doc.asXML());

        return xml;

    }

    public Element addRequestRoot(Document doc) {

        Element request = doc.addElement("RequestMessage");

        request.addNamespace("m", "http://iec.ch/TC57/2011/schema/message");

        request.addNamespace("ns", "http://iec.ch/TC57/2011/schema/message");

        request.addNamespace("xsi", "http://www.w3.org/2001/XMLSchema-instance");

        request.addAttribute("xsi:schemaLocation", "http://iec.ch/TC57/2011/schema/message Message.xsd");

        return request;

    }

    public void createHeader(Element headerElement, Map<String, String> map){

        String randomID = UUID.randomUUID().toString().toUpperCase();

        String type = map.get("type");

        String scenarios = map.get("scenarios");

        Element verbElement = headerElement.addElement("Verb");

        Element nounElement = headerElement.addElement("Noun");

        Element revisionElement = headerElement.addElement("Revision");

        Element timestampElement = headerElement.addElement("Timestamp");

        Element sourceElement = headerElement.addElement("Source");

        Element ackRequiredElement = headerElement.addElement("AckRequired");

        Element asyncReplyFlagElement = headerElement.addElement("AsyncReplyFlag");

        Element messageIDElement = headerElement.addElement("MessageID");

        Element correlationIDElement = headerElement.addElement("CorrelationID");

        if("Billing Data".equals(scenarios)){

            Element comment = headerElement.addElement("Comment");

            comment.setText("This is test billing");

        }

        //赋值

        if("EndDeviceControls".equals(type)){

            verbElement.setText("create");

        }else{

            verbElement.setText("get");

        }

        nounElement.setText(type);

        revisionElement.setText("2.0");

        timestampElement.setText(sdfCim.format(new Date()));

        sourceElement.setText("MDM");

        ackRequiredElement.setText("false");

        asyncReplyFlagElement.setText("false");

        messageIDElement.setText(randomID);

        correlationIDElement.setText(randomID);

    }

    public void createPayLoad(Element payLoadElement, Map<String, String> map) {

        String type = map.get("type");

        if(type.equals("MeterReadings")){

            MeterReadings(payLoadElement, map);

        }

        if(type.equals("EndDeviceEvents")){

            EndDeviceEvents(payLoadElement, map);

        }

        if(type.equals("EndDeviceControls")){

            EndDeviceControls(payLoadElement, map);

        }

    }

    //PayLoad-MeterReadings

    public void MeterReadings(Element payLoadElement, Map<String, String> map){

        String scenarios = map.get("scenarios");

        if ("Billing Data".equals(scenarios) || "LoadProfile1".equals(scenarios)

                || "LoadProfile2".equals(scenarios)){

            Element MeterReadings = payLoadElement.addElement("m:MeterReadings");

            Element readingType = MeterReadings.addElement("m:ReadingType");

            Element names = readingType.addElement("m:Names");

            Element name = names.addElement("m:name");

            Element nameType = names.addElement("m:NameType");

            Element name1 = nameType.addElement("m:name");

            if(scenarios.equals("LoadProfile1") || scenarios.equals("LoadProfile2")){

                name.setText(scenarios);

                name1.setText("LoadProfileType");

            }

            if(scenarios.equals("Billing Data")){

                name.setText("MonthlyBilling");

                name1.setText("BillingType");

            }

            String meterNos = map.get("meterNo");

            //多表，循环生成

            if(meterNos.indexOf(",") != -1){

                String[] meterNo = meterNos.split(",");

                for(String meter : meterNo){

                    map.put("meterNo", meter);

                    createMeterNoElements(MeterReadings, map);

                }

            }else{

                createMeterNoElements(MeterReadings, map);

            }

        }

        if("Meter Reading".equals(scenarios) || "Instantaneous Data".equals(scenarios)){

            Element meterReadings = payLoadElement.addElement("m:MeterReadings");

            Element meterReading = meterReadings.addElement("m:MeterReading");

            Element meter = meterReading.addElement("m:Meter");

            Element mRID = meter.addElement("m:mRID");

            mRID.setText(map.get("meterNo"));

            //多个readingType抄读项

            String readType = map.get("readType");

            if(readType.indexOf(",") != -1){

                String[] readTypes = readType.split(",");

                for(String read : readTypes){

                    map.put("readType", read);

                    createReadTypeElements(meterReading, map);

                }

            }else{

                createReadTypeElements(meterReading, map);

            }

        }

    }

    //PayLoad-EndDeviceEvents

    public void EndDeviceEvents(Element payLoadElement, Map<String, String> map) {

        Element endDeviceEvents = payLoadElement.addElement("m:EndDeviceEvents");

        String meterNos = map.get("meterNo");

        // 多表

        if (meterNos.indexOf(",") != -1) {

            String[] meterNo = meterNos.split(",");

            for (String No : meterNo) {

                map.put("meterNo", No);

                createElements(endDeviceEvents, map);

            }

        } else {

            createElements(endDeviceEvents, map);

        }

        Element timeSchedule = endDeviceEvents.addElement("m:TimeSchedule");

        Element scheduleInterval = timeSchedule.addElement("m:scheduleInterval");

        Element end = scheduleInterval.addElement("m:end");

        Element start = scheduleInterval.addElement("m:start");

        end.setText(map.get("endTime"));

        start.setText(map.get("startTime"));

    }

    //PayLoad-EndDeviceEvents

    public void EndDeviceControls(Element payLoadElement, Map<String, String> map) {

        Element endDeviceControls = payLoadElement.addElement("m:EndDeviceControls");

        Element endDeviceControl = endDeviceControls.addElement("m:EndDeviceControl");

        Element endDevices = endDeviceControl.addElement("m:EndDevices");

        Element mRID = endDevices.addElement("m:mRID");

        Element endDeviceControlType = endDeviceControl.addElement("m:EndDeviceControlType");

        mRID.setText(map.get("meterNo"));

        endDeviceControlType.addAttribute("ref", map.get("readType"));

    }

    //多表

    public void createMeterNoElements(Element meterReadings, Map<String, String> map){

        Element meterReading = meterReadings.addElement("m:MeterReading");

        Element meter = meterReading.addElement("m:Meter");

        Element mRID = meter.addElement("m:mRID");

        Element readings = meterReading.addElement("m:Readings");

        Element timePeriod = readings.addElement("m:timePeriod");

        Element end = timePeriod.addElement("m:end");

        Element start = timePeriod.addElement("m:start");

        mRID.setText(map.get("meterNo"));

        end.setText(map.get("endTime"));

        start.setText(map.get("startTime"));

    }

    //多表

    public void createElements(Element endDeviceEvents, Map<String, String> map) {

        Element meter = endDeviceEvents.addElement("m:Meter");

        Element mRID = meter.addElement("m:mRID");

        mRID.setText(map.get("meterNo"));

    }

    //多个readingType

    public void createReadTypeElements(Element meterReading, Map<String, String> map) {

        Element readings = meterReading.addElement("m:Readings");

        Element reason = readings.addElement("m:reason");

        Element readingType = readings.addElement("m:ReadingType");

        if("Instantaneous Data".equals(map.get("scenarios"))){

            reason.setText("reading");

        }

        if("Meter Reading".equals(map.get("scenarios"))){

            reason.setText("MeterReading");

        }

        readingType.addAttribute("ref", map.get("readType"));

    }

    public CimResult Object2xml(Object obj, CimHeader header) {

        CimResult re = new CimResult(false);

        if (!re.isSuccess()) {

            return re;

        }

        try {

            Class<?> c = Class.forName(obj.getClass().getName());

            Method setRunArgsMethod = c.getMethod("handler",

                    new Class[] { CimHeader.class });

            re = (CimResult) setRunArgsMethod.invoke(obj,

                    new Object[] { header });

        } catch (SecurityException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (IllegalArgumentException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (NoSuchMethodException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (ClassNotFoundException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (IllegalAccessException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (InvocationTargetException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        return re;

    }

    //字符串XML格式化

    public String formatXML(String inputXML) {

        SAXReader reader = new SAXReader();

        String requestXML = null;

        Document document;

        try {

            document = reader.read(new StringReader(inputXML));

            XMLWriter writer = null;

            if (document != null) {

                try {

                    StringWriter stringWriter = new StringWriter();

                    OutputFormat format = new OutputFormat("        ", true);

                    writer = new XMLWriter(stringWriter, format);

                    try {

                        writer.write(document);

                        writer.flush();

                    } catch (Exception e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                    }

                    requestXML = stringWriter.getBuffer().toString();

                } finally {

                    if (writer != null) {

                        try {

                            writer.close();

                        } catch (IOException e) {

                        }

                    }

                }

            }

        } catch (DocumentException e1) {

            // TODO Auto-generated catch block

            e1.printStackTrace();

        }

        return requestXML;

    }

    //判空

    public final boolean isEmptyString(String s) {

        return s == null || s.trim().equals("") || s.equals("null") || s.equals("NULL") || s.trim().equals("undefined");

    }

    public String getString(Object s){

        return s == null?"":String.valueOf(s).trim();

    }

}

工具类代码

相关文章