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.io.gryo.kryoshim; import org.apache.commons.configuration.Configuration; import org.apache.commons.configuration.ConfigurationUtils; import org.apache.tinkerpop.gremlin.util.SystemUtil; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.ByteArrayOutputStream; import java.io.InputStream; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.ServiceLoader; /** * Loads the highest-priority or user-selected {@link KryoShimService}. */ public class KryoShimServiceLoader { private static volatile KryoShimService cachedShimService; private static volatile Configuration configuration; private static final Logger log = LoggerFactory.getLogger(KryoShimServiceLoader.class); /** * Set this system property to the fully-qualified name of a {@link KryoShimService} * package-and-classname to force it into service. Setting this property causes the * priority-selection mechanism ({@link KryoShimService#getPriority()}) to be ignored. */ public static final String KRYO_SHIM_SERVICE = "gremlin.io.kryoShimService"; public static void applyConfiguration(final Configuration configuration) { if (null == KryoShimServiceLoader.configuration || null == KryoShimServiceLoader.cachedShimService || !KryoShimServiceLoader.configuration.getKeys().hasNext()) { KryoShimServiceLoader.configuration = configuration; load(true); } } public static void close() { if (null != cachedShimService) cachedShimService.close(); cachedShimService = null; configuration = null; } /** * Return a reference to the shim service. This method may return a cached shim service * unless {@code forceReload} is true. Calls to this method need not be externally * synchonized. * * @param forceReload if false, this method may use its internal service cache; if true, * this method must ignore cache, and it must invoke {@link ServiceLoader#reload()} * before selecting a new service to return * @return the shim service */ private static KryoShimService load(final boolean forceReload) { // if the service is loaded and doesn't need reloading, simply return in if (null != cachedShimService && !forceReload) return cachedShimService; // if a service is already loaded, close it if (null != cachedShimService) cachedShimService.close(); // if the configuration is null, try and load the configuration from System.properties if (null == configuration) configuration = SystemUtil.getSystemPropertiesConfiguration("tinkerpop", true); // get all of the shim services final ArrayList<KryoShimService> services = new ArrayList<>(); final ServiceLoader<KryoShimService> serviceLoader = ServiceLoader.load(KryoShimService.class); synchronized (KryoShimServiceLoader.class) { if (forceReload) serviceLoader.reload(); for (final KryoShimService kss : serviceLoader) { services.add(kss); } } // if a shim service class is specified in the configuration, use it -- else, priority-based if (configuration.containsKey(KRYO_SHIM_SERVICE)) { for (final KryoShimService kss : services) { if (kss.getClass().getCanonicalName().equals(configuration.getString(KRYO_SHIM_SERVICE))) { log.info("Set KryoShimService to {} because of configuration {}={}", kss.getClass().getSimpleName(), KRYO_SHIM_SERVICE, configuration.getString(KRYO_SHIM_SERVICE)); cachedShimService = kss; break; } } } else { Collections.sort(services, KryoShimServiceComparator.INSTANCE); for (final KryoShimService kss : services) { log.debug("Found KryoShimService: {} (priority {})", kss.getClass().getCanonicalName(), kss.getPriority()); } if (0 != services.size()) { cachedShimService = services.get(services.size() - 1); log.info("Set KryoShimService to {} because its priority value ({}) is the best available", cachedShimService.getClass().getSimpleName(), cachedShimService.getPriority()); } } // no shim service was available if (null == cachedShimService) throw new IllegalStateException("Unable to load KryoShimService"); // once the shim service is defined, configure it log.info( "Configuring KryoShimService {} with the following configuration:\n#######START########\n{}\n########END#########", cachedShimService.getClass().getCanonicalName(), ConfigurationUtils.toString(configuration)); cachedShimService.applyConfiguration(configuration); return cachedShimService; } /** * A loose abstraction of {@link org.apache.tinkerpop.shaded.kryo.Kryo#writeClassAndObject}, * where the {@code output} parameter is an internally-created {@link ByteArrayOutputStream}. Returns * the byte array underlying that stream. * * @param object an object for which the instance and class are serialized * @return the serialized form */ public static byte[] writeClassAndObjectToBytes(final Object object) { final KryoShimService shimService = load(false); final ByteArrayOutputStream baos = new ByteArrayOutputStream(); shimService.writeClassAndObject(object, baos); return baos.toByteArray(); } /** * A loose abstraction of {@link org.apache.tinkerpop.shaded.kryo.Kryo#readClassAndObject}, * where the {@code input} parameter is {@code source}. Returns the deserialized object. * * @param inputStream an input stream containing data for a serialized object class and instance * @param <T> the type to which the deserialized object is cast as it is returned * @return the deserialized object */ public static <T> T readClassAndObject(final InputStream inputStream) { final KryoShimService shimService = load(false); return (T) shimService.readClassAndObject(inputStream); } /** * Selects the service with greatest {@link KryoShimService#getPriority()} * (not absolute value). * <p> * Breaks ties with lexicographical comparison of classnames where the * name that sorts last is considered to have highest priority. Ideally * nothing should rely on that tiebreaking behavior, but it beats random * selection in case a user ever gets into that situation by accident and * tries to figure out what's going on. */ private enum KryoShimServiceComparator implements Comparator<KryoShimService> { INSTANCE; @Override public int compare(final KryoShimService a, final KryoShimService b) { final int ap = a.getPriority(); final int bp = b.getPriority(); if (ap < bp) { return -1; } else if (bp < ap) { return 1; } else { final int result = a.getClass().getCanonicalName().compareTo(b.getClass().getCanonicalName()); if (0 == result) { log.warn("Found two {} implementations with the same canonical classname: {}. " + "This may indicate a problem with the classpath/classloader such as " + "duplicate or conflicting copies of the file " + "META-INF/services/org.apache.tinkerpop.gremlin.structure.io.gryo.kryoshim.KryoShimService.", a.getClass().getCanonicalName()); } else { final String winner = 0 < result ? a.getClass().getCanonicalName() : b.getClass().getCanonicalName(); log.warn("{} implementations {} and {} are tied with priority value {}. " + "Preferring {} to the other because it has a lexicographically greater classname. " + "Consider setting the system property \"{}\" instead of relying on priority tie-breaking.", KryoShimService.class.getSimpleName(), a, b, ap, winner, KRYO_SHIM_SERVICE); } return result; } } } }