Mybatis框架学习随笔记录

动态数据库表创建--------这个时候需要考虑使用${}  ---没有使用预编译，底层使用Statement

#{} 预编译，  会在参数上加上单引号,防止预编译，底层使用PrepareStatement 



<where></where>  去掉前and 

<set></set> 去掉最后的逗号

<trim></trim>

超过三证表的join ，会降低查询性能。

Mybatis 一级缓存[默认是开启，如果要关闭 在select标签中设置 flushCache = "true"]
存在SqlSession的生命周期中，
同一个sqlSession中查询，Mybatis会把执行的方法和参数通过计算生成缓存的键值
将键值和查询结果存放到一个Map对象中。

如果同一个 SqlSession 中执行的方法和参数完全一致，那么通过算法会生成相同的键值，
当 Map 缓存对象中己经存在该键值时，则会返回缓存中的对象;

任何的 INSERT 、UPDATE 、 DELETE 操作都会清空一级缓存；


二级缓存:
1.存在于 SqlSessionFactory 的生命周期中，可以理解为跨sqlSession
2.缓存是以namespace为单位的，不同namespace下的操作互不影响
3.在MyBatis的核心配置文件中 cacheEnabled参数是二级缓存的全局开关，默认值是 true，
如果把这个参数设置为 false，即使有后面的二级缓存配置，也不会生效
要开启二级缓存,你需要在你的 SQL Mapper文件中添加配置
<cache eviction=“LRU" flushInterval="60000" size="512" readOnly="true"/> 
	- 映射语句文件中的所有 select 语句将会被缓存
	- 映射语句文件中的所有 insert,update 和 delete 语句会刷新缓存
	- 缓存会使用 Least Recently Used(LRU,最近最少使用的)算法来收回
	- 根据时间表(比如 no Flush Interval,没有刷新间隔), 缓存不会以任何时间顺序 来刷新
	- 缓存会存储列表集合或对象(无论查询方法返回什么)的 512个引用
	- 缓存会被视为是 read/write(可读/可写)的缓存
使用二级缓存容易出现脏读，建议避免使用二级缓存，在业务层使用可控制的缓存代替更好

除了全局配置中开启二级缓存之外，还需要在mapper.xml中使用<cache></cache> 开启namespace 的二级缓存。就可以使用二级缓存
<cache-ref namespace=""/> 两个命名空间共享二级缓存。

一级缓存是sqlSession独享(线程独有的),不会出现脏读。

public void saleManTools(String size){
    System.out.println("你要购买的尺寸为:"+size);
}

private ATools aTools;

public MyProxy(ATools aTools){
    this.aTools = aTools;
}


public void saleManTools(String size){
   System.out.println("购买前进行商品调研.....")
   aTools.salManTools(size);
   System.out.println("谢谢购买")
}

}

private Object target;

public JDKDynamicProxy(Object target) {
    this.target = target;
}

/**
 * 获取被代理接口实例对象
 * @param <T>
 * @return
 */
public <T> T getProxy() {
    return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("Do something before");
    Object result = method.invoke(target, args);
    System.out.println("Do something after");
    return result;
}

数据源模块

池化技术

javax.sql.DataSource接口
MyBatis不但要能集成第三方的数据源组件，自身也提供了数据源的实现

工厂方法  Factory Method
简单工厂 Simple Facotry  ----- 对象的创建  和对象的使用 进行分离[解耦]
SimpleFactory 违背了单一职责原则 和 开闭原则

参与角色:
1.产品接口Product
2.具体产品类ConcreateProduct


3.工厂接口Factory
4.具体工厂接口 ConcreateFactroy



请详细描述从数据库连接池中获取一个连接资源的过程？数据结构和算法。
MyBatis --PoolDataSource

PooledDataSource：一个简单，同步的、线程安全的数据库连接池
PooledConnection：使用动态代理封装了真正的数据库连接对象；
PoolState：用于管理PooledConnection对象状态的组件，通过两个list分别 管理空闲状态的连接资源和活跃状态的连接资源,数据库俩接放入到了一个ArrayList集合中来进行管理.


数据接口使用两个ArrayList  一个保存闲置的连接 | 一个是活跃连接  | 其他计数器。

 比如:PoolState：用于管理PooledConnection对象状态的组件，通过两个list分别
	protected PooledDataSource dataSource;
  //空闲的连接池资源集合
  protected final List<PooledConnection> idleConnections = new ArrayList<>();
  //活跃的连接池资源集合
  protected final List<PooledConnection> activeConnections = new ArrayList<>();
  //请求的次数
  protected long requestCount = 0;
  //累计的获得连接的时间
  protected long accumulatedRequestTime = 0;
  //累计的使用连接的时间。从连接取出到归还，算一次使用的时间；
  protected long accumulatedCheckoutTime = 0;
  //使用连接超时的次数
  protected long claimedOverdueConnectionCount = 0;
  //累计超时时间
  protected long accumulatedCheckoutTimeOfOverdueConnections = 0;
  //累计等待时间
  protected long accumulatedWaitTime = 0;
  //等待次数 
  protected long hadToWaitCount = 0;
  //无效的连接次数 
  protected long badConnectionCount = 0;


算法:

/**
   *
   *回收连接资源
   */
  protected void pushConnection(PooledConnection conn) throws SQLException {

    synchronized (state) {//回收连接必须是同步的 --- 线程安全问题
      state.activeConnections.remove(conn);//从活跃连接池中删除此连接
      if (conn.isValid()) {
    	  //判断闲置连接池资源是否已经达到上限
        if (state.idleConnections.size() < poolMaximumIdleConnections && conn.getConnectionTypeCode() == expectedConnectionTypeCode) {
        	//没有达到上限，进行回收
          state.accumulatedCheckoutTime += conn.getCheckoutTime();
          if (!conn.getRealConnection().getAutoCommit()) {
            //如果还有事务没有提交，进行回滚操作
            conn.getRealConnection().rollback();
          }
          //基于该连接，创建一个新的连接资源，并刷新连接状态
          PooledConnection newConn = new PooledConnection(conn.getRealConnection(), this);
          state.idleConnections.add(newConn);
          newConn.setCreatedTimestamp(conn.getCreatedTimestamp());
          newConn.setLastUsedTimestamp(conn.getLastUsedTimestamp());
          //老连接失效
          conn.invalidate();
          if (log.isDebugEnabled()) {
            log.debug("Returned connection " + newConn.getRealHashCode() + " to pool.");
          }
          //唤醒其他被阻塞的线程
          state.notifyAll();
        } else {//如果闲置连接池已经达到上限了，将连接真实关闭
          state.accumulatedCheckoutTime += conn.getCheckoutTime();
          if (!conn.getRealConnection().getAutoCommit()) {
            conn.getRealConnection().rollback();
          }
          //关闭真的数据库连接
          conn.getRealConnection().close();
          if (log.isDebugEnabled()) {
            log.debug("Closed connection " + conn.getRealHashCode() + ".");
          }
          //将连接对象设置为无效
          conn.invalidate();
        }
      } else {
        if (log.isDebugEnabled()) {
          log.debug("A bad connection (" + conn.getRealHashCode() + ") attempted to return to the pool, discarding connection.");
        }
        state.badConnectionCount++;
      }
    }
  }

  //从连接池获取资源
  private PooledConnection popConnection(String username, String password) throws SQLException {
    boolean countedWait = false;
    PooledConnection conn = null;
    long t = System.currentTimeMillis();//记录尝试获取连接的起始时间戳
    int localBadConnectionCount = 0;//初始化获取到无效连接的次数

    while (conn == null) {
      synchronized (state) {//获取连接必须是同步的
        if (!state.idleConnections.isEmpty()) {//检测是否有空闲连接
          // Pool has available connection
          //有空闲连接直接使用
          conn = state.idleConnections.remove(0);
          if (log.isDebugEnabled()) {
            log.debug("Checked out connection " + conn.getRealHashCode() + " from pool.");
          }
        } else {// 没有空闲连接
          if (state.activeConnections.size() < poolMaximumActiveConnections) {//判断活跃连接池中的数量是否大于最大连接数
            // 没有则可创建新的连接
            conn = new PooledConnection(dataSource.getConnection(), this);
            if (log.isDebugEnabled()) {
              log.debug("Created connection " + conn.getRealHashCode() + ".");
            }
          } else {// 如果已经等于最大连接数，则不能创建新连接
            //获取最早创建的连接
            PooledConnection oldestActiveConnection = state.activeConnections.get(0);
            long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
            if (longestCheckoutTime > poolMaximumCheckoutTime) {//检测是否已经以及超过最长使用时间
              // 如果超时，对超时连接的信息进行统计
              state.claimedOverdueConnectionCount++;//超时连接次数+1
              state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;//累计超时时间增加
              state.accumulatedCheckoutTime += longestCheckoutTime;//累计的使用连接的时间增加
              state.activeConnections.remove(oldestActiveConnection);//从活跃队列中删除
              if (!oldestActiveConnection.getRealConnection().getAutoCommit()) {//如果超时连接未提交，则手动回滚
                try {
                  oldestActiveConnection.getRealConnection().rollback();
                } catch (SQLException e) {//发生异常仅仅记录日志
                  /*
                     Just log a message for debug and continue to execute the following
                     statement like nothing happend.
                     Wrap the bad connection with a new PooledConnection, this will help
                     to not intterupt current executing thread and give current thread a
                     chance to join the next competion for another valid/good database
                     connection. At the end of this loop, bad {@link @conn} will be set as null.
                   */
                  log.debug("Bad connection. Could not roll back");
                }  
              }
              //在连接池中创建新的连接，注意对于数据库来说，并没有创建新连接；
              conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this);
              conn.setCreatedTimestamp(oldestActiveConnection.getCreatedTimestamp());
              conn.setLastUsedTimestamp(oldestActiveConnection.getLastUsedTimestamp());
              //让老连接失效
              oldestActiveConnection.invalidate();
              if (log.isDebugEnabled()) {
                log.debug("Claimed overdue connection " + conn.getRealHashCode() + ".");
              }
            } else {
              // 无空闲连接，最早创建的连接没有失效，无法创建新连接，只能阻塞
              try {
                if (!countedWait) {
                  state.hadToWaitCount++;//连接池累计等待次数加1
                  countedWait = true;
                }
                if (log.isDebugEnabled()) {
                  log.debug("Waiting as long as " + poolTimeToWait + " milliseconds for connection.");
                }
                long wt = System.currentTimeMillis();
                state.wait(poolTimeToWait);//阻塞等待指定时间
                state.accumulatedWaitTime += System.currentTimeMillis() - wt;//累计等待时间增加
              } catch (InterruptedException e) {
                break;
              }
            }
          }
        }
        if (conn != null) {//获取连接成功的，要测试连接是否有效，同时更新统计数据
          // ping to server and check the connection is valid or not
          if (conn.isValid()) {//检测连接是否有效
            if (!conn.getRealConnection().getAutoCommit()) {
              conn.getRealConnection().rollback();//如果遗留历史的事务，回滚
            }
            //连接池相关统计信息更新
            conn.setConnectionTypeCode(assembleConnectionTypeCode(dataSource.getUrl(), username, password));
            conn.setCheckoutTimestamp(System.currentTimeMillis());
            conn.setLastUsedTimestamp(System.currentTimeMillis());
            state.activeConnections.add(conn);
            state.requestCount++;
            state.accumulatedRequestTime += System.currentTimeMillis() - t;
          } else {//如果连接无效
            if (log.isDebugEnabled()) {
              log.debug("A bad connection (" + conn.getRealHashCode() + ") was returned from the pool, getting another connection.");
            }
            state.badConnectionCount++;//累计的获取无效连接次数+1
            localBadConnectionCount++;//当前获取无效连接次数+1
            conn = null;
            //拿到无效连接，但如果没有超过重试的次数，允许再次尝试获取连接，否则抛出异常
            if (localBadConnectionCount > (poolMaximumIdleConnections + poolMaximumLocalBadConnectionTolerance)) {
              if (log.isDebugEnabled()) {
                log.debug("PooledDataSource: Could not get a good connection to the database.");
              }
              throw new SQLException("PooledDataSource: Could not get a good connection to the database.");
            }
          }
        }
      }

    }

    if (conn == null) {
      if (log.isDebugEnabled()) {
        log.debug("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
      }
      throw new SQLException("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
    }

    return conn;
  }



并发编程  线程等待  |  唤醒线程