如何更优计算多处DAO数据库调用的耗时？

这问题我太懂了——手动在每个DAO调用前后加时间戳不仅繁琐，还容易漏写，维护起来也头疼。给你几个不用到处改代码的优质方案，都是业界常用的：

1. 面向切面编程（AOP）——最省心的通用方案 #

如果你的项目用了Spring/Spring Boot，AOP绝对是首选。通过定义一个切面，你可以拦截所有DAO层的方法调用，统一在调用前后统计耗时，完全不碰业务代码。

比如用Spring AOP实现：

@Aspect
@Component
public class DAOPerformanceAspect {

    private static final Logger logger = LoggerFactory.getLogger(DAOPerformanceAspect.class);

    // 定义切点：拦截com.yourpackage.dao包下所有类的所有方法
    @Pointcut("execution(* com.yourpackage.dao..*(..))")
    public void allDaoMethods() {}

    @Around("allDaoMethods()")
    public Object measureExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        try {
            // 执行原始DAO方法
            return joinPoint.proceed();
        } finally {
            long endTime = System.currentTimeMillis();
            long duration = endTime - startTime;
            // 打印耗时，也可以上报到监控系统
            logger.info("DAO方法 [{}] 执行耗时: {} ms", 
                joinPoint.getSignature().toShortString(), duration);
        }
    }
}

好处：

• 完全无侵入，一次配置，所有DAO方法自动被监控
• 支持统一处理异常场景下的耗时统计
• 轻松扩展：比如对耗时超过阈值的方法报警，或者把数据推送到监控平台

2. 代理模式——无框架依赖的轻量方案 #

如果你的项目没有用Spring这类AOP框架，手动实现动态代理也是个不错的选择。通过包装原始DAO对象，在代理类中统一处理耗时统计。

示例代码：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.concurrent.TimeUnit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DAOProxy<T> implements InvocationHandler {
    private final T targetDAO;
    private static final Logger logger = LoggerFactory.getLogger(DAOProxy.class);

    private DAOProxy(T targetDAO) {
        this.targetDAO = targetDAO;
    }

    // 创建代理对象的静态方法
    @SuppressWarnings("unchecked")
    public static <T> T createProxy(T targetDAO) {
        return (T) Proxy.newProxyInstance(
            targetDAO.getClass().getClassLoader(),
            targetDAO.getClass().getInterfaces(),
            new DAOProxy<>(targetDAO)
        );
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long startTime = System.nanoTime();
        try {
            // 调用原始DAO方法
            return method.invoke(targetDAO, args);
        } finally {
            long duration = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime);
            logger.info("DAO方法 [{}] 执行耗时: {} ms", method.getName(), duration);
        }
    }
}

使用的时候，把原始DAO替换成代理对象：

// 原来的代码：UserDao userDao = new UserDaoImpl();
// 现在的代码：
UserDao userDao = DAOProxy.createProxy(new UserDaoImpl());

好处：

• 不依赖任何框架，代码轻量
• 同样无侵入原始DAO业务代码
• 可以灵活控制哪些DAO类需要被代理

3. 利用ORM框架自带的监控插件——精准到SQL的统计 #

如果你的项目用了MyBatis、Hibernate这类ORM框架，它们自带的扩展机制可以帮你精准统计SQL执行耗时，甚至能拿到具体的SQL语句。

比如MyBatis的拦截器实现：

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Properties;

@Intercepts({
    @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
    @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, org.apache.ibatis.session.RowBounds.class, org.apache.ibatis.session.ResultHandler.class})
})
public class MyBatisPerformanceInterceptor implements Interceptor {
    private static final Logger logger = LoggerFactory.getLogger(MyBatisPerformanceInterceptor.class);

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement ms = (MappedStatement) invocation.getArgs()[0];
        String sqlId = ms.getId();
        long startTime = System.currentTimeMillis();
        try {
            return invocation.proceed();
        } finally {
            long endTime = System.currentTimeMillis();
            long duration = endTime - startTime;
            logger.info("MyBatis SQL [{}] 执行耗时: {} ms", sqlId, duration);
        }
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
        // 可以配置参数，比如超时阈值
    }
}

然后在MyBatis配置文件中注册这个拦截器，就能自动统计所有SQL的执行耗时了。

好处：

• 直接和ORM框架集成，统计更精准（能关联到具体SQL）
• 框架自带的扩展机制，稳定性高
• 支持配置参数，比如设置超时报警阈值

4. 字节码增强——底层定制化方案（进阶） #

如果需要更底层的控制（比如统计私有方法、非接口类的方法），可以用ASM、ByteBuddy这类字节码增强工具，在编译期或运行期修改DAO类的字节码，插入耗时统计代码。

不过这个方案相对复杂，一般只有在AOP和代理模式无法满足需求时才会用到，比如你的DAO类没有实现接口，或者需要修改第三方库中的DAO类。

总结 #

优先推荐AOP或者ORM框架插件，因为集成简单、维护成本低，完全符合开闭原则；如果你的项目没有用Spring这类AOP框架，代理模式是轻量且灵活的选择。这些方案都能帮你统一统计所有DAO调用的耗时，不用在每个方法里重复写时间戳代码，还能轻松扩展超时报警、数据上报到监控平台等功能。

内容的提问来源于stack exchange，提问作者Vivek