用annotation处理logging

前段时间，项目中讨论了改进logging的问题。

 

我们在日常的代码中常常需要在在一个方法（method）的开始的时候log一下输入参数，在方法（method）结束时log一下return参数（很常见的问题），之前我们都是通过开发人员自己手动写代码去实现log，但是这样真的很麻烦，很多类似log的代码在程序里也不好看，于是借鉴了他人的想法，利用反射和method级的annotation来实现对入参和return值的logging。

 

1。首先定义一个Annotation来标记method是否需要打log

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MethodLogEnabler {
    /**
     * log flag
     */
    public static enum LOG {
    /**
     * log input parameters
     */
    IN,
    /**
     * log output parameters
     */
    OUT,
    /**
     * log both input & output parameters
     */
    IN_OUT} 
    
    /**
     * The log value
     * @return The log value
     */
    public LOG value();
}

 

 

2。实现一个写log的Spring拦截器

public class MethodLoggerInterceptor implements MethodInterceptor{

    public Object invoke(MethodInvocation arg0) throws Throwable {
        MethodLoggerHandler handler = new MethodLoggerHandler();
        MyLogger logger = new MyLogger();
        handler.setLogger(logger);
        return handler.execute(arg0);
    }
}

 

    拦截器所调用的handler类

/**
 * To check if the invoking method is registered MethodLogEnabler
 * annotation, and log invoking method's parameter if the annotatioin
 * is registered
 */
public class MethodLoggerHandler {
    /**
     * Default Constructor
     */
    public MethodLoggerHandler(){
        //Default Constructor
    }
    /**
     * 
     * @param methodInvocation
     * @return Object
     * @throws Throwable
     */
    public Object execute(MethodInvocation methodInvocation) throws Throwable {

        Method method = methodInvocation.getMethod();

        MethodLogEnabler annotation = null;
        //Check if annotation exists
        if (method != null && method.getAnnotation(MethodLogEnabler.class) != null) {
            annotation = method.getAnnotation(MethodLogEnabler.class);
        }
        
        //try to log method's input parameter
        if (method != null && annotation != null) {
            logInputParameters(methodInvocation, method, annotation);
        }

        Object result = null;
        try {
            //the original method call
            result = methodInvocation.proceed();
        } catch (Throwable e) {
            //log the error.
            if (logger != null) {
                logger.error("", e);
            }
            throw e;
        }
        
        //try to log method's return values
        if (method != null && annotation != null) {
            logOutputValues(method, annotation, result);
        }
        
        return result;
    }
        
    private void append(Object obj, StringBuilder appender) {
        if (obj != null) {
            //handle array object 
            if (obj.getClass().isArray()) {
                Object[] objects = (Object[]) obj;
                appender.append(getArrayOutput(objects));
            }
            //handle list object
            if (obj instanceof List) {
                Object[] objects = toArray(obj);
                appender.append(getArrayOutput(objects));
            }

            appender.append(obj.toString());
        }
    }
    
    @SuppressWarnings("unchecked")
    private Object[] toArray(Object obj) {
        Object[] objects = ((List) obj).toArray();
        return objects;
    }

    private String getArrayOutput(Object[] objects) {
        if ((objects != null) && (objects.length > 0)) {

            StringBuffer arrayOutput = new StringBuffer();
            arrayOutput.append("ARRAY[");
            for (Object object : objects) {
                if (object != null) {
                    arrayOutput.append(object.toString()).append(",");
                }
            }

            // remove last ,
            if (arrayOutput.length() > 0) {
                arrayOutput.replace(arrayOutput.length() - 1, arrayOutput.length(), "");
            }
            
            arrayOutput.append("]");
            return arrayOutput.toString();
        }
        return null;
    }
    
    private void logOutputValues(Method method, MethodLogEnabler annotation, Object result) {
        if (MethodLogEnabler.LOG.OUT.equals(annotation.value())
                || MethodLogEnabler.LOG.IN_OUT.equals(annotation.value())) {
            
            //the method has return
            if (!Void.TYPE.equals(method.getReturnType())) {
                
                StringBuilder output = new StringBuilder();
                output.append("Class[").append(method.getDeclaringClass().getName()).append("]: Method[")
                        .append(method.getName()).append("]: Retrun Value[");

                append(result, output);

                output.append("]");

                if (logger != null && logger.isDebugEnabled()) {
                    logger.debug(output.toString());
                }
            }
        }
    }
    
    private void logInputParameters(MethodInvocation methodInvocation, Method method, MethodLogEnabler annotation) {
        if (MethodLogEnabler.LOG.IN.equals(annotation.value())
                || MethodLogEnabler.LOG.IN_OUT.equals(annotation.value())) {
            
            //the method has input parameters
            if (method.getParameterTypes().length > 0) {
                
                StringBuilder string = new StringBuilder();
                string.append("Class[").append(method.getDeclaringClass().getName()).append("]: Method[").append(
                        method.getName()).append("]: Parameter[");
                
                for (Object input : methodInvocation.getArguments()) {
                    if (logger != null && logger.isDebugEnabled()) {
                        append(input, string);
                        string.append(",");
                    }
                }
                string.append("]");

                if (logger != null && logger.isDebugEnabled()) {
                    logger.debug(string.toString());
                }
            }
        }
    }
    /**
     * @param logger The logger to set.
     */
    public void setLogger(Logger logger) {
        this.logger = logger;
    }

    /**
     * @return Returns the logger.
     */
    public Logger getLogger() {
        return logger;
    }

    private Logger logger;
}

 

3。Junit的测试

写一个DumpDTO

/**
 * class DumpDTO
 */
public class DumpDTO {
    private String id;
    private int num;
    private Date time;
    private Long u;
    
    
    /**
     * @return Returns the id.
     */
    public String getId() {
        return id;
    }
    /**
     * @param id The id to set.
     */
    public void setId(String id) {
        this.id = id;
    }
    /**
     * @return Returns the num.
     */
    public int getNum() {
        return num;
    }
    /**
     * @param num The num to set.
     */
    public void setNum(int num) {
        this.num = num;
    }
    /**
     * @return Returns the time.
     */
    public Date getTime() {
        return time;
    }
    /**
     * @param time The time to set.
     */
    public void setTime(Date time) {
        this.time = time;
    }
    /**
     * @return Returns the u.
     */
    public Long getU() {
        return u;
    }
    /**
     * @param u The u to set.
     */
    public void setU(Long u) {
        this.u = u;
    }

}

 

建一个DumpHandler接口，接口里使用刚创建的MethodLogEnabler标签去定义哪些方法需要打log

public interface DumpHandler {
    /**
     * no log, because no input paramters
     */
    @MethodLogEnabler(MethodLogEnabler.LOG.IN)
    public void doA();
    /**
     * 
     * @param a
     * @param b
     * @param c
     * @param d
     */
    @MethodLogEnabler(MethodLogEnabler.LOG.IN)
    public void doB(String a, int b, Date c, Long d);
    /**
     * Only log return values
     * @param dto
     * @param string
     * @return DumpDTO
     */
    @MethodLogEnabler(MethodLogEnabler.LOG.OUT)
    public DumpDTO doC(DumpDTO dto, String string);
    /**
     * Log both input parameters and return values
     * @param dto
     * @return List<DumpDTO>
     */
    @MethodLogEnabler(MethodLogEnabler.LOG.IN_OUT)
    public List<DumpDTO> doD(DumpDTO[] dto);
}

 简单的实现Handler的接口

public class DumpHandlerImpl implements DumpHandler {

    /* (non-Javadoc)
     * @see se.ericsson.nrg.ws.adapter.bwlist.DumpHandler#doA()
     */
    public void doA() {
        System.out.println("doA");
    }

    /* (non-Javadoc)
     * @see se.ericsson.nrg.ws.adapter.bwlist.DumpHandler#doB(java.lang.String, int, java.util.Date, java.lang.Long)
     */
    @SuppressWarnings("unused")
    public void doB( String a, int b, Date c, Long d) {
        System.out.println("doB");

    }

    /* (non-Javadoc)
     * @see se.ericsson.nrg.ws.adapter.bwlist.DumpHandler#doC(se.ericsson.nrg.ws.adapter.bwlist.DumpDTO, java.lang.String)
     */   
    public DumpDTO doC(DumpDTO dto, String string) {
        System.out.println("doC");
        dto.setId("updateId: " + string);
        return dto;
    }

    /* (non-Javadoc)
     * @see se.ericsson.nrg.ws.adapter.bwlist.DumpHandler#doC(se.ericsson.nrg.ws.adapter.bwlist.DumpDTO[])
     */    
    public List<DumpDTO> doD(DumpDTO[] dto) {
        System.out.println("doD");
        return Arrays.asList(dto);

    }

}

 Junit的代码

public class MethodLoggerHandlerTest extends TestCase {
    private static XmlBeanFactory factory;
    /* (non-Javadoc)
     * @see junit.framework.TestCase#setUp()
     */
    @Override
    protected void setUp() throws Exception {        
        super.setUp();
        File file = new File("test/junit/applicationContext.xml");
        if(file.exists()){
            System.out.println("file exits");
        }
        factory = new XmlBeanFactory(new FileSystemResource("test/junit/applicationContext.xml"));
        
    }

    /**
     * unit test
     */
    public void testExecute() {
        DumpHandler handler = (DumpHandler)factory.getBean("dumpHandler");
        DumpDTO[] dtos = new DumpDTO[3];
        for(int i = 0; i < dtos.length; i++) {
            DumpDTO dto = new DumpDTO();
            dto.setId("id" + i);
            dto.setNum(100 + i);
            dto.setTime(new Date());
            dto.setU(1000l + i);
            dtos[i] = dto;
        }
        
        handler.doA();//no log
        handler.doB("a", 100, new Date(), 1000l); //log input
        handler.doC(dtos[0], getName()); // log return only, see annotation defined in DumpHandler
        handler.doD(dtos); // log both input and return
    }
}

 最后是Spring的applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
    <bean id="dumpHandler"
        class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <list>
                <value>xxx.xxx.DumpHandler</value>
            </list>
        </property>
        <property name="interceptorNames">
            <list>
                <value>logInterceptor</value>
            </list>
        </property>
        <property name="target">
            <ref bean="testImpl" />
        </property>
    </bean>
    
    <bean id="logInterceptor" class="xxx.xxx.MethodLoggerInterceptor ">        
    </bean>

    <bean id="testImpl" class="xxx.xxx.DumpHandlerImpl">        
    </bean>       


</beans>

 OK，完工。