Java tutorial
/** * Licensed 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.aurora; import java.lang.annotation.Retention; import java.lang.annotation.Target; import java.lang.reflect.Method; import java.util.Set; import javax.inject.Qualifier; import com.google.common.base.Function; import com.google.common.base.Preconditions; import com.google.common.base.Predicate; import com.google.common.base.Predicates; import com.google.common.cache.CacheBuilder; import com.google.common.cache.CacheLoader; import com.google.common.cache.LoadingCache; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Iterables; import com.google.inject.Binder; import com.google.inject.matcher.AbstractMatcher; import com.google.inject.matcher.Matcher; import com.google.inject.matcher.Matchers; import org.aopalliance.intercept.MethodInterceptor; import org.aopalliance.intercept.MethodInvocation; import org.apache.aurora.common.collections.Pair; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import static java.lang.annotation.ElementType.METHOD; import static java.lang.annotation.RetentionPolicy.RUNTIME; /** * Utilities for guice configuration in aurora. */ public final class GuiceUtils { private static final Logger LOG = LoggerFactory.getLogger(GuiceUtils.class); // Method annotation that allows a trapped interface to whitelist methods that may throw // unchecked exceptions. @Qualifier @Target(METHOD) @Retention(RUNTIME) public @interface AllowUnchecked { } private GuiceUtils() { // utility } private static final Function<Method, Pair<String, Class<?>[]>> CANONICALIZE = method -> Pair .of(method.getName(), method.getParameterTypes()); /** * Creates a matcher that will match methods of an interface, optionally excluding inherited * methods. * * @param matchInterface The interface to match. * @param declaredMethodsOnly if {@code true} only methods directly declared in the interface * will be matched, otherwise all methods on the interface are matched. * @return A new matcher instance. */ public static Matcher<Method> interfaceMatcher(Class<?> matchInterface, boolean declaredMethodsOnly) { Method[] methods = declaredMethodsOnly ? matchInterface.getDeclaredMethods() : matchInterface.getMethods(); final Set<Pair<String, Class<?>[]>> interfaceMethods = ImmutableSet .copyOf(Iterables.transform(ImmutableList.copyOf(methods), CANONICALIZE)); final LoadingCache<Method, Pair<String, Class<?>[]>> cache = CacheBuilder.newBuilder() .build(CacheLoader.from(CANONICALIZE)); return new AbstractMatcher<Method>() { @Override public boolean matches(Method method) { return interfaceMethods.contains(cache.getUnchecked(method)); } }; } /** * Binds an interceptor that ensures the main ClassLoader is bound as the thread context * {@link ClassLoader} during JNI callbacks from mesos. Some libraries require a thread * context ClassLoader be set and this ensures those libraries work properly. * * @param binder The binder to use to register an interceptor with. * @param wrapInterface Interface whose methods should wrapped. */ public static void bindJNIContextClassLoader(Binder binder, Class<?> wrapInterface) { final ClassLoader mainClassLoader = GuiceUtils.class.getClassLoader(); binder.bindInterceptor(Matchers.subclassesOf(wrapInterface), interfaceMatcher(wrapInterface, false), new MethodInterceptor() { @Override public Object invoke(MethodInvocation invocation) throws Throwable { Thread currentThread = Thread.currentThread(); ClassLoader prior = currentThread.getContextClassLoader(); try { currentThread.setContextClassLoader(mainClassLoader); return invocation.proceed(); } finally { currentThread.setContextClassLoader(prior); } } }); } private static final Predicate<Method> IS_WHITELISTED = method -> method .getAnnotation(AllowUnchecked.class) != null; private static final Matcher<Method> WHITELIST_MATCHER = new AbstractMatcher<Method>() { @Override public boolean matches(Method method) { return IS_WHITELISTED.apply(method); } }; private static final Predicate<Method> VOID_METHOD = method -> method.getReturnType() == Void.TYPE; /** * Binds an exception trap on all interface methods of all classes bound against an interface. * Individual methods may opt out of trapping by annotating with {@link AllowUnchecked}. * Only void methods are allowed, any non-void interface methods must explicitly opt out. * * @param binder The binder to register an interceptor with. * @param wrapInterface Interface whose methods should be wrapped. * @throws IllegalArgumentException If any of the non-whitelisted interface methods are non-void. */ public static void bindExceptionTrap(Binder binder, Class<?> wrapInterface) throws IllegalArgumentException { Set<Method> disallowed = ImmutableSet .copyOf(Iterables.filter(ImmutableList.copyOf(wrapInterface.getMethods()), Predicates.and(Predicates.not(IS_WHITELISTED), Predicates.not(VOID_METHOD)))); Preconditions.checkArgument(disallowed.isEmpty(), "Non-void methods must be explicitly whitelisted with @AllowUnchecked: %s", disallowed); Matcher<Method> matcher = Matchers.not(WHITELIST_MATCHER).and(interfaceMatcher(wrapInterface, false)); binder.bindInterceptor(Matchers.subclassesOf(wrapInterface), matcher, new MethodInterceptor() { @Override public Object invoke(MethodInvocation invocation) throws Throwable { try { return invocation.proceed(); } catch (RuntimeException e) { LOG.warn("Trapped uncaught exception: " + e, e); return null; } } }); } }