java反射机制实现Log出力，事务处理_java 反射调用log-优快云博客

本文链接：https://blog.youkuaiyun.com/youandi79/article/details/1588952

本文介绍了如何使用Java反射机制创建代理类，并结合日志记录实现事务处理。`ServiceProxyFactory`类创建了目标类的代理实例，通过`InvocationHandler`接口的`invoke`方法处理事务开始、结束以及异常情况。`ServiceProxyHandler`实现了`InvocationHandler`，并在调用目标方法前后进行日志记录。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

ServiceProxyFactory.java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;

import jp.co.mg.mgstruts.exception.ProcessingException;

public class ServiceProxyFactory {

private static final int NON_TRANSACTION = 6;
private static final int TRANSACTION = 3;

private Class targetClass;
private static Map cache = new HashMap();

public ServiceProxyFactory(Class targetClass) {
this.targetClass = targetClass;
}

public synchronized Object getProxy(int transactionType)
   throws ProcessingException {
  Object target = cache.get(targetClass);
  if (target == null) {
   try {
    target = targetClass.newInstance();
   } catch (InstantiationException e) {
    throw new ProcessingException("CICORESE085");
   } catch (IllegalAccessException e) {
    throw new ProcessingException("CICORESE085");
   }
   cache.put(targetClass, target);
  }
  InvocationHandler handler = new ServiceProxyHandler(target, transactionType);
  return Proxy.newProxyInstance(target.getClass().getClassLoader(),
    target.getClass().getInterfaces(), handler);
}

public Object getTransactionalProxy() throws ProcessingException {
return getProxy(TRANSACTION);
}

public Object getNonTransactionalProxy() throws ProcessingException {
return getProxy(NON_TRANSACTION);
}
}

ServiceProxyHandler.java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import org.apache.log4j.Logger;

public class ServiceProxyHandler implements InvocationHandler {

Logger log = Logger.getLogger(ServiceProxyHandler.class.getName());

private final Object impl;
private int transactionType;
private Map methodNameCache;

public ServiceProxyHandler(Object impl, int transactionType) {
  methodNameCache = new HashMap();
  this.impl = impl;
  this.transactionType = transactionType;
}

public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable {

  // Log Start.
  logStart(method, args);
  // TODO Transaction Start.
  System.out.println("Transaction Start!");
  Object obj;
  try {
   obj = method.invoke(impl, args);
  } catch (Throwable t) {

   // TODO Transaction Error.
   System.out.println("Transaction Error!");
   // TODO Log Error.
   System.out.println("Log Error!");
   log.error("Log Start!");
   throw t;
  } finally {

  }
  // TODO Transaction End.
  System.out.println("Transaction End!");
  // Log End.
  logEnd(method, args);
  return obj;
}

private void logStart(Method method, Object[] args) {
  log.info("METHOD [" + method.getName() + "] START");
  if (!log.isDebugEnabled() || args == null) {
   return;
  }

  log.debug("METHOD [" + method.getName() + "] PARAM:");

  StringBuffer buff = new StringBuffer();

  for (Object obj : args) {
   LogHelper.dumpData(obj, buff);
  }
  log.debug(buff.toString());
}

private void logEnd(Method method, Object args[]) {
  log.info("METHOD [" + method.getName() + "] END");
}
}