connectionproperties.java

eq跨平台查询工具源码 eq跨平台查询工具源码

    static class XMLConnectionHandler extends DefaultHandler {

        private CharArrayWriter contents;
        private DatabaseConnection dc;
        private Properties advancedProps;
        
        public XMLConnectionHandler() {
            if (connections == null) {
                connections = new Vector<DatabaseConnection>();
            }
            contents = new CharArrayWriter();
        }

        public void startElement(String nameSpaceURI, String localName,
                                 String qName, Attributes attrs) {
            contents.reset();
            
            if (localName.equals(CONNECTION)) {
                dc = new DatabaseConnection();
                String value = attrs.getValue(STORE_PASSWORD);
                if (!MiscUtils.isNull(value)) {
                    dc.setPasswordStored(Boolean.valueOf(value).booleanValue());
                }
            }
            else if (localName.equals(PASSWORD)) {
                String value = attrs.getValue(ENCRYPTED);
                if (!MiscUtils.isNull(value)) {
                    dc.setPasswordEncrypted(Boolean.valueOf(value).booleanValue());
                }
            }
            else if (localName.equals(PROPERTY)) {
                if (advancedProps == null) {
                    advancedProps = new Properties();
                }
                advancedProps.setProperty(attrs.getValue(KEY), attrs.getValue(VALUE));
            }
            
        }
        
        public void endElement(String nameSpaceURI, String localName,
                               String qName) {

            if (localName.equals(NAME)) {
                dc.setName(contents.toString());
            } 
            else if (localName.equals(USER)) {
                dc.setUserName(contents.toString());
            } 
            else if (localName.equals(PASSWORD)) {
                String value = contents.toString();
                if (!MiscUtils.isNull(value)) {
                    if (dc.isPasswordEncrypted()) {
                        dc.setEncryptedPassword(value);
                    } else {
                        dc.setPassword(value);
                    }
                    dc.setPasswordStored(true);
                } else {
                    dc.setPasswordStored(false);
                }
            } 
            else if (localName.equals(HOST)) {
                dc.setHost(contents.toString());
            } 
            else if (localName.equals(DATA_SOURCE)) {
                dc.setSourceName(contents.toString());
            } 
            else if (localName.equals(PORT)) {
                dc.setPort(contents.toString());
            } 
            else if (localName.equals(URL)) {
                dc.setURL(contents.toString());
            } 
            else if (localName.equals(DRIVER_ID)) {
                dc.setDriverId(Long.parseLong(contents.toString()));
            }
            else if (localName.equals(DRIVER_NAME)) {
                dc.setDriverName(contents.toString());
            }
            else if (localName.equals(AUTO_COMMIT)) {
                String value = contents.toString();
                if (!MiscUtils.isNull(value)) {
                    dc.setAutoCommit(Boolean.valueOf(value));
                }
            }
            else if (localName.equals(TX_ISOLATION)) {
                String value = contents.toString();
                if (!MiscUtils.isNull(value)) {
                    dc.setTransactionIsolation(new Integer(value));
                } else {
                    dc.setTransactionIsolation(-1);
                }
            }
            else if (localName.equals(ADVANCED)) {
                if (advancedProps != null && advancedProps.size() > 0) {
                    dc.setJdbcProperties(advancedProps);
                }
            } 
            else if (localName.equals(CONNECTION)) {
                connections.add(dc);
                advancedProps = null;
                dc = null;
            }

        }
        
        public void characters(char[] data, int start, int length) {
            contents.write(data, start, length);
        }
        
        public void ignorableWhitespace(char[] data, int start, int length) {
            characters(data, start, length);
        }
        
        public void error(SAXParseException spe) throws SAXException {
            throw new SAXException(spe.getMessage());
        }
    } // XMLHandler
    
    static class ConnectionInputSource extends InputSource {
        private DatabaseConnection[] dca;
        
        public ConnectionInputSource(DatabaseConnection[] dc) {
            dca = dc;
        }
        
        public DatabaseConnection[] getConnections() {
            return dca;
        }
        
    } // class ConnectionInputSource
    
    static class ConnectionParser implements XMLReader {
        private String nsu = Constants.EMPTY;
        private AttributesImpl atts = new AttributesImpl();
        
        private ContentHandler handler;
        
        private static char[] newLine = {'\n'};
        private static String indent_1 = "\n   ";
        private static String indent_2 = "\n      ";
        private static String indent_3 = "\n         ";
        
        public ConnectionParser() {}
        
        public void parse(InputSource input) throws SAXException, IOException {
            if (!(input instanceof ConnectionInputSource)) {
                throw new SAXException("Parser can only accept a ConnectionInputSource");
            }
            
            parse((ConnectionInputSource)input);
        }
        
        public void parse(ConnectionInputSource input) throws IOException, SAXException {
            try {
                if (handler == null) {
                    throw new SAXException("No content handler");
                }
                
                DatabaseConnection[] conns = input.getConnections();
                
                handler.startDocument();
                handler.startElement(nsu, SAVED_CONNECTIONS, SAVED_CONNECTIONS, atts);
                handler.ignorableWhitespace(newLine, 0, 1);
                
                String marker = null;
                Properties advProps = null;
                
                for (int i = 0; i < conns.length; i++) {
                    DatabaseConnection conn = conns[i];
                    handler.ignorableWhitespace(indent_1.toCharArray(), 0, indent_1.length());
                    
                    atts.addAttribute(nsu, STORE_PASSWORD, STORE_PASSWORD, CDDATA,
                                            Boolean.toString(conns[i].isPasswordStored()));
                    
                    handler.startElement(nsu, CONNECTION, CONNECTION, atts);
                    atts.removeAttribute(atts.getIndex(STORE_PASSWORD));
                    
                    writeXML(NAME, conn.getName(), indent_2);
                    writeXML(USER, conn.getUserName(), indent_2);

                    atts.addAttribute(nsu, ENCRYPTED, ENCRYPTED, CDDATA,
                                      Boolean.toString(conn.isPasswordEncrypted()));

                    if (conn.isPasswordStored()) {
                        writeXML(PASSWORD, conn.getPassword(), indent_2);
                    } else {
                        writeXML(PASSWORD, Constants.EMPTY, indent_2);
                    }
                    atts.removeAttribute(atts.getIndex(ENCRYPTED));
                    
                    writeXML(HOST, conn.getHost(), indent_2);
                    writeXML(DATA_SOURCE, conn.getSourceName(), indent_2);
                    writeXML(PORT, conn.getPort(), indent_2);
                    writeXML(URL, conn.getURL(), indent_2);
                    // TODO: remove driver name from save
                    writeXML(DRIVER_NAME, conn.getDriverName(), indent_2);
                    
                    writeXML(DRIVER_ID, Long.toString(conn.getDriverId()), indent_2);
                    
                    writeXML(AUTO_COMMIT, 
                            Boolean.toString(conn.isAutoCommit()), indent_2);
                    writeXML(TX_ISOLATION, 
                            Integer.toString(conn.getTransactionIsolation()), indent_2);
                    
                    if (conn.hasAdvancedProperties()) {
                        handler.ignorableWhitespace(indent_2.toCharArray(), 0, indent_2.length());
                        handler.startElement(nsu, ADVANCED, ADVANCED, atts);
                        
                        advProps = conn.getJdbcProperties();
                        
                        for (Enumeration j = advProps.propertyNames(); 
                               j.hasMoreElements();) {
                            marker = (String)j.nextElement();
                            atts.addAttribute(Constants.EMPTY, KEY, KEY, CDDATA, marker);
                            atts.addAttribute(Constants.EMPTY, VALUE, VALUE, CDDATA,
                            advProps.getProperty(marker));
                            writeXML(PROPERTY, null, indent_3);
                            atts.removeAttribute(atts.getIndex(KEY));
                            atts.removeAttribute(atts.getIndex(VALUE));
                        } 
                        
                        handler.ignorableWhitespace(indent_2.toCharArray(), 0, indent_2.length());
                        handler.endElement(nsu, ADVANCED, ADVANCED);
                    } else {
                        writeXML(ADVANCED, null, indent_2);
                    }
                    
                    handler.ignorableWhitespace(indent_1.toCharArray(), 0, indent_1.length());
                    handler.endElement(nsu, CONNECTION, CONNECTION);
                    handler.ignorableWhitespace(newLine, 0, 1);
                    
                    //conn.setNewConnection(false);
                    marker = null;
                } 
                
                handler.ignorableWhitespace(newLine, 0, 1);
                handler.endElement(nsu, SAVED_CONNECTIONS, SAVED_CONNECTIONS);
                handler.endDocument();
                
            } catch (Exception e) {
                e.printStackTrace();
            } 
        }
        
        private void writeXML(String name, String line, String space) throws SAXException {
            if (line == null) {
                line = Constants.EMPTY;
            }
            
            int textLength = line.length();
            handler.ignorableWhitespace(space.toCharArray(), 0, space.length());
            handler.startElement(nsu, name, name, atts);
            handler.characters(line.toCharArray(), 0, textLength);
            handler.endElement(nsu, name, name);
        }
        
        public void setContentHandler(ContentHandler handler) {
            this.handler = handler;
        }
        
        public ContentHandler getContentHandler() {
            return this.handler;
        }
        
        public void setErrorHandler(ErrorHandler handler) {}
        
        public ErrorHandler getErrorHandler() {
            return null;
        }
        
        public void parse(String systemId) throws IOException, SAXException {
        }
        
        public DTDHandler getDTDHandler() {
            return null;
        }
        
        public EntityResolver getEntityResolver() {
            return null;
        }
        
        public void setEntityResolver(EntityResolver resolver) {}
        
        public void setDTDHandler(DTDHandler handler) {}
        
        public Object getProperty(String name) {
            return null;
        }
        
        public void setProperty(String name, java.lang.Object value) {}
        
        public void setFeature(String name, boolean value) {}
        
        public boolean getFeature(String name) {
            return false;
        }
    } // class ConnectionParser
    
}