Wstrzyknięty konstruktor sprężyny rejestratora SLF4J - jak uzyskać klasę docelową wtrysku?

Question

Próbuję użyć Wiosna wstrzyknąć rejestratora slf4j do klasy tak:

@Component 
public class Example { 

    private final Logger logger; 

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

Znalazłem klasę FactoryBean, które zostały wdrożone. Problem polega jednak na tym, że nie mogę uzyskać żadnych informacji na temat celu wstrzykiwania:

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? */); 
    } 
} 

Czy FactoryBean jest jeszcze dobrym rozwiązaniem? Podczas korzystania z picocontainerów factory injection, dostajesz Type przekazanego celu. W guice jest to nieco trickier. Ale jak to osiągnąć na wiosnę?

Answer 1

Rozwiązałem go za pomocą niestandardowego BeanFactory. Jeśli ktoś wymyśli lepsze rozwiązanie, byłbym szczęśliwy, słysząc to. Tak czy inaczej, oto fabryka fasola:

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); 
     } 
    } 
} 

Przykład użycia z config XML:

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

EDIT:

Poniżej można znaleźć Arend v Reinersdorffs poprawiona wersja (patrz komentarze do An. wyjaśnienie).

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. Dlaczego tworzysz nowy program rejestrujący dla każdej instancji? Typowy wzór to jeden rejestrator na klasę (jako prywatny statyczny element członkowski).

2. Jeśli naprawdę chcesz to zrobić w ten sposób: Może możesz napisać klasę fabryki rejestratora i wstrzyknąć to? Coś jak:

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

Answer 3

Tak, idziesz w złym kierunku. Gdybym był tobą, wstrzyknęłabym LoggerFactory. Jeśli chcesz ukryć, że jest to slf4j, to zdefiniowałbym interfejs LoggerFactory i wstrzyknę klasę, która deleguje do Slf4j Logger.

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); 
    } 
} 

Jednak zanim się tam udasz, jest to mniej więcej to, co robi org.apache.commons.logging, prawda? http://commons.apache.org/logging/

użyć dziennika zamiast rejestratorów:

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

Apache następnie przegląda ścieżki klasy, aby sprawdzić, czy masz log4j lub innym i delegatów na „najlepszego” ten, który znajdzie. Slf4j zastępuje log4j w ścieżce klas, więc jeśli masz to załadowane (i wyłączone jest logowanie apache), to zamiast tego zostanie przeniesione do niego wspólne logowanie.

Answer 4

Oto alternatywa dla rozwiązania. Możesz osiągnąć swój cel dzięki implementacji BeanFactoryPostProcessor.

Załóżmy, że chcesz mieć zajęcia z rejestracją.Oto ona:

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

    @Loggable 
    public class MyBean { 

    private Logger logger; 
    } 

Jak można zobaczyć klasa ta nie robi nic i stworzył po prostu być pojemnik rejestrator dla prostoty. Jedyną niezwykłą rzeczą jest tutaj adnotacja: @Loggable. tu swój kod źródłowy:

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 { 
} 

tej uwagi jest jedynie markerem dla dalszego przetwarzania. I tu jest najciekawsza część:

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(); 
       } 
      } 
     } 
    } 
} 

To przeszukuje wszystkie fasola, fasola i jeżeli jest oznaczony jako @Loggable, to zainicjować swój prywatny pole z nazwą rejestratora. Możesz przejść jeszcze dalej i przekazać niektóre parametry w adnotacji @Loggable. Na przykład może to być nazwa pola odpowiadającego loggerowi.

Użyłem Log4j w tym przykładzie, ale myślę, że powinien działać dokładnie tak samo z slf4j.

Answer 5

Próbuję włączyć tę funkcję do oficjalnego API SLF4J. Prosimy o wsparcie/głos/przyczynić: https://issues.jboss.org/browse/JBLOGGING-62

(ta funkcja jest już realizowany przez JBoss Seam Rejestrowanie + lutowane, patrz http://docs.jboss.org/seam/3/latest/reference/en-US/html/solder-logging.html)

11,4. Native rejestrator API

Można również wstrzyknąć "zwykły stary" Logger (z Logging API JBoss):

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

public class LogService { 

    @Inject 
    private Logger log; 

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

} 

wiadomości dziennika utworzone z tego rejestratora będzie miała kategorię (nazwa rejestratora) równa się w pełni -kwalifikowalna nazwa klasy klasy implementacji bean. Kategorię można jawnie określić za pomocą adnotacji.

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

Można również określić kategorię używając odniesienie do typu:

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

Przepraszamy za nie dostarczenie odpowiedniej odpowiedzi.

Answer 6

Spróbuj czegoś takiego:

@Component 
public class Example { 

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

} 

oraz:

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

Answer 7

od wiosny 4.3.0 można użyć InjectionPoint lub DependencyDescriptor jako parametry do fasoli produkujących metodami:

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

Answer 8

Aby spraw, aby twój kod był bardziej sprężysty, używaj InjectionPoint do definiowania rejestratorów, tj.:

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

@Scope("prototype") konieczna jest tutaj, aby utworzyć „rejestratora” wystąpienie fasoli każda metoda jest wywoływana raz.