Logger Template

log4j 1.2.x:PropertyConfigurator.configure("");
${:import(org.apache.log4j.Logger,java.lang.invoke.MethodHandles)}
private static final Logger logger = Logger.getLogger(MethodHandles.lookup().lookupClass());

log4j 2.x:Configurator.initialize(null);
${:import(org.apache.logging.log4j.Logger,org.apache.logging.log4j.LogManager,java.lang.invoke.MethodHandles)}
private static final Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass());

slf4j
${:import(org.slf4j.Logger,org.slf4j.LoggerFactory,java.lang.invoke.MethodHandles)}
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());

private static final Logger logger = Logger.getLogger(MethodHandles.lookup().lookupClass());
private static final Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass());
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass()); 

slf4j,@see http://glauche.de/2009/08/24/logging-with-slf4j-and-guice/

import java.lang.annotation.Target;
import java.lang.annotation.Retention;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Target({FIELD})
@Retention(RUNTIME)
public @interface Log {}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.Field;
import com.google.inject.MembersInjector;

public class Slf4jMembersInjector<T>  implements MembersInjector<T> {
	
    private final Field field;
    private final Logger logger;
    
    Slf4jMembersInjector(Field aField) {
    	field = aField;
    	logger = LoggerFactory.getLogger(field.getDeclaringClass());
    	field.setAccessible(true);
    }
  
    public void injectMembers(T instance) {
	try {
		field.set(instance,logger);
	} catch (IllegalAccessException e) {
		throw new RuntimeException(e);
	}
   }	
}

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

public class Slf4jTypeListener implements TypeListener {

	public <I> void hear(TypeLiteral<I> typeLiteral,TypeEncounter<I> typeEncounter) {
		
		for (Field field : typeLiteral.getRawType().getDeclaredFields()) {
			if (field.getType() == Logger.class && field.isAnnotationPresent(Log.class)) {
	        	        typeEncounter.register(new Slf4jMembersInjector<I>(field));
	                }
		}
	}
	
}

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

public class Module extends AbstractModule {

	protected void configure() {
                 bindListener(Matchers.any(),new Slf4jTypeListener());
        }
    
}

@Log Logger log;
public void testLog(boolean magicNumIndex){
	StackTraceElement[] steArr = Thread.currentThread().getStackTrace();
	StackTraceElement ste = magicNumIndex ? steArr[1] : steArr[2];
	log.info("className:{},fileName:{},methodName:{},lineNumber:{}",
		ste.getClassName(),ste.getFileName(),ste.getMethodName(),ste.getLineNumber());
}