diff --git a/.springjavaformatconfig b/.springjavaformatconfig
new file mode 100644
index 0000000..1264378
--- /dev/null
+++ b/.springjavaformatconfig
@@ -0,0 +1 @@
+java-baseline=8
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index bc5921a..17dfdd9 100644
--- a/pom.xml
+++ b/pom.xml
@@ -117,6 +117,20 @@
+
+ io.spring.javaformat
+ spring-javaformat-maven-plugin
+ 0.0.31
+
+
+ validate
+ true
+
+ validate
+
+
+
+
diff --git a/src/main/java/org/springframework/guice/annotation/GuiceFactoryBean.java b/src/main/java/org/springframework/guice/annotation/GuiceFactoryBean.java
index dda7479..4cf1fc2 100644
--- a/src/main/java/org/springframework/guice/annotation/GuiceFactoryBean.java
+++ b/src/main/java/org/springframework/guice/annotation/GuiceFactoryBean.java
@@ -22,17 +22,19 @@ import com.google.inject.Key;
/**
* Convenience class used to map a Guice {@link Provider} to a Spring bean.
- *
+ *
* @author Dave Syer
*/
class GuiceFactoryBean implements FactoryBean {
+
private final Key key;
+
private final Class beanType;
+
private final boolean isSingleton;
-
+
@Autowired
private Injector injector;
-
public GuiceFactoryBean(Class beanType, Key key, boolean isSingleton) {
this.beanType = beanType;
@@ -54,4 +56,5 @@ class GuiceFactoryBean implements FactoryBean {
public boolean isSingleton() {
return this.isSingleton;
}
+
}
\ No newline at end of file
diff --git a/src/main/java/org/springframework/guice/annotation/GuiceModule.java b/src/main/java/org/springframework/guice/annotation/GuiceModule.java
index 30cd924..3f718a9 100644
--- a/src/main/java/org/springframework/guice/annotation/GuiceModule.java
+++ b/src/main/java/org/springframework/guice/annotation/GuiceModule.java
@@ -30,9 +30,9 @@ import org.springframework.guice.module.SpringModule;
* class (and if added to many then the filters are combined with logical OR). By default
* all beans in the context will be bound to Guice with all of their implemented
* interfaces. If you need to filter out which beans are added you can filter by class.
- *
+ *
* @author Dave Syer
- *
+ *
* @see SpringModule
* @see GuiceModuleMetadata
*
@@ -45,42 +45,39 @@ public @interface GuiceModule {
/**
* Specifies which types are eligible for inclusion in Guice module
- *
* @return filters for inclusion
*/
Filter[] includeFilters() default {};
/**
* Specifies which types are not eligible for inclusion in Guice module.
- *
* @return filters for exclusion
*/
Filter[] excludeFilters() default {};
/**
* Specifies which names (by regex) are eligible for inclusion in Guice module
- *
* @return regexes
*/
String[] includePatterns() default {};
/**
- * Specifies which bean names (by regex) are not eligible for inclusion in Guice module.
- *
+ * Specifies which bean names (by regex) are not eligible for inclusion in Guice
+ * module.
* @return regexes
*/
String[] excludePatterns() default {};
/**
- * Specifies which names (by simple wildcard match) are eligible for inclusion in Guice module
- *
+ * Specifies which names (by simple wildcard match) are eligible for inclusion in
+ * Guice module
* @return bean names
*/
String[] includeNames() default {};
/**
- * Specifies which bean names (by simple wildcard match) are not eligible for inclusion in Guice module.
- *
+ * Specifies which bean names (by simple wildcard match) are not eligible for
+ * inclusion in Guice module.
* @return bean names
*/
String[] excludeNames() default {};
diff --git a/src/main/java/org/springframework/guice/annotation/GuiceModuleRegistrar.java b/src/main/java/org/springframework/guice/annotation/GuiceModuleRegistrar.java
index 2ffa26d..5e0475c 100644
--- a/src/main/java/org/springframework/guice/annotation/GuiceModuleRegistrar.java
+++ b/src/main/java/org/springframework/guice/annotation/GuiceModuleRegistrar.java
@@ -47,12 +47,11 @@ import org.springframework.util.Assert;
/**
* Registers bean definitions for Guice modules.
- *
+ *
* @author Dave Syer
*
*/
-class GuiceModuleRegistrar implements ImportBeanDefinitionRegistrar,
- ResourceLoaderAware {
+class GuiceModuleRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {
private ResourceLoader resourceLoader = new DefaultResourceLoader();
@@ -62,30 +61,20 @@ class GuiceModuleRegistrar implements ImportBeanDefinitionRegistrar,
}
@Override
- public void registerBeanDefinitions(AnnotationMetadata annotation,
- BeanDefinitionRegistry registry) {
- BeanDefinitionBuilder builder = BeanDefinitionBuilder
- .genericBeanDefinition(GuiceModuleMetadataFactory.class);
- builder.addPropertyValue("includeFilters",
- parseFilters(annotation, "includeFilters"));
- builder.addPropertyValue("excludeFilters",
- parseFilters(annotation, "excludeFilters"));
- builder.addPropertyValue("includePatterns",
- parsePatterns(annotation, "includePatterns"));
- builder.addPropertyValue("excludePatterns",
- parsePatterns(annotation, "excludePatterns"));
- builder.addPropertyValue("includeNames",
- parseNames(annotation, "includeNames"));
- builder.addPropertyValue("excludeNames",
- parseNames(annotation, "excludeNames"));
+ public void registerBeanDefinitions(AnnotationMetadata annotation, BeanDefinitionRegistry registry) {
+ BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(GuiceModuleMetadataFactory.class);
+ builder.addPropertyValue("includeFilters", parseFilters(annotation, "includeFilters"));
+ builder.addPropertyValue("excludeFilters", parseFilters(annotation, "excludeFilters"));
+ builder.addPropertyValue("includePatterns", parsePatterns(annotation, "includePatterns"));
+ builder.addPropertyValue("excludePatterns", parsePatterns(annotation, "excludePatterns"));
+ builder.addPropertyValue("includeNames", parseNames(annotation, "includeNames"));
+ builder.addPropertyValue("excludeNames", parseNames(annotation, "excludeNames"));
AbstractBeanDefinition definition = builder.getBeanDefinition();
- String name = new DefaultBeanNameGenerator().generateBeanName(definition,
- registry);
+ String name = new DefaultBeanNameGenerator().generateBeanName(definition, registry);
registry.registerBeanDefinition(name, definition);
}
- protected static class GuiceModuleMetadataFactory implements
- FactoryBean {
+ protected static class GuiceModuleMetadataFactory implements FactoryBean {
private Collection includeFilters;
@@ -125,19 +114,12 @@ class GuiceModuleRegistrar implements ImportBeanDefinitionRegistrar,
@Override
public GuiceModuleMetadata getObject() throws Exception {
- return new GuiceModuleMetadata()
- .include(
- includeFilters.toArray(new TypeFilter[includeFilters.size()]))
- .exclude(
- excludeFilters.toArray(new TypeFilter[excludeFilters.size()]))
- .include(
- includePatterns.toArray(new Pattern[includePatterns.size()]))
- .exclude(
- excludePatterns.toArray(new Pattern[excludePatterns.size()]))
- .include(
- includeNames.toArray(new String[includeNames.size()]))
- .exclude(
- excludeNames.toArray(new String[excludeNames.size()]));
+ return new GuiceModuleMetadata().include(includeFilters.toArray(new TypeFilter[includeFilters.size()]))
+ .exclude(excludeFilters.toArray(new TypeFilter[excludeFilters.size()]))
+ .include(includePatterns.toArray(new Pattern[includePatterns.size()]))
+ .exclude(excludePatterns.toArray(new Pattern[excludePatterns.size()]))
+ .include(includeNames.toArray(new String[includeNames.size()]))
+ .exclude(excludeNames.toArray(new String[excludeNames.size()]));
}
@Override
@@ -178,8 +160,7 @@ class GuiceModuleRegistrar implements ImportBeanDefinitionRegistrar,
return result;
}
- private Set parseFilters(AnnotationMetadata annotation,
- String attributeName) {
+ private Set parseFilters(AnnotationMetadata annotation, String attributeName) {
Set result = new HashSet();
AnnotationAttributes attributes = new AnnotationAttributes(
@@ -202,8 +183,7 @@ class GuiceModuleRegistrar implements ImportBeanDefinitionRegistrar,
switch (filterType) {
case ANNOTATION:
Assert.isAssignable(Annotation.class, filterClass,
- "An error occured when processing a @ComponentScan "
- + "ANNOTATION type filter: ");
+ "An error occured when processing a @ComponentScan " + "ANNOTATION type filter: ");
@SuppressWarnings("unchecked")
Class annoClass = (Class) filterClass;
typeFilters.add(new AnnotationTypeFilter(annoClass));
@@ -213,10 +193,8 @@ class GuiceModuleRegistrar implements ImportBeanDefinitionRegistrar,
break;
case CUSTOM:
Assert.isAssignable(TypeFilter.class, filterClass,
- "An error occured when processing a @ComponentScan "
- + "CUSTOM type filter: ");
- typeFilters
- .add(BeanUtils.instantiateClass(filterClass, TypeFilter.class));
+ "An error occured when processing a @ComponentScan " + "CUSTOM type filter: ");
+ typeFilters.add(BeanUtils.instantiateClass(filterClass, TypeFilter.class));
break;
default:
throw new IllegalArgumentException("Unknown filter type " + filterType);
@@ -229,10 +207,11 @@ class GuiceModuleRegistrar implements ImportBeanDefinitionRegistrar,
if ("REGEX".equals(rawName)) {
typeFilters.add(new RegexPatternTypeFilter(Pattern.compile(expression)));
- } else if ("ASPECTJ".equals(rawName)) {
- typeFilters.add(new AspectJTypeFilter(expression, this.resourceLoader
- .getClassLoader()));
- } else {
+ }
+ else if ("ASPECTJ".equals(rawName)) {
+ typeFilters.add(new AspectJTypeFilter(expression, this.resourceLoader.getClassLoader()));
+ }
+ else {
throw new IllegalArgumentException("Unknown filter type " + filterType);
}
}
@@ -244,7 +223,8 @@ class GuiceModuleRegistrar implements ImportBeanDefinitionRegistrar,
try {
return filterAttributes.getStringArray("pattern");
- } catch (IllegalArgumentException o_O) {
+ }
+ catch (IllegalArgumentException o_O) {
return new String[0];
}
}
diff --git a/src/main/java/org/springframework/guice/annotation/InjectorFactory.java b/src/main/java/org/springframework/guice/annotation/InjectorFactory.java
index a1c4358..070952c 100644
--- a/src/main/java/org/springframework/guice/annotation/InjectorFactory.java
+++ b/src/main/java/org/springframework/guice/annotation/InjectorFactory.java
@@ -6,11 +6,11 @@ import com.google.inject.Injector;
import com.google.inject.Module;
/***
- * Factory which allows for custom creation of the Guice Injector to be used
- * in the @{@link EnableGuiceModules} feature.
+ * Factory which allows for custom creation of the Guice Injector to be used in
+ * the @{@link EnableGuiceModules} feature.
*/
public interface InjectorFactory {
-
- public Injector createInjector(List modules);
+
+ public Injector createInjector(List modules);
}
diff --git a/src/main/java/org/springframework/guice/annotation/ModuleRegistryConfiguration.java b/src/main/java/org/springframework/guice/annotation/ModuleRegistryConfiguration.java
index d1ce23a..f4cb8bd 100644
--- a/src/main/java/org/springframework/guice/annotation/ModuleRegistryConfiguration.java
+++ b/src/main/java/org/springframework/guice/annotation/ModuleRegistryConfiguration.java
@@ -73,12 +73,15 @@ import java.util.stream.Collectors;
class ModuleRegistryConfiguration implements BeanDefinitionRegistryPostProcessor, ApplicationContextAware {
private static final String SPRING_GUICE_DEDUPE_BINDINGS_PROPERTY_NAME = "spring.guice.dedup";
+
private static final String SPRING_GUICE_AUTOWIRE_JIT_PROPERTY_NAME = "spring.guice.autowireJIT";
+
private static final String SPRING_GUICE_STAGE_PROPERTY_NAME = "spring.guice.stage";
private final Log logger = LogFactory.getLog(getClass());
private ApplicationContext applicationContext;
+
private boolean enableJustInTimeBinding = true;
@Override
@@ -90,13 +93,13 @@ class ModuleRegistryConfiguration implements BeanDefinitionRegistryPostProcessor
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
- List modules = new ArrayList<>(((ConfigurableListableBeanFactory) registry)
- .getBeansOfType(Module.class).values());
+ List modules = new ArrayList<>(
+ ((ConfigurableListableBeanFactory) registry).getBeansOfType(Module.class).values());
modules.add(new SpringModule((ConfigurableListableBeanFactory) registry, enableJustInTimeBinding));
Map, Binding> bindings = new HashMap, Binding>();
List elements = Elements.getElements(Stage.TOOL, modules);
- if (applicationContext.getEnvironment().getProperty(
- SPRING_GUICE_DEDUPE_BINDINGS_PROPERTY_NAME, Boolean.class, false)) {
+ if (applicationContext.getEnvironment().getProperty(SPRING_GUICE_DEDUPE_BINDINGS_PROPERTY_NAME, Boolean.class,
+ false)) {
elements = removeDuplicates(elements);
modules = Collections.singletonList(Elements.getModule(elements));
}
@@ -132,17 +135,16 @@ class ModuleRegistryConfiguration implements BeanDefinitionRegistryPostProcessor
}
private void mapBindings(Map, Binding> bindings, BeanDefinitionRegistry registry) {
- Stage stage = applicationContext.getEnvironment().getProperty(SPRING_GUICE_STAGE_PROPERTY_NAME, Stage.class, Stage.PRODUCTION);
+ Stage stage = applicationContext.getEnvironment().getProperty(SPRING_GUICE_STAGE_PROPERTY_NAME, Stage.class,
+ Stage.PRODUCTION);
boolean ifLazyInit = stage.equals(Stage.DEVELOPMENT);
for (Entry, Binding> entry : bindings.entrySet()) {
- if (entry.getKey().getTypeLiteral().getRawType().equals(Injector.class)
- || SpringModule.SPRING_GUICE_SOURCE
+ if (entry.getKey().getTypeLiteral().getRawType().equals(Injector.class) || SpringModule.SPRING_GUICE_SOURCE
.equals(Optional.ofNullable(entry.getValue().getSource()).map(Object::toString).orElse(""))) {
continue;
}
- if (entry.getKey().getAnnotationType() != null &&
- entry.getKey().getAnnotationType().getName()
- .startsWith("com.google.inject.multibindings")) {
+ if (entry.getKey().getAnnotationType() != null
+ && entry.getKey().getAnnotationType().getName().startsWith("com.google.inject.multibindings")) {
continue;
}
@@ -157,21 +159,20 @@ class ModuleRegistryConfiguration implements BeanDefinitionRegistryPostProcessor
args.addIndexedArgumentValue(2, Scopes.isSingleton(binding));
bean.setConstructorArgumentValues(args);
bean.setTargetType(ResolvableType.forType(key.getTypeLiteral().getType()));
- if(!Scopes.isSingleton(binding)) {
+ if (!Scopes.isSingleton(binding)) {
bean.setScope(ConfigurableBeanFactory.SCOPE_PROTOTYPE);
}
if (source instanceof ElementSource) {
- bean.setResourceDescription(
- ((ElementSource) source).getDeclaringSource().toString());
+ bean.setResourceDescription(((ElementSource) source).getDeclaringSource().toString());
}
else {
bean.setResourceDescription(SpringModule.SPRING_GUICE_SOURCE);
}
bean.setAttribute(SpringModule.SPRING_GUICE_SOURCE, true);
if (key.getAnnotationType() != null) {
- bean.addQualifier(new AutowireCandidateQualifier(Qualifier.class,
- getValueAttributeForNamed(key)));
- bean.addQualifier(new AutowireCandidateQualifier(key.getAnnotationType(), getValueAttributeForNamed(key)));
+ bean.addQualifier(new AutowireCandidateQualifier(Qualifier.class, getValueAttributeForNamed(key)));
+ bean.addQualifier(
+ new AutowireCandidateQualifier(key.getAnnotationType(), getValueAttributeForNamed(key)));
}
if (ifLazyInit) {
bean.setLazyInit(true);
@@ -199,7 +200,7 @@ class ModuleRegistryConfiguration implements BeanDefinitionRegistryPostProcessor
else if (key.getAnnotation() instanceof javax.inject.Named) {
return ((javax.inject.Named) key.getAnnotation()).value();
}
- else if (key.getAnnotationType() != null){
+ else if (key.getAnnotationType() != null) {
return key.getAnnotationType().getName();
}
else {
@@ -207,22 +208,22 @@ class ModuleRegistryConfiguration implements BeanDefinitionRegistryPostProcessor
}
}
- private boolean elementFilter(String[] modulesToFilter, Element element){
+ private boolean elementFilter(String[] modulesToFilter, Element element) {
try {
- return Arrays.stream(modulesToFilter)
- .noneMatch(ex -> Optional.of(element).map(Element::getSource).map(Object::toString).orElse("").contains(ex));
- } catch (Exception e){
- logger.error(String.format("Unable fo filter element[%s] with filter [%s]", element, Arrays.toString(modulesToFilter)), e);
+ return Arrays.stream(modulesToFilter).noneMatch(
+ ex -> Optional.of(element).map(Element::getSource).map(Object::toString).orElse("").contains(ex));
+ }
+ catch (Exception e) {
+ logger.error(String.format("Unable fo filter element[%s] with filter [%s]", element,
+ Arrays.toString(modulesToFilter)), e);
return false;
}
}
- private void extractPrivateElements(Map, Binding> bindings,
- PrivateElements privateElements) {
+ private void extractPrivateElements(Map, Binding> bindings, PrivateElements privateElements) {
List elements = privateElements.getElements();
for (Element e : elements) {
- if (e instanceof Binding && privateElements.getExposedKeys()
- .contains(((Binding) e).getKey())) {
+ if (e instanceof Binding && privateElements.getExposedKeys().contains(((Binding) e).getKey())) {
Binding binding = (Binding) e;
bindings.put(binding.getKey(), binding);
}
@@ -237,22 +238,21 @@ class ModuleRegistryConfiguration implements BeanDefinitionRegistryPostProcessor
* for a given binding key
*/
protected List removeDuplicates(List elements) {
- List duplicateElements = elements.stream()
- .filter(e -> e instanceof Binding).map(e -> (Binding) e)
+ List duplicateElements = elements.stream().filter(e -> e instanceof Binding).map(e -> (Binding) e)
.collect(Collectors.groupingBy(ModuleRegistryConfiguration::getLinkedKeyIfRequired)).entrySet().stream()
- .filter(e -> e.getValue().size() > 1 && e.getValue().stream().anyMatch(
- binding -> binding.getSource() != null && binding.getSource()
- .toString().contains(SpringModule.SPRING_GUICE_SOURCE))) // find duplicates
+ .filter(e -> e.getValue().size() > 1 && e.getValue().stream()
+ .anyMatch(binding -> binding.getSource() != null
+ && binding.getSource().toString().contains(SpringModule.SPRING_GUICE_SOURCE))) // find
+ // duplicates
.flatMap(e -> e.getValue().stream())
- .filter(e -> e.getSource() != null && !e.getSource().toString()
- .contains(SpringModule.SPRING_GUICE_SOURCE))
+ .filter(e -> e.getSource() != null
+ && !e.getSource().toString().contains(SpringModule.SPRING_GUICE_SOURCE))
.collect(Collectors.toList());
@SuppressWarnings("unlikely-arg-type")
List dedupedElements = elements.stream().filter(e -> {
if (e instanceof Binding) {
- return !duplicateElements
- .contains(new SourceComparableBinding((Binding) e));
+ return !duplicateElements.contains(new SourceComparableBinding((Binding) e));
}
else {
return true;
@@ -275,6 +275,7 @@ class ModuleRegistryConfiguration implements BeanDefinitionRegistryPostProcessor
}
private static class SourceComparableBinding {
+
private Binding binding;
public SourceComparableBinding(Binding binding) {
@@ -286,8 +287,7 @@ class ModuleRegistryConfiguration implements BeanDefinitionRegistryPostProcessor
if (obj instanceof Binding) {
Binding compareTo = (Binding) obj;
if (compareTo.getSource() != null && this.binding != null) {
- return binding.equals(compareTo)
- && Objects.equals(binding.getSource(), compareTo.getSource());
+ return binding.equals(compareTo) && Objects.equals(binding.getSource(), compareTo.getSource());
}
else {
return Objects.equals(binding, compareTo);
@@ -297,29 +297,37 @@ class ModuleRegistryConfiguration implements BeanDefinitionRegistryPostProcessor
return false;
}
}
+
}
+
}
/**
* Creates the Guice injector and registers it.
*
- * The correct time to create the injector is after all Bean Post Processors were registered (after the
- * registerBeanPostProcessors() phase), but before other beans get resolved. To achieve this, we create the injector
- * when the first bean gets resolved - in its post-processing phase. However, this creates a possibility for a circular
- * initialization error (i.e. if the first bean is also being dependant on by a Guice provided binding). To resolve
- * this we publish an event that will be triggered in the registerListeners() phase, and create the injector then.
- * Combining both initialization mechanisms (post-processor and the event publishing) ensures the injector will be
- * created no later then the registerListeners() phase, but after the registerBeanPostProcessors() phase.
- * For application contexts that override onRefresh() and create beans then (i.e. WebServer based application contexts)
- * the post-processor initialization will kick-in and create the injector before.
+ * The correct time to create the injector is after all Bean Post Processors were
+ * registered (after the registerBeanPostProcessors() phase), but before other beans get
+ * resolved. To achieve this, we create the injector when the first bean gets resolved -
+ * in its post-processing phase. However, this creates a possibility for a circular
+ * initialization error (i.e. if the first bean is also being dependant on by a Guice
+ * provided binding). To resolve this we publish an event that will be triggered in the
+ * registerListeners() phase, and create the injector then. Combining both initialization
+ * mechanisms (post-processor and the event publishing) ensures the injector will be
+ * created no later then the registerListeners() phase, but after the
+ * registerBeanPostProcessors() phase. For application contexts that override onRefresh()
+ * and create beans then (i.e. WebServer based application contexts) the post-processor
+ * initialization will kick-in and create the injector before.
*/
-class GuiceInjectorInitializer implements BeanPostProcessor, ApplicationListener {
+class GuiceInjectorInitializer
+ implements BeanPostProcessor, ApplicationListener {
+
private final AtomicBoolean injectorCreated = new AtomicBoolean(false);
+
private final List modules;
+
private final ConfigurableApplicationContext applicationContext;
- public GuiceInjectorInitializer(List modules,
- ConfigurableApplicationContext applicationContext) {
+ public GuiceInjectorInitializer(List modules, ConfigurableApplicationContext applicationContext) {
this.modules = modules;
this.applicationContext = applicationContext;
@@ -346,8 +354,7 @@ class GuiceInjectorInitializer implements BeanPostProcessor, ApplicationListener
try {
Map beansOfType = applicationContext.getBeansOfType(InjectorFactory.class);
if (beansOfType.size() > 1) {
- throw new ApplicationContextException("Found multiple beans of type "
- + InjectorFactory.class.getName()
+ throw new ApplicationContextException("Found multiple beans of type " + InjectorFactory.class.getName()
+ " Please ensure that only one InjectorFactory bean is defined. InjectorFactory beans found: "
+ beansOfType.keySet());
}
@@ -367,12 +374,13 @@ class GuiceInjectorInitializer implements BeanPostProcessor, ApplicationListener
}
static class CreateInjectorEvent extends ApplicationEvent {
+
private static final long serialVersionUID = -6546970378679850504L;
public CreateInjectorEvent() {
super(serialVersionUID);
}
+
}
+
}
-
-
diff --git a/src/main/java/org/springframework/guice/injector/SpringInjector.java b/src/main/java/org/springframework/guice/injector/SpringInjector.java
index 909621c..7b42542 100644
--- a/src/main/java/org/springframework/guice/injector/SpringInjector.java
+++ b/src/main/java/org/springframework/guice/injector/SpringInjector.java
@@ -37,16 +37,17 @@ import com.google.inject.name.Named;
import com.google.inject.spi.TypeConverterBinding;
/**
- * An {@link Injector} that wraps an {@link ApplicationContext}, and can be used
- * to expose the Guice APIs over a Spring application. Does not use Guice at all
- * internally: just adapts the Spring API to the Guice one.
- *
+ * An {@link Injector} that wraps an {@link ApplicationContext}, and can be used to expose
+ * the Guice APIs over a Spring application. Does not use Guice at all internally: just
+ * adapts the Spring API to the Guice one.
+ *
* @author Dave Syer
*
*/
public class SpringInjector implements Injector {
private Injector injector;
+
private DefaultListableBeanFactory beanFactory;
public SpringInjector(ApplicationContext context) {
@@ -134,8 +135,9 @@ public class SpringInjector implements Injector {
@SuppressWarnings("unchecked")
@Override
public T get() {
- if(key.getAnnotation() != null) {
- return (T) BeanFactoryAnnotationUtils.qualifiedBeanOfType(SpringInjector.this.beanFactory, type, name);
+ if (key.getAnnotation() != null) {
+ return (T) BeanFactoryAnnotationUtils.qualifiedBeanOfType(SpringInjector.this.beanFactory, type,
+ name);
}
return SpringInjector.this.beanFactory.getBean(cls);
}
@@ -146,7 +148,8 @@ public class SpringInjector implements Injector {
final Annotation annotation = key.getAnnotation();
if (annotation instanceof Named) {
return ((Named) annotation).value();
- } else if (annotation instanceof javax.inject.Named) {
+ }
+ else if (annotation instanceof javax.inject.Named) {
return ((javax.inject.Named) annotation).value();
}
return key.getTypeLiteral().getRawType().getSimpleName();
diff --git a/src/main/java/org/springframework/guice/module/BeanFactoryProvider.java b/src/main/java/org/springframework/guice/module/BeanFactoryProvider.java
index 6c00639..57f11d0 100644
--- a/src/main/java/org/springframework/guice/module/BeanFactoryProvider.java
+++ b/src/main/java/org/springframework/guice/module/BeanFactoryProvider.java
@@ -50,21 +50,22 @@ import org.springframework.core.OrderComparator;
* register an {@link ApplicationContextInitializer} that sets a shutdown hook, so that
* the context is closed automatically when the JVM ends.
*
- *
+ *
* @author Dave Syer
*
*/
-public class BeanFactoryProvider
- implements Provider, Closeable {
+public class BeanFactoryProvider implements Provider, Closeable {
private Class[] config;
+
private String[] basePackages;
+
private List> initializers = new ArrayList>();
+
private PartiallyRefreshableApplicationContext context;
/**
* Create an application context by scanning these base packages.
- *
* @param basePackages base packages to scan
* @return a provider
*/
@@ -74,7 +75,6 @@ public class BeanFactoryProvider
/**
* Create an application context using these configuration classes.
- *
* @param config classes to build an application
* @return a provider
*/
@@ -132,8 +132,7 @@ public class BeanFactoryProvider
return context.getBeanFactory();
}
- private static final class PartiallyRefreshableApplicationContext
- extends AnnotationConfigApplicationContext {
+ private static final class PartiallyRefreshableApplicationContext extends AnnotationConfigApplicationContext {
private final AtomicBoolean partiallyRefreshed = new AtomicBoolean(false);
@@ -143,8 +142,7 @@ public class BeanFactoryProvider
*/
private void partialRefresh() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
- beanFactory.registerSingleton("refreshListener",
- new ContextRefreshingProvisionListener(this));
+ beanFactory.registerSingleton("refreshListener", new ContextRefreshingProvisionListener(this));
prepareBeanFactory(beanFactory);
invokeBeanFactoryPostProcessors(beanFactory);
}
@@ -158,21 +156,21 @@ public class BeanFactoryProvider
}
@Override
- protected void invokeBeanFactoryPostProcessors(
- ConfigurableListableBeanFactory beanFactory) {
+ protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
if (partiallyRefreshed.compareAndSet(false, true)) {
super.invokeBeanFactoryPostProcessors(beanFactory);
}
}
+
}
- private static final class ContextRefreshingProvisionListener
- implements ProvisionListener {
+ private static final class ContextRefreshingProvisionListener implements ProvisionListener {
+
private final PartiallyRefreshableApplicationContext context;
+
private final AtomicBoolean initialized = new AtomicBoolean(false);
- private ContextRefreshingProvisionListener(
- PartiallyRefreshableApplicationContext context) {
+ private ContextRefreshingProvisionListener(PartiallyRefreshableApplicationContext context) {
this.context = context;
}
@@ -183,6 +181,7 @@ public class BeanFactoryProvider
}
provision.provision();
}
+
}
}
diff --git a/src/main/java/org/springframework/guice/module/GuiceAutowireCandidateResolver.java b/src/main/java/org/springframework/guice/module/GuiceAutowireCandidateResolver.java
index 56d7681..f72946d 100644
--- a/src/main/java/org/springframework/guice/module/GuiceAutowireCandidateResolver.java
+++ b/src/main/java/org/springframework/guice/module/GuiceAutowireCandidateResolver.java
@@ -35,7 +35,6 @@ import java.util.Optional;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
-
/**
* @author Dave Syer
* @author Taylor Wicksell
@@ -44,101 +43,107 @@ import java.util.concurrent.atomic.AtomicReference;
*/
class GuiceAutowireCandidateResolver extends ContextAnnotationAutowireCandidateResolver {
- private Provider injectorProvider;
- private final Log logger = LogFactory.getLog(getClass());
+ private Provider injectorProvider;
- public GuiceAutowireCandidateResolver(Provider injectorProvider) {
- this.injectorProvider = injectorProvider;
- addQualifierType(BindingAnnotation.class);
- }
+ private final Log logger = LogFactory.getLog(getClass());
- @Override
- public Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, String beanName) {
- return (isLazy(descriptor, beanName) ? buildLazyResolutionProxy(descriptor, beanName) : null);
- }
+ public GuiceAutowireCandidateResolver(Provider injectorProvider) {
+ this.injectorProvider = injectorProvider;
+ addQualifierType(BindingAnnotation.class);
+ }
- protected boolean isLazy(DependencyDescriptor descriptor, String beanName) {
- Assert.state(getBeanFactory() instanceof DefaultListableBeanFactory,
- "BeanFactory needs to be a DefaultListableBeanFactory");
- final DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) getBeanFactory();
+ @Override
+ public Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, String beanName) {
+ return (isLazy(descriptor, beanName) ? buildLazyResolutionProxy(descriptor, beanName) : null);
+ }
- if (isCollectionType(descriptor.getDependencyType())) {
- return false;
- }
+ protected boolean isLazy(DependencyDescriptor descriptor, String beanName) {
+ Assert.state(getBeanFactory() instanceof DefaultListableBeanFactory,
+ "BeanFactory needs to be a DefaultListableBeanFactory");
+ final DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) getBeanFactory();
- if (super.isLazy(descriptor)) {
- return true;
- }
+ if (isCollectionType(descriptor.getDependencyType())) {
+ return false;
+ }
- try {
- beanFactory.doResolveDependency(descriptor, beanName, null, null);
- } catch (NoSuchBeanDefinitionException e) {
- if (e.getResolvableType() != null) {
- logger.info(String.format("Use just in time binding for %s in bean: %s",
- e.getResolvableType().getType().getTypeName(), beanName));
- }
- return true;
- }
+ if (super.isLazy(descriptor)) {
+ return true;
+ }
- return false;
- }
+ try {
+ beanFactory.doResolveDependency(descriptor, beanName, null, null);
+ }
+ catch (NoSuchBeanDefinitionException e) {
+ if (e.getResolvableType() != null) {
+ logger.info(String.format("Use just in time binding for %s in bean: %s",
+ e.getResolvableType().getType().getTypeName(), beanName));
+ }
+ return true;
+ }
- protected Object buildLazyResolutionProxy(final DependencyDescriptor descriptor, final String beanName) {
- Assert.state(getBeanFactory() instanceof DefaultListableBeanFactory,
- "BeanFactory needs to be a DefaultListableBeanFactory");
- final DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) getBeanFactory();
- TargetSource ts = new TargetSource() {
- private Optional isGuiceResolvable = Optional.empty();
+ return false;
+ }
- @Override
- public Class getTargetClass() {
- return descriptor.getDependencyType();
- }
+ protected Object buildLazyResolutionProxy(final DependencyDescriptor descriptor, final String beanName) {
+ Assert.state(getBeanFactory() instanceof DefaultListableBeanFactory,
+ "BeanFactory needs to be a DefaultListableBeanFactory");
+ final DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) getBeanFactory();
+ TargetSource ts = new TargetSource() {
+ private Optional isGuiceResolvable = Optional.empty();
- @Override
- public boolean isStatic() {
- return false;
- }
+ @Override
+ public Class getTargetClass() {
+ return descriptor.getDependencyType();
+ }
- @Override
- public Object getTarget() {
- Object target = null;
- if (isGuiceResolvable.isPresent() && isGuiceResolvable.get()) {
- target = injectorProvider.get().getInstance(Key.get(descriptor.getResolvableType().getType()));
- } else {
- try {
- target = beanFactory.doResolveDependency(descriptor, beanName, null, null);
- } catch (NoSuchBeanDefinitionException e) {
- target = injectorProvider.get().getInstance(Key.get(descriptor.getResolvableType().getType()));
- isGuiceResolvable = Optional.of(true);
- }
- }
- if (target == null) {
- throw new NoSuchBeanDefinitionException(descriptor.getDependencyType(),
- "Optional dependency not present for lazy injection point");
- }
- return target;
- }
+ @Override
+ public boolean isStatic() {
+ return false;
+ }
- @Override
- public void releaseTarget(Object target) {
- }
- };
- try {
- ProxyFactory pf = new ProxyFactory();
- pf.setTargetSource(ts);
- Class dependencyType = descriptor.getDependencyType();
- if (dependencyType.isInterface()) {
- pf.addInterface(dependencyType);
- }
- return pf.getProxy(beanFactory.getBeanClassLoader());
- } catch(Exception e) {
- logger.debug("Failed to build lazy resolution proxy to Guice", e);
- }
- return null;
- }
+ @Override
+ public Object getTarget() {
+ Object target = null;
+ if (isGuiceResolvable.isPresent() && isGuiceResolvable.get()) {
+ target = injectorProvider.get().getInstance(Key.get(descriptor.getResolvableType().getType()));
+ }
+ else {
+ try {
+ target = beanFactory.doResolveDependency(descriptor, beanName, null, null);
+ }
+ catch (NoSuchBeanDefinitionException e) {
+ target = injectorProvider.get().getInstance(Key.get(descriptor.getResolvableType().getType()));
+ isGuiceResolvable = Optional.of(true);
+ }
+ }
+ if (target == null) {
+ throw new NoSuchBeanDefinitionException(descriptor.getDependencyType(),
+ "Optional dependency not present for lazy injection point");
+ }
+ return target;
+ }
+
+ @Override
+ public void releaseTarget(Object target) {
+ }
+ };
+ try {
+ ProxyFactory pf = new ProxyFactory();
+ pf.setTargetSource(ts);
+ Class dependencyType = descriptor.getDependencyType();
+ if (dependencyType.isInterface()) {
+ pf.addInterface(dependencyType);
+ }
+ return pf.getProxy(beanFactory.getBeanClassLoader());
+ }
+ catch (Exception e) {
+ logger.debug("Failed to build lazy resolution proxy to Guice", e);
+ }
+ return null;
+ }
+
+ private boolean isCollectionType(Class type) {
+ return Collection.class.isAssignableFrom(type) || Map.class == type;
+ }
- private boolean isCollectionType(Class type) {
- return Collection.class.isAssignableFrom(type) || Map.class == type;
- }
}
diff --git a/src/main/java/org/springframework/guice/module/GuiceModuleMetadata.java b/src/main/java/org/springframework/guice/module/GuiceModuleMetadata.java
index aa2f180..e4cd735 100644
--- a/src/main/java/org/springframework/guice/module/GuiceModuleMetadata.java
+++ b/src/main/java/org/springframework/guice/module/GuiceModuleMetadata.java
@@ -38,7 +38,7 @@ import org.springframework.util.PatternMatchUtils;
* Encapsulates some metadata about a Guice module that is to be created from a Spring
* application context. Can be used directly as a @Bean, but it is easier to
* just add @ {@link GuiceModule} to your @Configuration.
- *
+ *
* @author Dave Syer
*
*/
@@ -97,7 +97,7 @@ public class GuiceModuleMetadata implements BindingTypeMatcher {
@Override
public boolean matches(String name, Type type) {
- Type rawType = type instanceof ParameterizedType ? ((ParameterizedType)type).getRawType() : type;
+ Type rawType = type instanceof ParameterizedType ? ((ParameterizedType) type).getRawType() : type;
if (!matches(name) || !matches(rawType)) {
return false;
}
@@ -143,30 +143,28 @@ public class GuiceModuleMetadata implements BindingTypeMatcher {
if (includeFilters != null) {
try {
- MetadataReader reader = metadataReaderFactory.getMetadataReader(type
- .getTypeName());
+ MetadataReader reader = metadataReaderFactory.getMetadataReader(type.getTypeName());
for (TypeFilter filter : includeFilters) {
if (!filter.match(reader, metadataReaderFactory)) {
return false;
}
}
- } catch (IOException e) {
- throw new IllegalStateException("Cannot read metadata for class " + type,
- e);
+ }
+ catch (IOException e) {
+ throw new IllegalStateException("Cannot read metadata for class " + type, e);
}
}
if (excludeFilters != null) {
try {
- MetadataReader reader = metadataReaderFactory.getMetadataReader(type
- .getTypeName());
+ MetadataReader reader = metadataReaderFactory.getMetadataReader(type.getTypeName());
for (TypeFilter filter : excludeFilters) {
if (filter.match(reader, metadataReaderFactory)) {
return false;
}
}
- } catch (IOException e) {
- throw new IllegalStateException("Cannot read metadata for class " + type,
- e);
+ }
+ catch (IOException e) {
+ throw new IllegalStateException("Cannot read metadata for class " + type, e);
}
}
return true;
@@ -175,8 +173,7 @@ public class GuiceModuleMetadata implements BindingTypeMatcher {
private boolean visible(Type type) {
Class cls = ResolvableType.forType(type).resolve();
while (cls != null && cls != Object.class) {
- if (!Modifier.isInterface(cls.getModifiers())
- && !Modifier.isPublic(cls.getModifiers())
+ if (!Modifier.isInterface(cls.getModifiers()) && !Modifier.isPublic(cls.getModifiers())
&& !Modifier.isProtected(cls.getModifiers())) {
return false;
}
diff --git a/src/main/java/org/springframework/guice/module/SpringModule.java b/src/main/java/org/springframework/guice/module/SpringModule.java
index d9edd07..27d5707 100644
--- a/src/main/java/org/springframework/guice/module/SpringModule.java
+++ b/src/main/java/org/springframework/guice/module/SpringModule.java
@@ -84,16 +84,14 @@ public class SpringModule extends AbstractModule {
}
public SpringModule(ApplicationContext context, boolean enableJustInTimeBinding) {
- this((ConfigurableListableBeanFactory) context.getAutowireCapableBeanFactory(),
- enableJustInTimeBinding);
+ this((ConfigurableListableBeanFactory) context.getAutowireCapableBeanFactory(), enableJustInTimeBinding);
}
public SpringModule(ConfigurableListableBeanFactory beanFactory) {
this(beanFactory, true);
}
- public SpringModule(ConfigurableListableBeanFactory beanFactory,
- boolean enableJustInTimeBinding) {
+ public SpringModule(ConfigurableListableBeanFactory beanFactory, boolean enableJustInTimeBinding) {
this.beanFactory = beanFactory;
this.enableJustInTimeBinding = enableJustInTimeBinding;
}
@@ -109,19 +107,16 @@ public class SpringModule extends AbstractModule {
}
if (beanFactory.getBeanNamesForType(ProvisionListener.class).length > 0) {
binder().bindListener(Matchers.any(),
- beanFactory.getBeansOfType(ProvisionListener.class).values()
- .toArray(new ProvisionListener[0]));
+ beanFactory.getBeansOfType(ProvisionListener.class).values().toArray(new ProvisionListener[0]));
}
if (enableJustInTimeBinding) {
if (beanFactory instanceof DefaultListableBeanFactory) {
- ((DefaultListableBeanFactory) beanFactory)
- .setAutowireCandidateResolver(new GuiceAutowireCandidateResolver(
- binder().getProvider(Injector.class)));
+ ((DefaultListableBeanFactory) beanFactory).setAutowireCandidateResolver(
+ new GuiceAutowireCandidateResolver(binder().getProvider(Injector.class)));
}
}
if (beanFactory.getBeanNamesForType(GuiceModuleMetadata.class).length > 0) {
- this.matcher = new CompositeTypeMatcher(
- beanFactory.getBeansOfType(GuiceModuleMetadata.class).values());
+ this.matcher = new CompositeTypeMatcher(beanFactory.getBeansOfType(GuiceModuleMetadata.class).values());
}
bind(beanFactory);
}
@@ -133,10 +128,8 @@ public class SpringModule extends AbstractModule {
if (definition.hasAttribute(SPRING_GUICE_SOURCE)) {
continue;
}
- Optional bindingAnnotation = getAnnotationForBeanDefinition(
- definition, beanFactory);
- if (definition.isAutowireCandidate()
- && definition.getRole() == AbstractBeanDefinition.ROLE_APPLICATION) {
+ Optional bindingAnnotation = getAnnotationForBeanDefinition(definition, beanFactory);
+ if (definition.isAutowireCandidate() && definition.getRole() == AbstractBeanDefinition.ROLE_APPLICATION) {
Type type;
Class clazz = beanFactory.getType(name);
if (clazz == null) {
@@ -147,53 +140,47 @@ public class SpringModule extends AbstractModule {
.getMergedBeanDefinition(name);
if (rootBeanDefinition.getFactoryBeanName() != null
&& rootBeanDefinition.getResolvedFactoryMethod() != null) {
- type = rootBeanDefinition.getResolvedFactoryMethod()
- .getGenericReturnType();
+ type = rootBeanDefinition.getResolvedFactoryMethod().getGenericReturnType();
}
else {
type = rootBeanDefinition.getResolvableType().getType();
}
if (type instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType) type;
- if (parameterizedType.getRawType() instanceof Class &&
- FactoryBean.class.isAssignableFrom((Class) parameterizedType.getRawType())) {
- type = Types.newParameterizedTypeWithOwner(parameterizedType.getOwnerType(),
- clazz, parameterizedType.getActualTypeArguments());
+ if (parameterizedType.getRawType() instanceof Class
+ && FactoryBean.class.isAssignableFrom((Class) parameterizedType.getRawType())) {
+ type = Types.newParameterizedTypeWithOwner(parameterizedType.getOwnerType(), clazz,
+ parameterizedType.getActualTypeArguments());
}
}
- } else {
+ }
+ else {
type = clazz;
}
if (type == null) {
continue;
}
- Provider typeProvider = BeanFactoryProvider.typed(beanFactory, type,
- bindingAnnotation);
- Provider namedProvider = BeanFactoryProvider.named(beanFactory,
- name, type, bindingAnnotation);
+ Provider typeProvider = BeanFactoryProvider.typed(beanFactory, type, bindingAnnotation);
+ Provider namedProvider = BeanFactoryProvider.named(beanFactory, name, type, bindingAnnotation);
if (!clazz.isInterface() && !ClassUtils.isCglibProxyClass(clazz)) {
- bindConditionally(binder(), name, clazz, typeProvider, namedProvider,
- bindingAnnotation);
+ bindConditionally(binder(), name, clazz, typeProvider, namedProvider, bindingAnnotation);
}
for (Type superType : getAllSuperTypes(type, clazz)) {
if (!ClassUtils.isCglibProxyClassName(superType.getTypeName())) {
- bindConditionally(binder(), name, superType, typeProvider,
- namedProvider, bindingAnnotation);
+ bindConditionally(binder(), name, superType, typeProvider, namedProvider, bindingAnnotation);
}
}
for (Type iface : clazz.getGenericInterfaces()) {
- bindConditionally(binder(), name, iface, typeProvider, namedProvider,
- bindingAnnotation);
+ bindConditionally(binder(), name, iface, typeProvider, namedProvider, bindingAnnotation);
}
}
}
}
- private static String getNameFromBindingAnnotation(
- Optional bindingAnnotation) {
+ private static String getNameFromBindingAnnotation(Optional bindingAnnotation) {
if (bindingAnnotation.isPresent()) {
Annotation annotation = bindingAnnotation.get();
if (annotation instanceof Named) {
@@ -211,16 +198,14 @@ public class SpringModule extends AbstractModule {
}
}
- private static Optional getAnnotationForBeanDefinition(
- BeanDefinition definition, ConfigurableListableBeanFactory beanFactory) {
+ private static Optional getAnnotationForBeanDefinition(BeanDefinition definition,
+ ConfigurableListableBeanFactory beanFactory) {
if (definition instanceof AnnotatedBeanDefinition
- && ((AnnotatedBeanDefinition) definition)
- .getFactoryMethodMetadata() != null) {
+ && ((AnnotatedBeanDefinition) definition).getFactoryMethodMetadata() != null) {
try {
Method factoryMethod = getFactoryMethod(beanFactory, definition);
return Arrays.stream(AnnotationUtils.getAnnotations(factoryMethod))
- .filter(a -> Annotations.isBindingAnnotation(a.annotationType()))
- .findFirst();
+ .filter(a -> Annotations.isBindingAnnotation(a.annotationType())).findFirst();
}
catch (Exception e) {
return Optional.empty();
@@ -231,25 +216,21 @@ public class SpringModule extends AbstractModule {
}
}
- private static Method getFactoryMethod(ConfigurableListableBeanFactory beanFactory,
- BeanDefinition definition) throws Exception {
+ private static Method getFactoryMethod(ConfigurableListableBeanFactory beanFactory, BeanDefinition definition)
+ throws Exception {
if (definition instanceof AnnotatedBeanDefinition) {
- MethodMetadata factoryMethodMetadata = ((AnnotatedBeanDefinition) definition)
- .getFactoryMethodMetadata();
+ MethodMetadata factoryMethodMetadata = ((AnnotatedBeanDefinition) definition).getFactoryMethodMetadata();
if (factoryMethodMetadata instanceof StandardMethodMetadata) {
- return ((StandardMethodMetadata) factoryMethodMetadata)
- .getIntrospectedMethod();
+ return ((StandardMethodMetadata) factoryMethodMetadata).getIntrospectedMethod();
}
}
- BeanDefinition factoryDefinition = beanFactory
- .getBeanDefinition(definition.getFactoryBeanName());
+ BeanDefinition factoryDefinition = beanFactory.getBeanDefinition(definition.getFactoryBeanName());
Class factoryClass = ClassUtils.forName(factoryDefinition.getBeanClassName(),
beanFactory.getBeanClassLoader());
return getFactoryMethod(definition, factoryClass);
}
- private static Method getFactoryMethod(BeanDefinition definition,
- Class factoryClass) {
+ private static Method getFactoryMethod(BeanDefinition definition, Class factoryClass) {
Method uniqueMethod = null;
for (Method candidate : getCandidateFactoryMethods(definition, factoryClass)) {
if (candidate.getName().equals(definition.getFactoryMethodName())) {
@@ -264,10 +245,8 @@ public class SpringModule extends AbstractModule {
return uniqueMethod;
}
- private static Method[] getCandidateFactoryMethods(BeanDefinition definition,
- Class factoryClass) {
- return shouldConsiderNonPublicMethods(definition)
- ? ReflectionUtils.getAllDeclaredMethods(factoryClass)
+ private static Method[] getCandidateFactoryMethods(BeanDefinition definition, Class factoryClass) {
+ return shouldConsiderNonPublicMethods(definition) ? ReflectionUtils.getAllDeclaredMethods(factoryClass)
: factoryClass.getMethods();
}
@@ -293,10 +272,8 @@ public class SpringModule extends AbstractModule {
allInterfaces.add(type);
if (type instanceof Class) {
for (Type i : ((Class) type).getInterfaces()) {
- if (i instanceof Class
- && ((Class) i).isAssignableFrom(typeToken.getRawType())) {
- Type superInterface = typeToken.getSupertype((Class) i)
- .getType();
+ if (i instanceof Class && ((Class) i).isAssignableFrom(typeToken.getRawType())) {
+ Type superInterface = typeToken.getSupertype((Class) i).getType();
queue.add(superInterface);
if (!(superInterface instanceof Class)) {
queue.add(i);
@@ -305,8 +282,7 @@ public class SpringModule extends AbstractModule {
}
if (((Class) type).getSuperclass() != null
&& ((Class) type).isAssignableFrom(typeToken.getRawType())) {
- Type superClass = typeToken
- .getSupertype(((Class) type).getSuperclass()).getType();
+ Type superClass = typeToken.getSupertype(((Class) type).getSuperclass()).getType();
queue.add(superClass);
}
}
@@ -315,8 +291,7 @@ public class SpringModule extends AbstractModule {
}
@SuppressWarnings({ "rawtypes", "unchecked" })
- private void bindConditionally(Binder binder, String name, Type type,
- Provider typeProvider, Provider namedProvider,
+ private void bindConditionally(Binder binder, String name, Type type, Provider typeProvider, Provider namedProvider,
Optional bindingAnnotation) {
if (!this.matcher.matches(name, type)) {
return;
@@ -332,8 +307,7 @@ public class SpringModule extends AbstractModule {
}
}
}
- Key key = bindingAnnotation.map(a -> (Key