mybatis 3.1 개발자 local용

 

 

아쉽게 블로그 포스팅을 거의 못하고 있어서...시간 내서 작성을 하려고 합니다^-^good~

오늘의 포스팅은! mybatis logger쪽 입니다.

 

환경 :

Spring 3.1

mybatis-3.1.1.jar

 

서론 :

현재 mybatis에서는 sql문과 parameter 부분이 서로 나뉘어져 logging되고 있습니다.

개발을 할 때 param이 많다면 일일이 매핑 시켜서 오렌지나, sql develop 등등으로 보기에는 너무 힘이 들 것 입니다. 그래서 간단히..mybatis 소스를 조작하여 개발하여 보았습니다만..

개발자 local용이라는 단점이 있습니다. server용은 아닙니다..ㅋㅋ;;

 

        기본 제공                                             변경 후

ex) select * from acetDB                =>    select * from acetDB 

      where 1=1 and aaa in(?. ?)      =>     where 1=1 and aaa in(100. 200)

 

본론 :

어떻게 구현을 했는지..창피하지만...사실 고친것도 없습니다..;;

한번 살펴보겠습니다^-^

 

mybatis 소스 중에 org/apache/ibatis/logging/jdbc 의 패키지 밑에 아래의 소스를 수정하였습니다.

BaseJdbcLogger.java

ConnectionLogger.java

PreparedStatementLogger.java

 

새롭게 만든 소스

PrintQueryParam.java

 

간단히 위의 소스에 대해서 설명을 드리자면..

ConnectionLogger.java  : 요놈이 SQL문을 가지고 있습니다.

PreparedStatementLogger.java : 요놈은 parameter의 값을 가지고 있습니다.

BaseJdbcLogger.java : 요녀석은 ConnectionLogger, PreparedStatementLogger java에서 상속하여 쓰고 있는 Adapter 패턴 처럼 보입니다. 또한 Dynamic Proxy 패턴도 쓰입니다. 오픈소스는 디자인 패턴의 놀이터?? 인 것 같습니다..ㅋㅋ;

 

ex) public final class ConnectionLogger extends BaseJdbcLogger implements InvocationHandler {

           .......................

      }

 

그래서...서로 다른 java와 값들...어떻게 한곳으로 몰아서 작업을 통해서 sql문과 파라미터를 함께 찍어줄수 있을까...고민했습니다...

 

그래서 일단은 개발자 local 즉, 혼자서 개발 시에 사용 할 수 있는 ver을 만들었습니다.

How? 요즘..디자인 패턴을 내부에서 스터디를 하고 있는터라..떠오르는것이..Singleton 패턴 이였습니다--;;

간단히 말하면..

기본적인 Singleton 패턴이며, ConnectionLogger와 PreparedStatementLogger에서 공통의 객체를 공유하되

saveSql 이라는 녀석에다가 쿼리를 ConnectionLogger에서 넣어주게 되고, PreparedStatementLogger에서 쿼리문을 꺼내다가 파라미터와 합치는 작업을 하게 되어집니다.

 

1) PrintQueryParam.java

package org.apache.ibatis.logging.jdbc;

public class PrintQueryParam {
   
    private static PrintQueryParam printQueryParam;
   
    private String saveSql=null;
   
    private PrintQueryParam(){}
   
    public static PrintQueryParam getInstance(){
 if(printQueryParam == null){
     synchronized(PrintQueryParam.class){
  if(printQueryParam == null){
      printQueryParam = new PrintQueryParam();
  }
     }
 }
 
 return printQueryParam;
 
    }

    public String getSaveSql() {
        return saveSql;
    }

    public void setSaveSql(String saveSql) {
        this.saveSql = saveSql;
    }

}

 

2) ConnectionLogger.java

/*
 *    Copyright 2009-2012 The MyBatis Team
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.logging.jdbc;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.Statement;

import org.apache.ibatis.logging.Log;
import org.apache.ibatis.reflection.ExceptionUtil;

/*
 * Connection proxy to add logging
 */
public final class ConnectionLogger extends BaseJdbcLogger implements InvocationHandler {

  private Connection connection;
 private PrintQueryParam printQueryParam;

  private ConnectionLogger(Connection conn, Log statementLog) {
    super(statementLog);
    this.connection = conn;
    if (isDebugEnabled()) {
      debug("ooooooStartoooooo Using Connection [" + conn + "]");
    }
  }

  public Object invoke(Object proxy, Method method, Object[] params)
      throws Throwable {
    try {
      if ("prepareStatement".equals(method.getName())) {
        if (isDebugEnabled()) {
          //debug("==>  Preparing: " + removeBreakingWhitespace((String) params[0]));
          
          printQueryParam = PrintQueryParam.getInstance();
         printQueryParam.setSaveSql((String) params[0]);
        }       
        PreparedStatement stmt = (PreparedStatement) method.invoke(connection, params);
        stmt = PreparedStatementLogger.newInstance(stmt, getStatementLog());
        return stmt;
      } else if ("prepareCall".equals(method.getName())) {
        if (isDebugEnabled()) {
          debug("==>  Preparing: " + removeBreakingWhitespace((String) params[0]));
        }       
        PreparedStatement stmt = (PreparedStatement) method.invoke(connection, params);
        stmt = PreparedStatementLogger.newInstance(stmt, getStatementLog());
        return stmt;
      } else if ("createStatement".equals(method.getName())) {
        Statement stmt = (Statement) method.invoke(connection, params);
        stmt = StatementLogger.newInstance(stmt, getStatementLog());
        return stmt;
      } else if ("close".equals(method.getName())) {
        if (isDebugEnabled()) {
          debug("xxx Connection Closed");
        }
        return method.invoke(connection, params);
      } else {
        return method.invoke(connection, params);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  }

  /*
   * Creates a logging version of a connection
   *
   * @param conn - the original connection
   * @return - the connection with logging
   */
  public static Connection newInstance(Connection conn, Log statementLog) {
    InvocationHandler handler = new ConnectionLogger(conn, statementLog);
    ClassLoader cl = Connection.class.getClassLoader();
    return (Connection) Proxy.newProxyInstance(cl, new Class[]{Connection.class}, handler);
  }

  /*
   * return the wrapped connection
   *
   * @return the connection
   */
  public Connection getConnection() {
    return connection;
  }

}

 

3) PreparedStatementLogger.java

/*
 *    Copyright 2009-2012 The MyBatis Team
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.logging.jdbc;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import org.apache.ibatis.logging.Log;
import org.apache.ibatis.reflection.ExceptionUtil;

/*
 * PreparedStatement proxy to add logging
 */
public final class PreparedStatementLogger extends BaseJdbcLogger implements InvocationHandler {

  private PreparedStatement statement;
  private PrintQueryParam printQueryParam;
  private String nowSql;

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

  public Object invoke(Object proxy, Method method, Object[] params) throws Throwable {
    try {
      if (EXECUTE_METHODS.contains(method.getName())) {
        if (isDebugEnabled()) {
          
          printQueryParam = PrintQueryParam.getInstance();
          nowSql = printQueryParam.getSaveSql();
         
          String nowParam = getParameterValueString();
          
          //debug("==> Ace-T nowSql : " + nowSql);
          //debug("==> Ace-T parameter : "+ nowParam);
          
          String[] sperateParam = nowParam.split(",");
          
          for(int i=0; i < sperateParam.length; i++){
              //debug("####sperateParam===============>"+sperateParam[i]);
             
              //debug("#before## nowSql["+i+"] ==>"+nowSql);
              
              nowSql=nowSql.replaceFirst("\\?", sperateParam[i]);
              
              //debug("#after## nowSql["+i+"] ==>"+nowSql);
              
          }
          
          //debug("#############################################");
         debug("==>  Preparing+Prameter: \n"+nowSql);          
          //debug("#############################################");
          System.out.println("=======================");
         
        }
        clearColumnInfo();
        if ("executeQuery".equals(method.getName())) {
          ResultSet rs = (ResultSet) method.invoke(statement, params);
          if (rs != null) {
            return ResultSetLogger.newInstance(rs, getStatementLog());
          } else {
            return null;
          }
        } else {
          return method.invoke(statement, params);
        }
      } else if (SET_METHODS.contains(method.getName())) {
        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);
        if (rs != null) {
          return ResultSetLogger.newInstance(rs, getStatementLog());
        } else {
          return null;
        }
      } else if ("equals".equals(method.getName())) {
        Object ps = params[0];
        return ps instanceof Proxy && proxy == ps;
      } else if ("hashCode".equals(method.getName())) {
        return proxy.hashCode();
      } else {
        return method.invoke(statement, params);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  }

  /*
   * Creates a logging version of a PreparedStatement
   *
   * @param stmt - the statement
   * @param sql  - the sql statement
   * @return - the proxy
   */
  public static PreparedStatement newInstance(PreparedStatement stmt, Log statementLog) {
    InvocationHandler handler = new PreparedStatementLogger(stmt, statementLog);
    ClassLoader cl = PreparedStatement.class.getClassLoader();
    return (PreparedStatement) Proxy.newProxyInstance(cl, new Class[]{PreparedStatement.class, CallableStatement.class}, handler);
  }

  /*
   * Return the wrapped prepared statement
   *
   * @return the PreparedStatement
   */
  public PreparedStatement getPreparedStatement() {
    return statement;
  }

}

 

4) BaseJdbcLogger.java

/*
 *    Copyright 2009-2011 The MyBatis Team
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.logging.jdbc;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;

import org.apache.ibatis.logging.Log;

/*
 * Base class for proxies to do logging
 */
public abstract class BaseJdbcLogger {

  protected static final Set<String> SET_METHODS = new HashSet<String>();
  protected static final Set<String> EXECUTE_METHODS = new HashSet<String>();

  private Map<Object, Object> columnMap = new HashMap<Object, Object>();

  private List<Object> columnNames = new ArrayList<Object>();
  private List<Object> columnValues = new ArrayList<Object>();

  private Log statementLog;
 

  /*
   * Default constructor
   */
  public BaseJdbcLogger(Log log) {
    this.statementLog = log;
  }

  static {
    SET_METHODS.add("setString");
    SET_METHODS.add("setInt");
    SET_METHODS.add("setByte");
    SET_METHODS.add("setShort");
    SET_METHODS.add("setLong");
    SET_METHODS.add("setDouble");
    SET_METHODS.add("setFloat");
    SET_METHODS.add("setTimestamp");
    SET_METHODS.add("setDate");
    SET_METHODS.add("setTime");
    SET_METHODS.add("setArray");
    SET_METHODS.add("setBigDecimal");
    SET_METHODS.add("setAsciiStream");
    SET_METHODS.add("setBinaryStream");
    SET_METHODS.add("setBlob");
    SET_METHODS.add("setBoolean");
    SET_METHODS.add("setBytes");
    SET_METHODS.add("setCharacterStream");
    SET_METHODS.add("setClob");
    SET_METHODS.add("setObject");
    SET_METHODS.add("setNull");

    EXECUTE_METHODS.add("execute");
    EXECUTE_METHODS.add("executeUpdate");
    EXECUTE_METHODS.add("executeQuery");
    EXECUTE_METHODS.add("addBatch");
  }

  protected void setColumn(Object key, Object value) {
    columnMap.put(key, value);
    columnNames.add(key);
    columnValues.add(value);
  }

  protected Object getColumn(Object key) {
    return columnMap.get(key);
  }

  protected String getParameterValueString() {
    List<Object> typeList = new ArrayList<Object>(columnValues.size());
    
    System.out.println("==> Mybatis info ");
    for (Object value : columnValues) {
      if (value == null) {
        typeList.add("null");
      } else {
   
   
   System.out.println(value+ "("+ value.getClass().getSimpleName() + ")");
   
   
   if("String".equals(value.getClass().getSimpleName())){
       typeList.add("\'"+value+"\'");
   }else{
       typeList.add(value);
   }
   
          //typeList.add(value + "(" + value.getClass().getSimpleName() + ")");
   //typeList.add(value);
      }
    }
    System.out.println("=======================");
    final String parameters = typeList.toString();
   
    return parameters.substring(1, parameters.length() - 1);
  }
 
  protected String getColumnString() {
    return columnNames.toString();
  }

  protected void clearColumnInfo() {
    columnMap.clear();
    columnNames.clear();
    columnValues.clear();
  }

  protected String removeBreakingWhitespace(String original) {
     
    StringTokenizer whitespaceStripper = new StringTokenizer(original);
    StringBuilder builder = new StringBuilder();
    while (whitespaceStripper.hasMoreTokens()) {
      builder.append(whitespaceStripper.nextToken());
      builder.append(" ");
    }
   
    return builder.toString();
  }

  protected boolean isDebugEnabled() {
    return statementLog.isDebugEnabled();
  }

  protected boolean isTraceEnabled() {
    return statementLog.isTraceEnabled();
  }

  protected void debug(String text) {
    if (statementLog.isDebugEnabled()) {
      statementLog.debug(text);
    }
  }

  protected void trace(String text) {
    if (statementLog.isTraceEnabled()) {
      statementLog.trace(text);
    }
  }

  public Log getStatementLog() {
    return statementLog;
  }

}

 

결론 :

아래의 jar를 기존 mybatis-3.1.1.jar 대신 사용 하면 됩니다.

 

mybatis-3.1.1.aa.local.jar

 

추신 :

서버용은 mybatis plug-in 이라는 것을 사용하여 만들 수 있을 것 같다.

지금은 다른쪽을 해야해서 못하고 있으나..만드는 즉시 포스팅 하도록 하겠습니다.^-^good~

 

- 끝 -