MyBatis日志模块源码分析
MyBatis源码的logging包下是日志模块的相关实现，Mybatis日志模块通过适配器模式和代理模式优雅的实现了SQL日志的输出功能。
一. 适配器模式实现了MyBatis对第三方日志框架的适配
Mybatis内部没有提供日志实现类，需要接入第三方的日志组件，但第三方组件都有自己的log级别，并且各不相同，Mybatis 在内部定义了Log接口统一提供了trace debug warn error四个日志级别。
/**
* 由于不同的日志框架，拥有不同的日志级别，所以MyBatis在内部定义了Log接口，
* 用于让其他日志框架适配MyBatis内部规定的日志级别
*/
public interface Log {
boolean isDebugEnabled();
boolean isTraceEnabled();
/**
* -----------规定的日志级别-----------
*/
void error(String s, Throwable e);
void error(String s);
void debug(String s);
void trace(String s);
void warn(String s);
}
Mybatis 使用适配器模式，在每个第三方日志厂商和自己的log之间都存在一个适配器，将第三方的日志级别适配为自己的log级别。
其中日志适配器的继承体系如下：
我们以Jdk14LoggingImpl类（JDK日志框架的适配器）源码为例，分析适配器所做的事情。可以看到在JDK自带的日志框架中包含SEVERE、WARNING、INFO、CONFIG、FINE等8个日志级别，而Mybatis只提供了error、debug、trace、warn四种日志日志级别，这就需要认为将两者的日志级别对应起来。
/**
* JDK内置日志框架的适配器，用于适配MyBatis内部约定的Log接口
* @author Clinton Begin
*/
public class Jdk14LoggingImpl implements Log {
private final Logger log;
public Jdk14LoggingImpl(String clazz) {
log = Logger.getLogger(clazz);
}
@Override
public boolean isDebugEnabled() {
return log.isLoggable(Level.FINE);
}
@Override
public boolean isTraceEnabled() {
return log.isLoggable(Level.FINER);
}
@Override
public void error(String s, Throwable e) {
log.log(Level.SEVERE, s, e);//JDK中SEVERE级别日志对应MyBatis中error
}
@Override
public void error(String s) {
log.log(Level.SEVERE, s);
}
@Override
public void debug(String s) {
log.log(Level.FINE, s);
}
@Override
public void trace(String s) {
log.log(Level.FINER, s);
}
@Override
public void warn(String s) {
log.log(Level.WARNING, s);
}
}
可以看到使用适配器模式，我们解决第三方日志框架内部实现不一致的问题，但是这些日志适配器的使用就需要借助Mybatis提供的日志工厂类了（org.apache.ibatis.logging.LogFactory）。在该类拥有一个静态代码块，用于动态加载项目中依赖的日志框架：
static {
//按照顺序扫描当前项目中配置的日志框架。注：双冒号是JDK8的语法，代表方法引用（语法糖）
tryImplementation(LogFactory::useSlf4jLogging);
tryImplementation(LogFactory::useCommonsLogging);
tryImplementation(LogFactory::useLog4J2Logging);
tryImplementation(LogFactory::useLog4JLogging);
tryImplementation(LogFactory::useJdkLogging);
tryImplementation(LogFactory::useNoLogging);
}
该类会按照slf4J → commonsLoging → Log4J2 → Log4J → JdkLog顺序加载日志框架，如果加载成功一个，就不会加载后面的日志框架了。
private static void tryImplementation(Runnable runnable) {
//如果前面的适配器都没有创建成功，则试图创建当前类型的适配器
if (logConstructor == null) {
try {
runnable.run();
} catch (Throwable t) {
// ignore
}
}
}
public static synchronized void useSlf4jLogging() {
setImplementation(org.apache.ibatis.logging.slf4j.Slf4jImpl.class);
}
/**
* 设置具体的日志实现类构造器
*
* @param implClass
*/
private static void setImplementation(Class<? extends Log> implClass) {
try {
Constructor<? extends Log> candidate = implClass.getConstructor(String.class);
//这里调用目标日志框架的适配器中的构造器，试图创建适配器对象，如果没有该框架的依赖则会抛出异常
Log log = candidate.newInstance(LogFactory.class.getName());
if (log.isDebugEnabled()) {
log.debug("Logging initialized using '" + implClass + "' adapter.");
}
logConstructor = candidate;
} catch (Throwable t) {
throw new LogException("Error setting Log implementation. Cause: " + t, t);
}
}
二. 代理模式实现了SQL日志输出
Mybatis 日志的使用优雅的嵌入到主体功能中（动态代理增强），接下来我们看一下是如何进行日志增强的。
2.1日志输出的体系结构
org.apache.ibatis.logging.jdbc包中存放就是JDBC相关对象的增强类，它们就是MyBatis实现日志打印的核心：
其中BaseJdbcLogger类保存着日志打印所需要的信息：
/**
* MyBatis用于输出执行器SQL日志记录的基类。
*
* @author Clinton Begin
* @author Eduardo Macarron
*/
public abstract class BaseJdbcLogger {
//保存PreparedStatement中常用的set方法（用于占位符设值的方法）
protected static final Set<String> SET_METHODS;
//保存PreparedStatement中常用的执行SQL语句的方法
protected static final Set<String> EXECUTE_METHODS = new HashSet<>();
//保存PreparedStatement中set方法的键值对
private final Map<Object, Object> columnMap = new HashMap<>();
//保存PreparedStatement中set方法的key值
private final List<Object> columnNames = new ArrayList<>();
//保存PreparedStatement中set方法的value值
private final List<Object> columnValues = new ArrayList<>();
//用于打印日志的对象
protected final Log statementLog;
而ConnectionLogger、PreparedStatementLogger、ResultSetLogger、StatementLogger这几个类都实现了InvocationHandler接口，这也证明了它们分别是对Conneciton、PreparedStatement、ResultSet、Statemtent类的加强。
2.2 探寻入口
org.apache.ibatis.executor.BaseExecutor是MyBatis中的执行器，是Mybatis实际操作数据库的类，该类中的getConnection()方法返回的就是经过加强的连接对象，也就是：ConnectionLogger：
protected Connection getConnection(Log statementLog) throws SQLException {
Connection connection = transaction.getConnection();
if (statementLog.isDebugEnabled()) {
return ConnectionLogger.newInstance(connection, statementLog, queryStack);
} else {
return connection;
}
}
2.2.1 ConnectionLogger
其中ConnectionLogger负责在调用prepareStatement()方法时打印SQL语句日志，并返回经过加强后的PreparedStatement，也就是PreparedStatementLogger。
/**
* 负责打印数据库连接相关信息和SQL语句，并创建PreparedStatementLogger
*
* @author Clinton Begin
* @author Eduardo Macarron
*/
public final class ConnectionLogger extends BaseJdbcLogger implements InvocationHandler {
//真正的连接对象
private final Connection connection;
private ConnectionLogger(Connection conn, Log statementLog, int queryStack) {
super(statementLog, queryStack);
this.connection = conn;
}
@Override
public Object invoke(Object proxy, Method method, Object[] params)
throws Throwable {
try {
//如果调用的是Object的方法则跳过代理
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, params);
}
//如果是调用prepareStatement或者prepareCall，则打印SQL语句
if ("prepareStatement".equals(method.getName()) || "prepareCall".equals(method.getName())) {
if (isDebugEnabled()) {
debug(" Preparing: " + removeBreakingWhitespace((String) params[0]), true);
}
PreparedStatement stmt = (PreparedStatement) method.invoke(connection, params);
/**
* 创建PreparedStatement的代理类PreparedStatementLogger对象，并返回这个对象
*/
stmt = PreparedStatementLogger.newInstance(stmt, statementLog, queryStack);
return stmt;
} else if ("createStatement".equals(method.getName())) {
Statement stmt = (Statement) method.invoke(connection, params);
stmt = StatementLogger.newInstance(stmt, statementLog, queryStack);
return stmt;
} else {
return method.invoke(connection, params);
}
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
}
.....
}
2.2.2 PreparedStatementLogger
PreparedStatementLogger增强类是为了在调用目标对象的executeQuery方时输出将要执行的SQL语句，并将返回的ResultSet加强为ResultSetLogger：
public final class PreparedStatementLogger extends BaseJdbcLogger implements InvocationHandler {
private final PreparedStatement statement;
private PreparedStatementLogger(PreparedStatement stmt, Log statementLog, int queryStack) {
super(statementLog, queryStack);
this.statement = stmt;
}
@Override
public Object invoke(Object proxy, Method method, Object[] params) throws Throwable {
try {
//判断调用的是不是Object的方法
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, params);
}
//如果执行的是SQL执行相关的方法，则打印参数
if (EXECUTE_METHODS.contains(method.getName())) {
if (isDebugEnabled()) {
debug("Parameters: " + getParameterValueString(), true);
}
//清除父类中保存的SQL参数
clearColumnInfo();
if ("executeQuery".equals(method.getName())) {
//执行executeQuery方法，获取查询结果集
ResultSet rs = (ResultSet) method.invoke(statement, params);
//将查询结果集封装成ResultSetLogger代理对象
return rs == null ? null : ResultSetLogger.newInstance(rs, statementLog, queryStack);
} else {
//如果不是查询语句，则不生成代理对象，也就不会打印日志
return method.invoke(statement, params);
}
} else if (SET_METHODS.contains(method.getName())) {
/**
* 如果执行的是PreparedStatement中的Set方法，则将对应的参数值放入父类专门保存SQL参数值的容器中
*/
if ("setNull".equals(method.getName())) {
setColumn(params[0], null);
} else {
setColumn(params[0], params[1]);
}
return method.invoke(statement, params);
} else if ("getResultSet".equals(method.getName())) {
ResultSet rs = (ResultSet) method.invoke(statement, params);
return rs == null ? null : ResultSetLogger.newInstance(rs, statementLog, queryStack);
} else if ("getUpdateCount".equals(method.getName())) {
int updateCount = (Integer) method.invoke(statement, params);
if (updateCount != -1) {
debug(" Updates: " + updateCount, false);
}
return updateCount;
} else {
return method.invoke(statement, params);
}
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
}
2.2.3 ResultSetLogger
ResultSetLogger增强类是为了在获取结果集时打印结果集信息。
public final class ResultSetLogger extends BaseJdbcLogger implements InvocationHandler {
private static final Set<Integer> BLOB_TYPES = new HashSet<>();
private boolean first = true;
private int rows;
private final ResultSet rs;
private final Set<Integer> blobColumns = new HashSet<>();
static {
BLOB_TYPES.add(Types.BINARY);
BLOB_TYPES.add(Types.BLOB);
BLOB_TYPES.add(Types.CLOB);
BLOB_TYPES.add(Types.LONGNVARCHAR);
BLOB_TYPES.add(Types.LONGVARBINARY);
BLOB_TYPES.add(Types.LONGVARCHAR);
BLOB_TYPES.add(Types.NCLOB);
BLOB_TYPES.add(Types.VARBINARY);
}
private ResultSetLogger(ResultSet rs, Log statementLog, int queryStack) {
super(statementLog, queryStack);
this.rs = rs;
}
@Override
public Object invoke(Object proxy, Method method, Object[] params) throws Throwable {
try {
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, params);
}
Object o = method.invoke(rs, params);
if ("next".equals(method.getName())) {
if ((Boolean) o) {
rows++;
if (isTraceEnabled()) {
ResultSetMetaData rsmd = rs.getMetaData();
final int columnCount = rsmd.getColumnCount();
if (first) {
first = false;
printColumnHeaders(rsmd, columnCount);
}
printColumnValues(columnCount);
}
} else {
debug(" Total: " + rows, false);
}
}
clearColumnInfo();
return o;
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
}
}
注：上文中并没有分析StatementLogger类，具体的分析方式与上文一致。
详细的代码注释请移步至：http://github.com/tianjindong/mybatis-source-annotation
三. 总结
MyBatis中使用适配器模式对第三方日志框架输出级别进行统一，使用JDK动态代理技术分别加强Connection、PreparedStatement、ResultSet类使之能在自己的声明周期中打印SQL执行的相关信息。
