/** * Factory method, equivalent to a "fromXML" for step creation. Looks for a class with the same * name as the XML tag, with the first letter capitalized. For example, <call /> is * abbot.script.Call. */ public static Step createStep(Resolver resolver, Element el) throws InvalidScriptException { String tag = el.getName(); Map attributes = createAttributeMap(el); String name = tag.substring(0, 1).toUpperCase() + tag.substring(1); if (tag.equals(TAG_WAIT)) { attributes.put(TAG_WAIT, "true"); name = "Assert"; } try { name = "abbot.script." + name; Log.debug("Instantiating " + name); Class cls = Class.forName(name); try { // Steps with contents require access to the XML element Class[] argTypes = new Class[] {Resolver.class, Element.class, Map.class}; Constructor ctor = cls.getConstructor(argTypes); return (Step) ctor.newInstance(new Object[] {resolver, el, attributes}); } catch (NoSuchMethodException nsm) { // All steps must support this ctor Class[] argTypes = new Class[] {Resolver.class, Map.class}; Constructor ctor = cls.getConstructor(argTypes); return (Step) ctor.newInstance(new Object[] {resolver, attributes}); } } catch (ClassNotFoundException cnf) { String msg = Strings.get("step.unknown_tag", new Object[] {tag}); throw new InvalidScriptException(msg); } catch (InvocationTargetException ite) { Log.warn(ite); throw new InvalidScriptException(ite.getTargetException().getMessage()); } catch (Exception exc) { Log.warn(exc); throw new InvalidScriptException(exc.getMessage()); } }
// ------------------------------------------------------------------------------------------------ // 描述: // 设计: Skyline(2001.12.29) // 实现: Skyline // 修改: // ------------------------------------------------------------------------------------------------ public JFunctionStub getFunctionByID(String ID, Object OwnerObject) { IFunction IF = null; JFunctionStub FS = null; String FT; try { for (int i = 0; i < FunctionList.size(); i++) { FS = (JFunctionStub) FunctionList.get(i); // System.out.println(FS.FunctionID); FT = FS.FunctionID + "_"; if (FS.FunctionID.equals(ID) || FT.equals(ID)) { if (FS.Function == null) { FS.FunctionClass = Class.forName(FS.ClassName); FS.Function = (IFunction) FS.FunctionClass.newInstance(); FS.Function.InitFunction(FS); } /* else { // modify by liukun 找到了就直接返回吧 20100715 return FS; } */ // if (OwnerObject != null && OwnerObject instanceof Hashtable) { Hashtable OTable = (Hashtable) OwnerObject; JFunctionStub fs = (JFunctionStub) OTable.get(ID); if (fs == null) { fs = new JFunctionStub(); fs.ClassName = FS.ClassName; fs.FunctionClass = FS.FunctionClass; fs.FunctionID = FS.FunctionID; OTable.put(ID, fs); } if (fs.Function == null) { fs.FunctionClass = Class.forName(FS.ClassName); fs.Function = (IFunction) FS.FunctionClass.newInstance(); fs.Function.InitFunction(FS); } FS = fs; } else { /** * 如果不在用户列表中则需要重新初始化函数 不能直接用系统缓存因为系统缓存只在登录时初始 这样对于像BB类函数,缓冲坐标的行为就可能会出错(中间修改过行列) modified * by hufeng 2007.11.20 */ FS.Function = (IFunction) FS.FunctionClass.newInstance(); FS.Function.InitFunction(FS); } return FS; } } } catch (Exception e) { e.printStackTrace(); } return null; }
private /*synchronized*/ StructureType assignStructureType(String structType) throws VisualizerLoadException { if (debug) System.out.println("In assignStructureType with " + structType); // Handle objects whose constructors require args separately if ((structType.toUpperCase().compareTo("BAR") == 0) || (structType.toUpperCase().compareTo("SCAT") == 0)) return (new BarScat(structType.toUpperCase())); else if ((structType.toUpperCase().compareTo("GRAPH") == 0) || (structType.toUpperCase().compareTo("NETWORK") == 0)) return (new Graph_Network(structType.toUpperCase())); else { // Constructor for object does not require args try { return ((StructureType) ((Class.forName(insure_text_case_correct_for_legacy_scripts(structType))) .newInstance())); } catch (InstantiationException e) { System.out.println(e); throw (new VisualizerLoadException(structType + " is invalid structure type")); } catch (IllegalAccessException e) { System.out.println(e); throw (new VisualizerLoadException(structType + " is invalid structure type")); } catch (ClassNotFoundException e) { System.out.println(e); throw (new VisualizerLoadException(structType + " is invalid structure type")); } } }
/** * This creates an empty <code>Document</code> object based on a specific parser implementation. * * @return <code>Document</code> - created DOM Document. * @throws JDOMException when errors occur. */ public Document createDocument() throws JDOMException { try { return (Document) Class.forName("org.apache.xerces.dom.DocumentImpl").newInstance(); } catch (Exception e) { throw new JDOMException( e.getClass().getName() + ": " + e.getMessage() + " when creating document", e); } }
/** * Look up an appropriate ComponentTester given an arbitrary Component-derived class. If the class * is derived from abbot.tester.ComponentTester, instantiate one; if it is derived from * java.awt.Component, return a matching Tester. Otherwise return abbot.tester.ComponentTester. * * <p> * * @throws ClassNotFoundException If the given class can't be found. * @throws IllegalArgumentException If the tester cannot be instantiated. */ protected ComponentTester resolveTester(String className) throws ClassNotFoundException { Class testedClass = resolveClass(className); if (Component.class.isAssignableFrom(testedClass)) return ComponentTester.getTester(testedClass); else if (ComponentTester.class.isAssignableFrom(testedClass)) { try { return (ComponentTester) testedClass.newInstance(); } catch (Exception e) { String msg = "Custom ComponentTesters must provide " + "an accessible no-args Constructor: " + e.getMessage(); throw new IllegalArgumentException(msg); } } String msg = "The given class '" + className + "' is neither a Component nor a ComponentTester"; throw new IllegalArgumentException(msg); }
/** * This creates a new <code>{@link Document}</code> from an existing <code>InputStream</code> by * letting a DOM parser handle parsing using the supplied stream. * * @param in <code>InputStream</code> to parse. * @param validate <code>boolean</code> to indicate if validation should occur. * @return <code>Document</code> - instance ready for use. * @throws IOException when I/O error occurs. * @throws JDOMException when errors occur in parsing. */ public Document getDocument(InputStream in, boolean validate) throws IOException, JDOMException { try { // Load the parser class Class parserClass = Class.forName("org.apache.xerces.parsers.DOMParser"); Object parser = parserClass.newInstance(); // Set validation Method setFeature = parserClass.getMethod("setFeature", new Class[] {java.lang.String.class, boolean.class}); setFeature.invoke( parser, new Object[] {"http://xml.org/sax/features/validation", new Boolean(validate)}); // Set namespaces true setFeature.invoke( parser, new Object[] {"http://xml.org/sax/features/namespaces", new Boolean(true)}); // Set the error handler if (validate) { Method setErrorHandler = parserClass.getMethod("setErrorHandler", new Class[] {ErrorHandler.class}); setErrorHandler.invoke(parser, new Object[] {new BuilderErrorHandler()}); } // Parse the document Method parse = parserClass.getMethod("parse", new Class[] {org.xml.sax.InputSource.class}); parse.invoke(parser, new Object[] {new InputSource(in)}); // Get the Document object Method getDocument = parserClass.getMethod("getDocument", null); Document doc = (Document) getDocument.invoke(parser, null); return doc; } catch (InvocationTargetException e) { Throwable targetException = e.getTargetException(); if (targetException instanceof org.xml.sax.SAXParseException) { SAXParseException parseException = (SAXParseException) targetException; throw new JDOMException( "Error on line " + parseException.getLineNumber() + " of XML document: " + parseException.getMessage(), e); } else if (targetException instanceof IOException) { IOException ioException = (IOException) targetException; throw ioException; } else { throw new JDOMException(targetException.getMessage(), e); } } catch (Exception e) { throw new JDOMException(e.getClass().getName() + ": " + e.getMessage(), e); } }
public DBConnection(String type) { if (type.equals("mysql")) { try { String userName = ""; String password = ""; String url = ""; Class.forName("com.mysql.jdbc.Driver").newInstance(); mysqlCon = DriverManager.getConnection(url, userName, password); System.out.println("Database connection established"); if (!mysqlCon.isClosed()) System.out.println("Successfully connected to " + "MySQL server using TCP/IP..."); } catch (Exception e) { System.err.println("Exception: " + e.getMessage()); } } else if (type.equals("postgre")) { } }
/** * Creates a SAX XMLReader. * * @return <code>XMLReader</code> a SAX2 parser. * @throws Exception if no parser can be created. */ protected XMLReader createParser() throws Exception { XMLReader parser = null; // Try using JAXP... // Note we need JAXP 1.1, and if JAXP 1.0 is all that's // available then the getXMLReader call fails and we skip // to the hard coded default parser try { Class factoryClass = Class.forName("javax.xml.parsers.SAXParserFactory"); // MODIFIED: Added (Class[]) and (Object[]) cast sentences in "null" parameters // to avoid warnings during compilation // factory = SAXParserFactory.newInstance(); Method newParserInstance = factoryClass.getMethod("newInstance", (Class[]) null); Object factory = newParserInstance.invoke(null, (Object[]) null); // jaxpParser = factory.newSAXParser(); Method newSAXParser = factoryClass.getMethod("newSAXParser", (Class[]) null); Object jaxpParser = newSAXParser.invoke(factory, (Object[]) null); // parser = jaxpParser.getXMLReader(); Class parserClass = jaxpParser.getClass(); Method getXMLReader = parserClass.getMethod("getXMLReader", (Class[]) null); parser = (XMLReader) getXMLReader.invoke(jaxpParser, (Object[]) null); } catch (ClassNotFoundException e) { // e.printStackTrace(); } catch (InvocationTargetException e) { // e.printStackTrace(); } catch (NoSuchMethodException e) { // e.printStackTrace(); } catch (IllegalAccessException e) { // e.printStackTrace(); } // Check to see if we got a parser yet, if not, try to use a // hard coded default if (parser == null) { parser = XMLReaderFactory.createXMLReader("org.apache.xerces.parsers.SAXParser"); } return parser; }
/** * Returns the Class corresponding to the given class name. Provides just-in-time classname * resolution to ensure loading by the proper class loader. * * <p> */ public Class resolveClass(String className) throws ClassNotFoundException { ClassLoader cl = getResolver().getContextClassLoader(); return Class.forName(className, true, cl); }
public WhatsNew(AbstractProjectViewer pv, boolean onlyShowCurrentVersion) throws GeneralException { super(pv); String wn = Environment.getProperty(Constants.WHATS_NEW_VERSION_VIEWED_PROPERTY_NAME); if (wn == null) { wn = "0"; } // Get the current whats new version (i.e. old). Version lastWhatsNewVersion = new Version(wn); boolean betasAllowed = Environment.getUserProperties() .getPropertyAsBoolean(Constants.OPTIN_TO_BETA_VERSIONS_PROPERTY_NAME); try { String whatsNew = Environment.getResourceFileAsString(Constants.WHATS_NEW_FILE); // Load up all the whats new for greater versions. Element root = JDOMUtils.getStringAsElement(whatsNew); java.util.List verEls = JDOMUtils.getChildElements(root, XMLConstants.version, false); // Assume they are in the right order // TODO: Enforce the order and/or sort. for (int i = 0; i < verEls.size(); i++) { Element vEl = (Element) verEls.get(i); String id = JDOMUtils.getAttributeValue(vEl, XMLConstants.id, true); Version v = new Version(id); /* if ((v.isBeta ()) && (!betasAllowed) ) { // Ignore, the user isn't interested in betas. continue; } */ if ((lastWhatsNewVersion.isNewer(v)) || ((onlyShowCurrentVersion) && (v.isSame(Environment.getQuollWriterVersion())))) { String c = WhatsNewComponentProvider.class.getName(); int ind = c.lastIndexOf("."); if (ind > 0) { c = c.substring(0, ind); } WhatsNewComponentProvider compProv = null; String cl = JDOMUtils.getAttributeValue(vEl, XMLConstants.clazz, false); if (!cl.equals("")) { Class clz = null; try { clz = Class.forName(cl); if (WhatsNewComponentProvider.class.isAssignableFrom(clz)) { compProv = (WhatsNewComponentProvider) clz.newInstance(); } } catch (Exception e) { } } // This is a version we are interested in. java.util.List itemEls = JDOMUtils.getChildElements(vEl, WhatsNewItem.XMLConstants.root, true); java.util.List<WhatsNewItem> its = new ArrayList(); for (int j = 0; j < itemEls.size(); j++) { Element itEl = (Element) itemEls.get(j); WhatsNewItem it = new WhatsNewItem(itEl, compProv, pv); if (it.onlyIfCurrentVersion) { if (!Environment.getQuollWriterVersion().isSame(v)) { continue; } } if ((it.description == null) && (it.component == null)) { Environment.logMessage( "Whats new item has no description or component, referenced by: " + JDOMUtils.getPath(itEl)); continue; } its.add(it); } if (its.size() > 0) { this.items.put(v, its); } } } } catch (Exception e) { throw new GeneralException("Unable to init whats new", e); } }