Spring Constructor Injektion von SLF4J Logger - Wie bekommt man Injektionszielklasse?

Question

Ich versuche Frühling zu verwenden, um einen SLF4J Logger in eine Klasse zu injizieren etwa so:

@Component 
public class Example { 

    private final Logger logger; 

    @Autowired 
    public Example(final Logger logger) { 
    this.logger = logger; 
    } 
} 

ich die FactoryBean Klasse gefunden habe, die ich umgesetzt habe. Aber das Problem ist, dass ich keine Informationen über die Injektion Ziel zu erreichen:

public class LoggingFactoryBean implements FactoryBean<Logger> { 

    @Override 
    public Class<?> getObjectType() { 
     return Logger.class; 
    } 

    @Override 
    public boolean isSingleton() { 
     return false; 
    } 

    @Override 
    public Logger getObject() throws Exception { 
     return LoggerFactory.getLogger(/* how do I get a hold of the target class (Example.class) here? */); 
    } 
} 

Sind FactoryBean auch der richtige Weg zu gehen? Bei Verwendung von Picocontainern factory injection erhalten Sie die Type des Ziels übergeben. In guice ist es ein bisschen trickier. Aber wie schaffen Sie das im Frühling?

Answer 1

Ich löste es mit einer benutzerdefinierten BeanFactory. Wenn jemand eine bessere Lösung findet, würde ich mich freuen, es zu hören. Wie auch immer, hier ist der BeanFactory:

import java.util.Set; 

import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
import org.springframework.beans.BeansException; 
import org.springframework.beans.TypeConverter; 
import org.springframework.beans.factory.config.DependencyDescriptor; 
import org.springframework.beans.factory.support.DefaultListableBeanFactory; 

public class CustomBeanFactory extends DefaultListableBeanFactory { 

    public CustomBeanFactory() { 
    } 

    public CustomBeanFactory(DefaultListableBeanFactory delegate) { 
     super(delegate); 
    } 

    @Override 
    public Object resolveDependency(DependencyDescriptor descriptor, 
      String beanName, Set<String> autowiredBeanNames, 
      TypeConverter typeConverter) throws BeansException { 
     //Assign Logger parameters if required  
     if (descriptor.isRequired() 
       && Logger.class.isAssignableFrom(descriptor 
         .getMethodParameter().getParameterType())) {    
      return LoggerFactory.getLogger(descriptor.getMethodParameter() 
        .getDeclaringClass()); 
     } else { 
      return super.resolveDependency(descriptor, beanName, 
        autowiredBeanNames, typeConverter); 
     } 
    } 
} 

Beispiel für die Verwendung mit einem XML-config:

 CustomBeanFactory customBeanFactory = new CustomBeanFactory();  
     GenericApplicationContext ctx = new GenericApplicationContext(customBeanFactory); 
     XmlBeanDefinitionReader xmlReader = new XmlBeanDefinitionReader(ctx); 
     xmlReader.loadBeanDefinitions(new ClassPathResource("beans.xml")); 
     ctx.refresh(); 

EDIT:

Unten finden Arend v Reinersdorffs Version verbessert (siehe die Kommentare für ein. Erläuterung).

import java.lang.reflect.Field; 
import java.util.Set; 

import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
import org.springframework.beans.BeansException; 
import org.springframework.beans.TypeConverter; 
import org.springframework.beans.factory.config.DependencyDescriptor; 
import org.springframework.beans.factory.support.DefaultListableBeanFactory; 
import org.springframework.core.MethodParameter; 

public class CustomBeanFactory extends DefaultListableBeanFactory { 

    public CustomBeanFactory() { 
    } 

    public CustomBeanFactory(DefaultListableBeanFactory delegate) { 
     super(delegate); 
    } 

    @Override 
    public Object resolveDependency(DependencyDescriptor descriptor, 
      String beanName, Set<String> autowiredBeanNames, 
      TypeConverter typeConverter) throws BeansException { 
     //Assign Logger parameters if required  
     if (Logger.class == descriptor.getDependencyType()) {    
      return LoggerFactory.getLogger(getDeclaringClass(descriptor)); 
     } else { 
      return super.resolveDependency(descriptor, beanName, 
        autowiredBeanNames, typeConverter); 
     } 
    } 

    private Class<?> getDeclaringClass(DependencyDescriptor descriptor) { 
     MethodParameter methodParameter = descriptor.getMethodParameter(); 
     if (methodParameter != null) { 
      return methodParameter.getDeclaringClass(); 
     } 
     Field field = descriptor.getField(); 
     if (field != null) { 
      return field.getDeclaringClass(); 
     } 
     throw new AssertionError("Injection must be into a method parameter or field."); 
    } 
} 

Answer 2

1. Warum erstellen Sie einen neuen Logger für jede Instanz? Das typische Muster ist ein Logger pro Klasse (als privates statisches Mitglied).

2. Wenn Sie es wirklich so machen wollen: Vielleicht können Sie eine Logger-Fabrik-Klasse schreiben und das injizieren? Etwas wie:

   @Singleton 
   public class LogFactory { 
       public Logger getLogger(Object o) { 
        return LoggerFactory.getLogger(o.getClass()); 
       } 
   } 
   

Answer 3

Ja, Sie sind in der falschen Richtung. Wenn ich du wäre, würde ich die LoggerFactory injizieren. Wenn Sie ausblenden möchten, dass es slf4j ist, dann würde ich eine LoggerFactory-Schnittstelle definieren und eine Klasse injizieren, die an slfl4j Logger delegiert.

public interface LoggerFactory { 
    public Logger getLogger(Class<?> clazz); 
} 
... 
import org.slf4j.LoggerFactory; 
public class Slf4jLoggerFactory implements LoggerFactory { 
    public Logger getLogger(Class<?> clazz) { 
     return org.slf4j.LoggerFactory.getLogger(clazz); 
    } 
} 

Doch bevor Sie dorthin gehen, dann ist dies etwa, was org.apache.commons.logging richtig macht? http://commons.apache.org/logging/

Sie verwenden Logbuch statt Loggers:

import org.apache.commons.logging.Log; 
import org.apache.commons.logging.LogFactory; 
public class CLASS { 
    private Log log = LogFactory.getLog(CLASS.class); 
    ... 

Apache dann Classpath schaut durch, um zu sehen, ob Sie log4j oder andere und Delegierten der „beste“ eine, die es findet. Slf4j ersetzt log4j im Klassenpfad. Wenn Sie es also geladen haben (und Apache log4j ausgeschlossen), wird die Commons-Protokollierung stattdessen an diesen delegieren.

Answer 4

Hier ist eine Alternative zu Ihrer Lösung. Sie können Ihr Ziel mit BeanFactoryPostProcessor Implementierung erreichen.

Angenommen, Sie möchten eine Klasse mit Protokollierung haben.Hier ist sie:

package log; 
    import org.apache.log4j.Logger; 

    @Loggable 
    public class MyBean { 

    private Logger logger; 
    } 

Wie Sie diese Klasse nichts tut, sehen können, und erstellt nur ein Logger Behälter für Einfachheit zu sein. Die einzige bemerkenswerte Sache ist hier @Loggable Annotation. hier sein Quellcode:

package log; 

import java.lang.annotation.ElementType; 
import java.lang.annotation.Retention; 
import java.lang.annotation.RetentionPolicy; 
import java.lang.annotation.Target; 

@Retention(RetentionPolicy.RUNTIME) 
@Target(ElementType.TYPE) 
public @interface Loggable { 
} 

Diese Anmerkung ist nur ein Marker für die weitere Verarbeitung. Und hier ist ein interessanteste Teil:

package log; 

import org.apache.log4j.Logger; 
import org.springframework.beans.BeansException; 
import org.springframework.beans.factory.config.BeanFactoryPostProcessor; 
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; 

import java.lang.reflect.Field; 

public class LoggerBeanFactoryPostProcessor implements BeanFactoryPostProcessor{ 

    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { 
     String[] names = beanFactory.getBeanDefinitionNames(); 
     for(String name : names){ 
      Object bean = beanFactory.getBean(name); 
      if(bean.getClass().isAnnotationPresent(Loggable.class)){ 
       try { 
        Field field = bean.getClass().getDeclaredField("logger"); 
        field.setAccessible(true); 
        field.set(bean, Logger.getLogger(bean.getClass())); 
       } catch (Exception e) { 
        e.printStackTrace(); 
       } 
      } 
     } 
    } 
} 

Es durchsucht alle Bohnen, und wenn eine Bohne als @Loggable markiert ist, es seinen privaten Bereich initialisieren mit dem Namen Logger. Sie könnten sogar noch weiter gehen und einige Parameter in @Loggable Annotation übergeben. Zum Beispiel könnte es ein Name des Feldes sein, das dem Logger entspricht.

Ich habe Log4j in diesem Beispiel verwendet, aber ich denke, es sollte genau so funktionieren mit slf4j.

Answer 5

Ich versuche, diese Funktion in offizielle SLF4J API zu bekommen. Bitte unterstützen/Stimme/contribute: https://issues.jboss.org/browse/JBLOGGING-62

(diese Funktion bereits von JBoss Logging + Seam Solder implementiert ist, siehe http://docs.jboss.org/seam/3/latest/reference/en-US/html/solder-logging.html)

11,4. Logger native API

Sie können auch eine "plain old" Logger injizieren (von der JBoss Logging API):

import javax.inject.Inject; 
import org.jboss.logging.Logger; 

public class LogService { 

    @Inject 
    private Logger log; 

    public void logMessage() { 
     log.info("Hey sysadmins!"); 
    } 

} 

Log-Meldungen von diesem Logger erstellt eine Kategorie (Logger Name) haben gleich der vollständig -qualifizierter Klassenname der Bean-Implementierungsklasse Sie können eine Kategorie explizit mithilfe einer Anmerkung angeben.

@Inject @Category("billing") 
private Logger log; 

Sie können auch eine Kategorie mit einem Verweis auf einen Typ festlegen:

@Inject @TypedCategory(BillingService.class) 
private Logger log; 

Es tut uns keine relevante Antwort zu geben.

Answer 6

Versuchen Sie so etwas wie:

@Component 
public class Example { 

    @Autowired 
    @Qualifier("exampleLogger") 
    private final Logger logger; 

} 

Und:

<bean id="exampleLogger" class="org.slf4j.LoggerFactory" factory-method="getLogger"> 
    <constructor-arg type="java.lang.Class" value="package.Example"/>   
</bean> 

Answer 7

Seit dem Frühjahr 4.3.0 Sie InjectionPoint oder DependencyDescriptor als Parameter für Bohnenherstellungsverfahren verwendet werden können: Um

@Component 
public class LoggingFactoryBean { 
    @Bean 
    public Logger logger(InjectionPoint injectionPoint) { 
     Class<?> targetClass = injectionPoint.getMember().getDeclaringClass(); 
     return LoggerFactory.getLogger(targetClass); 
    } 
} 

Answer 8

Machen Sie Ihren Code mehr Frühling bewusst verwenden Sie die InjectionPoint, um die Logger zu definieren, d.h.:

@Bean 
@Scope("prototype") 
public Logger logger(InjectionPoint ip) { 
    return Logger.getLogger(ip.getMember().getDeclaringClass()); 
} 

@Scope("prototype") wird hier gebraucht 'Logger' Bean-Instanz jedes Mal Methode aufgerufen wird, zu erstellen.