MyBatis源码浅析

最新推荐文章于 2021-10-22 17:14:52 发布
最新推荐文章于 2021-10-22 17:14:52 发布
阅读量1.2k 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： MyBatis源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/androidmylove/article/details/41942529

什么是MyBatis      

      MyBatis是支持定制化SQL、存储过程以及高级映射的优秀的持久层框架。MyBatis 避免了几乎所有的 JDBC 代码和手工设置参数以及抽取结果集。MyBatis 使用简单的 XML 或注解来配置和映射基本体，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。

MyBatis简单示例

      虽然在使用MyBatis时一般都会使用XML文件，但是本文为了分析程序的简单性，简单的测试程序将不包含XML配置，该测试程序包含一个接口、一个启动类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public  interface  UserMapper {
   @Select ( "SELECT * FROM user WHERE id = #{id}" )
   User selectUser( int  id);
}
 
public  class  Test2 {
     public  static  void  main(String[] args) {
         SqlSessionFactory sqlSessionFactory = initSqlSessionFactory();
         SqlSession session = sqlSessionFactory.openSession();
         try  {
             User user = (User) session.selectOne(
                     "org.mybatis.example.UserMapper.selectUser" ,  1 );
             System.out.println(user.getUserAddress());
             System.out.println(user.getUserName());
         }  finally  {
             session.close();
         }
     }
 
     private  static  SqlSessionFactory initSqlSessionFactory() {
         DataSource dataSource =  new  PooledDataSource( "com.mysql.jdbc.Driver" ,
                 "jdbc:mysql://127.0.0.1:3306/jdbc" ,  "root" ,  "" );
         TransactionFactory transactionFactory =  new  JdbcTransactionFactory();
         Environment environment =  new  Environment( "development" ,
                 transactionFactory, dataSource);
         Configuration configuration =  new  Configuration(environment);
         configuration.addMapper(UserMapper. class );
         SqlSessionFactory sqlSessionFactory =  new  SqlSessionFactoryBuilder()
                 .build(configuration);
 
         return  sqlSessionFactory;
     }
}

　　UserMapper是一个接口，我们在构建sqlSessionFactory时通过configuration.addMapper(UserMapper.class)把该接口注册进了sqlSessionFactory中。从上面的代码中我们可以看出，要使用MyBatis，我们应该经过以下步骤：1、创建sqlSessionFactory（一次性操作）；2、用sqlSessionFactory对象构造sqlSession对象；3、调用sqlSession的相应方法；4、关闭sqlSession对象。

      在main方法中，我们没有配置sql，也没有根据查询结果拼接对象，只需在调用sqlSession方法时传入一个命名空间以及方法参数参数即可，所有的操作都是面向对象的。在UserMapper接口中，我们定制了自己的sql，MyBatis把书写sql的权利给予了我们，方便我们进行sql优化及sql排错。

JDBC基础回顾

      直接使用JDBC是很痛苦的，JDBC连接数据库包含以下几个基本步骤：1、注册驱动 ；2、建立连接(Connection)；3、创建SQL语句(Statement)；4、执行语句；5、处理执行结果(ResultSet)；6、释放资源，示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public  static  void  test()  throws  SQLException{
     // 1.注册驱动
     Class.forName( "com.mysql.jdbc.Driver" );
  
     // 2.建立连接  url格式 - JDBC:子协议:子名称//主机名:端口/数据库名？属性名=属性值&…
     Connection conn = DriverManager.getConnection( "jdbc:mysql://localhost:3306/jdbc" ,  "root" ,  "" );
  
     // 3.创建语句
     Statement st = conn.createStatement();
  
     // 4.执行语句
     ResultSet rs = st.executeQuery( "select * from user" );
  
     // 5.处理结果
     while  (rs.next()) {<br>　　　　　　User user =  new  User(rs.getObject( 1 ), rs.getObject( 2 ));
     }
  
     // 6.释放资源
     rs.close();
     st.close();
     conn.close();
}

　　可以看到与直接使用JDBC相比，MyBatis为我们简化了很多工作：

      1、把创建连接相关工作抽象成一个sqlSessionFactory对象，一次创建多次使用；

      2、把sql语句从业务层剥离，代码逻辑更加清晰，增加可维护性；

      3、自动完成结果集处理，不需要我们编写重复代码。

      但是，我们应该知道的是，框架虽然能够帮助我们简化工作，但是框架底层的代码肯定还是最基础的JDBC代码，因为这是Java平台连接数据库的通用方法，今天我将分析一下MyBatis源码，看看MyBatis是如何把这些基础代码封装成一个框架的。

MyBatis调用流程

      我们最终调用的是sqlSession对象上的方法，所以我们先跟踪sqlSession的创建方法：sqlSessionFactory.openSession()，最终这个方法会调用到DefaultSqlSessionFactory的以下方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private  SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level,  boolean  autoCommit) {
     Transaction tx =  null ;
     try  {
       final  Environment environment = configuration.getEnvironment();
       final  TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
       tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
       final  Executor executor = configuration.newExecutor(tx, execType);
       return  new  DefaultSqlSession(configuration, executor, autoCommit);
     }  catch  (Exception e) {
       closeTransaction(tx);  // may have fetched a connection so lets call close()
       throw  ExceptionFactory.wrapException( "Error opening session.  Cause: "  + e, e);
     }  finally  {
       ErrorContext.instance().reset();
     }
   }

　　最终返回的对象是一个DefaultSqlSession对象，在调试模式下，我们看到autoCommit为false，executor为CachingExecutor类型，在CachingExecutor里面有属性delegate，其类型为simpleExecutor：

      现在，我们跟进DefaultSqlSession的selectOne()方法，查看该方法的调用流程，selectOne()方法又会调用selectList()方法：

1
2
3
4
5
6
7
8
9
10
11
public  <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
   try  {
     MappedStatement ms = configuration.getMappedStatement(statement);
     List<E> result = executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
     return  result;
   }  catch  (Exception e) {
     throw  ExceptionFactory.wrapException( "Error querying database.  Cause: "  + e, e);
   }  finally  {
     ErrorContext.instance().reset();
   }
}

　　可以看到要得到查询结果，最终还是要调用executor上的query方法，这里的executor是CachingExecutor实例，跟进程序得到如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public  <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler)  throws  SQLException {
   BoundSql boundSql = ms.getBoundSql(parameterObject);
   CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
   return  query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
 
public  <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
     throws  SQLException {
   Cache cache = ms.getCache();
   if  (cache !=  null ) {
     flushCacheIfRequired(ms);
     if  (ms.isUseCache() && resultHandler ==  null ) {
       ensureNoOutParams(ms, parameterObject, boundSql);
       @SuppressWarnings ( "unchecked" )
       List<E> list = (List<E>) tcm.getObject(cache, key);
       if  (list ==  null ) {
         list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
         tcm.putObject(cache, key, list);  // issue #578. Query must be not synchronized to prevent deadlocks
       }
       return  list;
     }
   }
   return  delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

　　MyBatis框架首先生成了一个boundSql和CacheKey，在boundSql中包含有我们传入的sql语句：

      生成boundSql和CacheKey后会调用一个重载函数，在重载函数中，我们会检测是否有缓存，这个缓存是MyBatis的二级缓存，我们没有配置，那么直接调用最后一句delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql)，前面说过这个delagate其实就是simpleExecutor，跟进去查看一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public  <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)  throws  SQLException {
     ErrorContext.instance().resource(ms.getResource()).activity( "executing a query" ).object(ms.getId());
     if  (closed)  throw  new  ExecutorException( "Executor was closed." );
     if  (queryStack ==  0  && ms.isFlushCacheRequired()) {
       clearLocalCache();
     }
     List<E> list;
     try  {
       queryStack++;
       list = resultHandler ==  null  ? (List<E>) localCache.getObject(key) :  null ;
       if  (list !=  null ) {
         handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
       }  else  {
         list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
       }
     }  finally  {
       queryStack--;
     }
     if  (queryStack ==  0 ) {
       for  (DeferredLoad deferredLoad : deferredLoads) {
         deferredLoad.load();
       }
       deferredLoads.clear();  // issue #601
       if  (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
         clearLocalCache();  // issue #482
       }
     }
     return  list;
   }

　　关键代码是以下三行：

1
2
3
4
5
6
list = resultHandler ==  null  ? (List<E>) localCache.getObject(key) :  null ;
if  (list !=  null ) {
   handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
}  else  {
   list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

　　首先尝试从localCache中根据key得到List，这里的localCache是MyBatis的一级缓存，如果得不到则调用queryFromDatabase()从数据库中查询：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private  <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)  throws  SQLException {
   List<E> list;
   localCache.putObject(key, EXECUTION_PLACEHOLDER);
   try  {
     list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
   }  finally  {
     localCache.removeObject(key);
   }
   localCache.putObject(key, list);
   if  (ms.getStatementType() == StatementType.CALLABLE) {
     localOutputParameterCache.putObject(key, parameter);
   }
   return  list;
}

      其中关键代码是调用doQuery()代码，SimpleExecutor的doQuery()方法如下：

1
2
3
4
5
6
7
8
9
10
11
public  <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)  throws  SQLException {
   Statement stmt =  null ;
   try  {
     Configuration configuration = ms.getConfiguration();
     StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
     stmt = prepareStatement(handler, ms.getStatementLog());
     return  handler.<E>query(stmt, resultHandler);
   }  finally  {
     closeStatement(stmt);
   }
}

　　调用了prepareStatement方法，该方法如下：

1
2
3
4
5
6
7
private  Statement prepareStatement(StatementHandler handler, Log statementLog)  throws  SQLException {
   Statement stmt;
   Connection connection = getConnection(statementLog);
   stmt = handler.prepare(connection);
   handler.parameterize(stmt);
   return  stmt;
}

　　终于，我们看到熟悉的代码了，首先得到Connection，然后从Connection中得到Statement，同时在调试模式下我们看到，我们的sql语句已经被设置到stmt中了：

　　现在Statement对象有了，sql也设置进去了，就只差执行以及对象映射了，继续跟进代码，我们会跟踪到org.apache.ibatis.executor.statement.

PreparedStatementHandler类的executor方法：

1
2
3
4
5
public  <E> List<E> query(Statement statement, ResultHandler resultHandler)  throws  SQLException {
   PreparedStatement ps = (PreparedStatement) statement;
   ps.execute();
   return  resultSetHandler.<E> handleResultSets(ps);
}

　　在这里，调用了ps.execute()方法执行sql，接下来调用的resultSetHandler.<E> handleResultSets(ps)方法明显是对结果集进行封装，我就不继续跟进了。      

MyBatis的数据库连接池

     上面一部分介绍了MyBatis执行的整体流程，这一部分打算讨论一个具体话题：MyBatis的数据库连接池。

     我们知道，每次连接数据库时都创建Connection是十分耗费性能的，所以我们在写JDBC代码时，一般都会使用数据库连接池，把用过的Connection不是直接关闭，而是放入数据库连接池中，方便下次复用，开源的数据库连接池有DBCP、C3P0等，MyBatis也实现了自己的数据库连接池，在这一节我将探索一下MyBatis实现的数据库连接池源码。

      跟进上一节的getConnection()方法，我们最终会进入JdbcTransaction的getConnection()方法，getConnection()方法又会调用openConnection()方法，而openConnection()又将调用dataSource的getConnection()方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public  Connection getConnection()  throws  SQLException {
     if  (connection ==  null ) {
         openConnection();
     }
     return  connection;
}
 
protected  void  openConnection()  throws  SQLException {
     if  (log.isDebugEnabled()) {
         log.debug( "Opening JDBC Connection" );
     }
     connection = dataSource.getConnection();
     if  (level !=  null ) {
         connection.setTransactionIsolation(level.getLevel());
     }
     setDesiredAutoCommit(autoCommmit);
}

　　这里的dataSource是PooledDataSource类型，跟进查看源码如下：

1
2
3
4
5
6
7
public  Connection getConnection()  throws  SQLException {
   return  popConnection(dataSource.getUsername(), dataSource.getPassword()).getProxyConnection();
}
 
private  PooledConnection popConnection(String username, String password)  throws  SQLException {
   //暂不分析
}

      可以看到，在这里我们返回的对象其实已经不是原生的Connection对象了，而是一个动态代理对象，是PooledConnection的一个属性，所有对对Connection对象的操作都将被PooledConnection拦截，我们可以查看PooledConnection的定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
class  PooledConnection  implements  InvocationHandler {
     private  static  final  String CLOSE =  "close" ;
     private  static  final  Class<?>[] IFACES =  new  Class<?>[] { Connection. class  };
     private  int  hashCode =  0 ;
     private  PooledDataSource dataSource;
     private  Connection realConnection;
     private  Connection proxyConnection;
     private  long  checkoutTimestamp;
     private  long  createdTimestamp;
     private  long  lastUsedTimestamp;
     private  int  connectionTypeCode;
     private  boolean  valid;
 
     public  PooledConnection(Connection connection, PooledDataSource dataSource) {
         this .hashCode = connection.hashCode();
         this .realConnection = connection;
         this .dataSource = dataSource;
         this .createdTimestamp = System.currentTimeMillis();
         this .lastUsedTimestamp = System.currentTimeMillis();
         this .valid =  true ;
         this .proxyConnection = (Connection) Proxy.newProxyInstance(
                 Connection. class .getClassLoader(), IFACES,  this );
     }
 
     public  void  invalidate() {
         valid =  false ;
     }
 
     public  boolean  isValid() {
         return  valid && realConnection !=  null
                 && dataSource.pingConnection( this );
     }
 
     public  Connection getRealConnection() {
         return  realConnection;
     }
 
     public  Connection getProxyConnection() {
         return  proxyConnection;
     }
 
     public  int  getRealHashCode() {
         if  (realConnection ==  null ) {
             return  0 ;
         }  else  {
             return  realConnection.hashCode();
         }
     }
 
     public  int  getConnectionTypeCode() {
         return  connectionTypeCode;
     }
 
     public  void  setConnectionTypeCode( int  connectionTypeCode) {
         this .connectionTypeCode = connectionTypeCode;
     }
 
     public  long  getCreatedTimestamp() {
         return  createdTimestamp;
     }
 
     public  void  setCreatedTimestamp( long  createdTimestamp) {
         this .createdTimestamp = createdTimestamp;
     }
 
     public  long  getLastUsedTimestamp() {
         return  lastUsedTimestamp;
     }
 
     public  void  setLastUsedTimestamp( long  lastUsedTimestamp) {
         this .lastUsedTimestamp = lastUsedTimestamp;
     }
 
     public  long  getTimeElapsedSinceLastUse() {
         return  System.currentTimeMillis() - lastUsedTimestamp;
     }
 
     public  long  getAge() {
         return  System.currentTimeMillis() - createdTimestamp;
     }
 
     public  long  getCheckoutTimestamp() {
         return  checkoutTimestamp;
     }
 
     public  void  setCheckoutTimestamp( long  timestamp) {
         this .checkoutTimestamp = timestamp;
     }
 
     public  long  getCheckoutTime() {
         return  System.currentTimeMillis() - checkoutTimestamp;
     }
 
     public  int  hashCode() {
         return  hashCode;
     }
 
     public  boolean  equals(Object obj) {
         if  (obj  instanceof  PooledConnection) {
             return  realConnection.hashCode() == (((PooledConnection) obj).realConnection
                     .hashCode());
         }  else  if  (obj  instanceof  Connection) {
             return  hashCode == obj.hashCode();
         }  else  {
             return  false ;
         }
     }
 
     public  Object invoke(Object proxy, Method method, Object[] args)
             throws  Throwable {
         String methodName = method.getName();
         if  (CLOSE.hashCode() == methodName.hashCode()
                 && CLOSE.equals(methodName)) {
             dataSource.pushConnection( this );
             return  null ;
         }  else  {
             try  {
                 if  (!Object. class .equals(method.getDeclaringClass())) {
                     checkConnection();
                 }
                 return  method.invoke(realConnection, args);
             }  catch  (Throwable t) {
                 throw  ExceptionUtil.unwrapThrowable(t);
             }
         }
     }
 
     private  void  checkConnection()  throws  SQLException {
         if  (!valid) {
             throw  new  SQLException(
                     "Error accessing PooledConnection. Connection is invalid." );
         }
     }
}

　　可以看到这个类暴露了很多接口检测Connection状态，例如连接是否有效，连接创建时间最近使用连接等：

      这个类实现了InvocationHandler接口，最主要的一个方法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public  Object invoke(Object proxy, Method method, Object[] args)  throws  Throwable {
   String methodName = method.getName();
   if  (CLOSE.hashCode() == methodName.hashCode() && CLOSE.equals(methodName)) {
     dataSource.pushConnection( this );
     return  null ;
   }  else  {
     try  {
       if  (!Object. class .equals(method.getDeclaringClass())) {
         checkConnection();
       }
       return  method.invoke(realConnection, args);
     }  catch  (Throwable t) {
       throw  ExceptionUtil.unwrapThrowable(t);
     }
   }
}

　　可以看到，PooledConnection会拦截close方法，当客户端调用close()方法时，程序不会关闭Connection，而是会调用dataSource.pushConnection(this)方法，该方法的实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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++;
     }
   }
}

　　可以看到，首先会把Connection从活跃列表中删除，然后检测空闲列表的长度有没有达到最大长度（默认为5），若没有达到，把Connection放入空闲链表，否则关闭连接。这里的state是一个PoolState对象，该对象定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
public  class  PoolState {
   protected  PooledDataSource dataSource;
   protected  final  List<PooledConnection> idleConnections =  new  ArrayList<PooledConnection>();
   protected  final  List<PooledConnection> activeConnections =  new  ArrayList<PooledConnection>();
   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 ;
 
   public  PoolState(PooledDataSource dataSource) {
     this .dataSource = dataSource;
   }
 
   public  synchronized  long  getRequestCount() {
     return  requestCount;
   }
 
   public  synchronized  long  getAverageRequestTime() {
     return  requestCount ==  0  ?  0  : accumulatedRequestTime / requestCount;
   }
 
   public  synchronized  long  getAverageWaitTime() {
     return  hadToWaitCount ==  0  ?  0  : accumulatedWaitTime / hadToWaitCount;
   }
 
   public  synchronized  long  getHadToWaitCount() {
     return  hadToWaitCount;
   }
 
   public  synchronized  long  getBadConnectionCount() {
     return  badConnectionCount;
   }
 
   public  synchronized  long  getClaimedOverdueConnectionCount() {
     return  claimedOverdueConnectionCount;
   }
 
   public  synchronized  long  getAverageOverdueCheckoutTime() {
     return  claimedOverdueConnectionCount ==  0  ?  0  : accumulatedCheckoutTimeOfOverdueConnections / claimedOverdueConnectionCount;
   }
 
   public  synchronized  long  getAverageCheckoutTime() {
     return  requestCount ==  0  ?  0  : accumulatedCheckoutTime / requestCount;
   }
 
   public  synchronized  int  getIdleConnectionCount() {
     return  idleConnections.size();
   }
 
   public  synchronized  int  getActiveConnectionCount() {
     return  activeConnections.size();
   }
}

　　可以看到最终我们的Connection对象是放在ArrayList中的，该类还提供一些接口返回连接池基本信息。

      好了，现在我们可以回去看看PooledDataSource的popConnection方法了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
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.size() >  0 ) {
           // Pool has available connection
           conn = state.idleConnections.remove( 0 );
           if  (log.isDebugEnabled()) {
             log.debug( "Checked out connection "  + conn.getRealHashCode() +  " from pool." );
           }
         }  else  {
           // Pool does not have available connection
           if  (state.activeConnections.size() < poolMaximumActiveConnections) {
             // Can create new connection
             conn =  new  PooledConnection(dataSource.getConnection(),  this );
             @SuppressWarnings ( "unused" )
             //used in logging, if enabled
             Connection realConn = conn.getRealConnection();
             if  (log.isDebugEnabled()) {
               log.debug( "Created connection "  + conn.getRealHashCode() +  "." );
             }
           }  else  {
             // Cannot create new connection
             PooledConnection oldestActiveConnection = state.activeConnections.get( 0 );
             long  longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
             if  (longestCheckoutTime > poolMaximumCheckoutTime) {
               // Can claim overdue connection
               state.claimedOverdueConnectionCount++;
               state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;
               state.accumulatedCheckoutTime += longestCheckoutTime;
               state.activeConnections.remove(oldestActiveConnection);
               if  (!oldestActiveConnection.getRealConnection().getAutoCommit()) {
                 oldestActiveConnection.getRealConnection().rollback();
               }
               conn =  new  PooledConnection(oldestActiveConnection.getRealConnection(),  this );
               oldestActiveConnection.invalidate();
               if  (log.isDebugEnabled()) {
                 log.debug( "Claimed overdue connection "  + conn.getRealHashCode() +  "." );
               }
             }  else  {
               // Must wait
               try  {
                 if  (!countedWait) {
                   state.hadToWaitCount++;
                   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 ) {
           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++;
             localBadConnectionCount++;
             conn =  null ;
             if  (localBadConnectionCount > (poolMaximumIdleConnections +  3 )) {
               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;
   }

　　可以看到获取Connection一共分以下几种情况：1、如果有空闲Connection，那么直接使用空闲Connection，否则2；2、如果活跃Connection没有达到活跃Connection的上限，那么创建一个新Connection并返回，否则3；3、如果达到活跃上限，且被检出的Connection检出时间过长，那么把该Connection置为失效，新创建一个Connection，否则4；4、等待空闲Connection。

      至此，我们就把MyBatis的数据库连接池代码整理了一遍，其中有两个关键点：1、检出的Connection其实不是原生Connection，而是一个代理对象；2、存放Connection的容器是ArrayList，Connection的检出遵从先进先出原则。

MyBatis的缓存

      这篇博客讲的很好，mark一下：http://www.cnblogs.com/fangjian0423/p/mybatis-cache.html

MyBatis的事务

      首先回顾一下JDBC的事务知识。

      JDBC可以操作Connection的setAutoCommit()方法，给它false参数，提示数据库启动事务，在下达一连串的SQL命令后，自行调用Connection的commit()方法，提示数据库确认(Commit)操作。如果中间发生错误，则调用rollback()，提示数据库撤销(ROLLBACK)所有执行。同时，如果仅想要撤回某个SQL执行点，则可以设置存储点(SAVEPOINT)。一个示范的事务流程如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
Connection conn = ...;
Savepoint point =  null ;
try  {
     conn.setAutoCommit( false );
     Statement stmt = conn.createStatement();
     stmt.executeUpdate( "INSERT INTO ..." );
     ...
     point = conn.setSavepoint();
     stmt.executeUpdate( "INSERT INTO ..." );
     ...
     conn.commit();
}  catch  (SQLException e) {
     e.printStackTrace();
     if  (conn !=  null ) {
         try  {
             if  (point ==  null ) {
                 conn.rollback();
             }  else  {
                 conn.rollback(point);
                 conn.releaseSavepoint(point);
             }
         }  catch  (SQLException ex) {
             ex.printStackTrace();
         }
     }
}  finally  {
     ...
     if  (conn !=  null ) {
         try  {
             conn.setAutoCommit( true );
             conn.close();
         }  catch  (SQLException ex) {
             ex.printStackTrace();
         }
     }
}

　　在MyBatis调用流程一节就写过，在调试模式下，我们看到autoCommit为false，所以每个sqlSession其实都是一个事务，这也是为什么每次做删、改、查时都必须调用commit的原因。

javawebsoa
关注
mybatis-generator 源码浅析与修改
zjy1211079133的博客
09-27 5万+
title: mybatis-generator 源码浅析与修改 author: zjy date: 2017-12-15 14:42:59 tags: mybatis-generator 简介 Mybatis属于半自动ORM，在使用这个框架中，工作量最大的就是书写Mapping的映射文件，由于手动书写很容易出错，我们可以利用Mybatis-Generator来帮我们自动生成文件。项目中常用的： StudentExample example = new StudentExample();
从 Spring 集成 MyBatis 到浅析 Java 动态代理
KHOST的博客
06-02 435
前言 因为 MyBatis 的易上手性和可控性，使得它成为了 ORM框架中的首选。近日新起了一个项目，所以重新搭建了一下 Spring-mybatis, 下面是搭建笔记和从 Spring-mybatis源码分析其如何使用 Java动态代理，希望对大家有帮助。 Spring 集成 Mybatis Spring 集成 Mybatis的方式有很多种，大家耳熟能详的 xml配置方式或者本文的采用的方...
Error accessing PooledConnection. Connection is invalid.问题处理总结
zjltju1203的博客
01-14 5916
最近有个项目使用SpringBoot+Mybatis，进行大批量数据库操作，基本代码结构是6个类： 其中，AbstractSync定义的Session的获取，另外三个类集成自AbstractSync，从而获取数据库连接。 AbstractSync代码结构如下： public abstract class AbstractSync { private Logger log = L...
Activiti 5 使用ab并发测试100个并发失败
keepLearning的专栏
03-10 4308
使用ab -n 1000 -c 100 测试时，cmd界面出现 apr_poll: the timeout specified has expired 后台异常出现：Error accessing PooledConnection. Connection is invalid. 解决方法： 数据库链接池数量问题，Acitivit 的数据库链接配置默认是10个，设置为大一点就可以。在acti
MyBatis源码解析（六）——DataSource数据源模块之池型数据源
weixin_30426879的博客
04-07 276
原创作品，可以转载，但是请标注出处地址：http://www.cnblogs.com/V1haoge/p/6675674.html 1 回顾 　　上一文中解读了MyBatis中非池型数据源的源码，非池型也就是只拥有单一数据连接的数据源，他只管理着一个数据连接，这种数据源现在很少使用，一般都是用池型数据源，因为单个连接的情况下，为了保证操作的正确性，针对这个连接的使用要进行同步，这样无疑会拖慢...
MyBatis数据库链接池源码分析
君战
01-22 446
简介 MyBatis默认提供了一个数据库链接池的实现-PooledDataSource，但是在企业级项目中几乎没有公司使用。今天我们就来分析下其源码实现，以及为什么不使用该链接池的原因。需要提前声明的是，在阅读源码前最好有一些J.U.C(java.util.concurrent)方面的基础知识 源码分析 从类关系中可以看出，PooledDataSource实现了Java定义的DataSource接口。我们都知道从数据源获取一个数据库链接是调用getConnection方法。因此，我们首先来分析下getCon
MyBatis源码浅析（一）开篇
09-01
MyBatis是一个轻量级的持久层框架，...通过对MyBatis源码的深入理解，我们可以更好地定制和优化数据访问层，提高应用程序的性能和可维护性。同时，这也为理解其他类似框架如Spring JDBC、Hibernate等打下了坚实的基础。
mybatis源码浅析
随笔
02-01 216
简介 一直以来都在使用mybatis，但却没有深入的了解下它，这么一款常用的持久层框架还是有必要翻翻源代码的。先上一张我自己初学mybatis的图。 当时一看这图，觉得mybatis全都懂了。。。，再把后来看过的mybatis资料图附上。 架构图 组件关系 看完这些图立马觉得懂了。。。 浅析 话不多说直接看代码，就看官网的入门篇代码吧。 DataSource dataSource = BlogDataSourceFactory.getBlogD...
从Mybatis源码到Spring动态数据源底层原理分析系列一、Mybatis初始化源码浅析
m0_62301431的博客
10-22 244
一、引入 本系列文章最终的目标是为了分析spring动态数据源的原理, 相信大家在公司的开发中应该都会遇到一个项目中出现多个数据库连接的情况, 以我遇到的一种情况来说, 用户根据id分布在不同的数据库, 每个数据库中的表结构一模一样, 这就会导致, 在执行业务代码的时候, 不同的用户需求在不同的数据库中执行对应的sql, 即在mybatis作为持久层框架的情况下, 一个mapper可能会在不同的情况下, 对不同的数据库进行操作, 这就需要我们有能够执行动态数据源的功能, 而在这其中, 最重要的一部分就是事
c3p0 java.sql.SQLException: Connection is invalid
在爬行中进步
10-19 7914
异常信息： BasicResourcePool: An idle resource is broken and will be purged. java.sql.SQLException: Connection is invalid at com.mchange.v2.c3p0.impl.C3P0PooledConnectionPool$1.testPooledConnection(C
Mysql连接无效(invalid connection)解决方案
热门推荐
dghpgyss的博客
01-14 2万+
       一般连接数据库的代码库都有实现连接池，如golang语言database/sql库，其中SetConnMaxLifetime(d time.Duration)是用来设置连接池里每条连接关闭的时间，当d &lt;= 0时，连接池里的连接永久重用,即永远都在连接池里，拿来就用，不管此连接是否真的有效(这里有问题，下面讲)。当d &gt; 0时，到了时间d才会关闭连接，把连接移出连接池，但...
Connection is invalid
Java多线程学习总结一
11-10 891
在项目的运行过程中时不时的在控制台打印出的错误信息，错误信息出现后未影响到程序的运行，所以一直都未此过多关注，现在，项目接近尾声，想把此问题解决，控制台打印的具体信息如下： java.sql.SQLException: Connection is invalid at com.mchange.v2.c3p0.impl.C3P0PooledConnectionPool$1.tes...
Mybatis基础详细介绍
拉格朗日的学习笔记
04-25 493
1什么是框架 半成品软件,项目开发中的解决方法,不同的框架解决不同的问题 使用框架的好处就是封装了很多的细节,使得开发者可以使用既简单的方式来解决开发,大大的提高了开发的效率. 2.三层架构 1.表现层:展现数据 SpringMvc 2.业务层:业务需求 3.持久层:是和数据库进行交互 mybatis Spring 不属于任何一层但是无可替代 3.持久层的技术解决方案 JDBC技术: Connec...
【故障】mysql 中的timeStamp经过mybatis获取后就自动加了8小时
Metamorphosis
07-10 9749
语文太差了。。 这个问题我描述的不一定准确。。 情况是这样的… 某天，我们的某张定时任务进度依赖的一个config表中的时间戳，莫名其妙的出现了超过当前时间的未来的时间。。 按理说这是不可能的，因为所有的值都是取自实际表中的数据且必然小于now()… 经过日志打印， 上面的LINUX TIME是mybatis里面获得的某个result的日期对象toString的结果… 下面的TIME...
Mybatis的基础使用
xiangchaoming的博客
07-01 263
1、概述及相关jar包 （1）Mybatis持久层框架，它使开发者只需要关注SQL语句本身 （2）ORM思想（Object Relation Mapping），对象关系映射。简单说，就是把数据库表和实体类对应起来操作数据库表 <!-- mybatis --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId>
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值