org.grouplens.grapht.solver.DefaultInjector Maven / Gradle / Ivy
Show all versions of grapht Show documentation
/*
* Grapht, an open source dependency injector.
* Copyright 2014-2015 various contributors (see CONTRIBUTORS.txt)
* Copyright 2010-2014 Regents of the University of Minnesota
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program; if not, write to the Free Software Foundation, Inc., 51
* Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package org.grouplens.grapht.solver;
import com.google.common.base.Predicate;
import org.grouplens.grapht.*;
import org.grouplens.grapht.graph.DAGEdge;
import org.grouplens.grapht.graph.DAGNode;
import org.grouplens.grapht.reflect.Desire;
import org.grouplens.grapht.reflect.Desires;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.annotation.concurrent.ThreadSafe;
import java.lang.annotation.Annotation;
/**
*
* DefaultInjector is the default Injector implementation. When resolving the
* dependency graph for a desire, a "context" is built which consists of an
* ordering of qualified types that satisfy each dependency. The DefaultInjector
* uses the {@link DependencySolver} to manage dependency resolution. New
* injectors can easily be built to also use this solver.
*
* @author GroupLens Research
*/
@ThreadSafe
public class DefaultInjector implements Injector {
private static final Logger logger = LoggerFactory.getLogger(DefaultInjector.class);
private final DependencySolver solver;
private final InjectionContainer instantiator;
/**
*
* Create a new DefaultInjector. The created resolver will use a max
* dependency depth of 100 to estimate if there are cycles in the dependency
* hierarchy. Bindings with a NO_PREFERENCE cache policy will be treated as
* NEW_INSTANCE.
*
* @param functions The BindingFunctions to use, ordered with highest
* priority function first
* @throws NullPointerException if spi or functions ar enull
*/
public DefaultInjector(BindingFunction... functions) {
this(CachePolicy.MEMOIZE, functions);
}
/**
*
* Create a new DefaultInjector. The created resolver will use a max
* dependency depth of 100 to estimate if there are cycles in the dependency
* hierarchy. Bindings with a NO_PREFERENCE cache policy will use
* defaultPolicy.
*
* @param defaultPolicy The CachePolicy used in place of NO_PREFERENCE
* @param functions The BindingFunctions to use, ordered with highest
* priority functions first
* @throws IllegalArgumentException if defaultPolicy is NO_PREFERENCE
* @throws NullPointerException if spi or functions are null
*/
public DefaultInjector(CachePolicy defaultPolicy, BindingFunction... functions) {
this(defaultPolicy, 100, functions);
}
/**
*
* Create a new DefaultInjector. maxDepth represents the maximum
* depth of the dependency hierarchy before it is assume that there is a
* cycle. Bindings with a NO_PREFERENCE cache policy will use
* defaultPolicy.
*
* This constructor can be used to increase this depth in the event that
* configuration requires it, although for most purposes the default 100
* should be sufficient.
*
* @param defaultPolicy The CachePolicy used in place of NO_PREFERENCE
* @param maxDepth The maximum depth of the dependency hierarchy
* @param functions The BindingFunctions to use, ordered with highest
* priority functions first
* @throws IllegalArgumentException if maxDepth is less than 1, or if
* defaultPolicy is NO_PREFERENCE
* @throws NullPointerException if spi or functions are null
*/
public DefaultInjector(CachePolicy defaultPolicy, int maxDepth, BindingFunction... functions) {
if (defaultPolicy.equals(CachePolicy.NO_PREFERENCE)) {
throw new IllegalArgumentException("Default CachePolicy cannot be NO_PREFERENCE");
}
solver = DependencySolver.newBuilder()
.addBindingFunctions(functions)
.setMaxDepth(maxDepth)
.build();
instantiator = InjectionContainer.create(defaultPolicy);
}
/**
* @return The DependencySolver backing this injector
*/
public DependencySolver getSolver() {
return solver;
}
@Nonnull
@Override
public T getInstance(Class type) throws InjectionException {
return getInstance(null, type);
}
@Nonnull
@Override
@SuppressWarnings("unchecked")
public T getInstance(Annotation qualifier, Class type) throws InjectionException {
Object obj = getInstance(Desires.create(qualifier, type, false));
assert obj != null;
return type.cast(obj);
}
@Nullable
@Override
public T tryGetInstance(Annotation qualifier, Class type) throws InjectionException {
Object obj = getInstance(Desires.create(qualifier, type, true));
return type.cast(obj);
}
private Object getInstance(Desire desire) throws InjectionException {
// All Provider cache access, graph resolution, etc. occur
// within this exclusive lock so we know everything is thread safe
// albeit in a non-optimal way.
synchronized(this) {
Predicate pred = Dependency.hasInitialDesire(desire);
// check if the desire is already in the graph
DAGEdge resolved =
solver.getGraph().getOutgoingEdgeWithLabel(pred);
// The edge is only non-null if instantiate() has been called before,
// it may be present in the graph at a deeper node. If that's the case
// it will be properly merged after regenerating the graph at the root context.
if (resolved == null) {
logger.info("Must resolve desire: {}", desire);
solver.resolve(desire);
resolved = solver.getGraph().getOutgoingEdgeWithLabel(pred);
}
// Check if the provider for the resolved node is in our cache
DAGNode resolvedNode = resolved.getTail();
return instantiator.makeInstantiator(resolvedNode, solver.getBackEdges()).instantiate();
}
}
}