diff --git a/loginject/loginject-api/src/main/java/org/loginject/LogInject.java b/loginject/loginject-api/src/main/java/org/loginject/LogInject.java index 04f5a4d..b6c49a8 100644 --- a/loginject/loginject-api/src/main/java/org/loginject/LogInject.java +++ b/loginject/loginject-api/src/main/java/org/loginject/LogInject.java @@ -23,6 +23,7 @@ import java.util.function.Function; import java.util.function.Predicate; import java.util.function.Supplier; +import java.util.stream.Collectors; import java.util.stream.Stream; import static java.util.stream.StreamSupport.stream; @@ -115,7 +116,13 @@ ClassType getLoggerClassType() _Logger_ createLogger(Class currentClass) { Stream parameters = Arrays.stream(parameterTypes).map(parameter -> parameter.getValue(currentClass)); - return loggerCreator.apply(parameters.toArray(Object[]::new)); +System.err.println("loggerCreator=" + loggerCreator); +System.err.println("parameters=" + Arrays.stream(parameterTypes).map(parameter -> parameter.getValue(currentClass)).collect(Collectors.toList())); +try { + _Logger_ logger = loggerCreator.apply(parameters.toArray(Object[]::new)); +System.err.println("logger=" + logger); + return logger; +} catch (Throwable t) {t.printStackTrace();return null;} } /** diff --git a/loginject/loginject-guice/src/main/java/org/loginject/GuiceLogInjectionService.java b/loginject/loginject-guice/src/main/java/org/loginject/GuiceLogInjectionService.java index b59b6f4..ddb19fd 100644 --- a/loginject/loginject-guice/src/main/java/org/loginject/GuiceLogInjectionService.java +++ b/loginject/loginject-guice/src/main/java/org/loginject/GuiceLogInjectionService.java @@ -1,5 +1,5 @@ // // -// Copyright 2016 Mirko Raner // +// Copyright 2015 - 2021 Mirko Raner // // // // Licensed under the Apache License, Version 2.0 (the "License"); // // you may not use this file except in compliance with the License. // @@ -28,16 +28,25 @@ import com.google.inject.TypeLiteral; import com.google.inject.matcher.Matchers; import com.google.inject.spi.BindingTargetVisitor; +import com.google.inject.spi.ConstructorBinding; +import com.google.inject.spi.ConvertedConstantBinding; import com.google.inject.spi.DefaultBindingTargetVisitor; import com.google.inject.spi.Dependency; -import com.google.inject.spi.DependencyAndSource; +import com.google.inject.spi.HasDependencies; import com.google.inject.spi.InjectionPoint; +import com.google.inject.spi.InstanceBinding; import com.google.inject.spi.ProviderInstanceBinding; import com.google.inject.spi.ProvisionListener; import com.google.inject.util.Modules; import static java.util.stream.Collectors.toList; import static java.util.stream.Collectors.toSet; +import java.lang.reflect.Field; +import java.lang.reflect.Member; +import java.lang.reflect.Method; +import java.lang.reflect.Type; +import java.util.ArrayDeque; + /** * The class {@link GuiceLogInjectionService} implements a {@link LogInjectionService} for the * {@link com.google.inject.Guice Guice} dependency injection framework. It binds a @@ -61,7 +70,10 @@ private Module getBindings(LogInject<_Logger_> logInject, Class<_Logger_> logger { TypeLiteral<_Logger_> loggerType = TypeLiteral.get(loggerClass); GuiceLoggerProvider<_Logger_> provider = new GuiceLoggerProvider<>(); - Predicate> matchesLogger = dependency -> loggerType.equals(dependency.getKey().getTypeLiteral()); + Predicate matchesLogger = injectionPoint -> { +System.err.println("matches " + loggerType + " <-> " + getType(injectionPoint)); + return loggerType.equals(getType(injectionPoint)); + }; return new AbstractModule() { @Override @@ -69,30 +81,57 @@ protected void configure() { ProvisionListener provisionListener = new ProvisionListener() { + private final ThreadLocal>> bindingStack = + new ThreadLocal>>() + { + @Override protected ArrayDeque> initialValue() + { + return new ArrayDeque<>(); + } + }; + @Override public <_Target_> void onProvision(ProvisionInvocation<_Target_> provision) { Binding<_Target_> binding = provision.getBinding(); + bindingStack.get().push(binding); + try { + provision.provision(); + } catch (Exception e) + { + } finally { + bindingStack.get().pop(); + } if (loggerType.equals(binding.getKey().getTypeLiteral())) { - Dependency loggerDependency; - Stream> stream; - stream = provision.getDependencyChain().stream().map(DependencyAndSource::getDependency); - Iterator> dependencies = reverse(stream.collect(toList())).iterator(); - if (dependencies.hasNext() && matchesLogger.test(loggerDependency = dependencies.next())) +System.err.println("binding stack=" + bindingStack.get()); +// Dependency loggerDependency; +// Stream> stream = ((HasDependencies)binding).getDependencies().stream(); +System.err.println("binding=" + binding); +System.err.println("deps=" + ((HasDependencies)binding).getDependencies()); +// Iterator> dependencies = reverse(stream.collect(toList())).iterator(); + Binding topBinding = bindingStack.get().peek(); +System.err.println("top binding=" + topBinding); +System.err.println("top binding injection points=" + getInjectionPoints(topBinding)); + Stream injectionPoints = getInjectionPoints(topBinding) + .stream() + .filter(matchesLogger); + //if (dependencies.hasNext() && matchesLogger.test(loggerDependency = dependencies.next())) + injectionPoints.forEach(injectionPoint -> { - InjectionPoint injectionPoint = loggerDependency.getInjectionPoint(); +System.err.println("injection point=" + injectionPoint); TypeLiteral declaringType = injectionPoint.getDeclaringType(); TypeLiteral targetType = null; - if (dependencies.hasNext()) - { - TypeLiteral typeLiteral = dependencies.next().getKey().getTypeLiteral(); - if (declaringType.getRawType().isAssignableFrom(typeLiteral.getRawType())) - { - targetType = typeLiteral; - } - } - Class logger = (targetType != null? targetType:declaringType).getRawType(); +// if (dependencies.hasNext()) +// { +// TypeLiteral typeLiteral = dependencies.next().getKey().getTypeLiteral(); +// if (declaringType.getRawType().isAssignableFrom(typeLiteral.getRawType())) +// { +// targetType = typeLiteral; +// } +// } + Class logger = getType(injectionPoint).getRawType();//(targetType != null? targetType:declaringType).getRawType(); +System.err.println("logger=" + logger); BindingTargetVisitor<_Target_, Void> bindingTargetVisitor; bindingTargetVisitor = new DefaultBindingTargetVisitor<_Target_, Void>() { @@ -101,13 +140,15 @@ public Void visit(ProviderInstanceBinding instanceBinding) { if (provider.equals(instanceBinding.getUserSuppliedProvider())) { - provider.setLogger(logInject.createLogger(logger)); + _Logger_ loggerInstance = logInject.createLogger(logger); +System.err.println("loggerInstance=" + loggerInstance); + provider.setLogger(loggerInstance); } return null; } }; binding.acceptTargetVisitor(bindingTargetVisitor); - } + }); } } }; @@ -154,6 +195,49 @@ <_Type_> List<_Type_> reverse(List<_Type_> list) return list; } + TypeLiteral getType(InjectionPoint injectionPoint) + { + Type type = getMemberType(injectionPoint.getMember()); + return TypeLiteral.get(type); + } + + Type getMemberType(Member member) + { + if (member instanceof Field) + { + return ((Field)member).getGenericType(); + } + if (member instanceof Method) + { + return ((Method)member).getGenericReturnType(); + } + return null; + } + + Set getInjectionPoints(Binding binding) + { + if (binding instanceof ConstructorBinding) + { + return ((ConstructorBinding)binding).getInjectableMembers(); + } + if (binding instanceof InstanceBinding) + { + return ((InstanceBinding)binding).getInjectionPoints(); + } + if (binding instanceof ProviderInstanceBinding) + { + return ((ProviderInstanceBinding)binding).getInjectionPoints(); + } + if (binding instanceof ConvertedConstantBinding) + { + return ((ConvertedConstantBinding)binding).getDependencies() + .stream() + .map(Dependency::getInjectionPoint) + .collect(toSet()); + } + return Collections.emptySet(); + } + Stream> getAllBindingTypes(Class type) { return getAllPotentialBindingTypes(type).stream().filter(this::noJDKClasses); diff --git a/loginject/pom.xml b/loginject/pom.xml index f3c8ff8..57148eb 100644 --- a/loginject/pom.xml +++ b/loginject/pom.xml @@ -49,7 +49,7 @@ UTF-8 2.6.1 - 4.1.0 + 5.0.1 2.17.1