Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.tinkerpop.gremlin.structure.util; import org.apache.tinkerpop.gremlin.structure.Graph; import org.apache.tinkerpop.gremlin.util.config.YamlConfiguration; import org.apache.commons.configuration.Configuration; import org.apache.commons.configuration.ConfigurationException; import org.apache.commons.configuration.MapConfiguration; import org.apache.commons.configuration.PropertiesConfiguration; import org.apache.commons.configuration.XMLConfiguration; import java.io.File; import java.util.Map; /** * Factory to construct new {@link org.apache.tinkerpop.gremlin.structure.Graph} instances from a * {@code Configuration} object or properties file. * * @author Stephen Mallette (http://stephen.genoprime.com) */ public final class GraphFactory { private GraphFactory() { } /** * Open a graph. See each {@link Graph} instance for its configuration options. * * @param configuration A configuration object that specifies the minimally required properties for a I * {@link Graph} instance. This minimum is determined by the * {@link Graph} instance itself. * @return A {@link org.apache.tinkerpop.gremlin.structure.Graph} instance. * @throws IllegalArgumentException if {@code configuration} */ public static Graph open(final Configuration configuration) { if (null == configuration) throw Graph.Exceptions.argumentCanNotBeNull("configuration"); final String clazz = configuration.getString(Graph.GRAPH, null); if (null == clazz) throw new RuntimeException( String.format("Configuration must contain a valid '%s' setting", Graph.GRAPH)); final Class<?> graphClass; try { graphClass = Class.forName(clazz); } catch (final ClassNotFoundException e) { throw new RuntimeException(String .format("GraphFactory could not find [%s] - Ensure that the jar is in the classpath", clazz)); } // If the graph class specifies a factory class then use that instead of the specified class. final GraphFactoryClass factoryAnnotation = graphClass.getAnnotation(GraphFactoryClass.class); final Class<?> factoryClass = factoryAnnotation != null ? factoryAnnotation.value() : graphClass; return open(configuration, factoryClass); } private static Graph open(final Configuration configuration, final Class<?> graphFactoryClass) { final Graph g; try { // will use open(Configuration c) to instantiate g = (Graph) graphFactoryClass.getMethod("open", Configuration.class).invoke(null, configuration); } catch (final NoSuchMethodException e1) { throw new RuntimeException(String.format( "GraphFactory can only instantiate Graph implementations from classes that have a static open() method that takes a single Apache Commons Configuration argument - [%s] does not seem to have one", graphFactoryClass)); } catch (final Exception e2) { throw new RuntimeException(String.format( "GraphFactory could not instantiate this Graph implementation [%s]", graphFactoryClass), e2); } return g; } /** * Open a graph. See each {@link Graph} instance for its configuration options. This file may be XML, YAML, * or a standard properties file. How the configuration is used (and which kind is required) is dependent on * the implementation. * <p/> * If using XML, ensure that the appropriate version of Apache {@code commons-collections} is available on the * classpath as it is an optional dependency of Apache {@code commons-configuration}, the library that * {@code GraphFactory} depends on. * * @param configurationFile The location of a configuration file that specifies the minimally required properties * for a {@link org.apache.tinkerpop.gremlin.structure.Graph} instance. This minimum is determined by the {@link org.apache.tinkerpop.gremlin.structure.Graph} instance * itself. * @return A {@link org.apache.tinkerpop.gremlin.structure.Graph} instance. * @throws IllegalArgumentException if {@code configurationFile} is null */ public static Graph open(final String configurationFile) { if (null == configurationFile) throw Graph.Exceptions.argumentCanNotBeNull("configurationFile"); return open(getConfiguration(new File(configurationFile))); } /** * Open a graph. See each {@link org.apache.tinkerpop.gremlin.structure.Graph} instance for its configuration options. * * @param configuration A {@link java.util.Map} based configuration that will be converted to an {@link org.apache.commons.configuration.Configuration} object * via {@link org.apache.commons.configuration.MapConfiguration} and passed to the appropriate overload. * @return A Graph instance. */ public static Graph open(final Map configuration) { if (null == configuration) throw Graph.Exceptions.argumentCanNotBeNull("configuration"); return open(new MapConfiguration(configuration)); } private static Configuration getConfiguration(final File configurationFile) { if (!configurationFile.isFile()) throw new IllegalArgumentException(String.format( "The location configuration must resolve to a file and [%s] does not", configurationFile)); try { final String fileName = configurationFile.getName(); final String fileExtension = fileName.substring(fileName.lastIndexOf('.') + 1); switch (fileExtension) { case "yml": case "yaml": final YamlConfiguration config = new YamlConfiguration(); config.load(configurationFile); return config; case "xml": return new XMLConfiguration(configurationFile); default: return new PropertiesConfiguration(configurationFile); } } catch (final ConfigurationException e) { throw new IllegalArgumentException( String.format("Could not load configuration at: %s", configurationFile), e); } } }