Java log4j2的自定义注入

我一直在尝试按照文档进行操作，但正在为log4j2更新它。我好像错过了这节课

---

你知道我遗漏了什么吗？或者有人有我能看到的工作示例吗？

InjectLogger

是一种自定义注释类型，由你自己定义

下面是一个简单的例子：

Log4j2CustomInjection.java

package test.guice;

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.matcher.Matchers;

public class Log4j2CustomInjection {

  public static void main(String[] args) {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                bind(PaymentService.class).asEagerSingleton();
                bindListener(Matchers.any(), new Log4JTypeListener());
              }
            });

    PaymentService ps = injector.getInstance(PaymentService.class);
    ps.logger.info("hello");
  }
}

package test.guice;

import org.apache.logging.log4j.Logger;

public class PaymentService {
  @InjectLogger Logger logger;
}

package test.guice;

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.FIELD})
public @interface InjectLogger {}

package test.guice;

import com.google.inject.TypeLiteral;
import com.google.inject.spi.TypeEncounter;
import com.google.inject.spi.TypeListener;
import java.lang.reflect.Field;
import org.apache.logging.log4j.Logger;

class Log4JTypeListener implements TypeListener {
  public <T> void hear(TypeLiteral<T> typeLiteral, TypeEncounter<T> typeEncounter) {
    Class<?> clazz = typeLiteral.getRawType();
    while (clazz != null) {
      for (Field field : clazz.getDeclaredFields()) {
        if (field.getType() == Logger.class && field.isAnnotationPresent(InjectLogger.class)) {
          typeEncounter.register(new Log4JMembersInjector<>(field));
        }
      }
      clazz = clazz.getSuperclass();
    }
  }
}

package test.guice;

import com.google.inject.MembersInjector;
import java.lang.reflect.Field;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

class Log4JMembersInjector<T> implements MembersInjector<T> {
  private final Field field;
  private final Logger logger;

  Log4JMembersInjector(Field field) {
    this.field = field;
    this.logger = LogManager.getLogger(field.getDeclaringClass());
    field.setAccessible(true);
  }

  public void injectMembers(T t) {
    try {
      field.set(t, logger);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(e);
    }
  }
}

PaymentService.java

package test.guice;

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.matcher.Matchers;

public class Log4j2CustomInjection {

  public static void main(String[] args) {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                bind(PaymentService.class).asEagerSingleton();
                bindListener(Matchers.any(), new Log4JTypeListener());
              }
            });

    PaymentService ps = injector.getInstance(PaymentService.class);
    ps.logger.info("hello");
  }
}

package test.guice;

import org.apache.logging.log4j.Logger;

public class PaymentService {
  @InjectLogger Logger logger;
}

package test.guice;

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.FIELD})
public @interface InjectLogger {}

package test.guice;

import com.google.inject.TypeLiteral;
import com.google.inject.spi.TypeEncounter;
import com.google.inject.spi.TypeListener;
import java.lang.reflect.Field;
import org.apache.logging.log4j.Logger;

class Log4JTypeListener implements TypeListener {
  public <T> void hear(TypeLiteral<T> typeLiteral, TypeEncounter<T> typeEncounter) {
    Class<?> clazz = typeLiteral.getRawType();
    while (clazz != null) {
      for (Field field : clazz.getDeclaredFields()) {
        if (field.getType() == Logger.class && field.isAnnotationPresent(InjectLogger.class)) {
          typeEncounter.register(new Log4JMembersInjector<>(field));
        }
      }
      clazz = clazz.getSuperclass();
    }
  }
}

package test.guice;

import com.google.inject.MembersInjector;
import java.lang.reflect.Field;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

class Log4JMembersInjector<T> implements MembersInjector<T> {
  private final Field field;
  private final Logger logger;

  Log4JMembersInjector(Field field) {
    this.field = field;
    this.logger = LogManager.getLogger(field.getDeclaringClass());
    field.setAccessible(true);
  }

  public void injectMembers(T t) {
    try {
      field.set(t, logger);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(e);
    }
  }
}

InjectLogger.java

package test.guice;

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.matcher.Matchers;

public class Log4j2CustomInjection {

  public static void main(String[] args) {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                bind(PaymentService.class).asEagerSingleton();
                bindListener(Matchers.any(), new Log4JTypeListener());
              }
            });

    PaymentService ps = injector.getInstance(PaymentService.class);
    ps.logger.info("hello");
  }
}

package test.guice;

import org.apache.logging.log4j.Logger;

public class PaymentService {
  @InjectLogger Logger logger;
}

package test.guice;

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.FIELD})
public @interface InjectLogger {}

package test.guice;

import com.google.inject.TypeLiteral;
import com.google.inject.spi.TypeEncounter;
import com.google.inject.spi.TypeListener;
import java.lang.reflect.Field;
import org.apache.logging.log4j.Logger;

class Log4JTypeListener implements TypeListener {
  public <T> void hear(TypeLiteral<T> typeLiteral, TypeEncounter<T> typeEncounter) {
    Class<?> clazz = typeLiteral.getRawType();
    while (clazz != null) {
      for (Field field : clazz.getDeclaredFields()) {
        if (field.getType() == Logger.class && field.isAnnotationPresent(InjectLogger.class)) {
          typeEncounter.register(new Log4JMembersInjector<>(field));
        }
      }
      clazz = clazz.getSuperclass();
    }
  }
}

package test.guice;

import com.google.inject.MembersInjector;
import java.lang.reflect.Field;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

class Log4JMembersInjector<T> implements MembersInjector<T> {
  private final Field field;
  private final Logger logger;

  Log4JMembersInjector(Field field) {
    this.field = field;
    this.logger = LogManager.getLogger(field.getDeclaringClass());
    field.setAccessible(true);
  }

  public void injectMembers(T t) {
    try {
      field.set(t, logger);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(e);
    }
  }
}

Log4JTypeListener.java

package test.guice;

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.matcher.Matchers;

public class Log4j2CustomInjection {

  public static void main(String[] args) {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                bind(PaymentService.class).asEagerSingleton();
                bindListener(Matchers.any(), new Log4JTypeListener());
              }
            });

    PaymentService ps = injector.getInstance(PaymentService.class);
    ps.logger.info("hello");
  }
}

package test.guice;

import org.apache.logging.log4j.Logger;

public class PaymentService {
  @InjectLogger Logger logger;
}

package test.guice;

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.FIELD})
public @interface InjectLogger {}

package test.guice;

import com.google.inject.TypeLiteral;
import com.google.inject.spi.TypeEncounter;
import com.google.inject.spi.TypeListener;
import java.lang.reflect.Field;
import org.apache.logging.log4j.Logger;

class Log4JTypeListener implements TypeListener {
  public <T> void hear(TypeLiteral<T> typeLiteral, TypeEncounter<T> typeEncounter) {
    Class<?> clazz = typeLiteral.getRawType();
    while (clazz != null) {
      for (Field field : clazz.getDeclaredFields()) {
        if (field.getType() == Logger.class && field.isAnnotationPresent(InjectLogger.class)) {
          typeEncounter.register(new Log4JMembersInjector<>(field));
        }
      }
      clazz = clazz.getSuperclass();
    }
  }
}

package test.guice;

import com.google.inject.MembersInjector;
import java.lang.reflect.Field;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

class Log4JMembersInjector<T> implements MembersInjector<T> {
  private final Field field;
  private final Logger logger;

  Log4JMembersInjector(Field field) {
    this.field = field;
    this.logger = LogManager.getLogger(field.getDeclaringClass());
    field.setAccessible(true);
  }

  public void injectMembers(T t) {
    try {
      field.set(t, logger);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(e);
    }
  }
}

package test.guice；
导入com.google.inject.TypeLiteral；
导入com.google.inject.spi.typeconference；
导入com.google.inject.spi.TypeListener；
导入java.lang.reflect.Field；
导入org.apache.logging.log4j.Logger；
类Log4JTypeListener实现TypeListener{
public void hear（TypeLiteral-TypeLiteral，typeconference-typeconference）{
类clazz=typeLiteral.getRawType（）；
while（clazz！=null）{
for（字段：clazz.getDeclaredFields（））{
if（field.getType（）==Logger.class&&field.isAnnotationPresent（InjectLogger.class））{
TypeConference.register（新的Log4JMembersInjector（字段））；
}
}
clazz=clazz.getSuperclass（）；
}
}
}

Log4JMembersInjector.java

package test.guice;

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.matcher.Matchers;

public class Log4j2CustomInjection {

  public static void main(String[] args) {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                bind(PaymentService.class).asEagerSingleton();
                bindListener(Matchers.any(), new Log4JTypeListener());
              }
            });

    PaymentService ps = injector.getInstance(PaymentService.class);
    ps.logger.info("hello");
  }
}

package test.guice;

import org.apache.logging.log4j.Logger;

public class PaymentService {
  @InjectLogger Logger logger;
}

package test.guice;

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.FIELD})
public @interface InjectLogger {}

package test.guice;

import com.google.inject.TypeLiteral;
import com.google.inject.spi.TypeEncounter;
import com.google.inject.spi.TypeListener;
import java.lang.reflect.Field;
import org.apache.logging.log4j.Logger;

class Log4JTypeListener implements TypeListener {
  public <T> void hear(TypeLiteral<T> typeLiteral, TypeEncounter<T> typeEncounter) {
    Class<?> clazz = typeLiteral.getRawType();
    while (clazz != null) {
      for (Field field : clazz.getDeclaredFields()) {
        if (field.getType() == Logger.class && field.isAnnotationPresent(InjectLogger.class)) {
          typeEncounter.register(new Log4JMembersInjector<>(field));
        }
      }
      clazz = clazz.getSuperclass();
    }
  }
}

package test.guice;

import com.google.inject.MembersInjector;
import java.lang.reflect.Field;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

class Log4JMembersInjector<T> implements MembersInjector<T> {
  private final Field field;
  private final Logger logger;

  Log4JMembersInjector(Field field) {
    this.field = field;
    this.logger = LogManager.getLogger(field.getDeclaringClass());
    field.setAccessible(true);
  }

  public void injectMembers(T t) {
    try {
      field.set(t, logger);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(e);
    }
  }
}

package test.guice；
导入com.google.inject.membersInject；
导入java.lang.reflect.Field；
导入org.apache.logging.log4j.LogManager；
导入org.apache.logging.log4j.Logger；
类Log4JMembersInjector实现MembersInjector{
私人终场；
私人最终记录器；
Log4JMembersInjector（字段）{
this.field=字段；
this.logger=LogManager.getLogger（field.getDeclaringClass（））；
字段。setAccessible（true）；
}
公众成员（T）{
试一试{
字段设置（t，记录器）；
}捕获（非法访问例外e）{
抛出新的运行时异常（e）；
}
}
}