org.apache.ibatis.logging.Log Java Examples

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  Statement stmt;
  //得到绑定的SQL语句
  BoundSql boundSql = handler.getBoundSql();
  String sql = boundSql.getSql();
  //如果缓存中已经有了，直接得到Statement
  if (hasStatementFor(sql)) {
    stmt = getStatement(sql);
  } else {
    //如果缓存没有找到，则和SimpleExecutor处理完全一样，然后加入缓存
    Connection connection = getConnection(statementLog);
    stmt = handler.prepare(connection);
    putStatement(sql, stmt);
  }
  handler.parameterize(stmt);
  return stmt;
}
 

private void bindingLog(Invocation invocation) throws SQLException {

        Object[] args = invocation.getArgs();
        MappedStatement ms = (MappedStatement) args[0];
        Object parameterObject = args[1];
        StatementType statementType = ms.getStatementType();
        if (StatementType.PREPARED == statementType || StatementType.CALLABLE == statementType) {
            Log statementLog = ms.getStatementLog();
            if (isDebugEnable(statementLog)) {
                BoundSql boundSql = ms.getBoundSql(parameterObject);

                String sql = boundSql.getSql();
                List<String> parameterList = getParameters(ms, parameterObject, boundSql);
                debug(statementLog, "==> BindingLog: " + bindLogFormatter.format(sql, parameterList));
            }
        }
    }
 

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  Statement stmt;
  //得到绑定的SQL语句
  BoundSql boundSql = handler.getBoundSql();
  String sql = boundSql.getSql();
  //如果缓存中已经有了，直接得到Statement
  if (hasStatementFor(sql)) {
    stmt = getStatement(sql);
  } else {
    //如果缓存没有找到，则和SimpleExecutor处理完全一样，然后加入缓存
    Connection connection = getConnection(statementLog);
    stmt = handler.prepare(connection);
    putStatement(sql, stmt);
  }
  handler.parameterize(stmt);
  return stmt;
}
 

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  Statement stmt;
  Connection connection = getConnection(statementLog);
  //调用StatementHandler.prepare
  stmt = handler.prepare(connection);
  //调用StatementHandler.parameterize
  handler.parameterize(stmt);
  return stmt;
}
 

protected Connection getConnection(Log statementLog) throws SQLException {
  Connection connection = transaction.getConnection();
  if (statementLog.isDebugEnabled()) {
    //如果需要打印Connection的日志，返回一个ConnectionLogger(代理模式, AOP思想)
    return ConnectionLogger.newInstance(connection, statementLog, queryStack);
  } else {
    return connection;
  }
}
 

public BaseJdbcLogger(Log log, int queryStack) {
  this.statementLog = log;
  if (queryStack == 0) {
    this.queryStack = 1;
  } else {
    this.queryStack = queryStack;
  }
}
 

@SuppressWarnings("unchecked")
public void setLogImpl(Class<?> logImpl) {
  if (logImpl != null) {
    this.logImpl = (Class<? extends Log>) logImpl;
    LogFactory.useCustomLogging(this.logImpl);
  }
}
 

public void debug(Log statementLogger, String msg) {
    if (statementLogger.isDebugEnabled()) {
        statementLogger.debug(msg);
    } else {
        pLogger.debug(msg);
    }
}
 

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  Statement stmt;
  Connection connection = getConnection(statementLog);
  //调用StatementHandler.prepare
  stmt = handler.prepare(connection);
  //调用StatementHandler.parameterize
  handler.parameterize(stmt);
  return stmt;
}
 

protected Connection getConnection(Log statementLog) throws SQLException {
  Connection connection = transaction.getConnection();
  if (statementLog.isDebugEnabled()) {
    //如果需要打印Connection的日志，返回一个ConnectionLogger(代理模式, AOP思想)
    return ConnectionLogger.newInstance(connection, statementLog, queryStack);
  } else {
    return connection;
  }
}
 

public BaseJdbcLogger(Log log, int queryStack) {
  this.statementLog = log;
  if (queryStack == 0) {
    this.queryStack = 1;
  } else {
    this.queryStack = queryStack;
  }
}
 

@SuppressWarnings("unchecked")
public void setLogImpl(Class<?> logImpl) {
  if (logImpl != null) {
    this.logImpl = (Class<? extends Log>) logImpl;
    LogFactory.useCustomLogging(this.logImpl);
  }
}
 

/**
     * 查询总纪录数
     * @param sql             SQL语句
     * @param connection      数据库连接
     * @param mappedStatement mapped
     * @param parameterObject 参数
     * @param boundSql        boundSql
     * @return 总记录数
     * @throws SQLException sql查询错误
     */
    public static int getCount(final String sql, final Connection connection,
    							final MappedStatement mappedStatement, final Object parameterObject,
    							final BoundSql boundSql, Log log) throws SQLException {
        final String countSql = "select count(1) from (" + sql + ") tmp_count";
//        final String countSql = "select count(1) " + removeSelect(removeOrders(sql));
        Connection conn = connection;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
        	if (log.isDebugEnabled()) {
                log.debug("COUNT SQL: " + StringUtils.replaceEach(countSql, new String[]{"\n", "\t"}, new String[]{" ", " "}));
            }
        	if (conn == null){
        		conn = mappedStatement.getConfiguration().getEnvironment().getDataSource().getConnection();
            }
        	ps = conn.prepareStatement(countSql);
            BoundSql countBS = new BoundSql(mappedStatement.getConfiguration(), countSql,
                    boundSql.getParameterMappings(), parameterObject);
            SQLHelper.setParameters(ps, mappedStatement, countBS, parameterObject);
            rs = ps.executeQuery();
            int count = 0;
            if (rs.next()) {
                count = rs.getInt(1);
            }
            return count;
        } finally {
            if (rs != null) {
                rs.close();
            }
            if (ps != null) {
            	ps.close();
            }
            if (conn != null) {
            	conn.close();
            }
        }
    }
 

@SuppressWarnings("unchecked")
public void setLogImpl(Class<?> logImpl) {
	if (logImpl != null) {
		this.logImpl = (Class<? extends Log>) logImpl;
		LogFactory.useCustomLogging(this.logImpl);
	}
}
 

public static PreparedStatement newInstance(PreparedStatement stmt, Log statementLog, int queryStack) {
  InvocationHandler handler = new PreparedStatementLogger(stmt, statementLog, queryStack);
  ClassLoader cl = PreparedStatement.class.getClassLoader();
  return (PreparedStatement) Proxy.newProxyInstance(cl, new Class[]{PreparedStatement.class, CallableStatement.class}, handler);
}
 

public BaseJdbcLogger(Log log) {
    this.statementLog = log;
}
 

private Log getLogger() {
  if (this.log == null) {
    this.log = LogFactory.getLog(this.getClass());
  }
  return this.log;
}
 

public Log getStatementLog() {
    return this.statementLog;
}
 

public static Connection newInstance(Connection conn, Log statementLog, int queryStack) {
  InvocationHandler handler = new ConnectionLogger(conn, statementLog, queryStack);
  ClassLoader cl = Connection.class.getClassLoader();
  return (Connection) Proxy.newProxyInstance(cl, new Class[]{Connection.class}, handler);
}
 

private ConnectionLogger(Connection conn, Log statementLog, int queryStack) {
  super(statementLog, queryStack);
  this.connection = conn;
}
 

public Class<? extends Log> getLogImpl() {
	return logImpl;
}
 

public static ResultSet newInstance(ResultSet rs, Log statementLog, int queryStack) {
  InvocationHandler handler = new ResultSetLogger(rs, statementLog, queryStack);
  ClassLoader cl = ResultSet.class.getClassLoader();
  return (ResultSet) Proxy.newProxyInstance(cl, new Class[]{ResultSet.class}, handler);
}
 

private ResultSetLogger(ResultSet rs, Log statementLog, int queryStack) {
  super(statementLog, queryStack);
  this.rs = rs;
}
 

public static PreparedStatement newInstance(PreparedStatement stmt, Log statementLog, int queryStack) {
  InvocationHandler handler = new PreparedStatementLogger(stmt, statementLog, queryStack);
  ClassLoader cl = PreparedStatement.class.getClassLoader();
  return (PreparedStatement) Proxy.newProxyInstance(cl, new Class[]{PreparedStatement.class, CallableStatement.class}, handler);
}
 

private PreparedStatementLogger(PreparedStatement stmt, Log statementLog, int queryStack) {
  super(statementLog, queryStack);
  this.statement = stmt;
}
 

public static Statement newInstance(Statement stmt, Log statementLog, int queryStack) {
  InvocationHandler handler = new StatementLogger(stmt, statementLog, queryStack);
  ClassLoader cl = Statement.class.getClassLoader();
  return (Statement) Proxy.newProxyInstance(cl, new Class[]{Statement.class}, handler);
}
 

private StatementLogger(Statement stmt, Log statementLog, int queryStack) {
  super(statementLog, queryStack);
  this.statement = stmt;
}
 

public Class<? extends Log> getLogImpl() {
  return logImpl;
}
 

public Log getStatementLog() {
  return statementLog;
}
 

public boolean isDebugEnable(Log statementLogger) {
    return statementLogger.isDebugEnabled() || pLogger.isDebugEnabled();
}