String resource = "mybatis.cfg.xml";  
        Reader reader = Resources.getResourceAsReader(resource);  
        SqlSessionFactory ssf = new SqlSessionFactoryBuilder().build(reader);  
          
      <strong>  </strong>SqlSession session = ssf.openSession();  
          
        try {  
            UserInfo user = (UserInfo) session.selectOne("User.selectUser", "1");  
            System.out.println(user);  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            session.close();  
        }

SqlSession session = ssf.openSession();  
        
UserInfo user = (UserInfo) session.selectOne("User.selectUser", "1");

SqlSession session = ssf.openSession();

public SqlSession openSession() {  
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);  
  }

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {  
    Connection connection = null;  
    try {  
      final Environment environment = configuration.getEnvironment();  
      final DataSource dataSource = getDataSourceFromEnvironment(environment);  
      TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);  
      connection = dataSource.getConnection();  
      if (level != null) {  
        connection.setTransactionIsolation(level.getLevel());  
      }  
      connection = wrapConnection(connection);  
      Transaction tx = transactionFactory.newTransaction(connection, autoCommit);  
      Executor executor = configuration.newExecutor(tx, execType);  
      return new DefaultSqlSession(configuration, executor, autoCommit);  
    } catch (Exception e) {  
      closeConnection(connection);  
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);  
    } finally {  
      ErrorContext.instance().reset();  
    }  
  }

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {  
   executorType = executorType == null ? defaultExecutorType : executorType;  
   executorType = executorType == null ? ExecutorType.SIMPLE : executorType;  
   Executor executor;  
   if (ExecutorType.BATCH == executorType) {  
     executor = new BatchExecutor(this, transaction);  
   } else if (ExecutorType.REUSE == executorType) {  
     executor = new ReuseExecutor(this, transaction);  
   } else {  
     executor = new SimpleExecutor(this, transaction);  
   }  
   if (cacheEnabled) {  
     executor = new CachingExecutor(executor);  
   }  
   executor = (Executor) interceptorChain.pluginAll(executor);  
   return executor;  
 }

UserInfo user = (UserInfo) session.selectOne("User.selectUser", "1");

public Object selectOne(String statement, Object parameter) {  
    // Popular vote was to return null on 0 results and throw exception on too many.  
    List list = selectList(statement, parameter);  
    if (list.size() == 1) {  
      return list.get(0);  
    } else if (list.size() > 1) {  
      throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());  
    } else {  
      return null;  
    }  
  }

public List selectList(String statement, Object parameter) {  
    return selectList(statement, parameter, RowBounds.DEFAULT);  
  }  
  
  public List selectList(String statement, Object parameter, RowBounds rowBounds) {  
    try {  
      MappedStatement ms = configuration.getMappedStatement(statement);  
      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);  
    } catch (Exception e) {  
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);  
    } finally {  
      ErrorContext.instance().reset();  
    }  
  }

public List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {  
    Statement stmt = null;  
    try {  
      Configuration configuration = ms.getConfiguration();  
      StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, rowBounds, resultHandler);  
      stmt = prepareStatement(handler);  
      return handler.query(stmt, resultHandler);  
    } finally {  
      closeStatement(stmt);  
    }  
  }

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) {  
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler);  
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);  
    return statementHandler;  
  }

public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) {  
  
   switch (ms.getStatementType()) {  
     case STATEMENT:  
       delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler);  
       break;  
     case PREPARED:  
       delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler);  
       break;  
     case CALLABLE:  
       delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler);  
       break;  
     default:  
       throw new ExecutorException("Unknown statement type: " + ms.getStatementType());  
   }  
  
 }

private Statement prepareStatement(StatementHandler handler) throws SQLException {  
   Statement stmt;  
   Connection connection = transaction.getConnection();  
   //从连接中获取Statement对象  
   stmt = handler.prepare(connection);  
   //处理预编译的传入参数  
   handler.parameterize(stmt);  
   return stmt;  
 }